From b9668b996c3beec45ca76022a829224f5c077bbe Mon Sep 17 00:00:00 2001
From: Andrei Maiboroda <andrei@ethereum.org>
Date: Mon, 12 Apr 2021 13:31:59 +0200
Subject: [PATCH 001/285] [test] Check that memory is exported/imported with
 correct min limit (#1293)

---
 test/core/imports.wast | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/test/core/imports.wast b/test/core/imports.wast
index 147f4c335..35e8c917f 100644
--- a/test/core/imports.wast
+++ b/test/core/imports.wast
@@ -577,6 +577,26 @@
 (assert_return (invoke "grow" (i32.const 1)) (i32.const -1))
 (assert_return (invoke "grow" (i32.const 0)) (i32.const 2))
 
+(module $Mgm
+  (memory (export "memory") 1) ;; initial size is 1
+  (func (export "grow") (result i32) (memory.grow (i32.const 1)))
+)
+(register "grown-memory" $Mgm)
+(assert_return (invoke $Mgm "grow") (i32.const 1)) ;; now size is 2
+(module $Mgim1
+  ;; imported memory limits should match, because external memory size is 2 now
+  (memory (export "memory") (import "grown-memory" "memory") 2) 
+  (func (export "grow") (result i32) (memory.grow (i32.const 1)))
+)
+(register "grown-imported-memory" $Mgim1)
+(assert_return (invoke $Mgim1 "grow") (i32.const 2)) ;; now size is 3
+(module $Mgim2
+  ;; imported memory limits should match, because external memory size is 3 now
+  (import "grown-imported-memory" "memory" (memory 3))
+  (func (export "size") (result i32) (memory.size))
+)
+(assert_return (invoke $Mgim2 "size") (i32.const 3))
+
 
 ;; Syntax errors
 

From 8b73d0070d1961aee3022fb53b06848bd52e4e8f Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@dfinity.org>
Date: Wed, 14 Apr 2021 10:29:42 +0200
Subject: [PATCH 002/285] [spec] Adjust oversight in reversal of br_table
 validation (#1305)

---
 document/core/valid/instructions.rst | 25 +++++++++++++++++++------
 1 file changed, 19 insertions(+), 6 deletions(-)

diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 0308362af..f329a6779 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -21,6 +21,7 @@ and the provided output stack with result values of types :math:`t_2^\ast` that
 Stack types are akin to :ref:`function types <syntax-functype>`,
 except that they allow individual operands to be classified as :math:`\bot` (*bottom*), indicating that the type is unconstrained.
 As an auxiliary notion, an operand type :math:`t_1` *matches* another operand type :math:`t_2`, if :math:`t_1` is either :math:`\bot` or equal to :math:`t_2`.
+This is extended to stack types in a point-wise manner.
 
 .. _match-opdtype:
 
@@ -35,6 +36,13 @@ As an auxiliary notion, an operand type :math:`t_1` *matches* another operand ty
      \vdash \bot \leq t
    }
 
+.. math::
+   \frac{
+     (\vdash t \leq t')^\ast
+   }{
+     \vdash [t^\ast] \leq [{t'}^\ast]
+   }
+
 .. note::
    For example, the instruction :math:`\I32.\ADD` has type :math:`[\I32~\I32] \to [\I32]`,
    consuming two |I32| values and producing one.
@@ -949,6 +957,7 @@ Control Instructions
 :math:`\BRTABLE~l^\ast~l_N`
 ...........................
 
+
 * The label :math:`C.\CLABELS[l_N]` must be defined in the context.
 
 * Let :math:`[t^\ast]` be the :ref:`result type <syntax-resulttype>` :math:`C.\CLABELS[l_N]`.
@@ -956,16 +965,20 @@ Control Instructions
 * For all :math:`l_i` in :math:`l^\ast`,
   the label :math:`C.\CLABELS[l_i]` must be defined in the context.
 
-* For all :math:`l_i` in :math:`l^\ast`,
-  :math:`C.\CLABELS[l_i]` must be :math:`[t^\ast]`.
+* There must be a :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`, such that:
+
+  * For each :ref:`operand type <syntax-opdtype>` :math:`t_j` in :math:`t^\ast` and corresponding type :math:`t'_{Nj}` in :math:`C.\CLABELS[l_N]`, :math:`t_j` :ref:`matches <match-opdtype>` :math:`t'_{Nj}`.
+
+  * For all :math:`l_i` in :math:`l^\ast`,
+    and for each :ref:`operand type <syntax-opdtype>` :math:`t_j` in :math:`t^\ast` and corresponding type :math:`t'_{ij}` in :math:`C.\CLABELS[l_i]`, :math:`t_j` :ref:`matches <match-opdtype>` :math:`t'_{ij}`.
 
 * Then the instruction is valid with type :math:`[t_1^\ast~t^\ast~\I32] \to [t_2^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
 .. math::
    \frac{
-     (C.\CLABELS[l] = [t^\ast])^\ast
+     (\vdash [t^\ast] \leq C.\CLABELS[l])^\ast
      \qquad
-     C.\CLABELS[l_N] = [t^\ast]
+     \vdash [t^\ast] \leq C.\CLABELS[l_N]
    }{
      C \vdashinstr \BRTABLE~l^\ast~l_N : [t_1^\ast~t^\ast~\I32] \to [t_2^\ast]
    }
@@ -1088,7 +1101,7 @@ Non-empty Instruction Sequence: :math:`\instr^\ast~\instr_N`
    \frac{
      C \vdashinstrseq \instr^\ast : [t_1^\ast] \to [t_0^\ast~{t'}^\ast]
      \qquad
-     (\vdash t' \leq t)^\ast
+     \vdash [{t'}^\ast] \leq [t^\ast]
      \qquad
      C \vdashinstr \instr_N : [t^\ast] \to [t_3^\ast]
    }{
@@ -1121,7 +1134,7 @@ Expressions :math:`\expr` are classified by :ref:`result types <syntax-resulttyp
    \frac{
      C \vdashinstrseq \instr^\ast : [] \to [{t'}^\ast]
      \qquad
-     (\vdash t' \leq t)^\ast
+     \vdash [{t'}^\ast] \leq [t^\ast]
    }{
      C \vdashexpr \instr^\ast~\END : [t^\ast]
    }

From 7b270ee8034a7c9cbe07c6d987b5c9b0baccc9a0 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Wed, 14 Apr 2021 13:40:01 +0200
Subject: [PATCH 003/285] [interpreter] More robust make rule

---
 interpreter/Makefile | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/interpreter/Makefile b/interpreter/Makefile
index c163b15aa..175a9493a 100644
--- a/interpreter/Makefile
+++ b/interpreter/Makefile
@@ -69,12 +69,12 @@ main.native:	_tags
 
 # Building library
 
-FILES =		$(shell ls $(DIRS:%=%/*.ml*))
+FILES =		$(shell ls $(DIRS:%=%/*) | grep '[.]ml[^.]*$$')
 PACK =		$(shell echo `echo $(LIB) | sed 's/^\(.\).*$$/\\1/g' | tr [:lower:] [:upper:]``echo $(LIB) | sed 's/^.\(.*\)$$/\\1/g'`)
 
 .INTERMEDIATE:	$(LIB).mlpack
 $(LIB).mlpack:	$(DIRS)
-		ls $(DIRS:%=%/*.ml*) \
+		ls $(FILES) \
 		| sed 's:\(.*/\)\{0,1\}\(.*\)\.[^\.]*:\2:' \
 		| grep -v main \
 		| sort | uniq \

From f607ec9a776a9e3425639f3cbe9b2d96bdc16b60 Mon Sep 17 00:00:00 2001
From: Andrei Maiboroda <andrei@ethereum.org>
Date: Wed, 14 Apr 2021 13:45:43 +0200
Subject: [PATCH 004/285] [test] Fix alignment of i32.store instruction (#1312)

---
 test/core/binary.wast | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/core/binary.wast b/test/core/binary.wast
index d85c96851..c6f975570 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -641,7 +641,7 @@
     "\41\00"                   ;; i32.const 0
     "\41\03"                   ;; i32.const 3
     "\36"                      ;; i32.store
-    "\03"                      ;; alignment 2
+    "\02"                      ;; alignment 2
     "\82\80\80\80\10"          ;; offset 2 with unused bits set
     "\0b"                      ;; end
   )

From e3c108118657f04f605f92eb43ce0bae39f76efe Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@dfinity.org>
Date: Wed, 21 Apr 2021 16:04:05 +0200
Subject: [PATCH 005/285] [spec] Remove obsolete notes and fix inaccurate side
 conditions (#1311)

---
 document/core/binary/instructions.rst | 6 ------
 document/core/text/instructions.rst   | 8 ++++----
 2 files changed, 4 insertions(+), 10 deletions(-)

diff --git a/document/core/binary/instructions.rst b/document/core/binary/instructions.rst
index 17aa5f439..a43826a3c 100644
--- a/document/core/binary/instructions.rst
+++ b/document/core/binary/instructions.rst
@@ -71,9 +71,6 @@ Control Instructions
    Unlike any :ref:`other occurrence <binary-typeidx>`, the :ref:`type index <syntax-typeidx>` in a :ref:`block type <syntax-blocktype>` is encoded as a positive :ref:`signed integer <syntax-sint>`, so that its |SignedLEB128| bit pattern cannot collide with the encoding of :ref:`value types <binary-valtype>` or the special code :math:`\hex{40}`, which correspond to the LEB128 encoding of negative integers.
    To avoid any loss in the range of allowed indices, it is treated as a 33 bit signed integer. 
 
-   In future versions of WebAssembly, the zero byte occurring in the encoding
-   of the |CALLINDIRECT| instruction may be used to index additional tables.
-
 
 .. index:: reference instruction
    pair: binary format; instruction
@@ -95,9 +92,6 @@ Reference Instructions
      \hex{D2}~~x{:}\Bfuncidx &\Rightarrow& \REFFUNC~x \\
    \end{array}
 
-.. note::
-   These opcode assignments are preliminary.
-
 
 .. index:: parametric instruction, value type, polymorphism
    pair: binary format; instruction
diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index 89a275824..031beb341 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -71,7 +71,7 @@ However, the special case of a type use that is syntactically empty or consists
    &
    \begin{array}[t]{@{}lcll@{}}
      (t{:}\Tresult)^? &\Rightarrow& t^? \\
-     x,I'{:}\Ttypeuse_I &\Rightarrow& x & (\iff I' = \{\}) \\
+     x,I'{:}\Ttypeuse_I &\Rightarrow& x & (\iff I' = \{\ILOCALS~(\epsilon)^\ast\}) \\
    \end{array} \\
    \production{block instruction} & \Tblockinstr_I &::=&
      \text{block}~~I'{:}\Tlabel_I~~\X{bt}{:}\Tblocktype~~(\X{in}{:}\Tinstr_{I'})^\ast~~\text{end}~~\Tid^?
@@ -87,7 +87,7 @@ However, the special case of a type use that is syntactically empty or consists
    \end{array}
 
 .. note::
-   The side condition stating that the :ref:`identifier context <text-context>` :math:`I'` must be empty in the rule for |Ttypeuse| block types enforces that no identifier can be bound in any |Tparam| declaration for a block type.
+   The side condition stating that the :ref:`identifier context <text-context>` :math:`I'` must only contain unnamed entries in the rule for |Ttypeuse| block types enforces that no identifier can be bound in any |Tparam| declaration for a block type.
 
 
 .. _text-nop:
@@ -113,11 +113,11 @@ All other control instruction are represented verbatim.
      \text{return} &\Rightarrow& \RETURN \\ &&|&
      \text{call}~~x{:}\Tfuncidx_I &\Rightarrow& \CALL~x \\ &&|&
      \text{call\_indirect}~~x{:}\Ttableidx~~y,I'{:}\Ttypeuse_I &\Rightarrow& \CALLINDIRECT~x~y
-       & (\iff I' = \{\}) \\
+       & (\iff I' = \{\ILOCALS~(\epsilon)^\ast\}) \\
    \end{array}
 
 .. note::
-   The side condition stating that the :ref:`identifier context <text-context>` :math:`I'` must be empty in the rule for |CALLINDIRECT| enforces that no identifier can be bound in any |Tparam| declaration appearing in the type annotation.
+   The side condition stating that the :ref:`identifier context <text-context>` :math:`I'` must only contain unnamed entries in the rule for |CALLINDIRECT| enforces that no identifier can be bound in any |Tparam| declaration appearing in the type annotation.
 
 
 Abbreviations

From c4dd6e3a0a492984601b43de69396f3fc361cebc Mon Sep 17 00:00:00 2001
From: Ng Zhi An <zhin@chromium.org>
Date: Wed, 5 May 2021 09:32:24 -0700
Subject: [PATCH 006/285] binary: table instructions can be 1 byte or
 prefix+u32 (#1320)

---
 document/core/binary/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/binary/instructions.rst b/document/core/binary/instructions.rst
index a43826a3c..d6a60d83f 100644
--- a/document/core/binary/instructions.rst
+++ b/document/core/binary/instructions.rst
@@ -155,7 +155,7 @@ Variable Instructions
 Table Instructions
 ~~~~~~~~~~~~~~~~~~
 
-:ref:`Table instructions <syntax-instr-table>` are represented by either single byte or two byte codes.
+:ref:`Table instructions <syntax-instr-table>` are represented either by a single byte or a one byte prefix followed by a variable-length :ref:`unsigned integer <binary-uint>`.
 
 .. math::
    \begin{array}{llclll}

From c22bc3271ac5974c6bf96b273930605592847c1f Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Thu, 6 May 2021 11:37:25 +0200
Subject: [PATCH 007/285] [interpreter] Overdue version bump

---
 interpreter/main/main.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interpreter/main/main.ml b/interpreter/main/main.ml
index d7f2b44f3..91b91018f 100644
--- a/interpreter/main/main.ml
+++ b/interpreter/main/main.ml
@@ -1,5 +1,5 @@
 let name = "wasm"
-let version = "1.0"
+let version = "1.1"
 
 let configure () =
   Import.register (Utf8.decode "spectest") Spectest.lookup;

From e94c07a74f9b508b38fb83499c4874847a077d2c Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@dfinity.org>
Date: Mon, 10 May 2021 09:55:16 +0200
Subject: [PATCH 008/285] [spec] Fix side condition about fresh ids (#1315)

---
 document/core/text/modules.rst | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/document/core/text/modules.rst b/document/core/text/modules.rst
index 9ae3b2d11..7c8cb99d6 100644
--- a/document/core/text/modules.rst
+++ b/document/core/text/modules.rst
@@ -245,7 +245,7 @@ Functions can be defined as :ref:`imports <text-import>` or :ref:`exports <text-
        \text{(}~\text{export}~~\Tname~~\text{(}~\text{func}~~\Tid'~\text{)}~\text{)}~~
        \text{(}~\text{func}~~\Tid'~~\dots~\text{)}
        \\ & \qquad\qquad
-       (\iff \Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
+       (\iff \Tid^? \neq \epsilon \wedge \Tid' = \Tid^? \vee \Tid^? = \epsilon \wedge \Tid' \idfresh) \\
    \end{array}
 
 The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export.
@@ -290,7 +290,7 @@ An :ref:`element segment <text-elem>` can be given inline with a table definitio
        \text{(}~\text{table}~~\Tid'~~n~~n~~\Treftype~\text{)}~~
        \text{(}~\text{elem}~~\text{(}~\text{table}~~\Tid'~\text{)}~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Telemlist~\text{)}
        \\ & \qquad\qquad
-       (\iff \Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
+       (\iff \Tid^? \neq \epsilon \wedge \Tid' = \Tid^? \vee \Tid^? = \epsilon \wedge \Tid' \idfresh) \\
    \end{array}
 
 .. math::
@@ -300,7 +300,7 @@ An :ref:`element segment <text-elem>` can be given inline with a table definitio
        \text{(}~\text{table}~~\Tid'~~n~~n~~\Treftype~\text{)}~~
        \text{(}~\text{elem}~~\Tid'~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Tvec(\Texpr)~\text{)}
        \\ & \qquad\qquad
-       (\iff \Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
+       (\iff \Tid^? \neq \epsilon \wedge \Tid' = \Tid^? \vee \Tid^? = \epsilon \wedge \Tid' \idfresh) \\
    \end{array}
 
 Tables can be defined as :ref:`imports <text-import>` or :ref:`exports <text-export>` inline:
@@ -314,7 +314,7 @@ Tables can be defined as :ref:`imports <text-import>` or :ref:`exports <text-exp
        \text{(}~\text{export}~~\Tname~~\text{(}~\text{table}~~\Tid'~\text{)}~\text{)}~~
        \text{(}~\text{table}~~\Tid'~~\dots~\text{)}
        \\ & \qquad\qquad
-       (\iff \Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
+       (\iff \Tid^? \neq \epsilon \wedge \Tid' = \Tid^? \vee \Tid^? = \epsilon \wedge \Tid' \idfresh) \\
    \end{array}
 
 The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export or an inline elements segment.
@@ -359,7 +359,7 @@ A :ref:`data segment <text-data>` can be given inline with a memory definition,
        \text{(}~\text{memory}~~\Tid'~~m~~m~\text{)}~~
        \text{(}~\text{data}~~\text{(}~\text{memory}~~\Tid'~\text{)}~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Tdatastring~\text{)}
        \\ & \qquad\qquad
-       (\iff \Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh, m = \F{ceil}(n / 64\F{Ki})) \\
+       (\iff \Tid^? \neq \epsilon \wedge \Tid' = \Tid^? \vee \Tid^? = \epsilon \wedge \Tid' \idfresh, m = \F{ceil}(n / 64\F{Ki})) \\
    \end{array}
 
 Memories can be defined as :ref:`imports <text-import>` or :ref:`exports <text-export>` inline:
@@ -374,7 +374,7 @@ Memories can be defined as :ref:`imports <text-import>` or :ref:`exports <text-e
        \text{(}~\text{export}~~\Tname~~\text{(}~\text{memory}~~\Tid'~\text{)}~\text{)}~~
        \text{(}~\text{memory}~~\Tid'~~\dots~\text{)}
        \\ & \qquad\qquad
-       (\iff \Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
+       (\iff \Tid^? \neq \epsilon \wedge \Tid' = \Tid^? \vee \Tid^? = \epsilon \wedge \Tid' \idfresh) \\
    \end{array}
 
 The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export or an inline data segment.
@@ -418,7 +418,7 @@ Globals can be defined as :ref:`imports <text-import>` or :ref:`exports <text-ex
        \text{(}~\text{export}~~\Tname~~\text{(}~\text{global}~~\Tid'~\text{)}~\text{)}~~
        \text{(}~\text{global}~~\Tid'~~\dots~\text{)}
        \\ & \qquad\qquad
-       (\iff \Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
+       (\iff \Tid^? \neq \epsilon \wedge \Tid' = \Tid^? \vee \Tid^? = \epsilon \wedge \Tid' \idfresh) \\
    \end{array}
 
 The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export.

From 873197e5edd72a7946e7baf2b81af9387b92f141 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@dfinity.org>
Date: Mon, 10 May 2021 10:27:03 +0200
Subject: [PATCH 009/285] [spec] Fix various typos in rules (#1321)

---
 document/core/exec/instructions.rst |  2 +-
 document/core/text/instructions.rst |  4 +-
 document/core/text/modules.rst      | 34 ++++++++--------
 document/core/util/macros.def       |  2 +-
 test/core/data.wast                 |  8 ++++
 test/core/elem.wast                 | 62 ++++++++++++++++++++++++++++-
 6 files changed, 91 insertions(+), 21 deletions(-)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index d73228a12..6f4c7dc74 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -907,7 +907,7 @@ Table Instructions
        (\I32.\CONST~d+1)~(\I32.\CONST~s+1)~(\I32.\CONST~n)~(\TABLEINIT~x~y) \\
        \end{array}
      \\ \qquad
-     (\otherwise, \iff \val = S.\SELEMS[F.\AMODULE.\MIELEMS[x]].\EIELEM[s]) \\
+     (\otherwise, \iff \val = S.\SELEMS[F.\AMODULE.\MIELEMS[y]].\EIELEM[s]) \\
    \end{array}
 
 
diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index 031beb341..45c2a0597 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -592,6 +592,6 @@ No explicit :math:`\text{end}` keyword is included, since they only occur in bra
 
 .. math::
    \begin{array}{llclll}
-   \production{expression} & \Texpr &::=&
-     (\X{in}{:}\Tinstr)^\ast &\Rightarrow& \X{in}^\ast~\END \\
+   \production{expression} & \Texpr_I &::=&
+     (\X{in}{:}\Tinstr_I)^\ast &\Rightarrow& \X{in}^\ast~\END \\
    \end{array}
diff --git a/document/core/text/modules.rst b/document/core/text/modules.rst
index 7c8cb99d6..848f6880b 100644
--- a/document/core/text/modules.rst
+++ b/document/core/text/modules.rst
@@ -16,6 +16,8 @@ Modules
 .. _text-funcidx:
 .. _text-tableidx:
 .. _text-memidx:
+.. _text-elemidx:
+.. _text-dataidx:
 .. _text-globalidx:
 .. _text-localidx:
 .. _text-labelidx:
@@ -286,9 +288,9 @@ An :ref:`element segment <text-elem>` can be given inline with a table definitio
 .. math::
    \begin{array}{llclll}
    \production{module field} &
-     \text{(}~\text{table}~~\Tid^?~~\Treftype~~\text{(}~\text{elem}~~\Telemlist~\text{)} \quad\equiv \\ & \qquad
-       \text{(}~\text{table}~~\Tid'~~n~~n~~\Treftype~\text{)}~~
-       \text{(}~\text{elem}~~\text{(}~\text{table}~~\Tid'~\text{)}~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Telemlist~\text{)}
+     \text{(}~\text{table}~~\Tid^?~~\Treftype~~\text{(}~\text{elem}~~\expr^n{:}\Tvec(\Telemexpr)~\text{)}~~\text{)} \quad\equiv \\ & \qquad
+       \text{(}~\text{table}~~\Tid'~~n~~n~~\Treftype~\text{)} \\ & \qquad
+       \text{(}~\text{elem}~~\text{(}~\text{table}~~\Tid'~\text{)}~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Tvec(\Telemexpr)~\text{)}
        \\ & \qquad\qquad
        (\iff \Tid^? \neq \epsilon \wedge \Tid' = \Tid^? \vee \Tid^? = \epsilon \wedge \Tid' \idfresh) \\
    \end{array}
@@ -296,9 +298,9 @@ An :ref:`element segment <text-elem>` can be given inline with a table definitio
 .. math::
    \begin{array}{llclll}
    \production{module field} &
-     \text{(}~\text{table}~~\Tid^?~~\Treftype~~\text{(}~\text{elem}~~x^n{:}\Tvec(\Texpr)~\text{)}~~\text{)} \quad\equiv \\ & \qquad
-       \text{(}~\text{table}~~\Tid'~~n~~n~~\Treftype~\text{)}~~
-       \text{(}~\text{elem}~~\Tid'~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Tvec(\Texpr)~\text{)}
+     \text{(}~\text{table}~~\Tid^?~~\Treftype~~\text{(}~\text{elem}~~x^n{:}\Tvec(\Tfuncidx)~\text{)} \quad\equiv \\ & \qquad
+       \text{(}~\text{table}~~\Tid'~~n~~n~~\Treftype~\text{)} \\ & \qquad
+       \text{(}~\text{elem}~~\text{(}~\text{table}~~\Tid'~\text{)}~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Tvec(\Tfuncidx)~\text{)}
        \\ & \qquad\qquad
        (\iff \Tid^? \neq \epsilon \wedge \Tid' = \Tid^? \vee \Tid^? = \epsilon \wedge \Tid' \idfresh) \\
    \end{array}
@@ -356,7 +358,7 @@ A :ref:`data segment <text-data>` can be given inline with a memory definition,
    \begin{array}{llclll}
    \production{module field} &
      \text{(}~\text{memory}~~\Tid^?~~\text{(}~\text{data}~~b^n{:}\Tdatastring~\text{)}~~\text{)} \quad\equiv \\ & \qquad
-       \text{(}~\text{memory}~~\Tid'~~m~~m~\text{)}~~
+       \text{(}~\text{memory}~~\Tid'~~m~~m~\text{)} \\ & \qquad
        \text{(}~\text{data}~~\text{(}~\text{memory}~~\Tid'~\text{)}~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Tdatastring~\text{)}
        \\ & \qquad\qquad
        (\iff \Tid^? \neq \epsilon \wedge \Tid' = \Tid^? \vee \Tid^? = \epsilon \wedge \Tid' \idfresh, m = \F{ceil}(n / 64\F{Ki})) \\
@@ -496,16 +498,16 @@ Element segments allow for an optional :ref:`table index <text-tableidx>` to ide
 .. math::
    \begin{array}{llclll}
    \production{element segment} & \Telem_I &::=&
-     \text{(}~\text{elem}~~\Tid^?~~(et, y^\ast){:}\Telemlist~\text{)} \\ &&& \qquad
+     \text{(}~\text{elem}~~\Tid^?~~(et, y^\ast){:}\Telemlist_I~\text{)} \\ &&& \qquad
        \Rightarrow\quad \{ \ETYPE~et, \EINIT~y^\ast, \EMODE~\EPASSIVE \} \\ &&|&
-     \text{(}~\text{elem}~~\Tid^?~~x{:}\Ttableuse_I~~\text{(}~\text{offset}~~e{:}\Texpr_I~\text{)}~~(et, y^\ast){:}\Telemlist~\text{)} \\ &&& \qquad
+     \text{(}~\text{elem}~~\Tid^?~~x{:}\Ttableuse_I~~\text{(}~\text{offset}~~e{:}\Texpr_I~\text{)}~~(et, y^\ast){:}\Telemlist_I~\text{)} \\ &&& \qquad
        \Rightarrow\quad \{ \ETYPE~et, \EINIT~y^\ast, \EMODE~\EACTIVE~\{ \ETABLE~x, \EOFFSET~e \} \} \\ &&&
-     \text{(}~\text{elem}~~\Tid^?~~\text{declare}~~(et, y^\ast){:}\Telemlist~\text{)} \\ &&& \qquad
+     \text{(}~\text{elem}~~\Tid^?~~\text{declare}~~(et, y^\ast){:}\Telemlist_I~\text{)} \\ &&& \qquad
        \Rightarrow\quad \{ \ETYPE~et, \EINIT~y^\ast, \EMODE~\EDECLARATIVE \} \\
-   \production{element list} & \Telemlist &::=&
+   \production{element list} & \Telemlist_I &::=&
      t{:}\Treftype~~y^\ast{:}\Tvec(\Telemexpr_I) \qquad\Rightarrow\quad ( \ETYPE~t, \EINIT~y^\ast ) \\
-   \production{element expression} & \Telemexpr &::=&
-     \text{(}~\text{item}~~e{:}\Texpr~\text{)}
+   \production{element expression} & \Telemexpr_I &::=&
+     \text{(}~\text{item}~~e{:}\Texpr_I~\text{)}
        \quad\Rightarrow\quad e \\
    \production{table use} & \Ttableuse_I &::=&
      \text{(}~\text{table}~~x{:}\Ttableidx_I ~\text{)}
@@ -521,10 +523,10 @@ As an abbreviation, a single instruction may occur in place of the offset of an
 .. math::
    \begin{array}{llcll}
    \production{element offset} &
-     \Tinstr &\equiv&
+     \text{(}~\Tinstr~\text{)} &\equiv&
      \text{(}~\text{offset}~~\Tinstr~\text{)} \\
    \production{element item} &
-     \Tinstr &\equiv&
+     \text{(}~\Tinstr~\text{)} &\equiv&
      \text{(}~\text{item}~~\Tinstr~\text{)} \\
    \end{array}
 
@@ -594,7 +596,7 @@ As an abbreviation, a single instruction may occur in place of the offset of an
 .. math::
    \begin{array}{llcll}
    \production{data offset} &
-     \Tinstr &\equiv&
+     \text{(}~\Tinstr~\text{)} &\equiv&
      \text{(}~\text{offset}~~\Tinstr~\text{)}
    \end{array}
 
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index ab28b40a2..42b310ddc 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -714,7 +714,7 @@
 .. |Texportdesc| mathdef:: \xref{text/modules}{text-exportdesc}{\T{exportdesc}}
 .. |Telem| mathdef:: \xref{text/modules}{text-elem}{\T{elem}}
 .. |Telemlist| mathdef:: \xref{text/modules}{text-elemlist}{\T{elemlist}}
-.. |Telemexpr| mathdef:: \xref{text/modules}{text-elemexpr}{\X{elemexpr}}
+.. |Telemexpr| mathdef:: \xref{text/modules}{text-elemexpr}{\T{elemexpr}}
 .. |Ttableuse| mathdef:: \xref{text/modules}{text-tableuse}{\T{tableuse}}
 .. |Tcode| mathdef:: \xref{text/modules}{text-code}{\T{code}}
 .. |Tlocal| mathdef:: \xref{text/modules}{text-local}{\T{local}}
diff --git a/test/core/data.wast b/test/core/data.wast
index f7d1f09bc..4f339bed4 100644
--- a/test/core/data.wast
+++ b/test/core/data.wast
@@ -382,6 +382,14 @@
   "type mismatch"
 )
 
+(assert_invalid
+  (module
+    (memory 1)
+    (data (ref.null func))
+  )
+  "type mismatch"
+)
+
 (assert_invalid
   (module 
     (memory 1)
diff --git a/test/core/elem.wast b/test/core/elem.wast
index 19b5fe920..575ecef81 100644
--- a/test/core/elem.wast
+++ b/test/core/elem.wast
@@ -40,6 +40,7 @@
   (elem (i32.const 0) funcref (ref.func $f) (ref.null func))
   (elem (i32.const 0) func $f $f)
   (elem (i32.const 0) $f $f)
+  (elem (i32.const 0) funcref (item (ref.func $f)) (item (ref.null func)))
 
   (elem $a1 (table $t) (i32.const 0) funcref)
   (elem $a2 (table $t) (i32.const 0) funcref (ref.func $f) (ref.null func))
@@ -349,6 +350,14 @@
   "type mismatch"
 )
 
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (ref.null func))
+  )
+  "type mismatch"
+)
+
 (assert_invalid
   (module 
     (table 1 funcref)
@@ -418,7 +427,7 @@
 
 ;; Use of internal globals in constant expressions is not allowed in MVP.
 ;; (assert_invalid
-;;   (module (memory 1) (data (global.get $g)) (global $g (mut i32) (i32.const 0)))
+;;   (module (table 1 funcref) (elem (global.get $g)) (global $g i32 (i32.const 0)))
 ;;   "constant expression required"
 ;; )
 
@@ -448,6 +457,57 @@
    "constant expression required"
 )
 
+;; Invalid elements
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i32.const 0) funcref (ref.null extern))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i32.const 0) funcref (item (ref.null func) (ref.null func)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i32.const 0) funcref (i32.const 0))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i32.const 0) funcref (item (i32.const 0)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i32.const 0) funcref (item (call $f)))
+    (func $f (result funcref) (ref.null func))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i32.const 0) funcref (item (i32.add (i32.const 0) (i32.const 1))))
+  )
+  "constant expression required"
+)
+
 ;; Two elements target the same slot
 
 (module

From 6663b9e2234f34fc6a7efe46cf2cbffcffb68250 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@igalia.com>
Date: Mon, 10 May 2021 16:08:53 +0200
Subject: [PATCH 010/285] [spec] Remove obsolete note about multiple tables.

---
 document/core/syntax/modules.rst | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/document/core/syntax/modules.rst b/document/core/syntax/modules.rst
index f0973d814..8b15ea2db 100644
--- a/document/core/syntax/modules.rst
+++ b/document/core/syntax/modules.rst
@@ -182,12 +182,6 @@ Tables are referenced through :ref:`table indices <syntax-tableidx>`,
 starting with the smallest index not referencing a table :ref:`import <syntax-import>`.
 Most constructs implicitly reference table index :math:`0`.
 
-.. note::
-   In the current version of WebAssembly, at most one table may be defined or imported in a single module,
-   and *all* constructs implicitly reference this table :math:`0`.
-   This restriction may be lifted in future versions.
-
-
 .. index:: ! memory, memory index, memory type, limits, page size, data, import
    pair: abstract syntax; memory
 .. _syntax-mem:

From 361039b5e7a3402d28072093702c71f020b00800 Mon Sep 17 00:00:00 2001
From: jblebrun <jblebrun@gmail.com>
Date: Mon, 10 May 2021 12:18:33 -0700
Subject: [PATCH 011/285] [test] Revert accidental commenting-out of a test

---
 test/core/select.wast | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/core/select.wast b/test/core/select.wast
index b343bf93c..9c94326a5 100644
--- a/test/core/select.wast
+++ b/test/core/select.wast
@@ -315,7 +315,7 @@
 (assert_return (invoke "as-br_table-last" (i32.const 1)) (i32.const 2))
 
 (assert_return (invoke "as-call_indirect-first" (i32.const 0)) (i32.const 3))
-;;(assert_return (invoke "as-call_indirect-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-call_indirect-first" (i32.const 1)) (i32.const 2))
 (assert_return (invoke "as-call_indirect-mid" (i32.const 0)) (i32.const 1))
 (assert_return (invoke "as-call_indirect-mid" (i32.const 1)) (i32.const 1))
 (assert_trap (invoke "as-call_indirect-last" (i32.const 0)) "undefined element")

From a36e8510a7bc80abb3dfc1a947fdad83a742628c Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@igalia.com>
Date: Tue, 11 May 2021 12:53:24 +0200
Subject: [PATCH 012/285] [js-api] Fix links to the core specification.

The links were accidentally changed to point to the reference-types fork
when it was merged in 7fa2f20a6df4cf1c114582c8cb60f5bfcdbf1be1.
---
 document/js-api/index.bs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 1e4aa51d3..0e8a1e414 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -93,7 +93,7 @@ urlPrefix: https://tc39.github.io/ecma262/; spec: ECMASCRIPT
         text: BigInt; url: #sec-ecmascript-language-types-bigint-type
     type: abstract-op
         text: CreateMethodProperty; url: sec-createmethodproperty
-urlPrefix: https://webassembly.github.io/reference-types/core/; spec: WebAssembly; type: dfn
+urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: dfn
     url: valid/modules.html#valid-module
         text: valid
         text: WebAssembly module validation

From d97afb2ca20e484a6945e4b02d16e31eeef4b412 Mon Sep 17 00:00:00 2001
From: Jeffrey Yasskin <jyasskin@google.com>
Date: Tue, 11 May 2021 15:44:03 -0700
Subject: [PATCH 013/285] Fix the Editor metadata format

Names and affiliations are separated by a comma: https://tabatkins.github.io/bikeshed/#metadata-editor
---
 document/js-api/index.bs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 0e8a1e414..14141406c 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -6,7 +6,7 @@ Status: ED
 Level: 1
 TR: https://www.w3.org/TR/wasm-js-api-1/
 ED: https://webassembly.github.io/spec/js-api/
-Editor: Ms2ger (Igalia)
+Editor: Ms2ger, Igalia
 Repository: WebAssembly/spec
 Markup Shorthands: css no, markdown yes
 Abstract: This document provides an explicit JavaScript API for interacting with WebAssembly.

From 6f5a5af53e333d8c423f4411efbc8c00d3c59a83 Mon Sep 17 00:00:00 2001
From: Jeffrey Yasskin <jyasskin@google.com>
Date: Wed, 12 May 2021 09:05:51 -0700
Subject: [PATCH 014/285] Fix the Editor metadata format

Same as #1325
---
 document/web-api/index.bs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index 3cc610820..d5999b5fc 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -6,7 +6,7 @@ Status: ED
 Level: 1
 TR: https://www.w3.org/TR/wasm-web-api-1/
 ED: https://webassembly.github.io/spec/web-api/
-Editor: Ms2ger (Igalia)
+Editor: Ms2ger, Igalia
 Repository: WebAssembly/spec
 Abstract: This document describes the integration of WebAssembly with the broader web platform.
 Markup Shorthands: css no, markdown yes

From c681917a0b87df6ce84a8bb9265eded93ecf29c3 Mon Sep 17 00:00:00 2001
From: Alec Theriault <alec.theriault@gmail.com>
Date: Thu, 13 May 2021 04:14:21 -0700
Subject: [PATCH 015/285] Proper markup for ref.func instruction

---
 document/core/syntax/modules.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/syntax/modules.rst b/document/core/syntax/modules.rst
index 8b15ea2db..189d41d0d 100644
--- a/document/core/syntax/modules.rst
+++ b/document/core/syntax/modules.rst
@@ -256,7 +256,7 @@ Each element segment defines an :ref:`reference type <syntax-reftype>` and a cor
 Element segments have a mode that identifies them as either *passive*, *active*, or *declarative*.
 A passive element segment's elements can be copied to a table using the |TABLEINIT| instruction.
 An active element segment copies its elements into a table during :ref:`instantiation <exec-instantiation>`, as specified by a :ref:`table index <syntax-tableidx>` and a :ref:`constant <valid-constant>` :ref:`expression <syntax-expr>` defining an offset into that table.
-A declarative element segment is not available at runtime but merely serves to forward-declare references that are formed in code with instructions like :math:`REFFUNC`.
+A declarative element segment is not available at runtime but merely serves to forward-declare references that are formed in code with instructions like :math:`\REFFUNC`.
 
 .. math::
    \begin{array}{llll}

From 8c5432fe4c1928628cb4d4aa7ad7a5683ca0c859 Mon Sep 17 00:00:00 2001
From: theduke <a.github@omega-id.com>
Date: Mon, 17 May 2021 06:15:09 +0000
Subject: [PATCH 016/285] [spec] Fix grammar typo (#1328)

---
 document/core/syntax/modules.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/syntax/modules.rst b/document/core/syntax/modules.rst
index 189d41d0d..cfd8935aa 100644
--- a/document/core/syntax/modules.rst
+++ b/document/core/syntax/modules.rst
@@ -251,7 +251,7 @@ Element Segments
 The initial contents of a table is uninitialized. *Element segments* can be used to initialize a subrange of a table from a static :ref:`vector <syntax-vec>` of elements.
 
 The |MELEMS| component of a module defines a vector of element segments.
-Each element segment defines an :ref:`reference type <syntax-reftype>` and a corresponding list of :ref:`constant <valid-constant>` element :ref:`expressions <syntax-expr>`.
+Each element segment defines a :ref:`reference type <syntax-reftype>` and a corresponding list of :ref:`constant <valid-constant>` element :ref:`expressions <syntax-expr>`.
 
 Element segments have a mode that identifies them as either *passive*, *active*, or *declarative*.
 A passive element segment's elements can be copied to a table using the |TABLEINIT| instruction.

From 25d26e7d46af4d4d33579459bb5435abb4d168b2 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@dfinity.org>
Date: Wed, 19 May 2021 14:03:55 +0200
Subject: [PATCH 017/285] Add br_on_non_null (#48)

---
 document/core/appendix/algorithm.rst      |  7 +--
 interpreter/binary/decode.ml              |  2 +
 interpreter/binary/encode.ml              |  1 +
 interpreter/exec/eval.ml                  |  8 +++
 interpreter/syntax/ast.ml                 |  1 +
 interpreter/syntax/free.ml                |  2 +-
 interpreter/syntax/operators.ml           |  1 +
 interpreter/text/arrange.ml               |  1 +
 interpreter/text/lexer.mll                |  1 +
 interpreter/text/parser.mly               |  3 +-
 interpreter/valid/valid.ml                | 12 ++++
 proposals/function-references/Overview.md | 11 +++-
 test/core/br_on_non_null.wast             | 72 +++++++++++++++++++++++
 test/core/br_on_null.wast                 | 15 +----
 14 files changed, 117 insertions(+), 20 deletions(-)
 create mode 100644 test/core/br_on_non_null.wast

diff --git a/document/core/appendix/algorithm.rst b/document/core/appendix/algorithm.rst
index 1abe0b322..8bcf42039 100644
--- a/document/core/appendix/algorithm.rst
+++ b/document/core/appendix/algorithm.rst
@@ -290,10 +290,9 @@ Other instructions are checked in a similar manner.
          let rt = pop_ref()
          if (rt.heap =/= Bot)
            error_if(not is_def(rt.heap))
-           let t1*->t2* = lookup_def(rt.heap.def)  // TODO
-           pop_vals(t1*)
-           push_vals(t2*)
-
+           let ft = lookup_func_type(rt.heap.idx)  // TODO
+           pop_vals(ft.params)
+           push_vals(ft.results)
 
 .. note::
    It is an invariant under the current WebAssembly instruction set that an operand of :code:`Unknown` type is never duplicated on the stack.
diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 7f23f5a6b..646d8a437 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -500,6 +500,8 @@ let rec instr s =
   | 0xd2 -> ref_func (at var s)
   | 0xd3 -> ref_as_non_null
   | 0xd4 -> br_on_null (at var s)
+  | 0xd5 as b -> illegal s pos b
+  | 0xd6 -> br_on_non_null (at var s)
 
   | 0xfc as b ->
     (match vu32 s with
diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index 36725f7d2..567dcc331 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -185,6 +185,7 @@ struct
     | BrIf x -> op 0x0d; var x
     | BrTable (xs, x) -> op 0x0e; vec var xs; var x
     | BrOnNull x -> op 0xd4; var x
+    | BrOnNonNull x -> op 0xd6; var x
     | Return -> op 0x0f
     | Call x -> op 0x10; var x
     | CallRef -> op 0x14
diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index 6c322e4cb..9737e71e6 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -217,6 +217,14 @@ let rec step (c : config) : config =
           Ref r :: vs', []
         )
 
+      | BrOnNonNull x, Ref r :: vs' ->
+        (match r with
+        | NullRef _ ->
+          vs', []
+        | _ ->
+          Ref r :: vs', [Plain (Br x) @@ e.at]
+        )
+
       | Return, vs ->
         [], [Returning vs @@ e.at]
 
diff --git a/interpreter/syntax/ast.ml b/interpreter/syntax/ast.ml
index 108315489..d9ad52edc 100644
--- a/interpreter/syntax/ast.ml
+++ b/interpreter/syntax/ast.ml
@@ -88,6 +88,7 @@ and instr' =
   | BrIf of idx                       (* conditional break *)
   | BrTable of idx list * idx         (* indexed break *)
   | BrOnNull of idx                   (* break on null *)
+  | BrOnNonNull of idx                (* break on non-null *)
   | Return                            (* break from function body *)
   | Call of idx                       (* call function *)
   | CallRef                           (* call function through reference *)
diff --git a/interpreter/syntax/free.ml b/interpreter/syntax/free.ml
index 36632c784..a8e765976 100644
--- a/interpreter/syntax/free.ml
+++ b/interpreter/syntax/free.ml
@@ -106,7 +106,7 @@ let rec instr (e : instr) =
   | Let (bt, ts, es) ->
     let free = block_type bt ++ block es in
     {free with locals = Lib.Fun.repeat (List.length ts) shift free.locals}
-  | Br x | BrIf x | BrOnNull x -> labels (idx x)
+  | Br x | BrIf x | BrOnNull x | BrOnNonNull x -> labels (idx x)
   | BrTable (xs, x) -> list (fun x -> labels (idx x)) (x::xs)
   | Return | CallRef | ReturnCallRef -> empty
   | Call x -> funcs (idx x)
diff --git a/interpreter/syntax/operators.ml b/interpreter/syntax/operators.ml
index b75e7b614..ea71e3fc5 100644
--- a/interpreter/syntax/operators.ml
+++ b/interpreter/syntax/operators.ml
@@ -25,6 +25,7 @@ let br x = Br x
 let br_if x = BrIf x
 let br_table xs x = BrTable (xs, x)
 let br_on_null x = BrOnNull x
+let br_on_non_null x = BrOnNonNull x
 
 let return = Return
 let call x = Call x
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index 87f1f4615..a858fcd03 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -250,6 +250,7 @@ let rec instr e =
     | BrTable (xs, x) ->
       "br_table " ^ String.concat " " (list var (xs @ [x])), []
     | BrOnNull x -> "br_on_null " ^ var x, []
+    | BrOnNonNull x -> "br_on_non_null " ^ var x, []
     | Return -> "return", []
     | Call x -> "call " ^ var x, []
     | CallRef -> "call_ref", []
diff --git a/interpreter/text/lexer.mll b/interpreter/text/lexer.mll
index e2895df31..0b511723d 100644
--- a/interpreter/text/lexer.mll
+++ b/interpreter/text/lexer.mll
@@ -197,6 +197,7 @@ rule token = parse
   | "br_if" { BR_IF }
   | "br_table" { BR_TABLE }
   | "br_on_null" { BR_ON_NULL }
+  | "br_on_non_null" { BR_ON_NON_NULL }
   | "return" { RETURN }
   | "if" { IF }
   | "then" { THEN }
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index c06e24ece..d86750a13 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -210,7 +210,7 @@ let inline_func_type_explicit (c : context) x ft at =
 %token NUM_TYPE FUNCREF EXTERNREF REF EXTERN NULL MUT
 %token UNREACHABLE NOP DROP SELECT
 %token BLOCK END IF THEN ELSE LOOP LET
-%token BR BR_IF BR_TABLE BR_ON_NULL
+%token BR BR_IF BR_TABLE BR_ON_NULL BR_ON_NON_NULL
 %token CALL CALL_REF CALL_INDIRECT RETURN RETURN_CALL_REF FUNC_BIND
 %token LOCAL_GET LOCAL_SET LOCAL_TEE GLOBAL_GET GLOBAL_SET
 %token TABLE_GET TABLE_SET
@@ -398,6 +398,7 @@ plain_instr :
     { fun c -> let xs, x = Lib.List.split_last ($2 c label :: $3 c label) in
       br_table xs x }
   | BR_ON_NULL var { fun c -> br_on_null ($2 c label) }
+  | BR_ON_NON_NULL var { fun c -> br_on_non_null ($2 c label) }
   | RETURN { fun c -> return }
   | CALL var { fun c -> call ($2 c func) }
   | CALL_REF { fun c -> call_ref }
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index 06b65c877..f40b46eae 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -353,6 +353,18 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : op_type
     (label c x @ [RefType (Nullable, t)]) -->
       (label c x @ [RefType (NonNullable, t)])
 
+  | BrOnNonNull x ->
+    let (_, ht) as rt = peek_ref 0 s e.at in
+    let t' = RefType (NonNullable, ht) in
+    require (label c x <> []) e.at
+      ("type mismatch: instruction requires type " ^ string_of_value_type t' ^
+       " but label has " ^ string_of_result_type (label c x));
+    let ts0, t = Lib.List.split_last (label c x) in
+    require (match_value_type c.types [] t' t) e.at
+      ("type mismatch: instruction requires type " ^ string_of_value_type t' ^
+       " but label has " ^ string_of_result_type (label c x));
+    (ts0 @ [RefType rt]) --> ts0
+
   | Return ->
     c.results -->... []
 
diff --git a/proposals/function-references/Overview.md b/proposals/function-references/Overview.md
index 4d9ef64ff..7d08ed54d 100644
--- a/proposals/function-references/Overview.md
+++ b/proposals/function-references/Overview.md
@@ -36,7 +36,7 @@ Note: In a Wasm engine, function references (whether first-class or as table ent
 
 * Add an instruction `ref.as_non_null` that converts a nullable reference to a non-nullable one or traps if null
 
-* Add an instruction `br_on_null` that converts a nullable reference to a non-nullable one or branches if null
+* Add an instruction `br_on_null` that converts a nullable reference to a non-nullable one or branches if null, as well as the inverted `br_on_non_null`
 
 * Add an instruction `call_ref` for calling a function through a `ref $t`
 
@@ -228,12 +228,18 @@ The following rules, now defined in terms of heap types, replace and extend the
     - iff `ht ok`
   - traps on `null`
 
-* `br_on_null $l` checks for null and branches
+* `br_on_null $l` checks for null and branches if present
   - `br_on_null $l : [t* (ref null ht)] -> [t* (ref ht)]`
     - iff `$l : [t*]`
     - and `ht ok`
   - branches to `$l` on `null`, otherwise returns operand as non-null
 
+* `br_on_non_null $l` checks for null and branches if not present
+  - `br_on_non_null $l : [t* (ref null ht)] -> [t*]`
+    - iff `$l : [t* (ref ht)]`
+    - and `ht ok`
+  - branches to `$l` if operand is not `null`, passing the operand itself under non-null type (along with potential additional operands)
+
 * Note: `ref.is_null` already exists via the [reference types proposal](https://github.com/WebAssembly/reference-types)
 
 
@@ -299,6 +305,7 @@ The opcode for heap types is encoded as an `s33`.
 | 0x17   | `let <bt> <locals>`      | `bt : blocktype, locals : (as in functions)` |
 | 0xd3   | `ref.as_non_null`        |            |
 | 0xd4   | `br_on_null $l`          | `$l : u32` |
+| 0xd6   | `br_on_non_null $l`      | `$l : u32` |
 
 ### Tables
 
diff --git a/test/core/br_on_non_null.wast b/test/core/br_on_non_null.wast
new file mode 100644
index 000000000..145b4f832
--- /dev/null
+++ b/test/core/br_on_non_null.wast
@@ -0,0 +1,72 @@
+(module
+  (type $t (func (result i32)))
+
+  (func $nn (param $r (ref $t)) (result i32)
+    (call_ref
+      (block $l (result (ref $t))
+        (br_on_non_null $l (local.get $r))
+        (return (i32.const -1))
+      )
+    )
+  )
+  (func $n (param $r (ref null $t)) (result i32)
+    (call_ref
+      (block $l (result (ref $t))
+        (br_on_non_null $l (local.get $r))
+        (return (i32.const -1))
+      )
+    )
+  )
+
+  (elem func $f)
+  (func $f (result i32) (i32.const 7))
+
+  (func (export "nullable-null") (result i32) (call $n (ref.null $t)))
+  (func (export "nonnullable-f") (result i32) (call $nn (ref.func $f)))
+  (func (export "nullable-f") (result i32) (call $n (ref.func $f)))
+
+  (func (export "unreachable") (result i32)
+    (block $l
+      (return (call_ref (br_on_null $l (unreachable))))
+    )
+    (i32.const -1)
+  )
+)
+
+(assert_trap (invoke "unreachable") "unreachable")
+
+(assert_return (invoke "nullable-null") (i32.const -1))
+(assert_return (invoke "nonnullable-f") (i32.const 7))
+(assert_return (invoke "nullable-f") (i32.const 7))
+
+(module
+  (type $t (func))
+  (func (param $r (ref null $t)) (drop (block (result (ref $t)) (br_on_non_null 0 (local.get $r)) (unreachable))))
+  (func (param $r (ref null func)) (drop (block (result (ref func)) (br_on_non_null 0 (local.get $r)) (unreachable))))
+  (func (param $r (ref null extern)) (drop (block (result (ref extern)) (br_on_non_null 0 (local.get $r)) (unreachable))))
+)
+
+
+(module
+  (type $t (func (param i32) (result i32)))
+  (elem func $f)
+  (func $f (param i32) (result i32) (i32.mul (local.get 0) (local.get 0)))
+
+  (func $a (param $n i32) (param $r (ref null $t)) (result i32)
+    (call_ref
+      (block $l (result i32 (ref $t))
+        (return (br_on_non_null $l (local.get $n) (local.get $r)))
+      )
+    )
+  )
+
+  (func (export "args-null") (param $n i32) (result i32)
+    (call $a (local.get $n) (ref.null $t))
+  )
+  (func (export "args-f") (param $n i32) (result i32)
+    (call $a (local.get $n) (ref.func $f))
+  )
+)
+
+(assert_return (invoke "args-null" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "args-f" (i32.const 3)) (i32.const 9))
diff --git a/test/core/br_on_null.wast b/test/core/br_on_null.wast
index 3bae85000..ec3471cce 100644
--- a/test/core/br_on_null.wast
+++ b/test/core/br_on_null.wast
@@ -35,20 +35,11 @@
 (assert_return (invoke "nonnullable-f") (i32.const 7))
 (assert_return (invoke "nullable-f") (i32.const 7))
 
-(assert_invalid
-  (module
-    (type $t (func (result i32)))
-    (func $g (param $r (ref $t)) (drop (br_on_null 0 (local.get $r))))
-    (func (call $g (ref.null $t)))
-  )
-  "type mismatch"
-)
-
 (module
   (type $t (func))
-  (func (param $r (ref $t)) (drop (br_on_null 0 (local.get $r))))
-  (func (param $r (ref func)) (drop (br_on_null 0 (local.get $r))))
-  (func (param $r (ref extern)) (drop (br_on_null 0 (local.get $r))))
+  (func (param $r (ref null $t)) (drop (br_on_null 0 (local.get $r))))
+  (func (param $r (ref null func)) (drop (br_on_null 0 (local.get $r))))
+  (func (param $r (ref null extern)) (drop (br_on_null 0 (local.get $r))))
 )
 
 

From 484bb2b5b8a9cf5f774310bcd28e11186aa1705e Mon Sep 17 00:00:00 2001
From: "Ben L. Titzer" <ben.titzer@gmail.com>
Date: Tue, 1 Jun 2021 01:36:31 -0500
Subject: [PATCH 018/285] Factor unreachability tests out of select and
 br_table (#1329)

---
 test/core/br_table.wast          | 25 ----------
 test/core/select.wast            | 84 --------------------------------
 test/core/unreached-invalid.wast | 55 +++++++++++++++++++++
 test/core/unreached-valid.wast   | 62 +++++++++++++++++++++++
 4 files changed, 117 insertions(+), 109 deletions(-)
 create mode 100644 test/core/unreached-valid.wast

diff --git a/test/core/br_table.wast b/test/core/br_table.wast
index 734593d6c..5c1aa50c9 100644
--- a/test/core/br_table.wast
+++ b/test/core/br_table.wast
@@ -1251,17 +1251,6 @@
     )
   )
 
-  (func (export "meet-bottom")
-    (block (result f64)
-      (block (result f32)
-        (unreachable)
-        (br_table 0 1 1 (i32.const 1))
-      )
-      (drop)
-      (f64.const 0)
-    )
-    (drop)
-  )
 )
 
 (assert_return (invoke "type-i32"))
@@ -1612,20 +1601,6 @@
 )
 
 
-(assert_invalid
-  (module (func $meet-bottom (param i32) (result externref)
-    (block $l1 (result externref)
-      (drop
-        (block $l2 (result i32)
-          (br_table $l2 $l1 $l2 (ref.null extern) (local.get 0))
-        )
-      )
-      (ref.null extern)
-    )
-  ))
-  "type mismatch"
-)
-
 (assert_invalid
   (module (func $unbound-label
     (block (br_table 2 1 (i32.const 1)))
diff --git a/test/core/select.wast b/test/core/select.wast
index 9c94326a5..046e6fe2c 100644
--- a/test/core/select.wast
+++ b/test/core/select.wast
@@ -36,31 +36,6 @@
     (select (result externref) (local.get 0) (local.get 1) (local.get 2))
   )
 
-  ;; Check that both sides of the select are evaluated
-  (func (export "select-trap-left") (param $cond i32) (result i32)
-    (select (unreachable) (i32.const 0) (local.get $cond))
-  )
-  (func (export "select-trap-right") (param $cond i32) (result i32)
-    (select (i32.const 0) (unreachable) (local.get $cond))
-  )
-
-  (func (export "select-unreached")
-    (unreachable) (select)
-    (unreachable) (i32.const 0) (select)
-    (unreachable) (i32.const 0) (i32.const 0) (select)
-    (unreachable) (i32.const 0) (i32.const 0) (i32.const 0) (select)
-    (unreachable) (f32.const 0) (i32.const 0) (select)
-    (unreachable)
-  )
-
-  (func (export "select_unreached_result_1") (result i32)
-    (unreachable) (i32.add (select))
-  )
-
-  (func (export "select_unreached_result_2") (result i64)
-    (unreachable) (i64.add (select (i64.const 0) (i32.const 0)))
-  )
-
   ;; As the argument of control constructs and instructions
 
   (func (export "as-select-first") (param i32) (result i32)
@@ -203,19 +178,6 @@
       (i32.wrap_i64 (select (i64.const 1) (i64.const 0) (local.get 0)))
     )
   )
-
-  (func (export "unreachable-num")
-    (unreachable)
-    (select)
-    (i32.eqz)
-    (drop)
-  )
-  (func (export "unreachable-ref")
-    (unreachable)
-    (select)
-    (ref.is_null)
-    (drop)
-  )
 )
 
 (assert_return (invoke "select-i32" (i32.const 1) (i32.const 2) (i32.const 1)) (i32.const 1))
@@ -278,11 +240,6 @@
 (assert_return (invoke "select-f64-t" (f64.const 2) (f64.const nan) (i32.const 0)) (f64.const nan))
 (assert_return (invoke "select-f64-t" (f64.const 2) (f64.const nan:0x20304) (i32.const 0)) (f64.const nan:0x20304))
 
-(assert_trap (invoke "select-trap-left" (i32.const 1)) "unreachable")
-(assert_trap (invoke "select-trap-left" (i32.const 0)) "unreachable")
-(assert_trap (invoke "select-trap-right" (i32.const 1)) "unreachable")
-(assert_trap (invoke "select-trap-right" (i32.const 0)) "unreachable")
-
 (assert_return (invoke "as-select-first" (i32.const 0)) (i32.const 1))
 (assert_return (invoke "as-select-first" (i32.const 1)) (i32.const 0))
 (assert_return (invoke "as-select-mid" (i32.const 0)) (i32.const 2))
@@ -555,44 +512,3 @@
   "type mismatch"
 )
 
-;; Validation after unreachable
-
-;; The first two operands should have the same type as each other
-(assert_invalid
-  (module (func (unreachable) (select (i32.const 1) (i64.const 1) (i32.const 1)) (drop)))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (func (unreachable) (select (i64.const 1) (i32.const 1) (i32.const 1)) (drop)))
-  "type mismatch"
-)
-
-;; Third operand must be i32
-(assert_invalid
-  (module (func (unreachable) (select (i32.const 1) (i32.const 1) (i64.const 1)) (drop)))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (func (unreachable) (select (i32.const 1) (i64.const 1)) (drop)))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (func (unreachable) (select (i64.const 1)) (drop)))
-  "type mismatch"
-)
-
-;; Result of select has type of first two operands (type of second operand when first one is omitted)
-(assert_invalid
-  (module (func (result i32) (unreachable) (select (i64.const 1) (i32.const 1))))
-  "type mismatch"
-)
-
-;; select always has non-empty result
-(assert_invalid
-  (module (func (unreachable) (select)))
-  "type mismatch"
-)
-
diff --git a/test/core/unreached-invalid.wast b/test/core/unreached-invalid.wast
index 3ddd77385..5889ba114 100644
--- a/test/core/unreached-invalid.wast
+++ b/test/core/unreached-invalid.wast
@@ -693,3 +693,58 @@
   )
  "type mismatch"
 )
+
+;; The first two operands should have the same type as each other
+(assert_invalid
+  (module (func (unreachable) (select (i32.const 1) (i64.const 1) (i32.const 1)) (drop)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func (unreachable) (select (i64.const 1) (i32.const 1) (i32.const 1)) (drop)))
+  "type mismatch"
+)
+
+;; Third operand must be i32
+(assert_invalid
+  (module (func (unreachable) (select (i32.const 1) (i32.const 1) (i64.const 1)) (drop)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func (unreachable) (select (i32.const 1) (i64.const 1)) (drop)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func (unreachable) (select (i64.const 1)) (drop)))
+  "type mismatch"
+)
+
+;; Result of select has type of first two operands (type of second operand when first one is omitted)
+(assert_invalid
+  (module (func (result i32) (unreachable) (select (i64.const 1) (i32.const 1))))
+  "type mismatch"
+)
+
+
+;; select always has non-empty result
+(assert_invalid
+  (module (func (unreachable) (select)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $meet-bottom (param i32) (result externref)
+    (block $l1 (result externref)
+      (drop
+        (block $l2 (result i32)
+          (br_table $l2 $l1 $l2 (ref.null extern) (local.get 0))
+        )
+      )
+      (ref.null extern)
+    )
+  ))
+  "type mismatch"
+)
+
diff --git a/test/core/unreached-valid.wast b/test/core/unreached-valid.wast
new file mode 100644
index 000000000..00252171a
--- /dev/null
+++ b/test/core/unreached-valid.wast
@@ -0,0 +1,62 @@
+(module
+
+  ;; Check that both sides of the select are evaluated
+  (func (export "select-trap-left") (param $cond i32) (result i32)
+    (select (unreachable) (i32.const 0) (local.get $cond))
+  )
+  (func (export "select-trap-right") (param $cond i32) (result i32)
+    (select (i32.const 0) (unreachable) (local.get $cond))
+  )
+
+  (func (export "select-unreached")
+    (unreachable) (select)
+    (unreachable) (i32.const 0) (select)
+    (unreachable) (i32.const 0) (i32.const 0) (select)
+    (unreachable) (i32.const 0) (i32.const 0) (i32.const 0) (select)
+    (unreachable) (f32.const 0) (i32.const 0) (select)
+    (unreachable)
+  )
+
+  (func (export "select_unreached_result_1") (result i32)
+    (unreachable) (i32.add (select))
+  )
+
+  (func (export "select_unreached_result_2") (result i64)
+    (unreachable) (i64.add (select (i64.const 0) (i32.const 0)))
+  )
+
+  (func (export "unreachable-num")
+    (unreachable)
+    (select)
+    (i32.eqz)
+    (drop)
+  )
+  (func (export "unreachable-ref")
+    (unreachable)
+    (select)
+    (ref.is_null)
+    (drop)
+  )
+)
+
+(assert_trap (invoke "select-trap-left" (i32.const 1)) "unreachable")
+(assert_trap (invoke "select-trap-left" (i32.const 0)) "unreachable")
+(assert_trap (invoke "select-trap-right" (i32.const 1)) "unreachable")
+(assert_trap (invoke "select-trap-right" (i32.const 0)) "unreachable")
+
+;; Validation after unreachable
+
+(module
+  (func (export "meet-bottom")
+    (block (result f64)
+      (block (result f32)
+        (unreachable)
+        (br_table 0 1 1 (i32.const 1))
+      )
+      (drop)
+      (f64.const 0)
+    )
+    (drop)
+  )
+)
+

From 662232701afa7bef3c5b1e77362f2bab6173fca4 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@dfinity.org>
Date: Tue, 8 Jun 2021 11:56:13 +0200
Subject: [PATCH 019/285] [spec] Fix type typo (#1333)

---
 document/core/appendix/gen-index-instructions.py | 2 +-
 document/core/appendix/index-instructions.rst    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/appendix/gen-index-instructions.py b/document/core/appendix/gen-index-instructions.py
index c4e971ff4..6191a07b8 100755
--- a/document/core/appendix/gen-index-instructions.py
+++ b/document/core/appendix/gen-index-instructions.py
@@ -329,7 +329,7 @@ def Instruction(name, opcode, type=None, validation=None, execution=None, operat
     Instruction(r'\ELEMDROP~x', r'\hex{FC}~\hex{0D}', r'[] \to []', r'valid-elem.drop', r'exec-elem.drop'),
     Instruction(r'\TABLECOPY~x~y', r'\hex{FC}~\hex{0E}', r'[\I32~\I32~\I32] \to []', r'valid-table.copy', r'exec-table.copy'),
     Instruction(r'\TABLEGROW~x', r'\hex{FC}~\hex{0F}', r'[t~\I32] \to []', r'valid-table.grow', r'exec-table.grow'),
-    Instruction(r'\TABLESIZE~x', r'\hex{FC}~\hex{10}', r'[] \to []', r'valid-table.size', r'exec-table.size'),
+    Instruction(r'\TABLESIZE~x', r'\hex{FC}~\hex{10}', r'[] \to [\I32]', r'valid-table.size', r'exec-table.size'),
     Instruction(r'\TABLEFILL~x', r'\hex{FC}~\hex{11}', r'[\I32~t~\I32] \to []', r'valid-table.fill', r'exec-table.fill'),
 ]
 
diff --git a/document/core/appendix/index-instructions.rst b/document/core/appendix/index-instructions.rst
index e3b3d0bd9..55bf8fb98 100644
--- a/document/core/appendix/index-instructions.rst
+++ b/document/core/appendix/index-instructions.rst
@@ -277,6 +277,6 @@ Instruction                                Binary Opcode              Type
 :math:`\ELEMDROP~x`                        :math:`\hex{FC}~\hex{0D}`  :math:`[] \to []`                              :ref:`validation <valid-elem.drop>`      :ref:`execution <exec-elem.drop>`                              
 :math:`\TABLECOPY~x~y`                     :math:`\hex{FC}~\hex{0E}`  :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-table.copy>`     :ref:`execution <exec-table.copy>`                             
 :math:`\TABLEGROW~x`                       :math:`\hex{FC}~\hex{0F}`  :math:`[t~\I32] \to []`                        :ref:`validation <valid-table.grow>`     :ref:`execution <exec-table.grow>`                             
-:math:`\TABLESIZE~x`                       :math:`\hex{FC}~\hex{10}`  :math:`[] \to []`                              :ref:`validation <valid-table.size>`     :ref:`execution <exec-table.size>`                             
+:math:`\TABLESIZE~x`                       :math:`\hex{FC}~\hex{10}`  :math:`[] \to [\I32]`                          :ref:`validation <valid-table.size>`     :ref:`execution <exec-table.size>`                             
 :math:`\TABLEFILL~x`                       :math:`\hex{FC}~\hex{11}`  :math:`[\I32~t~\I32] \to []`                   :ref:`validation <valid-table.fill>`     :ref:`execution <exec-table.fill>`                             
 =========================================  =========================  =============================================  =======================================  ===============================================================

From f9770eb75117cac0c878feaa5eaf4a4d9dda61f5 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@igalia.com>
Date: Wed, 23 Jun 2021 14:49:28 +0200
Subject: [PATCH 020/285] [js-api] Fix link to HTML.

Although it was un-exported from HTML recently, this is one of the very few specs which has legitimate reason to link to it.
---
 document/js-api/index.bs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 14141406c..ff36c930c 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -1047,7 +1047,7 @@ Note: Exported Functions do not have a \[[Construct]] method and thus it is not
   To <dfn>create a host function</dfn> from the JavaScript object |func| and type |functype|, perform the following steps:
 
     1. Assert: [=IsCallable=](|func|).
-    1. Let |stored settings| be the [=incumbent settings object=].
+    1. Let |stored settings| be the <a spec=HTML>incumbent settings object</a>.
     1. Let |hostfunc| be a [=host function=] which performs the following steps when called with arguments |arguments|:
         1. Let |realm| be |func|'s [=associated Realm=].
         1. Let |relevant settings| be |realm|'s [=Realm/settings object=].

From 96ae61e1ff6ebe0e51e1e4faeb64e681067e8a53 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 24 Jun 2021 20:36:56 +0200
Subject: [PATCH 021/285] [spec] Add concrete ref types and surrounding
 semantics

---
 document/core/appendix/index-types.rst |   9 +-
 document/core/appendix/properties.rst  |   4 +-
 document/core/binary/instructions.rst  |   2 +-
 document/core/binary/types.rst         |  30 ++-
 document/core/exec/runtime.rst         |   1 +
 document/core/syntax/instructions.rst  |   2 +-
 document/core/syntax/modules.rst       |   2 +-
 document/core/syntax/types.rst         |  36 ++-
 document/core/text/instructions.rst    |  14 +-
 document/core/text/modules.rst         |  26 +--
 document/core/text/types.rst           |  70 ++++--
 document/core/util/macros.def          |  25 ++-
 document/core/valid/instructions.rst   |  38 +++-
 document/core/valid/modules.rst        |  76 +++++--
 document/core/valid/types.rst          | 294 ++++++++++++++++++++++---
 interpreter/binary/decode.ml           |  16 +-
 interpreter/binary/encode.ml           |   8 +-
 17 files changed, 514 insertions(+), 139 deletions(-)

diff --git a/document/core/appendix/index-types.rst b/document/core/appendix/index-types.rst
index fd38fe205..90a411934 100644
--- a/document/core/appendix/index-types.rst
+++ b/document/core/appendix/index-types.rst
@@ -13,9 +13,12 @@ Category                                  Constructor
 :ref:`Number type <syntax-numtype>`       |F32|                                        :math:`\hex{7D}` (-3 as |Bs7|)
 :ref:`Number type <syntax-numtype>`       |F64|                                        :math:`\hex{7C}` (-4 as |Bs7|)
 (reserved)                                                                             :math:`\hex{7B}` .. :math:`\hex{71}`
-:ref:`Reference type <syntax-reftype>`    |FUNCREF|                                    :math:`\hex{70}` (-16 as |Bs7|)
-:ref:`Reference type <syntax-reftype>`    |EXTERNREF|                                  :math:`\hex{6F}` (-17 as |Bs7|)
-(reserved)                                                                             :math:`\hex{6E}` .. :math:`\hex{61}`
+:ref:`Heap type <syntax-heaptype>`        |FUNC|                                       :math:`\hex{70}` (-16 as |Bs7|)
+:ref:`Heap type <syntax-heaptype>`        |EXTERN|                                     :math:`\hex{6F}` (-17 as |Bs7|)
+(reserved)                                                                             :math:`\hex{6E}` .. :math:`\hex{6D}`
+:ref:`Reference type <syntax-reftype>`    |REF| |NULL|                                 :math:`\hex{6C}` (-20 as |Bs7|)
+:ref:`Reference type <syntax-reftype>`    |REF|                                        :math:`\hex{6B}` (-21 as |Bs7|)
+(reserved)                                                                             :math:`\hex{6A}` .. :math:`\hex{61}`
 :ref:`Function type <syntax-functype>`    :math:`[\valtype^\ast] \to [\valtype^\ast]`  :math:`\hex{60}` (-32 as |Bs7|)
 (reserved)                                                                             :math:`\hex{5F}` .. :math:`\hex{41}`
 :ref:`Result type <syntax-resulttype>`    :math:`[\epsilon]`                           :math:`\hex{40}` (-64 as |Bs7|)
diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index cf1fd0fbc..749616b92 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -4,6 +4,8 @@
 Soundness
 ---------
 
+.. todo:: need to ensure wf of nondet types and operate wrt semantic types
+
 The :ref:`type system <type-system>` of WebAssembly is *sound*, implying both *type safety* and *memory safety* with respect to the WebAssembly semantics. For example:
 
 * All types declared and derived during validation are respected at run time;
@@ -50,7 +52,7 @@ Results
 :ref:`Results <syntax-result>` :math:`\TRAP`
 ............................................
 
-* The result is valid with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`, for any sequence :math:`t^\ast` of :ref:`value types <syntax-valtype>`.
+* The result is valid with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`, for any sequence :math:`t^\ast` of :ref:`valid <valid-valtype>` :ref:`value types <syntax-valtype>`.
 
 .. math::
    \frac{
diff --git a/document/core/binary/instructions.rst b/document/core/binary/instructions.rst
index 3529aab92..9da4e1889 100644
--- a/document/core/binary/instructions.rst
+++ b/document/core/binary/instructions.rst
@@ -87,7 +87,7 @@ Reference Instructions
 .. math::
    \begin{array}{llclll}
    \production{instruction} & \Binstr &::=& \dots \\ &&|&
-     \hex{D0}~~t{:}\Breftype &\Rightarrow& \REFNULL~t \\ &&|&
+     \hex{D0}~~t{:}\Bheaptype &\Rightarrow& \REFNULL~t \\ &&|&
      \hex{D1} &\Rightarrow& \REFISNULL \\ &&|&
      \hex{D2}~~x{:}\Bfuncidx &\Rightarrow& \REFFUNC~x \\
    \end{array}
diff --git a/document/core/binary/types.rst b/document/core/binary/types.rst
index 85ee3250d..67e378aec 100644
--- a/document/core/binary/types.rst
+++ b/document/core/binary/types.rst
@@ -6,8 +6,8 @@ Types
 -----
 
 .. note::
-   In future versions of WebAssembly, value types may include types denoted by :ref:`type indices <syntax-typeidx>`.
-   Thus, the binary format for types corresponds to the encodings of small negative :math:`\xref{binary/values}{binary-sint}{\sN}` values, so that they can coexist with (positive) type indices in the future.
+   In some places, possible types include both type constructors or types denoted by :ref:`type indices <syntax-typeidx>`.
+   Thus, the binary format for most type constructors corresponds to the encodings of small negative :math:`\xref{binary/values}{binary-sint}{\sN}` values, such that they can unambiguously occur in the same place as (positive) type indices.
 
 
 .. index:: number type
@@ -29,6 +29,24 @@ Number Types
    \end{array}
 
 
+.. index:: heap type
+   pair: binary format; heap type
+.. _binary-heaptype:
+
+Heap Types
+~~~~~~~~~~
+
+:ref:`Heap types <syntax-reftype>` are encoded as either a single byte, or as a :ref:`type index <binary-typeidx>` encoded as a positive :ref:`signed integer <binary-sint>`.
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{heap type} & \Bheaptype &::=&
+     \hex{6F} &\Rightarrow& \EXTERN \\ &&|&
+     \hex{70} &\Rightarrow& \FUNC \\ &&|&
+     x{:}\Bs33 &\Rightarrow& x & (\iff x \geq 0) \\
+   \end{array}
+
+
 .. index:: reference type
    pair: binary format; reference type
 .. _binary-reftype:
@@ -36,13 +54,15 @@ Number Types
 Reference Types
 ~~~~~~~~~~~~~~~
 
-:ref:`Reference types <syntax-reftype>` are also encoded by a single byte.
+:ref:`Reference types <syntax-reftype>` are either encoded by a single byte followed by a :ref:`heap type <binary-heaptype>`, or, as a short form, directly as a non-index heap type.
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
    \production{reference type} & \Breftype &::=&
-     \hex{70} &\Rightarrow& \FUNCREF \\ &&|&
-     \hex{6F} &\Rightarrow& \EXTERNREF \\
+     \hex{6B}~~\X{ht}{:}\Bheaptype &\Rightarrow& \REF~\X{ht} \\ &&|&
+     \hex{6C}~~\X{ht}{:}\Bheaptype &\Rightarrow& \REF~\NULL~\X{ht} \\ &&|&
+     \hex{6F} &\Rightarrow& \EXTERNREF \\ &&|&
+     \hex{70} &\Rightarrow& \FUNCREF \\
    \end{array}
 
 
diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index 02b90c012..5f042cd55 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -13,6 +13,7 @@ Runtime Structure
 .. _syntax-ref:
 .. _syntax-ref.extern:
 .. _syntax-val:
+.. _syntax-null:
 
 Values
 ~~~~~~
diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index 039d4cfb2..67bc409e3 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -434,7 +434,7 @@ Forward branches require operands according to the output of the targeted block'
 Backward branches require operands according to the input of the targeted block's type, i.e., represent the values consumed by the restarted block.
 
 The |CALL| instruction invokes another :ref:`function <syntax-func>`, consuming the necessary arguments from the stack and returning the result values of the call.
-The |CALLINDIRECT| instruction calls a function indirectly through an operand indexing into a :ref:`table <syntax-table>` that is denoted by a :ref:`table index <syntax-tableidx>` and must have type |FUNCREF|.
+The |CALLINDIRECT| instruction calls a function indirectly through an operand indexing into a :ref:`table <syntax-table>` that is denoted by a :ref:`table index <syntax-tableidx>` and must contain :ref:`function references <syntax-reftype>`.
 Since it may contain functions of heterogeneous type,
 the callee is dynamically checked against the :ref:`function type <syntax-functype>` indexed by the instruction's second immediate, and the call is aborted with a :ref:`trap <trap>` if it does not match.
 
diff --git a/document/core/syntax/modules.rst b/document/core/syntax/modules.rst
index cfd8935aa..33b6bfb74 100644
--- a/document/core/syntax/modules.rst
+++ b/document/core/syntax/modules.rst
@@ -273,7 +273,7 @@ The |EOFFSET| is given by a :ref:`constant <valid-constant>` :ref:`expression <s
 Element segments are referenced through :ref:`element indices <syntax-elemidx>`.
 
 .. note::
-   In the current version of WebAssembly, only tables of element type |FUNCREF| can be initialized with an element segment.
+   In the current version of WebAssembly, only tables whose elements are function references can be initialized with an element segment.
    This limitation may be lifted in the future.
 
 
diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index 858fbc1a4..ac8b224c5 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -41,7 +41,29 @@ Conventions
   That is, :math:`|\I32| = |\F32| = 32` and :math:`|\I64| = |\F64| = 64`.
 
 
-.. index:: ! reference type, reference, table, function, function type, null
+.. index:: ! heap type, store, type index
+   pair: abstract syntax; heap type
+.. _syntax-heaptype:
+
+Heap Types
+~~~~~~~~~~
+
+*Heap types* classify objects in the runtime :ref:`store <store>`.
+
+.. math::
+   \begin{array}{llll}
+   \production{heap type} & \heaptype &::=&
+     \FUNC ~|~ \EXTERN ~|~ \typeidx \\
+   \end{array}
+
+The type |FUNC| denotes the infinite union of all types of :ref:`functions <syntax-func>`, regardless of their concrete :ref:`function types <syntax-functype>`.
+
+The type |EXTERN| denotes the infinite union of all objects owned by the :ref:`embedder <embedder>` and that can be passed into WebAssembly under this type.
+
+A *concrete* heap type consists of a :ref:`type index <syntax-typeidx>` and classifies an object of the respective :ref:`type <syntax-type>` defined in the module.
+
+
+.. index:: ! reference type, heap type, reference, table, function, function type, null
    pair: abstract syntax; reference type
    pair: reference; type
 .. _syntax-reftype:
@@ -49,26 +71,28 @@ Conventions
 Reference Types
 ~~~~~~~~~~~~~~~
 
-*Reference types* classify first-class references to objects in the runtime :ref:`store <store>`.
+*Reference types* classify :ref:`values <syntax-value>` that are first-class references to objects in the runtime :ref:`store <store>`.
 
 .. math::
    \begin{array}{llll}
    \production{reference type} & \reftype &::=&
-     \FUNCREF ~|~ \EXTERNREF \\
+     \REF~\NULL^?~\heaptype \\
    \end{array}
 
-The type |FUNCREF| denotes the infinite union of all references to :ref:`functions <syntax-func>`, regardless of their :ref:`function types <syntax-functype>`.
+A reference type is characterised by the :ref:`heap type <syntax-heaptype>` it points to.
 
-The type |EXTERNREF| denotes the infinite union of all references to objects owned by the :ref:`embedder <embedder>` and that can be passed into WebAssembly under this type.
+In addition, a reference type of the form :math:`\REF \NULL \X{ht}` is *nullable*, meaning that it can either be a proper reference to :math:`\X{ht}` or :ref:`null <syntax-null>`.
+Other references are *non-null*.
 
 Reference types are *opaque*, meaning that neither their size nor their bit pattern can be observed.
 Values of reference type can be stored in :ref:`tables <syntax-table>`.
 
 
-.. index:: ! value type, number type, reference type
+.. index:: ! value type, number type, reference type, ! bottom type
    pair: abstract syntax; value type
    pair: value; type
 .. _syntax-valtype:
+.. _syntax-bottype:
 
 Value Types
 ~~~~~~~~~~~
diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index 45c2a0597..0c350d000 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -70,17 +70,17 @@ However, the special case of a type use that is syntactically empty or consists
    \begin{array}[t]{@{}c@{}} ::= \\ | \\ \end{array}
    &
    \begin{array}[t]{@{}lcll@{}}
-     (t{:}\Tresult)^? &\Rightarrow& t^? \\
+     (t{:}\Tresult_I)^? &\Rightarrow& t^? \\
      x,I'{:}\Ttypeuse_I &\Rightarrow& x & (\iff I' = \{\ILOCALS~(\epsilon)^\ast\}) \\
    \end{array} \\
    \production{block instruction} & \Tblockinstr_I &::=&
-     \text{block}~~I'{:}\Tlabel_I~~\X{bt}{:}\Tblocktype~~(\X{in}{:}\Tinstr_{I'})^\ast~~\text{end}~~\Tid^?
+     \text{block}~~I'{:}\Tlabel_I~~\X{bt}{:}\Tblocktype_I~~(\X{in}{:}\Tinstr_{I'})^\ast~~\text{end}~~\Tid^?
        \\ &&&\qquad \Rightarrow\quad \BLOCK~\X{bt}~\X{in}^\ast~\END
        \qquad\quad~~ (\iff \Tid^? = \epsilon \vee \Tid^? = \Tlabel) \\ &&|&
-     \text{loop}~~I'{:}\Tlabel_I~~\X{bt}{:}\Tblocktype~~(\X{in}{:}\Tinstr_{I'})^\ast~~\text{end}~~\Tid^?
+     \text{loop}~~I'{:}\Tlabel_I~~\X{bt}{:}\Tblocktype_I~~(\X{in}{:}\Tinstr_{I'})^\ast~~\text{end}~~\Tid^?
        \\ &&&\qquad \Rightarrow\quad \LOOP~\X{bt}~\X{in}^\ast~\END
        \qquad\qquad (\iff \Tid^? = \epsilon \vee \Tid^? = \Tlabel) \\ &&|&
-     \text{if}~~I'{:}\Tlabel_I~~\X{bt}{:}\Tblocktype~~(\X{in}_1{:}\Tinstr_{I'})^\ast~~
+     \text{if}~~I'{:}\Tlabel_I~~\X{bt}{:}\Tblocktype_I~~(\X{in}_1{:}\Tinstr_{I'})^\ast~~
        \text{else}~~\Tid_1^?~~(\X{in}_2{:}\Tinstr_{I'})^\ast~~\text{end}~~\Tid_2^?
        \\ &&&\qquad \Rightarrow\quad \IF~\X{bt}~\X{in}_1^\ast~\ELSE~\X{in}_2^\ast~\END
        \qquad (\iff \Tid_1^? = \epsilon \vee \Tid_1^? = \Tlabel, \Tid_2^? = \epsilon \vee \Tid_2^? = \Tlabel) \\
@@ -128,9 +128,9 @@ The :math:`\text{else}` keyword of an :math:`\text{if}` instruction can be omitt
 .. math::
    \begin{array}{llclll}
    \production{block instruction} &
-     \text{if}~~\Tlabel~~\Tblocktype~~\Tinstr^\ast~~\text{end}
+     \text{if}~~\Tlabel~~\Tblocktype_I~~\Tinstr^\ast~~\text{end}
        &\equiv&
-     \text{if}~~\Tlabel~~\Tblocktype~~\Tinstr^\ast~~\text{else}~~\text{end}
+     \text{if}~~\Tlabel~~\Tblocktype_I~~\Tinstr^\ast~~\text{else}~~\text{end}
    \end{array}
 
 Also, for backwards compatibility, the table index to :math:`\text{call\_indirect}` can be omitted, defaulting to :math:`0`.
@@ -178,7 +178,7 @@ Parametric Instructions
    \begin{array}{llclll}
    \production{instruction} & \Tplaininstr_I &::=& \dots \\ &&|&
      \text{drop} &\Rightarrow& \DROP \\ &&|&
-     \text{select}~((t{:}\Tresult)^\ast)^? &\Rightarrow& \SELECT~(t^\ast)^? \\
+     \text{select}~((t{:}\Tresult_I)^\ast)^? &\Rightarrow& \SELECT~(t^\ast)^? \\
    \end{array}
 
 
diff --git a/document/core/text/modules.rst b/document/core/text/modules.rst
index 848f6880b..d9e759849 100644
--- a/document/core/text/modules.rst
+++ b/document/core/text/modules.rst
@@ -72,8 +72,8 @@ Type definitions can bind a symbolic :ref:`type identifier <text-id>`.
 
 .. math::
    \begin{array}{llclll}
-   \production{type definition} & \Ttype &::=&
-     \text{(}~\text{type}~~\Tid^?~~\X{ft}{:}\Tfunctype~\text{)}
+   \production{type definition} & \Ttype_I &::=&
+     \text{(}~\text{type}~~\Tid^?~~\X{ft}{:}\Tfunctype_I~\text{)}
        &\Rightarrow& \X{ft} \\
    \end{array}
 
@@ -167,11 +167,11 @@ The descriptors in imports can bind a symbolic function, table, memory, or globa
    \production{import description} & \Timportdesc_I &::=&
      \text{(}~\text{func}~~\Tid^?~~x,I'{:}\Ttypeuse_I~\text{)}
        &\Rightarrow& \IDFUNC~x \\ &&|&
-     \text{(}~\text{table}~~\Tid^?~~\X{tt}{:}\Ttabletype~\text{)}
+     \text{(}~\text{table}~~\Tid^?~~\X{tt}{:}\Ttabletype_I~\text{)}
        &\Rightarrow& \IDTABLE~\X{tt} \\ &&|&
-     \text{(}~\text{memory}~~\Tid^?~~\X{mt}{:}\Tmemtype~\text{)}
+     \text{(}~\text{memory}~~\Tid^?~~\X{mt}{:}\Tmemtype_I~\text{)}
        &\Rightarrow& \IDMEM~~\X{mt} \\ &&|&
-     \text{(}~\text{global}~~\Tid^?~~\X{gt}{:}\Tglobaltype~\text{)}
+     \text{(}~\text{global}~~\Tid^?~~\X{gt}{:}\Tglobaltype_I~\text{)}
        &\Rightarrow& \IDGLOBAL~\X{gt} \\
    \end{array}
 
@@ -198,11 +198,11 @@ Function definitions can bind a symbolic :ref:`function identifier <text-id>`, a
    \begin{array}{llclll}
    \production{function} & \Tfunc_I &::=&
      \text{(}~\text{func}~~\Tid^?~~x,I'{:}\Ttypeuse_I~~
-     (t{:}\Tlocal)^\ast~~(\X{in}{:}\Tinstr_{I''})^\ast~\text{)} \\ &&& \qquad
+     (t{:}\Tlocal_I)^\ast~~(\X{in}{:}\Tinstr_{I''})^\ast~\text{)} \\ &&& \qquad
        \Rightarrow\quad \{ \FTYPE~x, \FLOCALS~t^\ast, \FBODY~\X{in}^\ast~\END \} \\ &&& \qquad\qquad\qquad
        (\iff I'' = I' \compose \{\ILOCALS~\F{id}(\Tlocal)^\ast\} \idcwellformed) \\[1ex]
-   \production{local} & \Tlocal &::=&
-     \text{(}~\text{local}~~\Tid^?~~t{:}\Tvaltype~\text{)}
+   \production{local} & \Tlocal_I &::=&
+     \text{(}~\text{local}~~\Tid^?~~t{:}\Tvaltype_I~\text{)}
        \quad\Rightarrow\quad t \\
    \end{array}
 
@@ -265,7 +265,7 @@ Table definitions can bind a symbolic :ref:`table identifier <text-id>`.
 .. math::
    \begin{array}{llclll}
    \production{table} & \Ttable_I &::=&
-     \text{(}~\text{table}~~\Tid^?~~\X{tt}{:}\Ttabletype~\text{)}
+     \text{(}~\text{table}~~\Tid^?~~\X{tt}{:}\Ttabletype_I~\text{)}
        &\Rightarrow& \{ \TTYPE~\X{tt} \} \\
    \end{array}
 
@@ -334,7 +334,7 @@ Memory definitions can bind a symbolic :ref:`memory identifier <text-id>`.
 .. math::
    \begin{array}{llclll}
    \production{memory} & \Tmem_I &::=&
-     \text{(}~\text{memory}~~\Tid^?~~\X{mt}{:}\Tmemtype~\text{)}
+     \text{(}~\text{memory}~~\Tid^?~~\X{mt}{:}\Tmemtype_I~\text{)}
        &\Rightarrow& \{ \MTYPE~\X{mt} \} \\
    \end{array}
 
@@ -394,7 +394,7 @@ Global definitions can bind a symbolic :ref:`global identifier <text-id>`.
 .. math::
    \begin{array}{llclll}
    \production{global} & \Tglobal_I &::=&
-     \text{(}~\text{global}~~\Tid^?~~\X{gt}{:}\Tglobaltype~~e{:}\Texpr_I~\text{)}
+     \text{(}~\text{global}~~\Tid^?~~\X{gt}{:}\Tglobaltype_I~~e{:}\Texpr_I~\text{)}
        &\Rightarrow& \{ \GTYPE~\X{gt}, \GINIT~e \} \\
    \end{array}
 
@@ -505,7 +505,7 @@ Element segments allow for an optional :ref:`table index <text-tableidx>` to ide
      \text{(}~\text{elem}~~\Tid^?~~\text{declare}~~(et, y^\ast){:}\Telemlist_I~\text{)} \\ &&& \qquad
        \Rightarrow\quad \{ \ETYPE~et, \EINIT~y^\ast, \EMODE~\EDECLARATIVE \} \\
    \production{element list} & \Telemlist_I &::=&
-     t{:}\Treftype~~y^\ast{:}\Tvec(\Telemexpr_I) \qquad\Rightarrow\quad ( \ETYPE~t, \EINIT~y^\ast ) \\
+     t{:}\Treftype_I~~y^\ast{:}\Tvec(\Telemexpr_I) \qquad\Rightarrow\quad ( \ETYPE~t, \EINIT~y^\ast ) \\
    \production{element expression} & \Telemexpr_I &::=&
      \text{(}~\text{item}~~e{:}\Texpr_I~\text{)}
        \quad\Rightarrow\quad e \\
@@ -641,7 +641,7 @@ The name serves a documentary role only.
    \production{module field} & \Tmodulefield_I &
    \begin{array}[t]{@{}clll}
    ::=&
-     \X{ty}{:}\Ttype &\Rightarrow& \{\MTYPES~\X{ty}\} \\ |&
+     \X{ty}{:}\Ttype_I &\Rightarrow& \{\MTYPES~\X{ty}\} \\ |&
      \X{im}{:}\Timport_I &\Rightarrow& \{\MIMPORTS~\X{im}\} \\ |&
      \X{fn}{:}\Tfunc_I &\Rightarrow& \{\MFUNCS~\X{fn}\} \\ |&
      \X{ta}{:}\Ttable_I &\Rightarrow& \{\MTABLES~\X{ta}\} \\ |&
diff --git a/document/core/text/types.rst b/document/core/text/types.rst
index 6d4ee3758..17a3f46a6 100644
--- a/document/core/text/types.rst
+++ b/document/core/text/types.rst
@@ -14,7 +14,7 @@ Number Types
 
 .. math::
    \begin{array}{llcll@{\qquad\qquad}l}
-   \production{number type} & \Tnumtype &::=&
+   \production{number type} & \Tnumtype_I &::=&
      \text{i32} &\Rightarrow& \I32 \\ &&|&
      \text{i64} &\Rightarrow& \I64 \\ &&|&
      \text{f32} &\Rightarrow& \F32 \\ &&|&
@@ -22,22 +22,48 @@ Number Types
    \end{array}
 
 
+.. index:: heap type
+   pair: text format; heap type
+.. _text-heaptype:
+
+Heap Types
+~~~~~~~~~~
+
+.. math::
+   \begin{array}{llcll@{\qquad\qquad}l}
+   \production{heap type} & \Theaptype_I &::=&
+     \text{func} &\Rightarrow& \FUNC \\ &&|&
+     \text{extern} &\Rightarrow& \EXTERN \\ &&|&
+     x{:}\Ttypeidx_I &\Rightarrow& x \\
+   \end{array}
+
+
 .. index:: reference type
    pair: text format; reference type
 .. _text-reftype:
-.. _text-heaptype:
 
 Reference Types
 ~~~~~~~~~~~~~~~
 
 .. math::
    \begin{array}{llcll@{\qquad\qquad}l}
-   \production{reference type} & \Treftype &::=&
-     \text{funcref} &\Rightarrow& \FUNCREF \\ &&|&
-     \text{externref} &\Rightarrow& \EXTERNREF \\
-   \production{heap type} & \Theaptype &::=&
-     \text{func} &\Rightarrow& \FUNCREF \\ &&|&
-     \text{extern} &\Rightarrow& \EXTERNREF \\
+   \production{reference type} & \Treftype_I &::=&
+     \text{(}~\text{ref}~~\X{ht}{:}\Theaptype~\text{)}
+       &\Rightarrow& \REF~\X{ht} \\ &&|&
+     \text{(}~\text{ref}~~\text{null}~~\X{ht}{:}\Theaptype~\text{)}
+       &\Rightarrow& \REF~\NULL~\X{ht} \\
+   \end{array}
+
+Abbreviations
+.............
+
+There are shorthands for references to abstract heap types.
+
+.. math::
+   \begin{array}{llclll}
+   \production{reference type} &
+     \text{funcref} &\equiv& \text{(}~\text{ref}~~\text{null}~~\text{func}~\text{)} \\
+     \text{externref} &\equiv& \text{(}~\text{ref}~~\text{null}~~\text{extern}~\text{)} \\
    \end{array}
 
 
@@ -50,9 +76,9 @@ Value Types
 
 .. math::
    \begin{array}{llcll@{\qquad\qquad}l}
-   \production{value type} & \Tvaltype &::=&
-     t{:}\Tnumtype &\Rightarrow& t \\ &&|&
-     t{:}\Treftype &\Rightarrow& t \\
+   \production{value type} & \Tvaltype_I &::=&
+     t{:}\Tnumtype_I &\Rightarrow& t \\ &&|&
+     t{:}\Treftype_I &\Rightarrow& t \\
    \end{array}
 
 
@@ -67,14 +93,14 @@ Function Types
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
-   \production{function type} & \Tfunctype &::=&
-     \text{(}~\text{func}~~t_1^\ast{:\,}\Tvec(\Tparam)~~t_2^\ast{:\,}\Tvec(\Tresult)~\text{)}
+   \production{function type} & \Tfunctype_I &::=&
+     \text{(}~\text{func}~~t_1^\ast{:\,}\Tvec(\Tparam_I)~~t_2^\ast{:\,}\Tvec(\Tresult_I)~\text{)}
        &\Rightarrow& [t_1^\ast] \to [t_2^\ast] \\
-   \production{parameter} & \Tparam &::=&
-     \text{(}~\text{param}~~\Tid^?~~t{:}\Tvaltype~\text{)}
+   \production{parameter} & \Tparam_I &::=&
+     \text{(}~\text{param}~~\Tid^?~~t{:}\Tvaltype_I~\text{)}
        &\Rightarrow& t \\
-   \production{result} & \Tresult &::=&
-     \text{(}~\text{result}~~t{:}\Tvaltype~\text{)}
+   \production{result} & \Tresult_I &::=&
+     \text{(}~\text{result}~~t{:}\Tvaltype_I~\text{)}
        &\Rightarrow& t \\
    \end{array}
 
@@ -119,7 +145,7 @@ Memory Types
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
-   \production{memory type} & \Tmemtype &::=&
+   \production{memory type} & \Tmemtype_I &::=&
      \X{lim}{:}\Tlimits &\Rightarrow& \X{lim} \\
    \end{array}
 
@@ -133,8 +159,8 @@ Table Types
 
 .. math::
    \begin{array}{llclll}
-   \production{table type} & \Ttabletype &::=&
-     \X{lim}{:}\Tlimits~~\X{et}{:}\Treftype &\Rightarrow& \X{lim}~\X{et} \\
+   \production{table type} & \Ttabletype_I &::=&
+     \X{lim}{:}\Tlimits~~\X{et}{:}\Treftype_I &\Rightarrow& \X{lim}~\X{et} \\
    \end{array}
 
 
@@ -148,7 +174,7 @@ Global Types
 
 .. math::
    \begin{array}{llclll}
-   \production{global type} & \Tglobaltype &::=&
+   \production{global type} & \Tglobaltype_I &::=&
      t{:}\Tvaltype &\Rightarrow& \MCONST~t \\ &&|&
-     \text{(}~\text{mut}~~t{:}\Tvaltype~\text{)} &\Rightarrow& \MVAR~t \\
+     \text{(}~\text{mut}~~t{:}\Tvaltype_I~\text{)} &\Rightarrow& \MVAR~t \\
    \end{array}
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index 3e970ccfb..dd900bcdb 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -179,8 +179,12 @@
 .. |F32| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{f32}}
 .. |F64| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{f64}}
 
-.. |FUNCREF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{funcref}}
-.. |EXTERNREF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{externref}}
+.. |REF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{ref}}
+.. |NULL| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{null}}
+.. |FUNC| mathdef:: \xref{syntax/types}{syntax-heaptype}{\K{func}}
+.. |EXTERN| mathdef:: \xref{syntax/types}{syntax-heaptype}{\K{extern}}
+.. |FUNCREF| mathdef:: \xref{syntax/types}{syntax-heaptype}{\K{funcref}}
+.. |EXTERNREF| mathdef:: \xref{syntax/types}{syntax-heaptype}{\K{externref}}
 
 .. |MVAR| mathdef:: \xref{syntax/types}{syntax-mut}{\K{var}}
 .. |MCONST| mathdef:: \xref{syntax/types}{syntax-mut}{\K{const}}
@@ -197,6 +201,7 @@
 .. Types, non-terminals
 
 .. |numtype| mathdef:: \xref{syntax/types}{syntax-numtype}{\X{numtype}}
+.. |heaptype| mathdef:: \xref{syntax/types}{syntax-heaptype}{\X{heaptype}}
 .. |reftype| mathdef:: \xref{syntax/types}{syntax-reftype}{\X{reftype}}
 .. |valtype| mathdef:: \xref{syntax/types}{syntax-valtype}{\X{valtype}}
 .. |resulttype| mathdef:: \xref{syntax/types}{syntax-resulttype}{\X{resulttype}}
@@ -307,7 +312,7 @@
 .. Modules, non-terminals
 
 .. |module| mathdef:: \xref{syntax/modules}{syntax-module}{\X{module}}
-.. |type| mathdef:: \xref{syntax/modules}{syntax-typedef}{\X{type}}
+.. |type| mathdef:: \xref{syntax/types}{syntax-functype}{\X{type}}
 .. |func| mathdef:: \xref{syntax/modules}{syntax-func}{\X{func}}
 .. |table| mathdef:: \xref{syntax/modules}{syntax-table}{\X{table}}
 .. |mem| mathdef:: \xref{syntax/modules}{syntax-mem}{\X{mem}}
@@ -500,6 +505,7 @@
 .. Types, non-terminals
 
 .. |Bnumtype| mathdef:: \xref{binary/types}{binary-numtype}{\B{numtype}}
+.. |Bheaptype| mathdef:: \xref{binary/types}{binary-heaptype}{\B{heaptype}}
 .. |Breftype| mathdef:: \xref{binary/types}{binary-reftype}{\B{reftype}}
 .. |Bvaltype| mathdef:: \xref{binary/types}{binary-valtype}{\B{valtype}}
 .. |Bresulttype| mathdef:: \xref{binary/types}{binary-resulttype}{\B{resulttype}}
@@ -661,8 +667,8 @@
 .. Types, non-terminals
 
 .. |Tnumtype| mathdef:: \xref{text/types}{text-numtype}{\T{numtype}}
-.. |Treftype| mathdef:: \xref{text/types}{text-reftype}{\T{reftype}}
 .. |Theaptype| mathdef:: \xref{text/types}{text-heaptype}{\T{heaptype}}
+.. |Treftype| mathdef:: \xref{text/types}{text-reftype}{\T{reftype}}
 .. |Tvaltype| mathdef:: \xref{text/types}{text-valtype}{\T{valtype}}
 .. |Tfunctype| mathdef:: \xref{text/types}{text-functype}{\T{functype}}
 
@@ -774,8 +780,11 @@
 .. |ok| mathdef:: \mathrel{\mbox{ok}}
 .. |const| mathdef:: \xref{valid/instructions}{valid-constant}{\mathrel{\mbox{const}}}
 
+.. |matchesheaptype| mathdef:: \xref{valid/types}{match-heaptype}{\leq}
+.. |matchesreftype| mathdef:: \xref{valid/types}{match-reftype}{\leq}
 .. |matchesvaltype| mathdef:: \xref{valid/types}{match-valtype}{\leq}
 .. |matchesresulttype| mathdef:: \xref{valid/types}{match-resulttype}{\leq}
+.. |matchesfunctype| mathdef:: \xref{valid/types}{match-functype}{\leq}
 
 
 .. Contexts
@@ -795,6 +804,11 @@
 
 .. Judgments
 
+.. |vdashnumtype| mathdef:: \xref{valid/types}{valid-numtype}{\vdash}
+.. |vdashheaptype| mathdef:: \xref{valid/types}{valid-heaptype}{\vdash}
+.. |vdashreftype| mathdef:: \xref{valid/types}{valid-reftype}{\vdash}
+.. |vdashvaltype| mathdef:: \xref{valid/types}{valid-valtype}{\vdash}
+.. |vdashresulttype| mathdef:: \xref{valid/types}{valid-resulttype}{\vdash}
 .. |vdashlimits| mathdef:: \xref{valid/types}{valid-limits}{\vdash}
 .. |vdashblocktype| mathdef:: \xref{valid/types}{valid-blocktype}{\vdash}
 .. |vdashfunctype| mathdef:: \xref{valid/types}{valid-functype}{\vdash}
@@ -804,9 +818,11 @@
 .. |vdashexterntype| mathdef:: \xref{valid/types}{valid-externtype}{\vdash}
 
 .. |vdashnumtypematch| mathdef:: \xref{valid/types}{match-numtype}{\vdash}
+.. |vdashheaptypematch| mathdef:: \xref{valid/types}{match-heaptype}{\vdash}
 .. |vdashreftypematch| mathdef:: \xref{valid/types}{match-reftype}{\vdash}
 .. |vdashvaltypematch| mathdef:: \xref{valid/types}{match-valtype}{\vdash}
 .. |vdashresulttypematch| mathdef:: \xref{valid/types}{match-resulttype}{\vdash}
+.. |vdashfunctypematch| mathdef:: \xref{valid/types}{match-functype}{\vdash}
 
 .. |vdashinstr| mathdef:: \xref{valid/instructions}{valid-instr}{\vdash}
 .. |vdashinstrseq| mathdef:: \xref{valid/instructions}{valid-instr-seq}{\vdash}
@@ -814,6 +830,7 @@
 .. |vdashexprconst| mathdef:: \xref{valid/instructions}{valid-constant}{\vdash}
 .. |vdashinstrconst| mathdef:: \xref{valid/instructions}{valid-constant}{\vdash}
 
+.. |vdashtypes| mathdef:: \xref{valid/modules}{valid-types}{\vdash}
 .. |vdashfunc| mathdef:: \xref{valid/modules}{valid-func}{\vdash}
 .. |vdashtable| mathdef:: \xref{valid/modules}{valid-table}{\vdash}
 .. |vdashmem| mathdef:: \xref{valid/modules}{valid-mem}{\vdash}
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 610c49cd4..89c0c21eb 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -248,22 +248,27 @@ Parametric Instructions
 
 * If :math:`t^\ast` is present, then:
 
+  * The :ref:`result type <syntax-resulttype>` :math:`[t^\ast]` must be :ref:`valid <valid-resulttype>`.
+
   * The length of :math:`t^\ast` must be :math:`1`.
 
   * Then the instruction is valid with type :math:`[t^\ast~t^\ast~\I32] \to [t^\ast]`.
 
 * Else:
 
-  * The instruction is valid with type :math:`[t~t~\I32] \to [t]`, for any :ref:`value type <syntax-valtype>` :math:`t` that :ref:`matches <match-valtype>` some :ref:`number type <syntax-numtype>`.
+  * The instruction is valid with type :math:`[t~t~\I32] \to [t]`, for any :ref:`valid <valid-valtype>` :ref:`value type <syntax-valtype>` :math:`t` that :ref:`matches <match-valtype>` some :ref:`number type <syntax-numtype>`.
 
 .. math::
    \frac{
+     C \vdashresulttype [t] \ok
    }{
      C \vdashinstr \SELECT~t : [t~t~\I32] \to [t]
    }
    \qquad
    \frac{
-     \vdashvaltypematch t \matchesvaltype \numtype
+     C \vdashresulttype [t] \ok
+     \qquad
+     C \vdashresulttypematch [t] \matchesresulttype [\numtype]
    }{
      C \vdashinstr \SELECT : [t~t~\I32] \to [t]
    }
@@ -569,7 +574,7 @@ Memory Instructions
 
 * The memory :math:`C.\CMEMS[0]` must be defined in the context.
 
-* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than the :ref:`bit width <syntax-valtype>` of :math:`t` divided by :math:`8`.
+* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than the :ref:`bit width <syntax-numtype>` of :math:`t` divided by :math:`8`.
 
 * Then the instruction is valid with type :math:`[\I32] \to [t]`.
 
@@ -609,7 +614,7 @@ Memory Instructions
 
 * The memory :math:`C.\CMEMS[0]` must be defined in the context.
 
-* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than the :ref:`bit width <syntax-valtype>` of :math:`t` divided by :math:`8`.
+* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than the :ref:`bit width <syntax-numtype>` of :math:`t` divided by :math:`8`.
 
 * Then the instruction is valid with type :math:`[\I32~t] \to []`.
 
@@ -778,10 +783,11 @@ Control Instructions
 :math:`\UNREACHABLE`
 ....................
 
-* The instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
+* The instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`, for any sequences of :ref:`valid <valid-valtype>` :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
 .. math::
    \frac{
+     C \vdashfunctype [t_1^\ast] \to [t_2^\ast] \ok
    }{
      C \vdashinstr \UNREACHABLE : [t_1^\ast] \to [t_2^\ast]
    }
@@ -885,11 +891,13 @@ Control Instructions
 
 * Let :math:`[t^\ast]` be the :ref:`result type <syntax-resulttype>` :math:`C.\CLABELS[l]`.
 
-* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
+* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`, for any sequences of :ref:`valid <valid-valtype>` :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
 .. math::
    \frac{
      C.\CLABELS[l] = [t^\ast]
+     \qquad
+     C \vdashfunctype [t_1^\ast] \to [t_2^\ast] \ok
    }{
      C \vdashinstr \BR~l : [t_1^\ast~t^\ast] \to [t_2^\ast]
    }
@@ -942,13 +950,15 @@ Control Instructions
   * For all :math:`l_i` in :math:`l^\ast`,
     the result type :math:`[t^\ast]` :ref:`matches <match-resulttype>` :math:`C.\CLABELS[l_i]`.
 
-* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast~\I32] \to [t_2^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
+* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast~\I32] \to [t_2^\ast]`, for any sequences of :ref:`valid <valid-valtype>` :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
 .. math::
    \frac{
      (\vdashresulttypematch [t^\ast] \matchesresulttype C.\CLABELS[l])^\ast
      \qquad
      \vdashresulttypematch [t^\ast] \matchesresulttype C.\CLABELS[l_N]
+     \qquad
+     C \vdashfunctype [t_1^\ast] \to [t_2^\ast] \ok
    }{
      C \vdashinstr \BRTABLE~l^\ast~l_N : [t_1^\ast~t^\ast~\I32] \to [t_2^\ast]
    }
@@ -972,11 +982,13 @@ Control Instructions
 
 * Let :math:`[t^\ast]` be the :ref:`result type <syntax-resulttype>` of :math:`C.\CRETURN`.
 
-* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
+* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`, for any sequences of :ref:`valid <valid-valtype>` :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
 .. math::
    \frac{
      C.\CRETURN = [t^\ast]
+     \qquad
+     C \vdashfunctype [t_1^\ast] \to [t_2^\ast] \ok
    }{
      C \vdashinstr \RETURN : [t_1^\ast~t^\ast] \to [t_2^\ast]
    }
@@ -1015,7 +1027,7 @@ Control Instructions
 
 * Let :math:`\limits~t` be the :ref:`table type <syntax-tabletype>` :math:`C.\CTABLES[x]`.
 
-* The :ref:`reference type <syntax-reftype>` :math:`t` must :ref:`match <match-reftype>` type |FUNCREF|.
+* The :ref:`reference type <syntax-reftype>` :math:`t` must :ref:`match <match-reftype>` type :math:`\REF~\NULL~\FUNC`.
 
 * The type :math:`C.\CTYPES[y]` must be defined in the context.
 
@@ -1027,7 +1039,7 @@ Control Instructions
    \frac{
      C.\CTABLES[x] = \limits~t
      \qquad
-     \vdashvaltypematch t \leq \FUNCREF
+     C \vdashvaltypematch t \matchesreftype \REF~\NULL~\FUNC
      \qquad
      C.\CTYPES[y] = [t_1^\ast] \to [t_2^\ast]
    }{
@@ -1100,9 +1112,9 @@ Expressions :math:`\expr` are classified by :ref:`result types <syntax-resulttyp
 :math:`\instr^\ast~\END`
 ........................
 
-* The instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with some :ref:`type <syntax-functype>` :math:`[] \to [t^\ast]`.
+* The instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with some :ref:`type <syntax-functype>` :math:`[] \to [{t'}^\ast]`.
 
-* For each :ref:`value type <syntax-valtype>` :math:`t'_i` in :math:`{t'}^\ast` and corresponding :ref:`value type <syntax-valtype>` type :math:`t_i` in :math:`t^\ast`, :math:`t'_i` :ref:`matches <match-valtype>` :math:`t_i`.
+* For each :ref:`value type <syntax-valtype>` :math:`t'_i` in :math:`{t'}^\ast` and corresponding :ref:`valid <valid-valtype>` :ref:`value type <syntax-valtype>` type :math:`t_i` in :math:`t^\ast`, :math:`t'_i` :ref:`matches <match-valtype>` :math:`t_i`.
 
 * Then the expression is valid with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`.
 
@@ -1110,6 +1122,8 @@ Expressions :math:`\expr` are classified by :ref:`result types <syntax-resulttyp
    \frac{
      C \vdashinstrseq \instr^\ast : [] \to [{t'}^\ast]
      \qquad
+     C \vdashresulttype [t^\ast] \ok
+     \qquad
      (\vdashvaltypematch t' \matchesvaltype t)^\ast
    }{
      C \vdashexpr \instr^\ast~\END : [t^\ast]
diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index 875464937..1d28153c6 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -67,7 +67,7 @@ Tables :math:`\table` are classified by :ref:`table types <syntax-tabletype>`.
 
 .. math::
    \frac{
-     \vdashtabletype \tabletype \ok
+     C \vdashtabletype \tabletype \ok
    }{
      C \vdashtable \{ \TTYPE~\tabletype \} : \tabletype
    }
@@ -92,7 +92,7 @@ Memories :math:`\mem` are classified by :ref:`memory types <syntax-memtype>`.
 
 .. math::
    \frac{
-     \vdashmemtype \memtype \ok
+     C \vdashmemtype \memtype \ok
    }{
      C \vdashmem \{ \MTYPE~\memtype \} : \memtype
    }
@@ -122,7 +122,7 @@ Globals :math:`\global` are classified by :ref:`global types <syntax-globaltype>
 
 .. math::
    \frac{
-     \vdashglobaltype \mut~t \ok
+     C \vdashglobaltype \mut~t \ok
      \qquad
      C \vdashexpr \expr : [t]
      \qquad
@@ -147,6 +147,8 @@ Element segments :math:`\elem` are classified by the :ref:`reference type <synta
 :math:`\{ \ETYPE~t, \EINIT~e^\ast, \EMODE~\elemmode \}`
 .......................................................
 
+* The :ref:`reference type <syntax-reftype>` :math:`t` must be :ref:`valid <valid-reftype>`.
+
 * For each :math:`e_i` in :math:`e^\ast`,
 
   * The expression :math:`e_i` must be :ref:`valid <valid-expr>`.
@@ -155,20 +157,22 @@ Element segments :math:`\elem` are classified by the :ref:`reference type <synta
 
 * The element mode :math:`\elemmode` must be valid with some :ref:`reference type <syntax-reftype>` :math:`t'`.
 
-* The :ref:`reference type <syntax-reftype>` :math:`t` must :ref:`match <match-reftype>` the reference type :math:`t'`.
+* The reference type :math:`t` must :ref:`match <match-reftype>` the reference type :math:`t'`.
 
 * Then the element segment is valid with :ref:`reference type <syntax-reftype>` :math:`t`.
 
 
 .. math::
    \frac{
+     C \vdashreftype t \ok
+     \qquad
      (C \vdashexpr e \ok)^\ast
      \qquad
      (C \vdashexprconst e \const)^\ast
      \qquad
      C \vdashelemmode \elemmode : t'
      \qquad
-     \vdashreftypematch t \matchesvaltype t'
+     C \vdashreftypematch t \matchesreftype t'
    }{
      C \vdashelem \{ \ETYPE~t, \EINIT~e^\ast, \EMODE~\elemmode \} : t
    }
@@ -179,10 +183,11 @@ Element segments :math:`\elem` are classified by the :ref:`reference type <synta
 :math:`\EPASSIVE`
 .................
 
-* The element mode is valid with any :ref:`reference type <syntax-reftype>`.
+* The element mode is valid with any :ref:`valid <valid-reftype>` :ref:`reference type <syntax-reftype>`.
 
 .. math::
    \frac{
+     C \vdashreftype \reftype \ok
    }{
      C \vdashelemmode \EPASSIVE : \reftype
    }
@@ -217,10 +222,11 @@ Element segments :math:`\elem` are classified by the :ref:`reference type <synta
 :math:`\EDECLARATIVE`
 .....................
 
-* The element mode is valid with any :ref:`reference type <syntax-reftype>`.
+* The element mode is valid with any :ref:`valid <valid-reftype>` :ref:`reference type <syntax-reftype>`.
 
 .. math::
    \frac{
+     C \vdashreftype \reftype \ok
    }{
      C \vdashelemmode \EDECLARATIVE : \reftype
    }
@@ -436,7 +442,7 @@ Imports :math:`\import` and import descriptions :math:`\importdesc` are classifi
 :math:`\IDFUNC~x`
 .................
 
-* The function :math:`C.\CTYPES[x]` must be defined in the context.
+* The function type :math:`C.\CTYPES[x]` must be defined in the context.
 
 * Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[x]`.
 
@@ -459,7 +465,7 @@ Imports :math:`\import` and import descriptions :math:`\importdesc` are classifi
 
 .. math::
    \frac{
-     \vdashtable \tabletype \ok
+     C \vdashtable \tabletype \ok
    }{
      C \vdashimportdesc \IDTABLE~\tabletype : \ETTABLE~\tabletype
    }
@@ -474,7 +480,7 @@ Imports :math:`\import` and import descriptions :math:`\importdesc` are classifi
 
 .. math::
    \frac{
-     \vdashmemtype \memtype \ok
+     C \vdashmemtype \memtype \ok
    }{
      C \vdashimportdesc \IDMEM~\memtype : \ETMEM~\memtype
    }
@@ -489,7 +495,7 @@ Imports :math:`\import` and import descriptions :math:`\importdesc` are classifi
 
 .. math::
    \frac{
-     \vdashglobaltype \globaltype \ok
+     C \vdashglobaltype \globaltype \ok
    }{
      C \vdashimportdesc \IDGLOBAL~\globaltype : \ETGLOBAL~\globaltype
    }
@@ -540,21 +546,26 @@ Instead, the context :math:`C` for validation of the module's content is constru
 
   * :math:`C.\CREFS` is the set :math:`\freefuncidx(\module \with \MFUNCS = \epsilon \with \MSTART = \epsilon)`, i.e., the set of :ref:`function indices <syntax-funcidx>` occurring in the module, except in its :ref:`functions <syntax-func>` or :ref:`start function <syntax-start>`.
 
-* Let :math:`C'` be the :ref:`context <context>` where:
+* For each function type :math:`\functype_i` in :math:`\module.\MTYPES`:
+
+  * Let :math:`C'_i` be the :ref:`context <context>` where :math:`C'_i.\CTYPES` is :math:`C.\CTYPES[0 \slice i]` and all other fields are empty.
+
+  * The function  :math:`\functype_i` must be :ref:`valid <valid-functype>` under context :math:`C'_i`.
+
+* Let :math:`C''` be the :ref:`context <context>` where:
 
-  * :math:`C'.\CGLOBALS` is the sequence :math:`\etglobals(\X{it}^\ast)`,
+  * :math:`C''.\CGLOBALS` is the sequence :math:`\etglobals(\X{it}^\ast)`,
 
-  * :math:`C'.\CFUNCS` is the same as :math:`C.\CFUNCS`,
+  * :math:`C''.\CTYPES` is the same as :math:`C.\CTYPES`,
 
-  * :math:`C'.\CREFS` is the same as :math:`C.\CREFS`,
+  * :math:`C''.\CFUNCS` is the same as :math:`C.\CFUNCS`,
+
+  * :math:`C''.\CREFS` is the same as :math:`C.\CREFS`,
 
   * all other fields are empty.
 
 * Under the context :math:`C`:
 
-  * For each :math:`\functype_i` in :math:`\module.\MTYPES`,
-    the :ref:`function type <syntax-functype>` :math:`\functype_i` must be :ref:`valid <valid-functype>`.
-
   * For each :math:`\func_i` in :math:`\module.\MFUNCS`,
     the definition :math:`\func_i` must be :ref:`valid <valid-func>` with a :ref:`function type <syntax-functype>` :math:`\X{ft}_i`.
 
@@ -566,7 +577,7 @@ Instead, the context :math:`C` for validation of the module's content is constru
 
   * For each :math:`\global_i` in :math:`\module.\MGLOBALS`:
 
-    * Under the context :math:`C'`,
+    * Under the context :math:`C''`,
       the definition :math:`\global_i` must be :ref:`valid <valid-global>` with a :ref:`global type <syntax-globaltype>` :math:`\X{gt}_i`.
 
   * For each :math:`\elem_i` in :math:`\module.\MELEMS`,
@@ -607,7 +618,7 @@ Instead, the context :math:`C` for validation of the module's content is constru
 .. math::
    \frac{
      \begin{array}{@{}c@{}}
-     (\vdashfunctype \type \ok)^\ast
+     \vdashtypes \type^\ast \ok
      \quad
      (C \vdashfunc \func : \X{ft})^\ast
      \quad
@@ -615,7 +626,7 @@ Instead, the context :math:`C` for validation of the module's content is constru
      \quad
      (C \vdashmem \mem : \X{mt})^\ast
      \quad
-     (C' \vdashglobal \global : \X{gt})^\ast
+     (C'' \vdashglobal \global : \X{gt})^\ast
      \\
      (C \vdashelem \elem : \X{rt})^\ast
      \quad
@@ -639,7 +650,9 @@ Instead, the context :math:`C` for validation of the module's content is constru
      \\
      C = \{ \CTYPES~\type^\ast, \CFUNCS~\X{ift}^\ast\,\X{ft}^\ast, \CTABLES~\X{itt}^\ast\,\X{tt}^\ast, \CMEMS~\X{imt}^\ast\,\X{mt}^\ast, \CGLOBALS~\X{igt}^\ast\,\X{gt}^\ast, \CELEMS~\X{rt}^\ast, \CDATAS~{\ok}^n, \CREFS~x^\ast \}
      \\
-     C' = \{ \CGLOBALS~\X{igt}^\ast, \CFUNCS~(C.\CFUNCS), \CREFS~(C.\CREFS) \}
+     (C' = \{ \CTYPES~\type^\ast \})^\ast
+     \\
+     C'' = \{ \CTYPES~\type^\ast, \CGLOBALS~\X{igt}^\ast, \CFUNCS~(C.\CFUNCS), \CREFS~(C.\CREFS) \}
      \qquad
      |C.\CMEMS| \leq 1
      \qquad
@@ -663,6 +676,25 @@ Instead, the context :math:`C` for validation of the module's content is constru
      \vdashmodule \module : \X{it}^\ast \to \X{et}^\ast
    }
 
+.. _valid-types:
+
+where:
+
+.. math::
+   \frac{
+     \vdashtypes \type^\ast \ok
+     \qquad
+     \{\CTYPES~\type^\ast\} \vdashtypes \type \ok
+   }{
+     \vdashtypes \type^\ast~\type \ok
+   }
+   \qquad
+   \frac{
+   }{
+     \vdashtypes \epsilon \ok
+   }
+
+
 .. note::
    Most definitions in a module -- particularly functions -- are mutually recursive.
    Consequently, the definition of the :ref:`context <context>` :math:`C` in this rule is recursive:
diff --git a/document/core/valid/types.rst b/document/core/valid/types.rst
index 1b790bb46..da276506c 100644
--- a/document/core/valid/types.rst
+++ b/document/core/valid/types.rst
@@ -1,13 +1,148 @@
 Types
 -----
 
-Most :ref:`types <syntax-type>` are universally valid.
-However, restrictions apply to :ref:`function types <syntax-functype>` as well as the :ref:`limits <syntax-limits>` of :ref:`table types <syntax-tabletype>` and :ref:`memory types <syntax-memtype>`, which must be checked during validation.
-
-On :ref:`value types <syntax-valtype>`, a simple notion of subtyping is defined.
+Simple :ref:`types <syntax-type>`, such as :ref:`number types <syntax-numtype>` are universally valid.
+However, restrictions apply to most other types, such as :ref:`reference types <syntax-reftype>`, :ref:`function types <syntax-functype>`, as well as the :ref:`limits <syntax-limits>` of :ref:`table types <syntax-tabletype>` and :ref:`memory types <syntax-memtype>`, which must be checked during validation.
 
 Moreover, :ref:`block types <syntax-blocktype>` are converted to plain :ref:`function types <syntax-functype>` for ease of processing.
 
+On most types, a simple notion of subtyping is defined that is applicable in validation rules or during :ref:`module instantiation <exec-instantiation>`.
+
+
+.. index:: number type
+   pair: validation; number type
+   single: abstract syntax; number type
+.. _valid-numtype:
+
+Number Types
+~~~~~~~~~~~~
+
+:ref:`Number types <syntax-numtype>` are always valid.
+
+.. math::
+   \frac{
+   }{
+     C \vdashnumtype \numtype \ok
+   }
+
+
+.. index:: heap type
+   pair: validation; heap type
+   single: abstract syntax; heap type
+.. _valid-heaptype:
+
+Heap Types
+~~~~~~~~~~
+
+Concrete :ref:`Heap types <syntax-heaptype>` are only valid when the :ref:`type index <syntax-typeidx>` is.
+
+:math:`\FUNC`
+.............
+
+* The heap type is valid.
+
+.. math::
+   \frac{
+   }{
+     C \vdashheaptype \FUNC \ok
+   }
+
+:math:`\EXTERN`
+...............
+
+* The heap type is valid.
+
+.. math::
+   \frac{
+   }{
+     C \vdashheaptype \EXTERN \ok
+   }
+
+:math:`\typeidx`
+................
+
+* The type :math:`C.\CTYPES[\typeidx]` must be defined in the context.
+
+* Then the heap type is valid.
+
+.. math::
+   \frac{
+     C.\CTYPES[\typeidx] = \functype
+   }{
+     C \vdashheaptype \typeidx \ok
+   }
+
+
+.. index:: reference type, heap type
+   pair: validation; reference type
+   single: abstract syntax; reference type
+.. _valid-reftype:
+
+Reference Types
+~~~~~~~~~~~~~~~
+
+:ref:`Reference types <syntax-reftype>` are valid when the referenced :ref:`heap type <syntax-heaptype>` is.
+
+:math:`\REF~\NULL^?~\heaptype`
+..............................
+
+* The heap type :math:`\heaptype` must be :ref:`valid <valid-heaptype>`.
+
+* Then the reference type is valid.
+
+.. math::
+   \frac{
+     C \vdashreftype \heaptype \ok
+   }{
+     C \vdashreftype \REF~\NULL^?~\heaptype \ok
+   }
+
+
+.. index:: value type, reference type, heap type, bottom type
+   pair: validation; value type
+   single: abstract syntax; value type
+.. _valid-valtype:
+.. _valid-bottype:
+
+Value Types
+~~~~~~~~~~~
+
+Valid :ref:`value types <syntax-valtype>` are either valid :ref:`number type <valid-numtype>`,  :ref:`reference type <valid-reftype>`, or the :ref:`bottom type <syntax-bottype>`.
+
+:math:`\BOT`
+............
+
+* The value type is valid.
+
+.. math::
+   \frac{
+   }{
+     C \vdashvaltype \BOT \ok
+   }
+
+
+.. index:: result type, value type
+   pair: validation; result type
+   single: abstract syntax; result type
+.. _valid-resulttype:
+
+Result Types
+~~~~~~~~~~~~
+
+:math:`[t^\ast]`
+................
+
+* Each :ref:`value type <syntax-valtype>` :math:`t_i` in the type sequence :math:`t^\ast` must be :ref:`valid <valid-valtype>`.
+
+* Then the result type is valid.
+
+.. math::
+   \frac{
+     (C \vdashvaltype t \ok)^\ast
+   }{
+     C \vdashresulttype [t^\ast] \ok
+   }
+
 
 .. index:: limits
    pair: validation; limits
@@ -72,10 +207,13 @@ Block Types
 :math:`[\valtype^?]`
 ....................
 
-* The block type is valid as :ref:`function type <syntax-functype>` :math:`[] \to [\valtype^?]`.
+* The value type :math:`\valtype` must either be absent, or :ref:`valid <valid-valtype>`.
+
+* Then the block type is valid as :ref:`function type <syntax-functype>` :math:`[] \to [\valtype^?]`.
 
 .. math::
    \frac{
+     (C \vdashvaltype \valtype \ok)^?
    }{
      C \vdashblocktype [\valtype^?] : [] \to [\valtype^?]
    }
@@ -89,17 +227,22 @@ Block Types
 Function Types
 ~~~~~~~~~~~~~~
 
-:ref:`Function types <syntax-functype>` are always valid.
+:math:`[t_1^\ast] \to [t_2^\ast]`
+.................................
 
-:math:`[t_1^n] \to [t_2^m]`
-...........................
+* The :ref:`result type <syntax-resulttype>` :math:`[t_1^\ast]` must be :ref:`valid <valid-resulttype>`.
+
+* The :ref:`result type <syntax-resulttype>` :math:`[t_2^\ast]` must be :ref:`valid <valid-resulttype>`.
 
-* The function type is valid.
+* Then the function type is valid.
 
 .. math::
    \frac{
+     C \vdashvaltype [t_1^\ast] \ok
+     \qquad
+     C \vdashvaltype [t_2^\ast] \ok
    }{
-     \vdashfunctype [t_1^\ast] \to [t_2^\ast] \ok
+     C \vdashfunctype [t_1^\ast] \to [t_2^\ast] \ok
    }
 
 
@@ -116,13 +259,17 @@ Table Types
 
 * The limits :math:`\limits` must be :ref:`valid <valid-limits>` within range :math:`2^{32}-1`.
 
+* The reference type :math:`\reftype` must be :ref:`valid <valid-reftype>`.
+
 * Then the table type is valid.
 
 .. math::
    \frac{
      \vdashlimits \limits : 2^{32} - 1
+     \qquad
+     C \vdashreftype \reftype \ok
    }{
-     \vdashtabletype \limits~\reftype \ok
+     C \vdashtabletype \limits~\reftype \ok
    }
 
 
@@ -160,12 +307,15 @@ Global Types
 :math:`\mut~\valtype`
 .....................
 
-* The global type is valid.
+* The value type :math:`\valtype` must be :ref:`valid <valid-valtype>`.
+
+* Then the global type is valid.
 
 .. math::
    \frac{
+     C \vdashreftype \valtype \ok
    }{
-     \vdashglobaltype \mut~\valtype \ok
+     C \vdashglobaltype \mut~\valtype \ok
    }
 
 
@@ -186,9 +336,9 @@ External Types
 
 .. math::
    \frac{
-     \vdashfunctype \functype \ok
+     C \vdashfunctype \functype \ok
    }{
-     \vdashexterntype \ETFUNC~\functype \ok
+     C \vdashexterntype \ETFUNC~\functype \ok
    }
 
 :math:`\ETTABLE~\tabletype`
@@ -200,9 +350,9 @@ External Types
 
 .. math::
    \frac{
-     \vdashtabletype \tabletype \ok
+     C \vdashtabletype \tabletype \ok
    }{
-     \vdashexterntype \ETTABLE~\tabletype \ok
+     C \vdashexterntype \ETTABLE~\tabletype \ok
    }
 
 :math:`\ETMEM~\memtype`
@@ -214,9 +364,9 @@ External Types
 
 .. math::
    \frac{
-     \vdashmemtype \memtype \ok
+     C \vdashmemtype \memtype \ok
    }{
-     \vdashexterntype \ETMEM~\memtype \ok
+     C \vdashexterntype \ETMEM~\memtype \ok
    }
 
 :math:`\ETGLOBAL~\globaltype`
@@ -228,9 +378,9 @@ External Types
 
 .. math::
    \frac{
-     \vdashglobaltype \globaltype \ok
+     C \vdashglobaltype \globaltype \ok
    }{
-     \vdashexterntype \ETGLOBAL~\globaltype \ok
+     C \vdashexterntype \ETGLOBAL~\globaltype \ok
    }
  
  
@@ -258,6 +408,44 @@ A :ref:`number type <syntax-numtype>` :math:`\numtype_1` matches a :ref:`number
    }
 
 
+.. index:: heap type
+
+.. _match-heaptype:
+
+Heap Types
+..........
+
+A :ref:`heap type <syntax-heaptype>` :math:`\heaptype_1` matches a :ref:`heap type <syntax-heaptype>` :math:`\heaptype_2` if and only if:
+
+* Either both :math:`\heaptype_1` and :math:`\heaptype_2` are the same.
+
+* Or :math:`\heaptype_1` is a :ref:`type index <syntax-typeidx>` that defines a function type and :math:`\heaptype_2` is :math:`FUNC`.
+
+* Or :math:`\heaptype_1` is a :ref:`type index <syntax-typeidx>` that defines a function type :math:`\functype_1`, and :math:`\heaptype_2` is a :ref:`type index <syntax-typeidx>` that defines a function type :math:`\functype_2`, and :math:`\functype_1` :ref:`matches <match-functype>` :math:`\functype_2`.
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+   }{
+     C \vdashheaptypematch \heaptype \matchesheaptype \heaptype
+   }
+   ~\\
+   \frac{
+     C.\CTYPES[\typeidx] = \functype
+   }{
+     C \vdashheaptypematch \typeidx \matchesheaptype \FUNC
+   }
+   ~\\
+   \frac{
+     C.\CTYPES[\typeidx_1] = \functype_1
+     \qquad
+     C.\CTYPES[\typeidx_2] = \functype_2
+     \qquad
+     C \vdashfunctypematch \functype_1 \matchesfunctype \functype_2
+   }{
+     C \vdashheaptypematch \typeidx_1 \matchesheaptype \typeidx_2
+   }
+
 
 .. index:: reference type
 
@@ -266,15 +454,24 @@ A :ref:`number type <syntax-numtype>` :math:`\numtype_1` matches a :ref:`number
 Reference Types
 ...............
 
-A :ref:`reference type <syntax-reftype>` :math:`\reftype_1` matches a :ref:`reference type <syntax-reftype>` :math:`\reftype_2` if and only if:
+A :ref:`reference type <syntax-reftype>` :math:`\REF~\NULL_1^?~heaptype_1` matches a :ref:`reference type <syntax-reftype>` :math:`\REF~\NULL_2^?~heaptype_2` if and only if:
+
+* The :ref:`heap type <syntax-heaptype>` :math:`\heaptype_1` :ref:`matches <match-heaptype>` :math:`\heaptype_2`.
 
-* Either both :math:`\reftype_1` and :math:`\reftype_2` are the same.
+* :math:`\NULL_1` is absent or :math:`\NULL_2` is present.
 
 .. math::
    ~\\[-1ex]
    \frac{
+     C \vdashheaptypematch \heaptype_1 \matchesheaptype \heaptype_2
    }{
-     \vdashreftypematch \reftype \matchesvaltype \reftype
+     C \vdashreftypematch \REF~\heaptype_1 \matchesreftype \REF~\heaptype_2
+   }
+   ~\\[-1ex]
+   \frac{
+     C \vdashheaptypematch \heaptype_1 \matchesheaptype \heaptype_2
+   }{
+     C \vdashreftypematch \REF~\NULL~\heaptype_1 \matchesreftype \REF~\NULL^?~\heaptype_2
    }
 
 
@@ -297,7 +494,7 @@ A :ref:`value type <syntax-valtype>` :math:`\valtype_1` matches a :ref:`value ty
    ~\\[-1ex]
    \frac{
    }{
-     \vdashvaltypematch \BOT \matchesvaltype \valtype
+     C \vdashvaltypematch \BOT \matchesvaltype \valtype
    }
 
 
@@ -314,12 +511,45 @@ That is, a :ref:`result type <syntax-resulttype>` :math:`[t_1^\ast]` matches a :
 .. math::
    ~\\[-1ex]
    \frac{
-     (\vdashvaltypematch t_1 \matchesvaltype t_2)^\ast
+     (C \vdashvaltypematch t_1 \matchesvaltype t_2)^\ast
    }{
-     \vdashresulttypematch [t_1^\ast] \matchesresulttype [t_2^ast]
+     C \vdashresulttypematch [t_1^\ast] \matchesresulttype [t_2^ast]
    }
 
 
+.. _match-functype:
+
+Function Types
+..............
+
+Subtyping is also defined for :ref:`function types <syntax-functype>`.
+However, it is required that they match in both directions, effectively demanding type equivalence.
+That is, a :ref:`function type <syntax-functype>` :math:`[t_{11}^\ast] \to [t_{12}^\ast]` matches a type :math:`[t_{21}^ast] \to [t_{22}^\ast]` if and only if:
+
+* The :ref:`result type <syntax-resulttype>` :math:`[t_{11}^\ast]` :ref:`matches <match-resulttype>` :math:`[t_{21}^\ast]`, and vice versa.
+
+* The :ref:`result type <syntax-resulttype>` :math:`[t_{12}^\ast]` :ref:`matches <match-resulttype>` :math:`[t_{22}^\ast]`, and vice versa.
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+     \begin{array}{@{}c@{}}
+     C \vdashresulttypematch [t_{11}^\ast] \matchesresulttype [t_{21}^ast]
+     \qquad
+     C \vdashresulttypematch [t_{12}^\ast] \matchesresulttype [t_{22}^\ast]
+     \\
+     C \vdashresulttypematch [t_{21}^\ast] \matchesresulttype [t_{11}^ast]
+     \qquad
+     C \vdashresulttypematch [t_{22}^\ast] \matchesresulttype [t_{12}^\ast]
+     \end{array}
+   }{
+     C \vdashfunctypematch [t_{11}^\ast] \to [t_{12}^\ast] \matchesfunctype [t_{21}^ast] \to [t_{22}^\ast]
+   }
+
+.. note::
+   In future versions of WebAssembly, subtyping on function types may be relaxed to support co- and contra-variance.
+
+
 .. index:: ! matching, external type
 .. _exec-import:
 .. _match:
@@ -331,6 +561,8 @@ When :ref:`instantiating <exec-module>` a module,
 :ref:`external values <syntax-externval>` must be provided whose :ref:`types <valid-externval>` are *matched* against the respective :ref:`external types <syntax-externtype>` classifying each import.
 In some cases, this allows for a simple form of subtyping, as defined here.
 
+.. todo:: this requires semantics types
+
 
 .. index:: limits
 .. _match-limits:
@@ -372,7 +604,7 @@ Limits
 .. _match-externtype:
 
 .. index:: function type
-.. _match-functype:
+.. _match-externfunctype:
 
 Functions
 .........
@@ -390,7 +622,7 @@ An :ref:`external type <syntax-externtype>` :math:`\ETFUNC~\functype_1` matches
 
 
 .. index:: table type, limits, element type
-.. _match-tabletype:
+.. _match-externtabletype:
 
 Tables
 ......
@@ -410,7 +642,7 @@ An :ref:`external type <syntax-externtype>` :math:`\ETTABLE~(\limits_1~\reftype_
 
 
 .. index:: memory type, limits
-.. _match-memtype:
+.. _match-externmemtype:
 
 Memories
 ........
@@ -428,7 +660,7 @@ An :ref:`external type <syntax-externtype>` :math:`\ETMEM~\limits_1` matches :ma
 
 
 .. index:: global type, value type, mutability
-.. _match-globaltype:
+.. _match-externglobaltype:
 
 Globals
 .......
diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 646d8a437..12d696e96 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -148,15 +148,19 @@ let num_type s =
 
 let heap_type s =
   let pos = pos s in
-  match vs33 s with
-  | -0x10l -> FuncHeapType
-  | -0x11l -> ExternHeapType
-  | i when i >= 0l -> DefHeapType (SynVar i)
-  | _ -> error s pos "malformed heap type"
+  if peek s land 0xc0 = 0x40 then
+    match vs7 s with
+    | -0x10l -> FuncHeapType
+    | -0x11l -> ExternHeapType
+    | _ -> error s pos "malformed heap type"
+  else
+    match vs33 s with
+    | i when i >= 0l -> DefHeapType (SynVar i)
+    | _ -> error s pos "malformed heap type"
 
 let ref_type s =
   let pos = pos s in
-  match vs33 s with
+  match vs7 s with
   | -0x10l -> (Nullable, FuncHeapType)
   | -0x11l -> (Nullable, ExternHeapType)
   | -0x14l -> (Nullable, heap_type s)
diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index 567dcc331..60edb66cc 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -108,10 +108,10 @@ struct
     | BotHeapType -> assert false
 
   let ref_type = function
-    | (Nullable, FuncHeapType) -> vs32 (-0x10l)
-    | (Nullable, ExternHeapType) -> vs32 (-0x11l)
-    | (Nullable, t) -> vs33 (-0x14l); heap_type t
-    | (NonNullable, t) -> vs33 (-0x15l); heap_type t
+    | (Nullable, FuncHeapType) -> vs7 (-0x10l)
+    | (Nullable, ExternHeapType) -> vs7 (-0x11l)
+    | (Nullable, t) -> vs7 (-0x14l); heap_type t
+    | (NonNullable, t) -> vs7 (-0x15l); heap_type t
 
   let value_type = function
     | NumType t -> num_type t

From ea1e36c3ea7ffe2fa8b9767722305bc3ab204190 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Fri, 25 Jun 2021 08:52:34 +0200
Subject: [PATCH 022/285] [spec] New instructions

---
 .../core/appendix/gen-index-instructions.py   |  12 +-
 document/core/appendix/index-instructions.rst | 548 +++++++++---------
 document/core/binary/instructions.rst         |  15 +-
 document/core/exec/instructions.rst           | 125 +++-
 document/core/syntax/instructions.rst         |  14 +-
 document/core/text/instructions.rst           |  12 +-
 document/core/util/macros.def                 |   6 +-
 document/core/valid/instructions.rst          | 120 +++-
 proposals/function-references/Overview.md     |   2 +-
 9 files changed, 528 insertions(+), 326 deletions(-)

diff --git a/document/core/appendix/gen-index-instructions.py b/document/core/appendix/gen-index-instructions.py
index 6191a07b8..f366ae480 100755
--- a/document/core/appendix/gen-index-instructions.py
+++ b/document/core/appendix/gen-index-instructions.py
@@ -81,7 +81,7 @@ def Instruction(name, opcode, type=None, validation=None, execution=None, operat
     Instruction(r'\CALLINDIRECT~x~y', r'\hex{11}', r'[t_1^\ast~\I32] \to [t_2^\ast]', r'valid-call_indirect', r'exec-call_indirect'),
     Instruction(None, r'\hex{12}'),
     Instruction(None, r'\hex{13}'),
-    Instruction(None, r'\hex{14}'),
+    Instruction(r'\CALLREF', r'\hex{14}', r'[t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]', r'valid-call_ref', r'exec-call_ref'),
     Instruction(None, r'\hex{15}'),
     Instruction(None, r'\hex{16}'),
     Instruction(None, r'\hex{17}'),
@@ -269,13 +269,13 @@ def Instruction(name, opcode, type=None, validation=None, execution=None, operat
     Instruction(None, r'\hex{CD}'),
     Instruction(None, r'\hex{CE}'),
     Instruction(None, r'\hex{CF}'),
-    Instruction(r'\REFNULL~t', r'\hex{D0}', r'[] \to [t]', r'valid-ref.null', r'exec-ref.null'),
-    Instruction(r'\REFISNULL', r'\hex{D1}', r'[t] \to [\I32]', r'valid-ref.is_null', r'exec-ref.is_null'),
+    Instruction(r'\REFNULL~\X{ht}', r'\hex{D0}', r'[] \to [(\REF~\NULL~\X{ht})]', r'valid-ref.null', r'exec-ref.null'),
+    Instruction(r'\REFISNULL', r'\hex{D1}', r'[(\REF~\NULL~\X{ht})] \to [\I32]', r'valid-ref.is_null', r'exec-ref.is_null'),
     Instruction(r'\REFFUNC~x', r'\hex{D2}', r'[] \to [\FUNCREF]', r'valid-ref.func', r'exec-ref.func'),
-    Instruction(None, r'\hex{D3}'),
-    Instruction(None, r'\hex{D4}'),
+    Instruction(r'\REFASNONNULL', r'\hex{D3}', r'[(\REF~\NULL~\X{ht})] \to [(\REF~\X{ht})]', r'valid-ref.as_non_null', r'exec-ref.as_non_null'),
+    Instruction(r'\BRONNULL~l', r'\hex{D4}', r'[t^\ast~(\REF~\NULL~\X{ht})] \to [t^\ast~(\REF~\X{ht})]', r'valid-br_on_null', r'exec-br_on_null'),
     Instruction(None, r'\hex{D5}'),
-    Instruction(None, r'\hex{D6}'),
+    Instruction(r'\BRONNONNULL~l', r'\hex{D6}', r'[t^\ast~(\REF~\NULL~\X{ht})] \to [t^\ast]', r'valid-br_on_non_null', r'exec-br_on_non_null'),
     Instruction(None, r'\hex{D7}'),
     Instruction(None, r'\hex{D8}'),
     Instruction(None, r'\hex{D9}'),
diff --git a/document/core/appendix/index-instructions.rst b/document/core/appendix/index-instructions.rst
index 55bf8fb98..545638b6b 100644
--- a/document/core/appendix/index-instructions.rst
+++ b/document/core/appendix/index-instructions.rst
@@ -6,277 +6,277 @@
 Index of Instructions
 ---------------------
 
-=========================================  =========================  =============================================  =======================================  ===============================================================
-Instruction                                Binary Opcode              Type                                           Validation                               Execution                                                      
-=========================================  =========================  =============================================  =======================================  ===============================================================
-:math:`\UNREACHABLE`                       :math:`\hex{00}`           :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-unreachable>`    :ref:`execution <exec-unreachable>`                            
-:math:`\NOP`                               :math:`\hex{01}`           :math:`[] \to []`                              :ref:`validation <valid-nop>`            :ref:`execution <exec-nop>`                                    
-:math:`\BLOCK~\X{bt}`                      :math:`\hex{02}`           :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-block>`          :ref:`execution <exec-block>`                                  
-:math:`\LOOP~\X{bt}`                       :math:`\hex{03}`           :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-loop>`           :ref:`execution <exec-loop>`                                   
-:math:`\IF~\X{bt}`                         :math:`\hex{04}`           :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-if>`             :ref:`execution <exec-if>`                                     
-:math:`\ELSE`                              :math:`\hex{05}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{06}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{07}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{08}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{09}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{0A}`                                                                                                                                                                  
-:math:`\END`                               :math:`\hex{0B}`                                                                                                                                                                  
-:math:`\BR~l`                              :math:`\hex{0C}`           :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`       :ref:`validation <valid-br>`             :ref:`execution <exec-br>`                                     
-:math:`\BRIF~l`                            :math:`\hex{0D}`           :math:`[t^\ast~\I32] \to [t^\ast]`             :ref:`validation <valid-br_if>`          :ref:`execution <exec-br_if>`                                  
-:math:`\BRTABLE~l^\ast~l`                  :math:`\hex{0E}`           :math:`[t_1^\ast~t^\ast~\I32] \to [t_2^\ast]`  :ref:`validation <valid-br_table>`       :ref:`execution <exec-br_table>`                               
-:math:`\RETURN`                            :math:`\hex{0F}`           :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`       :ref:`validation <valid-return>`         :ref:`execution <exec-return>`                                 
-:math:`\CALL~x`                            :math:`\hex{10}`           :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-call>`           :ref:`execution <exec-call>`                                   
-:math:`\CALLINDIRECT~x~y`                  :math:`\hex{11}`           :math:`[t_1^\ast~\I32] \to [t_2^\ast]`         :ref:`validation <valid-call_indirect>`  :ref:`execution <exec-call_indirect>`                          
-(reserved)                                 :math:`\hex{12}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{13}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{14}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{15}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{16}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{17}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{18}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{19}`                                                                                                                                                                  
-:math:`\DROP`                              :math:`\hex{1A}`           :math:`[t] \to []`                             :ref:`validation <valid-drop>`           :ref:`execution <exec-drop>`                                   
-:math:`\SELECT`                            :math:`\hex{1B}`           :math:`[t~t~\I32] \to [t]`                     :ref:`validation <valid-select>`         :ref:`execution <exec-select>`                                 
-:math:`\SELECT~t`                          :math:`\hex{1C}`           :math:`[t~t~\I32] \to [t]`                     :ref:`validation <valid-select>`         :ref:`execution <exec-select>`                                 
-(reserved)                                 :math:`\hex{1D}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{1E}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{1F}`                                                                                                                                                                  
-:math:`\LOCALGET~x`                        :math:`\hex{20}`           :math:`[] \to [t]`                             :ref:`validation <valid-local.get>`      :ref:`execution <exec-local.get>`                              
-:math:`\LOCALSET~x`                        :math:`\hex{21}`           :math:`[t] \to []`                             :ref:`validation <valid-local.set>`      :ref:`execution <exec-local.set>`                              
-:math:`\LOCALTEE~x`                        :math:`\hex{22}`           :math:`[t] \to [t]`                            :ref:`validation <valid-local.tee>`      :ref:`execution <exec-local.tee>`                              
-:math:`\GLOBALGET~x`                       :math:`\hex{23}`           :math:`[] \to [t]`                             :ref:`validation <valid-global.get>`     :ref:`execution <exec-global.get>`                             
-:math:`\GLOBALSET~x`                       :math:`\hex{24}`           :math:`[t] \to []`                             :ref:`validation <valid-global.set>`     :ref:`execution <exec-global.set>`                             
-:math:`\TABLEGET~x`                        :math:`\hex{25}`           :math:`[\I32] \to [t]`                         :ref:`validation <valid-table.get>`      :ref:`execution <exec-table.get>`                              
-:math:`\TABLESET~x`                        :math:`\hex{26}`           :math:`[\I32~t] \to []`                        :ref:`validation <valid-table.set>`      :ref:`execution <exec-table.set>`                              
-(reserved)                                 :math:`\hex{27}`                                                                                                                                                                  
-:math:`\I32.\LOAD~\memarg`                 :math:`\hex{28}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-load>`           :ref:`execution <exec-load>`                                   
-:math:`\I64.\LOAD~\memarg`                 :math:`\hex{29}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-load>`           :ref:`execution <exec-load>`                                   
-:math:`\F32.\LOAD~\memarg`                 :math:`\hex{2A}`           :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-load>`           :ref:`execution <exec-load>`                                   
-:math:`\F64.\LOAD~\memarg`                 :math:`\hex{2B}`           :math:`[\I32] \to [\F64]`                      :ref:`validation <valid-load>`           :ref:`execution <exec-load>`                                   
-:math:`\I32.\LOAD\K{8\_s}~\memarg`         :math:`\hex{2C}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I32.\LOAD\K{8\_u}~\memarg`         :math:`\hex{2D}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I32.\LOAD\K{16\_s}~\memarg`        :math:`\hex{2E}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I32.\LOAD\K{16\_u}~\memarg`        :math:`\hex{2F}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{8\_s}~\memarg`         :math:`\hex{30}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{8\_u}~\memarg`         :math:`\hex{31}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{16\_s}~\memarg`        :math:`\hex{32}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{16\_u}~\memarg`        :math:`\hex{33}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{32\_s}~\memarg`        :math:`\hex{34}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{32\_u}~\memarg`        :math:`\hex{35}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I32.\STORE~\memarg`                :math:`\hex{36}`           :math:`[\I32~\I32] \to []`                     :ref:`validation <valid-store>`          :ref:`execution <exec-store>`                                  
-:math:`\I64.\STORE~\memarg`                :math:`\hex{37}`           :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-store>`          :ref:`execution <exec-store>`                                  
-:math:`\F32.\STORE~\memarg`                :math:`\hex{38}`           :math:`[\I32~\F32] \to []`                     :ref:`validation <valid-store>`          :ref:`execution <exec-store>`                                  
-:math:`\F64.\STORE~\memarg`                :math:`\hex{39}`           :math:`[\I32~\F64] \to []`                     :ref:`validation <valid-store>`          :ref:`execution <exec-store>`                                  
-:math:`\I32.\STORE\K{8}~\memarg`           :math:`\hex{3A}`           :math:`[\I32~\I32] \to []`                     :ref:`validation <valid-storen>`         :ref:`execution <exec-storen>`                                 
-:math:`\I32.\STORE\K{16}~\memarg`          :math:`\hex{3B}`           :math:`[\I32~\I32] \to []`                     :ref:`validation <valid-storen>`         :ref:`execution <exec-storen>`                                 
-:math:`\I64.\STORE\K{8}~\memarg`           :math:`\hex{3C}`           :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-storen>`         :ref:`execution <exec-storen>`                                 
-:math:`\I64.\STORE\K{16}~\memarg`          :math:`\hex{3D}`           :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-storen>`         :ref:`execution <exec-storen>`                                 
-:math:`\I64.\STORE\K{32}~\memarg`          :math:`\hex{3E}`           :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-storen>`         :ref:`execution <exec-storen>`                                 
-:math:`\MEMORYSIZE`                        :math:`\hex{3F}`           :math:`[] \to [\I32]`                          :ref:`validation <valid-memory.size>`    :ref:`execution <exec-memory.size>`                            
-:math:`\MEMORYGROW`                        :math:`\hex{40}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-memory.grow>`    :ref:`execution <exec-memory.grow>`                            
-:math:`\I32.\CONST~\i32`                   :math:`\hex{41}`           :math:`[] \to [\I32]`                          :ref:`validation <valid-const>`          :ref:`execution <exec-const>`                                  
-:math:`\I64.\CONST~\i64`                   :math:`\hex{42}`           :math:`[] \to [\I64]`                          :ref:`validation <valid-const>`          :ref:`execution <exec-const>`                                  
-:math:`\F32.\CONST~\f32`                   :math:`\hex{43}`           :math:`[] \to [\F32]`                          :ref:`validation <valid-const>`          :ref:`execution <exec-const>`                                  
-:math:`\F64.\CONST~\f64`                   :math:`\hex{44}`           :math:`[] \to [\F64]`                          :ref:`validation <valid-const>`          :ref:`execution <exec-const>`                                  
-:math:`\I32.\EQZ`                          :math:`\hex{45}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-testop>`         :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`      
-:math:`\I32.\EQ`                           :math:`\hex{46}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`        
-:math:`\I32.\NE`                           :math:`\hex{47}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`        
-:math:`\I32.\LT\K{\_s}`                    :math:`\hex{48}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`      
-:math:`\I32.\LT\K{\_u}`                    :math:`\hex{49}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`      
-:math:`\I32.\GT\K{\_s}`                    :math:`\hex{4A}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`      
-:math:`\I32.\GT\K{\_u}`                    :math:`\hex{4B}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`      
-:math:`\I32.\LE\K{\_s}`                    :math:`\hex{4C}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`      
-:math:`\I32.\LE\K{\_u}`                    :math:`\hex{4D}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`      
-:math:`\I32.\GE\K{\_s}`                    :math:`\hex{4E}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`      
-:math:`\I32.\GE\K{\_u}`                    :math:`\hex{4F}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`      
-:math:`\I64.\EQZ`                          :math:`\hex{50}`           :math:`[\I64] \to [\I32]`                      :ref:`validation <valid-testop>`         :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`      
-:math:`\I64.\EQ`                           :math:`\hex{51}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`        
-:math:`\I64.\NE`                           :math:`\hex{52}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`        
-:math:`\I64.\LT\K{\_s}`                    :math:`\hex{53}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`      
-:math:`\I64.\LT\K{\_u}`                    :math:`\hex{54}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`      
-:math:`\I64.\GT\K{\_s}`                    :math:`\hex{55}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`      
-:math:`\I64.\GT\K{\_u}`                    :math:`\hex{56}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`      
-:math:`\I64.\LE\K{\_s}`                    :math:`\hex{57}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`      
-:math:`\I64.\LE\K{\_u}`                    :math:`\hex{58}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`      
-:math:`\I64.\GE\K{\_s}`                    :math:`\hex{59}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`      
-:math:`\I64.\GE\K{\_u}`                    :math:`\hex{5A}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`      
-:math:`\F32.\EQ`                           :math:`\hex{5B}`           :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`        
-:math:`\F32.\NE`                           :math:`\hex{5C}`           :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`        
-:math:`\F32.\LT`                           :math:`\hex{5D}`           :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`        
-:math:`\F32.\GT`                           :math:`\hex{5E}`           :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`        
-:math:`\F32.\LE`                           :math:`\hex{5F}`           :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`        
-:math:`\F32.\GE`                           :math:`\hex{60}`           :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`        
-:math:`\F64.\EQ`                           :math:`\hex{61}`           :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`        
-:math:`\F64.\NE`                           :math:`\hex{62}`           :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`        
-:math:`\F64.\LT`                           :math:`\hex{63}`           :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`        
-:math:`\F64.\GT`                           :math:`\hex{64}`           :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`        
-:math:`\F64.\LE`                           :math:`\hex{65}`           :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`        
-:math:`\F64.\GE`                           :math:`\hex{66}`           :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`        
-:math:`\I32.\CLZ`                          :math:`\hex{67}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`        
-:math:`\I32.\CTZ`                          :math:`\hex{68}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`        
-:math:`\I32.\POPCNT`                       :math:`\hex{69}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`     
-:math:`\I32.\ADD`                          :math:`\hex{6A}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`       
-:math:`\I32.\SUB`                          :math:`\hex{6B}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`       
-:math:`\I32.\MUL`                          :math:`\hex{6C}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`       
-:math:`\I32.\DIV\K{\_s}`                   :math:`\hex{6D}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`     
-:math:`\I32.\DIV\K{\_u}`                   :math:`\hex{6E}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`     
-:math:`\I32.\REM\K{\_s}`                   :math:`\hex{6F}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`     
-:math:`\I32.\REM\K{\_u}`                   :math:`\hex{70}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`     
-:math:`\I32.\AND`                          :math:`\hex{71}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`       
-:math:`\I32.\OR`                           :math:`\hex{72}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`        
-:math:`\I32.\XOR`                          :math:`\hex{73}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`       
-:math:`\I32.\SHL`                          :math:`\hex{74}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`       
-:math:`\I32.\SHR\K{\_s}`                   :math:`\hex{75}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`     
-:math:`\I32.\SHR\K{\_u}`                   :math:`\hex{76}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`     
-:math:`\I32.\ROTL`                         :math:`\hex{77}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`      
-:math:`\I32.\ROTR`                         :math:`\hex{78}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`      
-:math:`\I64.\CLZ`                          :math:`\hex{79}`           :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`        
-:math:`\I64.\CTZ`                          :math:`\hex{7A}`           :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`        
-:math:`\I64.\POPCNT`                       :math:`\hex{7B}`           :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`     
-:math:`\I64.\ADD`                          :math:`\hex{7C}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`       
-:math:`\I64.\SUB`                          :math:`\hex{7D}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`       
-:math:`\I64.\MUL`                          :math:`\hex{7E}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`       
-:math:`\I64.\DIV\K{\_s}`                   :math:`\hex{7F}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`     
-:math:`\I64.\DIV\K{\_u}`                   :math:`\hex{80}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`     
-:math:`\I64.\REM\K{\_s}`                   :math:`\hex{81}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`     
-:math:`\I64.\REM\K{\_u}`                   :math:`\hex{82}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`     
-:math:`\I64.\AND`                          :math:`\hex{83}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`       
-:math:`\I64.\OR`                           :math:`\hex{84}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`        
-:math:`\I64.\XOR`                          :math:`\hex{85}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`       
-:math:`\I64.\SHL`                          :math:`\hex{86}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`       
-:math:`\I64.\SHR\K{\_s}`                   :math:`\hex{87}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`     
-:math:`\I64.\SHR\K{\_u}`                   :math:`\hex{88}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`     
-:math:`\I64.\ROTL`                         :math:`\hex{89}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`      
-:math:`\I64.\ROTR`                         :math:`\hex{8A}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`      
-:math:`\F32.\ABS`                          :math:`\hex{8B}`           :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`        
-:math:`\F32.\NEG`                          :math:`\hex{8C}`           :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`        
-:math:`\F32.\CEIL`                         :math:`\hex{8D}`           :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`       
-:math:`\F32.\FLOOR`                        :math:`\hex{8E}`           :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`      
-:math:`\F32.\TRUNC`                        :math:`\hex{8F}`           :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`      
-:math:`\F32.\NEAREST`                      :math:`\hex{90}`           :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`    
-:math:`\F32.\SQRT`                         :math:`\hex{91}`           :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`       
-:math:`\F32.\ADD`                          :math:`\hex{92}`           :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`       
-:math:`\F32.\SUB`                          :math:`\hex{93}`           :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`       
-:math:`\F32.\MUL`                          :math:`\hex{94}`           :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`       
-:math:`\F32.\DIV`                          :math:`\hex{95}`           :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`       
-:math:`\F32.\FMIN`                         :math:`\hex{96}`           :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`       
-:math:`\F32.\FMAX`                         :math:`\hex{97}`           :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`       
-:math:`\F32.\COPYSIGN`                     :math:`\hex{98}`           :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`  
-:math:`\F64.\ABS`                          :math:`\hex{99}`           :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`        
-:math:`\F64.\NEG`                          :math:`\hex{9A}`           :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`        
-:math:`\F64.\CEIL`                         :math:`\hex{9B}`           :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`       
-:math:`\F64.\FLOOR`                        :math:`\hex{9C}`           :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`      
-:math:`\F64.\TRUNC`                        :math:`\hex{9D}`           :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`      
-:math:`\F64.\NEAREST`                      :math:`\hex{9E}`           :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`    
-:math:`\F64.\SQRT`                         :math:`\hex{9F}`           :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`       
-:math:`\F64.\ADD`                          :math:`\hex{A0}`           :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`       
-:math:`\F64.\SUB`                          :math:`\hex{A1}`           :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`       
-:math:`\F64.\MUL`                          :math:`\hex{A2}`           :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`       
-:math:`\F64.\DIV`                          :math:`\hex{A3}`           :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`       
-:math:`\F64.\FMIN`                         :math:`\hex{A4}`           :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`       
-:math:`\F64.\FMAX`                         :math:`\hex{A5}`           :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`       
-:math:`\F64.\COPYSIGN`                     :math:`\hex{A6}`           :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`  
-:math:`\I32.\WRAP\K{\_}\I64`               :math:`\hex{A7}`           :math:`[\I64] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-wrap>`       
-:math:`\I32.\TRUNC\K{\_}\F32\K{\_s}`       :math:`\hex{A8}`           :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
-:math:`\I32.\TRUNC\K{\_}\F32\K{\_u}`       :math:`\hex{A9}`           :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
-:math:`\I32.\TRUNC\K{\_}\F64\K{\_s}`       :math:`\hex{AA}`           :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
-:math:`\I32.\TRUNC\K{\_}\F64\K{\_u}`       :math:`\hex{AB}`           :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
-:math:`\I64.\EXTEND\K{\_}\I32\K{\_s}`      :math:`\hex{AC}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_s>`   
-:math:`\I64.\EXTEND\K{\_}\I32\K{\_u}`      :math:`\hex{AD}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_u>`   
-:math:`\I64.\TRUNC\K{\_}\F32\K{\_s}`       :math:`\hex{AE}`           :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
-:math:`\I64.\TRUNC\K{\_}\F32\K{\_u}`       :math:`\hex{AF}`           :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
-:math:`\I64.\TRUNC\K{\_}\F64\K{\_s}`       :math:`\hex{B0}`           :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
-:math:`\I64.\TRUNC\K{\_}\F64\K{\_u}`       :math:`\hex{B1}`           :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
-:math:`\F32.\CONVERT\K{\_}\I32\K{\_s}`     :math:`\hex{B2}`           :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
-:math:`\F32.\CONVERT\K{\_}\I32\K{\_u}`     :math:`\hex{B3}`           :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
-:math:`\F32.\CONVERT\K{\_}\I64\K{\_s}`     :math:`\hex{B4}`           :math:`[\I64] \to [\F32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
-:math:`\F32.\CONVERT\K{\_}\I64\K{\_u}`     :math:`\hex{B5}`           :math:`[\I64] \to [\F32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
-:math:`\F32.\DEMOTE\K{\_}\F64`             :math:`\hex{B6}`           :math:`[\F64] \to [\F32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-demote>`     
-:math:`\F64.\CONVERT\K{\_}\I32\K{\_s}`     :math:`\hex{B7}`           :math:`[\I32] \to [\F64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
-:math:`\F64.\CONVERT\K{\_}\I32\K{\_u}`     :math:`\hex{B8}`           :math:`[\I32] \to [\F64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
-:math:`\F64.\CONVERT\K{\_}\I64\K{\_s}`     :math:`\hex{B9}`           :math:`[\I64] \to [\F64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
-:math:`\F64.\CONVERT\K{\_}\I64\K{\_u}`     :math:`\hex{BA}`           :math:`[\I64] \to [\F64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
-:math:`\F64.\PROMOTE\K{\_}\F32`            :math:`\hex{BB}`           :math:`[\F32] \to [\F64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-promote>`    
-:math:`\I32.\REINTERPRET\K{\_}\F32`        :math:`\hex{BC}`           :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
-:math:`\I64.\REINTERPRET\K{\_}\F64`        :math:`\hex{BD}`           :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
-:math:`\F32.\REINTERPRET\K{\_}\I32`        :math:`\hex{BE}`           :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
-:math:`\F64.\REINTERPRET\K{\_}\I64`        :math:`\hex{BF}`           :math:`[\I64] \to [\F64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
-:math:`\I32.\EXTEND\K{8\_s}`               :math:`\hex{C0}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
-:math:`\I32.\EXTEND\K{16\_s}`              :math:`\hex{C1}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
-:math:`\I64.\EXTEND\K{8\_s}`               :math:`\hex{C2}`           :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
-:math:`\I64.\EXTEND\K{16\_s}`              :math:`\hex{C3}`           :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
-:math:`\I64.\EXTEND\K{32\_s}`              :math:`\hex{C4}`           :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
-(reserved)                                 :math:`\hex{C5}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{C6}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{C7}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{C8}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{C9}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{CA}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{CB}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{CC}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{CD}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{CE}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{CF}`                                                                                                                                                                  
-:math:`\REFNULL~t`                         :math:`\hex{D0}`           :math:`[] \to [t]`                             :ref:`validation <valid-ref.null>`       :ref:`execution <exec-ref.null>`                               
-:math:`\REFISNULL`                         :math:`\hex{D1}`           :math:`[t] \to [\I32]`                         :ref:`validation <valid-ref.is_null>`    :ref:`execution <exec-ref.is_null>`                            
-:math:`\REFFUNC~x`                         :math:`\hex{D2}`           :math:`[] \to [\FUNCREF]`                      :ref:`validation <valid-ref.func>`       :ref:`execution <exec-ref.func>`                               
-(reserved)                                 :math:`\hex{D3}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{D4}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{D5}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{D6}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{D7}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{D8}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{D9}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{DA}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{DB}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{DC}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{DD}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{DE}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{DF}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E0}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E1}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E2}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E3}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E4}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E5}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E6}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E7}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E8}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E9}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{EA}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{EB}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{EC}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{ED}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{EE}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{EF}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F0}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F1}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F2}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F3}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F4}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F5}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F6}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F7}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F8}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F9}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{FA}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{FB}`                                                                                                                                                                  
-:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_s}`  :math:`\hex{FC}~\hex{00}`  :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
-:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_u}`  :math:`\hex{FC}~\hex{01}`  :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
-:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_s}`  :math:`\hex{FC}~\hex{02}`  :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
-:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_u}`  :math:`\hex{FC}~\hex{03}`  :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
-:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_s}`  :math:`\hex{FC}~\hex{04}`  :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
-:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_u}`  :math:`\hex{FC}~\hex{05}`  :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
-:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_s}`  :math:`\hex{FC}~\hex{06}`  :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
-:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_u}`  :math:`\hex{FC}~\hex{07}`  :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
-:math:`\MEMORYINIT~x`                      :math:`\hex{FC}~\hex{08}`  :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-memory.init>`    :ref:`execution <exec-memory.init>`                            
-:math:`\DATADROP~x`                        :math:`\hex{FC}~\hex{09}`  :math:`[] \to []`                              :ref:`validation <valid-data.drop>`      :ref:`execution <exec-data.drop>`                              
-:math:`\MEMORYCOPY`                        :math:`\hex{FC}~\hex{0A}`  :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-memory.copy>`    :ref:`execution <exec-memory.copy>`                            
-:math:`\MEMORYFILL`                        :math:`\hex{FC}~\hex{0B}`  :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-memory.fill>`    :ref:`execution <exec-memory.fill>`                            
-:math:`\TABLEINIT~x~y`                     :math:`\hex{FC}~\hex{0C}`  :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-table.init>`     :ref:`execution <exec-table.init>`                             
-:math:`\ELEMDROP~x`                        :math:`\hex{FC}~\hex{0D}`  :math:`[] \to []`                              :ref:`validation <valid-elem.drop>`      :ref:`execution <exec-elem.drop>`                              
-:math:`\TABLECOPY~x~y`                     :math:`\hex{FC}~\hex{0E}`  :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-table.copy>`     :ref:`execution <exec-table.copy>`                             
-:math:`\TABLEGROW~x`                       :math:`\hex{FC}~\hex{0F}`  :math:`[t~\I32] \to []`                        :ref:`validation <valid-table.grow>`     :ref:`execution <exec-table.grow>`                             
-:math:`\TABLESIZE~x`                       :math:`\hex{FC}~\hex{10}`  :math:`[] \to [\I32]`                          :ref:`validation <valid-table.size>`     :ref:`execution <exec-table.size>`                             
-:math:`\TABLEFILL~x`                       :math:`\hex{FC}~\hex{11}`  :math:`[\I32~t~\I32] \to []`                   :ref:`validation <valid-table.fill>`     :ref:`execution <exec-table.fill>`                             
-=========================================  =========================  =============================================  =======================================  ===============================================================
+=========================================  =========================  ===============================================================  =========================================  ===============================================================
+Instruction                                Binary Opcode              Type                                                             Validation                                 Execution                                                      
+=========================================  =========================  ===============================================================  =========================================  ===============================================================
+:math:`\UNREACHABLE`                       :math:`\hex{00}`           :math:`[t_1^\ast] \to [t_2^\ast]`                                :ref:`validation <valid-unreachable>`      :ref:`execution <exec-unreachable>`                            
+:math:`\NOP`                               :math:`\hex{01}`           :math:`[] \to []`                                                :ref:`validation <valid-nop>`              :ref:`execution <exec-nop>`                                    
+:math:`\BLOCK~\X{bt}`                      :math:`\hex{02}`           :math:`[t_1^\ast] \to [t_2^\ast]`                                :ref:`validation <valid-block>`            :ref:`execution <exec-block>`                                  
+:math:`\LOOP~\X{bt}`                       :math:`\hex{03}`           :math:`[t_1^\ast] \to [t_2^\ast]`                                :ref:`validation <valid-loop>`             :ref:`execution <exec-loop>`                                   
+:math:`\IF~\X{bt}`                         :math:`\hex{04}`           :math:`[t_1^\ast] \to [t_2^\ast]`                                :ref:`validation <valid-if>`               :ref:`execution <exec-if>`                                     
+:math:`\ELSE`                              :math:`\hex{05}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{06}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{07}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{08}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{09}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{0A}`                                                                                                                                                                                      
+:math:`\END`                               :math:`\hex{0B}`                                                                                                                                                                                      
+:math:`\BR~l`                              :math:`\hex{0C}`           :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`                         :ref:`validation <valid-br>`               :ref:`execution <exec-br>`                                     
+:math:`\BRIF~l`                            :math:`\hex{0D}`           :math:`[t^\ast~\I32] \to [t^\ast]`                               :ref:`validation <valid-br_if>`            :ref:`execution <exec-br_if>`                                  
+:math:`\BRTABLE~l^\ast~l`                  :math:`\hex{0E}`           :math:`[t_1^\ast~t^\ast~\I32] \to [t_2^\ast]`                    :ref:`validation <valid-br_table>`         :ref:`execution <exec-br_table>`                               
+:math:`\RETURN`                            :math:`\hex{0F}`           :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`                         :ref:`validation <valid-return>`           :ref:`execution <exec-return>`                                 
+:math:`\CALL~x`                            :math:`\hex{10}`           :math:`[t_1^\ast] \to [t_2^\ast]`                                :ref:`validation <valid-call>`             :ref:`execution <exec-call>`                                   
+:math:`\CALLINDIRECT~x~y`                  :math:`\hex{11}`           :math:`[t_1^\ast~\I32] \to [t_2^\ast]`                           :ref:`validation <valid-call_indirect>`    :ref:`execution <exec-call_indirect>`                          
+(reserved)                                 :math:`\hex{12}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{13}`                                                                                                                                                                                      
+:math:`\CALLREF`                           :math:`\hex{14}`           :math:`[t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]`                 :ref:`validation <valid-call_ref>`         :ref:`execution <exec-call_ref>`                               
+(reserved)                                 :math:`\hex{15}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{16}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{17}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{18}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{19}`                                                                                                                                                                                      
+:math:`\DROP`                              :math:`\hex{1A}`           :math:`[t] \to []`                                               :ref:`validation <valid-drop>`             :ref:`execution <exec-drop>`                                   
+:math:`\SELECT`                            :math:`\hex{1B}`           :math:`[t~t~\I32] \to [t]`                                       :ref:`validation <valid-select>`           :ref:`execution <exec-select>`                                 
+:math:`\SELECT~t`                          :math:`\hex{1C}`           :math:`[t~t~\I32] \to [t]`                                       :ref:`validation <valid-select>`           :ref:`execution <exec-select>`                                 
+(reserved)                                 :math:`\hex{1D}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{1E}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{1F}`                                                                                                                                                                                      
+:math:`\LOCALGET~x`                        :math:`\hex{20}`           :math:`[] \to [t]`                                               :ref:`validation <valid-local.get>`        :ref:`execution <exec-local.get>`                              
+:math:`\LOCALSET~x`                        :math:`\hex{21}`           :math:`[t] \to []`                                               :ref:`validation <valid-local.set>`        :ref:`execution <exec-local.set>`                              
+:math:`\LOCALTEE~x`                        :math:`\hex{22}`           :math:`[t] \to [t]`                                              :ref:`validation <valid-local.tee>`        :ref:`execution <exec-local.tee>`                              
+:math:`\GLOBALGET~x`                       :math:`\hex{23}`           :math:`[] \to [t]`                                               :ref:`validation <valid-global.get>`       :ref:`execution <exec-global.get>`                             
+:math:`\GLOBALSET~x`                       :math:`\hex{24}`           :math:`[t] \to []`                                               :ref:`validation <valid-global.set>`       :ref:`execution <exec-global.set>`                             
+:math:`\TABLEGET~x`                        :math:`\hex{25}`           :math:`[\I32] \to [t]`                                           :ref:`validation <valid-table.get>`        :ref:`execution <exec-table.get>`                              
+:math:`\TABLESET~x`                        :math:`\hex{26}`           :math:`[\I32~t] \to []`                                          :ref:`validation <valid-table.set>`        :ref:`execution <exec-table.set>`                              
+(reserved)                                 :math:`\hex{27}`                                                                                                                                                                                      
+:math:`\I32.\LOAD~\memarg`                 :math:`\hex{28}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-load>`             :ref:`execution <exec-load>`                                   
+:math:`\I64.\LOAD~\memarg`                 :math:`\hex{29}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-load>`             :ref:`execution <exec-load>`                                   
+:math:`\F32.\LOAD~\memarg`                 :math:`\hex{2A}`           :math:`[\I32] \to [\F32]`                                        :ref:`validation <valid-load>`             :ref:`execution <exec-load>`                                   
+:math:`\F64.\LOAD~\memarg`                 :math:`\hex{2B}`           :math:`[\I32] \to [\F64]`                                        :ref:`validation <valid-load>`             :ref:`execution <exec-load>`                                   
+:math:`\I32.\LOAD\K{8\_s}~\memarg`         :math:`\hex{2C}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
+:math:`\I32.\LOAD\K{8\_u}~\memarg`         :math:`\hex{2D}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
+:math:`\I32.\LOAD\K{16\_s}~\memarg`        :math:`\hex{2E}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
+:math:`\I32.\LOAD\K{16\_u}~\memarg`        :math:`\hex{2F}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
+:math:`\I64.\LOAD\K{8\_s}~\memarg`         :math:`\hex{30}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
+:math:`\I64.\LOAD\K{8\_u}~\memarg`         :math:`\hex{31}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
+:math:`\I64.\LOAD\K{16\_s}~\memarg`        :math:`\hex{32}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
+:math:`\I64.\LOAD\K{16\_u}~\memarg`        :math:`\hex{33}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
+:math:`\I64.\LOAD\K{32\_s}~\memarg`        :math:`\hex{34}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
+:math:`\I64.\LOAD\K{32\_u}~\memarg`        :math:`\hex{35}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
+:math:`\I32.\STORE~\memarg`                :math:`\hex{36}`           :math:`[\I32~\I32] \to []`                                       :ref:`validation <valid-store>`            :ref:`execution <exec-store>`                                  
+:math:`\I64.\STORE~\memarg`                :math:`\hex{37}`           :math:`[\I32~\I64] \to []`                                       :ref:`validation <valid-store>`            :ref:`execution <exec-store>`                                  
+:math:`\F32.\STORE~\memarg`                :math:`\hex{38}`           :math:`[\I32~\F32] \to []`                                       :ref:`validation <valid-store>`            :ref:`execution <exec-store>`                                  
+:math:`\F64.\STORE~\memarg`                :math:`\hex{39}`           :math:`[\I32~\F64] \to []`                                       :ref:`validation <valid-store>`            :ref:`execution <exec-store>`                                  
+:math:`\I32.\STORE\K{8}~\memarg`           :math:`\hex{3A}`           :math:`[\I32~\I32] \to []`                                       :ref:`validation <valid-storen>`           :ref:`execution <exec-storen>`                                 
+:math:`\I32.\STORE\K{16}~\memarg`          :math:`\hex{3B}`           :math:`[\I32~\I32] \to []`                                       :ref:`validation <valid-storen>`           :ref:`execution <exec-storen>`                                 
+:math:`\I64.\STORE\K{8}~\memarg`           :math:`\hex{3C}`           :math:`[\I32~\I64] \to []`                                       :ref:`validation <valid-storen>`           :ref:`execution <exec-storen>`                                 
+:math:`\I64.\STORE\K{16}~\memarg`          :math:`\hex{3D}`           :math:`[\I32~\I64] \to []`                                       :ref:`validation <valid-storen>`           :ref:`execution <exec-storen>`                                 
+:math:`\I64.\STORE\K{32}~\memarg`          :math:`\hex{3E}`           :math:`[\I32~\I64] \to []`                                       :ref:`validation <valid-storen>`           :ref:`execution <exec-storen>`                                 
+:math:`\MEMORYSIZE`                        :math:`\hex{3F}`           :math:`[] \to [\I32]`                                            :ref:`validation <valid-memory.size>`      :ref:`execution <exec-memory.size>`                            
+:math:`\MEMORYGROW`                        :math:`\hex{40}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-memory.grow>`      :ref:`execution <exec-memory.grow>`                            
+:math:`\I32.\CONST~\i32`                   :math:`\hex{41}`           :math:`[] \to [\I32]`                                            :ref:`validation <valid-const>`            :ref:`execution <exec-const>`                                  
+:math:`\I64.\CONST~\i64`                   :math:`\hex{42}`           :math:`[] \to [\I64]`                                            :ref:`validation <valid-const>`            :ref:`execution <exec-const>`                                  
+:math:`\F32.\CONST~\f32`                   :math:`\hex{43}`           :math:`[] \to [\F32]`                                            :ref:`validation <valid-const>`            :ref:`execution <exec-const>`                                  
+:math:`\F64.\CONST~\f64`                   :math:`\hex{44}`           :math:`[] \to [\F64]`                                            :ref:`validation <valid-const>`            :ref:`execution <exec-const>`                                  
+:math:`\I32.\EQZ`                          :math:`\hex{45}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-testop>`           :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`      
+:math:`\I32.\EQ`                           :math:`\hex{46}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`        
+:math:`\I32.\NE`                           :math:`\hex{47}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`        
+:math:`\I32.\LT\K{\_s}`                    :math:`\hex{48}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`      
+:math:`\I32.\LT\K{\_u}`                    :math:`\hex{49}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`      
+:math:`\I32.\GT\K{\_s}`                    :math:`\hex{4A}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`      
+:math:`\I32.\GT\K{\_u}`                    :math:`\hex{4B}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`      
+:math:`\I32.\LE\K{\_s}`                    :math:`\hex{4C}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`      
+:math:`\I32.\LE\K{\_u}`                    :math:`\hex{4D}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`      
+:math:`\I32.\GE\K{\_s}`                    :math:`\hex{4E}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`      
+:math:`\I32.\GE\K{\_u}`                    :math:`\hex{4F}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`      
+:math:`\I64.\EQZ`                          :math:`\hex{50}`           :math:`[\I64] \to [\I32]`                                        :ref:`validation <valid-testop>`           :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`      
+:math:`\I64.\EQ`                           :math:`\hex{51}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`        
+:math:`\I64.\NE`                           :math:`\hex{52}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`        
+:math:`\I64.\LT\K{\_s}`                    :math:`\hex{53}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`      
+:math:`\I64.\LT\K{\_u}`                    :math:`\hex{54}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`      
+:math:`\I64.\GT\K{\_s}`                    :math:`\hex{55}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`      
+:math:`\I64.\GT\K{\_u}`                    :math:`\hex{56}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`      
+:math:`\I64.\LE\K{\_s}`                    :math:`\hex{57}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`      
+:math:`\I64.\LE\K{\_u}`                    :math:`\hex{58}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`      
+:math:`\I64.\GE\K{\_s}`                    :math:`\hex{59}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`      
+:math:`\I64.\GE\K{\_u}`                    :math:`\hex{5A}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`      
+:math:`\F32.\EQ`                           :math:`\hex{5B}`           :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`        
+:math:`\F32.\NE`                           :math:`\hex{5C}`           :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`        
+:math:`\F32.\LT`                           :math:`\hex{5D}`           :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`        
+:math:`\F32.\GT`                           :math:`\hex{5E}`           :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`        
+:math:`\F32.\LE`                           :math:`\hex{5F}`           :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`        
+:math:`\F32.\GE`                           :math:`\hex{60}`           :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`        
+:math:`\F64.\EQ`                           :math:`\hex{61}`           :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`        
+:math:`\F64.\NE`                           :math:`\hex{62}`           :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`        
+:math:`\F64.\LT`                           :math:`\hex{63}`           :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`        
+:math:`\F64.\GT`                           :math:`\hex{64}`           :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`        
+:math:`\F64.\LE`                           :math:`\hex{65}`           :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`        
+:math:`\F64.\GE`                           :math:`\hex{66}`           :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`        
+:math:`\I32.\CLZ`                          :math:`\hex{67}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`        
+:math:`\I32.\CTZ`                          :math:`\hex{68}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`        
+:math:`\I32.\POPCNT`                       :math:`\hex{69}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`     
+:math:`\I32.\ADD`                          :math:`\hex{6A}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`       
+:math:`\I32.\SUB`                          :math:`\hex{6B}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`       
+:math:`\I32.\MUL`                          :math:`\hex{6C}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`       
+:math:`\I32.\DIV\K{\_s}`                   :math:`\hex{6D}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`     
+:math:`\I32.\DIV\K{\_u}`                   :math:`\hex{6E}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`     
+:math:`\I32.\REM\K{\_s}`                   :math:`\hex{6F}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`     
+:math:`\I32.\REM\K{\_u}`                   :math:`\hex{70}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`     
+:math:`\I32.\AND`                          :math:`\hex{71}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`       
+:math:`\I32.\OR`                           :math:`\hex{72}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`        
+:math:`\I32.\XOR`                          :math:`\hex{73}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`       
+:math:`\I32.\SHL`                          :math:`\hex{74}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`       
+:math:`\I32.\SHR\K{\_s}`                   :math:`\hex{75}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`     
+:math:`\I32.\SHR\K{\_u}`                   :math:`\hex{76}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`     
+:math:`\I32.\ROTL`                         :math:`\hex{77}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`      
+:math:`\I32.\ROTR`                         :math:`\hex{78}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`      
+:math:`\I64.\CLZ`                          :math:`\hex{79}`           :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`        
+:math:`\I64.\CTZ`                          :math:`\hex{7A}`           :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`        
+:math:`\I64.\POPCNT`                       :math:`\hex{7B}`           :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`     
+:math:`\I64.\ADD`                          :math:`\hex{7C}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`       
+:math:`\I64.\SUB`                          :math:`\hex{7D}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`       
+:math:`\I64.\MUL`                          :math:`\hex{7E}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`       
+:math:`\I64.\DIV\K{\_s}`                   :math:`\hex{7F}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`     
+:math:`\I64.\DIV\K{\_u}`                   :math:`\hex{80}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`     
+:math:`\I64.\REM\K{\_s}`                   :math:`\hex{81}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`     
+:math:`\I64.\REM\K{\_u}`                   :math:`\hex{82}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`     
+:math:`\I64.\AND`                          :math:`\hex{83}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`       
+:math:`\I64.\OR`                           :math:`\hex{84}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`        
+:math:`\I64.\XOR`                          :math:`\hex{85}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`       
+:math:`\I64.\SHL`                          :math:`\hex{86}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`       
+:math:`\I64.\SHR\K{\_s}`                   :math:`\hex{87}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`     
+:math:`\I64.\SHR\K{\_u}`                   :math:`\hex{88}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`     
+:math:`\I64.\ROTL`                         :math:`\hex{89}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`      
+:math:`\I64.\ROTR`                         :math:`\hex{8A}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`      
+:math:`\F32.\ABS`                          :math:`\hex{8B}`           :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`        
+:math:`\F32.\NEG`                          :math:`\hex{8C}`           :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`        
+:math:`\F32.\CEIL`                         :math:`\hex{8D}`           :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`       
+:math:`\F32.\FLOOR`                        :math:`\hex{8E}`           :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`      
+:math:`\F32.\TRUNC`                        :math:`\hex{8F}`           :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`      
+:math:`\F32.\NEAREST`                      :math:`\hex{90}`           :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`    
+:math:`\F32.\SQRT`                         :math:`\hex{91}`           :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`       
+:math:`\F32.\ADD`                          :math:`\hex{92}`           :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`       
+:math:`\F32.\SUB`                          :math:`\hex{93}`           :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`       
+:math:`\F32.\MUL`                          :math:`\hex{94}`           :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`       
+:math:`\F32.\DIV`                          :math:`\hex{95}`           :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`       
+:math:`\F32.\FMIN`                         :math:`\hex{96}`           :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`       
+:math:`\F32.\FMAX`                         :math:`\hex{97}`           :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`       
+:math:`\F32.\COPYSIGN`                     :math:`\hex{98}`           :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`  
+:math:`\F64.\ABS`                          :math:`\hex{99}`           :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`        
+:math:`\F64.\NEG`                          :math:`\hex{9A}`           :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`        
+:math:`\F64.\CEIL`                         :math:`\hex{9B}`           :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`       
+:math:`\F64.\FLOOR`                        :math:`\hex{9C}`           :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`      
+:math:`\F64.\TRUNC`                        :math:`\hex{9D}`           :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`      
+:math:`\F64.\NEAREST`                      :math:`\hex{9E}`           :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`    
+:math:`\F64.\SQRT`                         :math:`\hex{9F}`           :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`       
+:math:`\F64.\ADD`                          :math:`\hex{A0}`           :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`       
+:math:`\F64.\SUB`                          :math:`\hex{A1}`           :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`       
+:math:`\F64.\MUL`                          :math:`\hex{A2}`           :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`       
+:math:`\F64.\DIV`                          :math:`\hex{A3}`           :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`       
+:math:`\F64.\FMIN`                         :math:`\hex{A4}`           :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`       
+:math:`\F64.\FMAX`                         :math:`\hex{A5}`           :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`       
+:math:`\F64.\COPYSIGN`                     :math:`\hex{A6}`           :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`  
+:math:`\I32.\WRAP\K{\_}\I64`               :math:`\hex{A7}`           :math:`[\I64] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-wrap>`       
+:math:`\I32.\TRUNC\K{\_}\F32\K{\_s}`       :math:`\hex{A8}`           :math:`[\F32] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
+:math:`\I32.\TRUNC\K{\_}\F32\K{\_u}`       :math:`\hex{A9}`           :math:`[\F32] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
+:math:`\I32.\TRUNC\K{\_}\F64\K{\_s}`       :math:`\hex{AA}`           :math:`[\F64] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
+:math:`\I32.\TRUNC\K{\_}\F64\K{\_u}`       :math:`\hex{AB}`           :math:`[\F64] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
+:math:`\I64.\EXTEND\K{\_}\I32\K{\_s}`      :math:`\hex{AC}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_s>`   
+:math:`\I64.\EXTEND\K{\_}\I32\K{\_u}`      :math:`\hex{AD}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_u>`   
+:math:`\I64.\TRUNC\K{\_}\F32\K{\_s}`       :math:`\hex{AE}`           :math:`[\F32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
+:math:`\I64.\TRUNC\K{\_}\F32\K{\_u}`       :math:`\hex{AF}`           :math:`[\F32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
+:math:`\I64.\TRUNC\K{\_}\F64\K{\_s}`       :math:`\hex{B0}`           :math:`[\F64] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
+:math:`\I64.\TRUNC\K{\_}\F64\K{\_u}`       :math:`\hex{B1}`           :math:`[\F64] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
+:math:`\F32.\CONVERT\K{\_}\I32\K{\_s}`     :math:`\hex{B2}`           :math:`[\I32] \to [\F32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
+:math:`\F32.\CONVERT\K{\_}\I32\K{\_u}`     :math:`\hex{B3}`           :math:`[\I32] \to [\F32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
+:math:`\F32.\CONVERT\K{\_}\I64\K{\_s}`     :math:`\hex{B4}`           :math:`[\I64] \to [\F32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
+:math:`\F32.\CONVERT\K{\_}\I64\K{\_u}`     :math:`\hex{B5}`           :math:`[\I64] \to [\F32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
+:math:`\F32.\DEMOTE\K{\_}\F64`             :math:`\hex{B6}`           :math:`[\F64] \to [\F32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-demote>`     
+:math:`\F64.\CONVERT\K{\_}\I32\K{\_s}`     :math:`\hex{B7}`           :math:`[\I32] \to [\F64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
+:math:`\F64.\CONVERT\K{\_}\I32\K{\_u}`     :math:`\hex{B8}`           :math:`[\I32] \to [\F64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
+:math:`\F64.\CONVERT\K{\_}\I64\K{\_s}`     :math:`\hex{B9}`           :math:`[\I64] \to [\F64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
+:math:`\F64.\CONVERT\K{\_}\I64\K{\_u}`     :math:`\hex{BA}`           :math:`[\I64] \to [\F64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
+:math:`\F64.\PROMOTE\K{\_}\F32`            :math:`\hex{BB}`           :math:`[\F32] \to [\F64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-promote>`    
+:math:`\I32.\REINTERPRET\K{\_}\F32`        :math:`\hex{BC}`           :math:`[\F32] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
+:math:`\I64.\REINTERPRET\K{\_}\F64`        :math:`\hex{BD}`           :math:`[\F64] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
+:math:`\F32.\REINTERPRET\K{\_}\I32`        :math:`\hex{BE}`           :math:`[\I32] \to [\F32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
+:math:`\F64.\REINTERPRET\K{\_}\I64`        :math:`\hex{BF}`           :math:`[\I64] \to [\F64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
+:math:`\I32.\EXTEND\K{8\_s}`               :math:`\hex{C0}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
+:math:`\I32.\EXTEND\K{16\_s}`              :math:`\hex{C1}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
+:math:`\I64.\EXTEND\K{8\_s}`               :math:`\hex{C2}`           :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
+:math:`\I64.\EXTEND\K{16\_s}`              :math:`\hex{C3}`           :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
+:math:`\I64.\EXTEND\K{32\_s}`              :math:`\hex{C4}`           :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
+(reserved)                                 :math:`\hex{C5}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{C6}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{C7}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{C8}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{C9}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{CA}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{CB}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{CC}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{CD}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{CE}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{CF}`                                                                                                                                                                                      
+:math:`\REFNULL~\X{ht}`                    :math:`\hex{D0}`           :math:`[] \to [(\REF~\NULL~\X{ht})]`                             :ref:`validation <valid-ref.null>`         :ref:`execution <exec-ref.null>`                               
+:math:`\REFISNULL`                         :math:`\hex{D1}`           :math:`[(\REF~\NULL~\X{ht})] \to [\I32]`                         :ref:`validation <valid-ref.is_null>`      :ref:`execution <exec-ref.is_null>`                            
+:math:`\REFFUNC~x`                         :math:`\hex{D2}`           :math:`[] \to [\FUNCREF]`                                        :ref:`validation <valid-ref.func>`         :ref:`execution <exec-ref.func>`                               
+:math:`\REFASNONNULL`                      :math:`\hex{D3}`           :math:`[(\REF~\NULL~\X{ht})] \to [(\REF~\X{ht})]`                :ref:`validation <valid-ref.as_non_null>`  :ref:`execution <exec-ref.as_non_null>`                        
+:math:`\BRONNULL~l`                        :math:`\hex{D4}`           :math:`[t^\ast~(\REF~\NULL~\X{ht})] \to [t^\ast~(\REF~\X{ht})]`  :ref:`validation <valid-br_on_null>`       :ref:`execution <exec-br_on_null>`                             
+(reserved)                                 :math:`\hex{D5}`                                                                                                                                                                                      
+:math:`\BRONNONNULL~l`                     :math:`\hex{D6}`           :math:`[t^\ast~(\REF~\NULL~\X{ht})] \to [t^\ast]`                :ref:`validation <valid-br_on_non_null>`   :ref:`execution <exec-br_on_non_null>`                         
+(reserved)                                 :math:`\hex{D7}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{D8}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{D9}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{DA}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{DB}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{DC}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{DD}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{DE}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{DF}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{E0}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{E1}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{E2}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{E3}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{E4}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{E5}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{E6}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{E7}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{E8}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{E9}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{EA}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{EB}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{EC}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{ED}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{EE}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{EF}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{F0}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{F1}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{F2}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{F3}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{F4}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{F5}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{F6}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{F7}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{F8}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{F9}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{FA}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{FB}`                                                                                                                                                                                      
+:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_s}`  :math:`\hex{FC}~\hex{00}`  :math:`[\F32] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
+:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_u}`  :math:`\hex{FC}~\hex{01}`  :math:`[\F32] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
+:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_s}`  :math:`\hex{FC}~\hex{02}`  :math:`[\F64] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
+:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_u}`  :math:`\hex{FC}~\hex{03}`  :math:`[\F64] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
+:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_s}`  :math:`\hex{FC}~\hex{04}`  :math:`[\F32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
+:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_u}`  :math:`\hex{FC}~\hex{05}`  :math:`[\F32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
+:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_s}`  :math:`\hex{FC}~\hex{06}`  :math:`[\F64] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
+:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_u}`  :math:`\hex{FC}~\hex{07}`  :math:`[\F64] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
+:math:`\MEMORYINIT~x`                      :math:`\hex{FC}~\hex{08}`  :math:`[\I32~\I32~\I32] \to []`                                  :ref:`validation <valid-memory.init>`      :ref:`execution <exec-memory.init>`                            
+:math:`\DATADROP~x`                        :math:`\hex{FC}~\hex{09}`  :math:`[] \to []`                                                :ref:`validation <valid-data.drop>`        :ref:`execution <exec-data.drop>`                              
+:math:`\MEMORYCOPY`                        :math:`\hex{FC}~\hex{0A}`  :math:`[\I32~\I32~\I32] \to []`                                  :ref:`validation <valid-memory.copy>`      :ref:`execution <exec-memory.copy>`                            
+:math:`\MEMORYFILL`                        :math:`\hex{FC}~\hex{0B}`  :math:`[\I32~\I32~\I32] \to []`                                  :ref:`validation <valid-memory.fill>`      :ref:`execution <exec-memory.fill>`                            
+:math:`\TABLEINIT~x~y`                     :math:`\hex{FC}~\hex{0C}`  :math:`[\I32~\I32~\I32] \to []`                                  :ref:`validation <valid-table.init>`       :ref:`execution <exec-table.init>`                             
+:math:`\ELEMDROP~x`                        :math:`\hex{FC}~\hex{0D}`  :math:`[] \to []`                                                :ref:`validation <valid-elem.drop>`        :ref:`execution <exec-elem.drop>`                              
+:math:`\TABLECOPY~x~y`                     :math:`\hex{FC}~\hex{0E}`  :math:`[\I32~\I32~\I32] \to []`                                  :ref:`validation <valid-table.copy>`       :ref:`execution <exec-table.copy>`                             
+:math:`\TABLEGROW~x`                       :math:`\hex{FC}~\hex{0F}`  :math:`[t~\I32] \to []`                                          :ref:`validation <valid-table.grow>`       :ref:`execution <exec-table.grow>`                             
+:math:`\TABLESIZE~x`                       :math:`\hex{FC}~\hex{10}`  :math:`[] \to [\I32]`                                            :ref:`validation <valid-table.size>`       :ref:`execution <exec-table.size>`                             
+:math:`\TABLEFILL~x`                       :math:`\hex{FC}~\hex{11}`  :math:`[\I32~t~\I32] \to []`                                     :ref:`validation <valid-table.fill>`       :ref:`execution <exec-table.fill>`                             
+=========================================  =========================  ===============================================================  =========================================  ===============================================================
diff --git a/document/core/binary/instructions.rst b/document/core/binary/instructions.rst
index 9da4e1889..f6e8051fe 100644
--- a/document/core/binary/instructions.rst
+++ b/document/core/binary/instructions.rst
@@ -34,8 +34,11 @@ Control Instructions
 .. _binary-br:
 .. _binary-br_if:
 .. _binary-br_table:
+.. _binary-br_on_null:
+.. _binary-br_on_non_null:
 .. _binary-return:
 .. _binary-call:
+.. _binary-call_ref:
 .. _binary-call_indirect:
 
 .. math::
@@ -62,7 +65,10 @@ Control Instructions
        &\Rightarrow& \BRTABLE~l^\ast~l_N \\ &&|&
      \hex{0F} &\Rightarrow& \RETURN \\ &&|&
      \hex{10}~~x{:}\Bfuncidx &\Rightarrow& \CALL~x \\ &&|&
-     \hex{11}~~y{:}\Btypeidx~~x{:}\Btableidx &\Rightarrow& \CALLINDIRECT~x~y \\
+     \hex{11}~~y{:}\Btypeidx~~x{:}\Btableidx &\Rightarrow& \CALLINDIRECT~x~y \\ &&|&
+     \hex{14}~~x{:}\Bfuncidx &\Rightarrow& \CALLREF \\ &&|&
+     \hex{D4}~~x{:}\Bfuncidx &\Rightarrow& \BRONNULL \\ &&|&
+     \hex{D6}~~x{:}\Bfuncidx &\Rightarrow& \BRONNONNULL \\
    \end{array}
 
 .. note::
@@ -82,14 +88,17 @@ Reference Instructions
 :ref:`Reference instructions <syntax-instr-ref>` are represented by single byte codes.
 
 .. _binary-ref.null:
-.. _binary-ref.isnull:
+.. _binary-ref.func:
+.. _binary-ref.is_null:
+.. _binary-ref.as_non_null:
 
 .. math::
    \begin{array}{llclll}
    \production{instruction} & \Binstr &::=& \dots \\ &&|&
      \hex{D0}~~t{:}\Bheaptype &\Rightarrow& \REFNULL~t \\ &&|&
      \hex{D1} &\Rightarrow& \REFISNULL \\ &&|&
-     \hex{D2}~~x{:}\Bfuncidx &\Rightarrow& \REFFUNC~x \\
+     \hex{D2}~~x{:}\Bfuncidx &\Rightarrow& \REFFUNC~x \\ &&|&
+     \hex{D3} &\Rightarrow& \REFASNONNULL \\
    \end{array}
 
 
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 6f4c7dc74..2872970b6 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -192,15 +192,35 @@ Reference Instructions
 
 .. _exec-ref.null:
 
-:math:`\REFNULL~t`
-..................
+:math:`\REFNULL~\X{ht}`
+.......................
 
-1. Push the value :math:`\REFNULL~t` to the stack.
+1. Push the value :math:`\REFNULL~\X{ht}` to the stack.
 
 .. note::
    No formal reduction rule is required for this instruction, since the |REFNULL| instruction is already a :ref:`value <syntax-val>`.
 
 
+.. _exec-ref.func:
+
+:math:`\REFFUNC~x`
+..................
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-ref.func>`, :math:`F.\AMODULE.\MIFUNCS[x]` exists.
+
+3. Let :math:`a` be the :ref:`function address <syntax-funcaddr>` :math:`F.\AMODULE.\MIFUNCS[x]`.
+
+4. Push the value :math:`\REFFUNCADDR~a` to the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   F; \REFFUNC~x &\stepto& F; \REFFUNCADDR~a
+     & (\iff a = F.\AMODULE.\MIFUNCS[x]) \\
+   \end{array}
+
+
 .. _exec-ref.is_null:
 
 :math:`\REFISNULL`
@@ -210,7 +230,7 @@ Reference Instructions
 
 2. Pop the value :math:`\val` from the stack.
 
-3. If :math:`\val` is :math:`\REFNULL~t`, then:
+3. If :math:`\val` is :math:`\REFNULL~\X{ht}`, then:
 
    a. Push the value :math:`\I32.\CONST~1` to the stack.
 
@@ -221,29 +241,33 @@ Reference Instructions
 .. math::
    \begin{array}{lcl@{\qquad}l}
    \val~\REFISNULL &\stepto& \I32.\CONST~1
-     & (\iff \val = \REFNULL~t) \\
+     & (\iff \val = \REFNULL~\X{ht}) \\
    \val~\REFISNULL &\stepto& \I32.\CONST~0
      & (\otherwise) \\
    \end{array}
 
 
-.. _exec-ref.func:
+.. _exec-ref.as_non_null:
 
-:math:`\REFFUNC~x`
-..................
+:math:`\REFASNONNULL`
+.....................
 
-1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+1. Assert: due to :ref:`validation <valid-ref.is_null>`, a :ref:`reference value <syntax-ref>` is on the top of the stack.
 
-2. Assert: due to :ref:`validation <valid-ref.func>`, :math:`F.\AMODULE.\MIFUNCS[x]` exists.
+2. Pop the value :math:`\val` from the stack.
 
-3. Let :math:`a` be the :ref:`function address <syntax-funcaddr>` :math:`F.\AMODULE.\MIFUNCS[x]`.
+3. If :math:`\val` is :math:`\REFNULL~\X{ht}`, then:
 
-4. Push the value :math:`\REFFUNCADDR~a` to the stack.
+   a. Trap.
+
+4. Push the value :math:`\val` back to the stack.
 
 .. math::
    \begin{array}{lcl@{\qquad}l}
-   F; \REFFUNC~x &\stepto& F; \REFFUNCADDR~a
-     & (\iff a = F.\AMODULE.\MIFUNCS[x]) \\
+   \val~\REFASNONNULL &\stepto& \TRAP
+     & (\iff \val = \REFNULL~\X{ht}) \\
+   \val~\REFASNONNULL &\stepto& \val
+     & (\otherwise) \\
    \end{array}
 
 
@@ -1722,6 +1746,60 @@ Control Instructions
    \end{array}
 
 
+.. _exec-br_on_null:
+
+:math:`\BRONNULL~l`
+...................
+
+1. Assert: due to :ref:`validation <valid-ref.is_null>`, a :ref:`reference value <syntax-ref>` is on the top of the stack.
+
+2. Pop the value :math:`\val` from the stack.
+
+3. If :math:`\val` is :math:`\REFNULL~\X{ht}`, then:
+
+   a. :ref:`Execute <exec-br>` the instruction :math:`(\BR~l)`.
+
+4. Else:
+
+   a. Push the value :math:`\val` back to the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   \val~(\BRONNULL~l) &\stepto& (\BR~l)
+     & (\iff \val = \REFNULL~\X{ht}) \\
+   \val~(\BRONNULL~l) &\stepto& \val
+     & (\otherwise) \\
+   \end{array}
+
+
+.. _exec-br_on_non_null:
+
+:math:`\BRONNONNULL~l`
+......................
+
+1. Assert: due to :ref:`validation <valid-ref.is_null>`, a :ref:`reference value <syntax-ref>` is on the top of the stack.
+
+2. Pop the value :math:`\val` from the stack.
+
+3. If :math:`\val` is :math:`\REFNULL~\X{ht}`, then:
+
+   a. Do nothing.
+
+4. Else:
+
+   a. Push the value :math:`\val` back to the stack.
+
+   b. :ref:`Execute <exec-br>` the instruction :math:`(\BR~l)`.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   \val~(\BRONNONNULL~l) &\stepto& \epsilon
+     & (\iff \val = \REFNULL~\X{ht}) \\
+   \val~(\BRONNONNULL~l) &\stepto& \val~(\BR~l)
+     & (\otherwise) \\
+   \end{array}
+
+
 .. _exec-return:
 
 :math:`\RETURN`
@@ -1776,6 +1854,23 @@ Control Instructions
    \end{array}
 
 
+.. _exec-call_ref:
+
+:math:`\CALLREF`
+................
+
+1. Assert: due to :ref:`validation <valid-call_ref>`, a :ref:`function reference <syntax-ref>` is on the top of the stack.
+
+2. Pop the value :math:`\REFFUNCADDR~a` from the stack.
+
+3. :ref:`Invoke <exec-invoke>` the function instance at address :math:`a`.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   F; (\REFFUNCADDR~a)~\CALLREF &\stepto& F; (\INVOKE~a)
+   \end{array}
+
+
 .. _exec-call_indirect:
 
 :math:`\CALLINDIRECT~x~y`
@@ -1805,7 +1900,7 @@ Control Instructions
 
 11. Let :math:`r` be the :ref:`reference <syntax-ref>` :math:`\X{tab}.\TIELEM[i]`.
 
-12. If :math:`r` is :math:`\REFNULL~t`, then:
+12. If :math:`r` is :math:`\REFNULL~\X{ht}`, then:
 
     a. Trap.
 
diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index 67bc409e3..3bebe174f 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -174,8 +174,9 @@ Occasionally, it is convenient to group operators together according to the foll
 .. index:: ! reference instruction, reference, null
    pair: abstract syntax; instruction
 .. _syntax-ref.null:
-.. _syntax-ref.is_null:
 .. _syntax-ref.func:
+.. _syntax-ref.is_null:
+.. _syntax-ref.as_non_null:
 .. _syntax-instr-ref:
 
 Reference Instructions
@@ -188,11 +189,13 @@ Instructions in this group are concerned with accessing :ref:`references <syntax
    \production{instruction} & \instr &::=&
      \dots \\&&|&
      \REFNULL~\reftype \\&&|&
+     \REFFUNC~\funcidx \\&&|&
      \REFISNULL \\&&|&
-     \REFFUNC~\funcidx \\
+     \REFASNONNULL \\
    \end{array}
 
-These instruction produce a null value, check for a null value, or produce a reference to a given function, respectively.
+The first three of these instruction produce a :ref:`null <syntax-null>` value, produce a reference to a given function, or check for a null value, respectively.
+The |REFASNONNULL| casts a :ref:`nullable <syntax-reftype>` to a non-null one, and :ref:`traps <trap>` if it encounters null.
 
 
 .. index:: ! parametric instruction, value type
@@ -389,8 +392,11 @@ Instructions in this group affect the flow of control.
      \BR~\labelidx \\&&|&
      \BRIF~\labelidx \\&&|&
      \BRTABLE~\vec(\labelidx)~\labelidx \\&&|&
+     \BRONNULL~\labelidx \\&&|&
+     \BRONNONNULL~\labelidx \\&&|&
      \RETURN \\&&|&
      \CALL~\funcidx \\&&|&
+     \CALLREF \\&&|&
      \CALLINDIRECT~\tableidx~\typeidx \\
    \end{array}
 
@@ -427,6 +433,7 @@ Branch instructions come in several flavors:
 |BR| performs an unconditional branch,
 |BRIF| performs a conditional branch,
 and |BRTABLE| performs an indirect branch through an operand indexing into the label vector that is an immediate to the instruction, or to a default target if the operand is out of bounds.
+The |BRONNULL| and |BRONNONNULL| instructions check whether a reference operand is :ref:`null <syntax-null>` and branch if that is the case or not the case, respectively.
 The |RETURN| instruction is a shortcut for an unconditional branch to the outermost block, which implicitly is the body of the current function.
 Taking a branch *unwinds* the operand stack up to the height where the targeted structured control instruction was entered.
 However, branches may additionally consume operands themselves, which they push back on the operand stack after unwinding.
@@ -434,6 +441,7 @@ Forward branches require operands according to the output of the targeted block'
 Backward branches require operands according to the input of the targeted block's type, i.e., represent the values consumed by the restarted block.
 
 The |CALL| instruction invokes another :ref:`function <syntax-func>`, consuming the necessary arguments from the stack and returning the result values of the call.
+The |CALLREF| instruction invokes a function indirectly through a :ref:`function reference <syntax-reftype>` operand.
 The |CALLINDIRECT| instruction calls a function indirectly through an operand indexing into a :ref:`table <syntax-table>` that is denoted by a :ref:`table index <syntax-tableidx>` and must contain :ref:`function references <syntax-reftype>`.
 Since it may contain functions of heterogeneous type,
 the callee is dynamically checked against the :ref:`function type <syntax-functype>` indexed by the instruction's second immediate, and the call is aborted with a :ref:`trap <trap>` if it does not match.
diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index 0c350d000..d116523d8 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -95,8 +95,11 @@ However, the special case of a type use that is syntactically empty or consists
 .. _text-br:
 .. _text-br_if:
 .. _text-br_table:
+.. _text-br_on_null:
+.. _text-br_on_non_null:
 .. _text-return:
 .. _text-call:
+.. _text-call_ref:
 .. _text-call_indirect:
 
 All other control instruction are represented verbatim.
@@ -110,8 +113,11 @@ All other control instruction are represented verbatim.
      \text{br\_if}~~l{:}\Tlabelidx_I &\Rightarrow& \BRIF~l \\ &&|&
      \text{br\_table}~~l^\ast{:}\Tvec(\Tlabelidx_I)~~l_N{:}\Tlabelidx_I
        &\Rightarrow& \BRTABLE~l^\ast~l_N \\ &&|&
+     \text{br\_on\_null}~~l{:}\Tlabelidx_I &\Rightarrow& \BRONNULL~l \\ &&|&
+     \text{br\_on\_non\_null}~~l{:}\Tlabelidx_I &\Rightarrow& \BRONNONNULL~l \\ &&|&
      \text{return} &\Rightarrow& \RETURN \\ &&|&
      \text{call}~~x{:}\Tfuncidx_I &\Rightarrow& \CALL~x \\ &&|&
+     \text{call\_ref} &\Rightarrow& \CALLREF \\ &&|&
      \text{call\_indirect}~~x{:}\Ttableidx~~y,I'{:}\Ttypeuse_I &\Rightarrow& \CALLINDIRECT~x~y
        & (\iff I' = \{\ILOCALS~(\epsilon)^\ast\}) \\
    \end{array}
@@ -152,15 +158,17 @@ Reference Instructions
 ~~~~~~~~~~~~~~~~~~~~~~
 
 .. _text-ref.null:
-.. _text-ref.is_null:
 .. _text-ref.func:
+.. _text-ref.is_null:
+.. _text-ref.as_non_null:
 
 .. math::
    \begin{array}{llclll}
    \production{instruction} & \Tplaininstr_I &::=& \dots \\ &&|&
      \text{ref.null}~~t{:}\Theaptype &\Rightarrow& \REFNULL~t \\ &&|&
-     \text{ref.is\_null} &\Rightarrow& \REFISNULL \\ &&|&
      \text{ref.func}~~x{:}\Tfuncidx &\Rightarrow& \REFFUNC~x \\ &&|&
+     \text{ref.is\_null} &\Rightarrow& \REFISNULL \\ &&|&
+     \text{ref.as\_non\_null} &\Rightarrow& \REFASNONNULL \\
    \end{array}
 
 
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index dd900bcdb..24e077401 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -351,8 +351,11 @@
 .. |BR| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{br}}
 .. |BRIF| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{br\_if}}
 .. |BRTABLE| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{br\_table}}
+.. |BRONNULL| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{br\_on\_null}}
+.. |BRONNONNULL| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{br\_on\_non\_null}}
 .. |RETURN| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{return}}
 .. |CALL| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{call}}
+.. |CALLREF| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{call\_ref}}
 .. |CALLINDIRECT| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{call\_indirect}}
 
 .. |DROP| mathdef:: \xref{syntax/instructions}{syntax-instr-parametric}{\K{drop}}
@@ -383,8 +386,9 @@
 .. |DATADROP| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{data.drop}}
 
 .. |REFNULL| mathdef:: \xref{syntax/instructions}{syntax-instr-ref}{\K{ref{.}null}}
-.. |REFISNULL| mathdef:: \xref{syntax/instructions}{syntax-instr-ref}{\K{ref{.}is\_null}}
 .. |REFFUNC| mathdef:: \xref{syntax/instructions}{syntax-instr-ref}{\K{ref{.}func}}
+.. |REFISNULL| mathdef:: \xref{syntax/instructions}{syntax-instr-ref}{\K{ref{.}is\_null}}
+.. |REFASNONNULL| mathdef:: \xref{syntax/instructions}{syntax-instr-ref}{\K{ref{.}as\_non\_null}}
 
 .. |CONST| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{const}}
 .. |EQZ| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{eqz}}
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 89c0c21eb..22d6647eb 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -166,32 +166,18 @@ Reference Instructions
 
 .. _valid-ref.null:
 
-:math:`\REFNULL~t`
-..................
-
-* The instruction is valid with type :math:`[] \to [t]`.
-
-.. math::
-   \frac{
-   }{
-     C \vdashinstr \REFNULL~t : [] \to [t]
-   }
+:math:`\REFNULL~\X{ht}`
+.......................
 
-.. note::
-   In future versions of WebAssembly, there may be reference types for which no null reference is allowed.
+* The :ref:`heap type <syntax-heaptype>` :math:`\X{ht}` must be :ref:`valid <valid-heaptype>`.
 
-.. _valid-ref.is_null:
-
-:math:`\REFISNULL`
-..................
-
-* The instruction is valid with type :math:`[t] \to [\I32]`, for any :ref:`reference type <syntax-reftype>` :math:`t`.
+* Then the instruction is valid with type :math:`[] \to [(\REF~\NULL~\X{ht})]`.
 
 .. math::
    \frac{
-     t = \reftype
+     C \vdashheaptype \X{ht} \ok
    }{
-     C \vdashinstr \REFISNULL : [t] \to [\I32]
+     C \vdashinstr \REFNULL~\X{ht} : [] \to [(\REF~\NULL~\X{ht})]
    }
 
 .. _valid-ref.func:
@@ -214,6 +200,34 @@ Reference Instructions
      C \vdashinstr \REFFUNC~x : [] \to [\FUNCREF]
    }
 
+.. _valid-ref.is_null:
+
+:math:`\REFISNULL`
+..................
+
+* The instruction is valid with type :math:`[(\REF~\NULL~\X{ht})] \to [\I32]`, for any :ref:`valid <valid-heaptype>` :ref:`heap type <syntax-heaptype>` :math:`\X{ht}`.
+
+.. math::
+   \frac{
+     C \vdashheaptype \X{ht} \ok
+   }{
+     C \vdashinstr \REFISNULL : [(\REF~\NULL~\X{ht})] \to [\I32]
+   }
+
+.. _valid-ref.as_non_null:
+
+:math:`\REFASNONNULL`
+.....................
+
+* The instruction is valid with type :math:`[(\REF~\NULL~\X{ht})] \to [(\REF~\X{ht})]`, for any :ref:`valid <valid-heaptype>` :ref:`heap type <syntax-heaptype>` :math:`\X{ht}`.
+
+.. math::
+   \frac{
+     C \vdashheaptype \X{ht} \ok
+   }{
+     C \vdashinstr \REFASNONNULL : [(\REF~\NULL~\X{ht})] \to [(\REF~\X{ht})]
+   }
+
 
 .. index:: parametric instructions, value type, polymorphism
    pair: validation; instruction
@@ -228,10 +242,11 @@ Parametric Instructions
 :math:`\DROP`
 .............
 
-* The instruction is valid with type :math:`[t] \to []`, for any :ref:`value type <syntax-valtype>` :math:`t`.
+* The instruction is valid with type :math:`[t] \to []`, for any :ref:`valid <valid-valtype>` :ref:`value type <syntax-valtype>` :math:`t`.
 
 .. math::
    \frac{
+     C \vdashvaltype t \ok
    }{
      C \vdashinstr \DROP : [t] \to []
    }
@@ -973,6 +988,52 @@ Control Instructions
    a simple :ref:`linear algorithm <algo-valid>` does not require this.
 
 
+.. _valid-br_on_null:
+
+:math:`\BRONNULL~l`
+...................
+
+* The label :math:`C.\CLABELS[l]` must be defined in the context.
+
+* Let :math:`[t^\ast]` be the :ref:`result type <syntax-resulttype>` :math:`C.\CLABELS[l]`.
+
+* Then the instruction is valid with type :math:`[t^\ast~(\REF~\NULL~\X{ht})] \to [t^\ast~(\REF~\X{ht})]` for any :ref:`valid <valid-heaptype>` :ref:`heap type <syntax-heaptype>` :math:`\X{ht}`.
+
+.. math::
+   \frac{
+     C.\CLABELS[l] = [t^\ast]
+     \qquad
+     C \vdashheaptype \X{ht} \ok
+   }{
+     C \vdashinstr \BRONNULL~l : [t^\ast~(\REF~\NULL~\X{ht})] \to [t^\ast~(\REF~\X{ht})]
+   }
+
+
+.. _valid-br_on_non_null:
+
+:math:`\BRONNONNULL~l`
+......................
+
+* The label :math:`C.\CLABELS[l]` must be defined in the context.
+
+* Let :math:`[{t'}^\ast]` be the :ref:`result type <syntax-resulttype>` :math:`C.\CLABELS[l]`.
+
+* The result type :math:`[{t'}^\ast]` must contain at least one type.
+
+* Let the :ref:`value type <syntax-valtype>` :math:`t_l` be the last element in the sequence :math:`{t'}^\ast`, and :math:`[t^\ast]` the remainder of the sequence preceding it.
+
+* The value type :math:`t_l` must be a reference type of the form :math:`\REF~\NULL^?~\X{ht}`.
+
+* Then the instruction is valid with type :math:`[t^\ast~(\REF~\NULL~\X{ht})] \to [t^\ast]`.
+
+.. math::
+   \frac{
+     C.\CLABELS[l] = [t^\ast~(\REF~\X{ht})]
+   }{
+     C \vdashinstr \BRONNONNULL~l : [t^\ast~(\REF~\NULL~\X{ht})] \to [t^\ast]
+   }
+
+
 .. _valid-return:
 
 :math:`\RETURN`
@@ -1018,6 +1079,23 @@ Control Instructions
    }
 
 
+.. _valid-call_ref:
+
+:math:`\CALLREF`
+................
+
+* Let :math:`x` be some :ref:`type index <syntax-typeidx>` for which :math:`C.\CTYPES[x]` is a :ref:`function type <syntax-functype>` of the form :math:`[t_1^\ast] \to [t_2^\ast]`.
+
+* Then the instruction is valid with type :math:`[t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]`.
+
+.. math::
+   \frac{
+     C.\CTYPES[x] = [t_1^\ast] \to [t_2^\ast]
+   }{
+     C \vdashinstr \CALLREF : [t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]
+   }
+
+
 .. _valid-call_indirect:
 
 :math:`\CALLINDIRECT~x~y`
diff --git a/proposals/function-references/Overview.md b/proposals/function-references/Overview.md
index 7d08ed54d..36dc946dd 100644
--- a/proposals/function-references/Overview.md
+++ b/proposals/function-references/Overview.md
@@ -168,7 +168,7 @@ The following rules, now defined in terms of heap types, replace and extend the
   - `(ref <heaptype1>) <: (ref null <heaptype2>)`
     - iff `<heaptype1> <: <heaptype2>`
 
-##### Constructed Types
+##### Heap Types
 
 * Any function type is a subtype of `func`
   - `$t <: func`

From 5e694c9148f9cb116b534a20cdb6a5251e628ad7 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@dfinity.org>
Date: Mon, 28 Jun 2021 15:54:22 +0200
Subject: [PATCH 023/285] [spec] Fix a bunch of minor editorial issues (#1338)

---
 document/core/binary/instructions.rst |  3 ++-
 document/core/binary/types.rst        |  4 ++--
 document/core/exec/instructions.rst   |  4 ++--
 document/core/syntax/instructions.rst | 10 +++++-----
 document/core/text/instructions.rst   |  6 +++---
 document/core/util/macros.def         |  2 +-
 document/core/valid/instructions.rst  |  6 +++---
 7 files changed, 18 insertions(+), 17 deletions(-)

diff --git a/document/core/binary/instructions.rst b/document/core/binary/instructions.rst
index d6a60d83f..26e0b8fc7 100644
--- a/document/core/binary/instructions.rst
+++ b/document/core/binary/instructions.rst
@@ -82,7 +82,8 @@ Reference Instructions
 :ref:`Reference instructions <syntax-instr-ref>` are represented by single byte codes.
 
 .. _binary-ref.null:
-.. _binary-ref.isnull:
+.. _binary-ref.func:
+.. _binary-ref.is_null:
 
 .. math::
    \begin{array}{llclll}
diff --git a/document/core/binary/types.rst b/document/core/binary/types.rst
index 7c462e029..0d1dfec86 100644
--- a/document/core/binary/types.rst
+++ b/document/core/binary/types.rst
@@ -6,8 +6,8 @@ Types
 -----
 
 .. note::
-   In future versions of WebAssembly, value types may include types denoted by :ref:`type indices <syntax-typeidx>`.
-   Thus, the binary format for types corresponds to the encodings of small negative :math:`\xref{binary/values}{binary-sint}{\sN}` values, so that they can coexist with (positive) type indices in the future.
+   In some places, possible types include both type constructors or types denoted by :ref:`type indices <syntax-typeidx>`.
+   Thus, the binary format for type constructors corresponds to the encodings of small negative :math:`\xref{binary/values}{binary-sint}{\sN}` values, such that they can unambiguously occur in the same place as (positive) type indices.
 
 
 .. index:: number type
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 6f4c7dc74..78c43da79 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -978,7 +978,7 @@ Memory Instructions
 
 9. If :math:`N` is not part of the instruction, then:
 
-   a. Let :math:`N` be the :ref:`bit width <syntax-valtype>` :math:`|t|` of :ref:`value type <syntax-valtype>` :math:`t`.
+   a. Let :math:`N` be the :ref:`bit width <syntax-numtype>` :math:`|t|` of :ref:`number type <syntax-numtype>` :math:`t`.
 
 10. If :math:`\X{ea} + N/8` is larger than the length of :math:`\X{mem}.\MIDATA`, then:
 
@@ -1058,7 +1058,7 @@ Memory Instructions
 
 11. If :math:`N` is not part of the instruction, then:
 
-    a. Let :math:`N` be the :ref:`bit width <syntax-valtype>` :math:`|t|` of :ref:`value type <syntax-valtype>` :math:`t`.
+    a. Let :math:`N` be the :ref:`bit width <syntax-numtype>` :math:`|t|` of :ref:`number type <syntax-numtype>` :math:`t`.
 
 12. If :math:`\X{ea} + N/8` is larger than the length of :math:`\X{mem}.\MIDATA`, then:
 
diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index 039d4cfb2..9c582d64c 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -35,7 +35,7 @@ The following sections group instructions into a number of different categories.
 Numeric Instructions
 ~~~~~~~~~~~~~~~~~~~~
 
-Numeric instructions provide basic operations over numeric :ref:`values <syntax-value>` of specific :ref:`type <syntax-valtype>`.
+Numeric instructions provide basic operations over numeric :ref:`values <syntax-value>` of specific :ref:`type <syntax-numtype>`.
 These operations closely match respective operations available in hardware.
 
 .. math::
@@ -118,7 +118,7 @@ These operations closely match respective operations available in hardware.
      \K{ge} \\
    \end{array}
 
-Numeric instructions are divided by :ref:`value type <syntax-valtype>`.
+Numeric instructions are divided by :ref:`number type <syntax-numtype>`.
 For each type, several subcategories can be distinguished:
 
 * *Constants*: return a static constant.
@@ -324,9 +324,9 @@ Instructions in this group are concerned with linear :ref:`memory <syntax-mem>`.
      \DATADROP~\dataidx \\
    \end{array}
 
-Memory is accessed with |LOAD| and |STORE| instructions for the different :ref:`value types <syntax-valtype>`.
+Memory is accessed with |LOAD| and |STORE| instructions for the different :ref:`number types <syntax-numtype>`.
 They all take a *memory immediate* |memarg| that contains an address *offset* and the expected *alignment* (expressed as the exponent of a power of 2).
-Integer loads and stores can optionally specify a *storage size* that is smaller than the :ref:`bit width <syntax-valtype>` of the respective value type.
+Integer loads and stores can optionally specify a *storage size* that is smaller than the :ref:`bit width <syntax-numtype>` of the respective value type.
 In the case of loads, a sign extension mode |sx| is then required to select appropriate behavior.
 
 The static address offset is added to the dynamic address operand, yielding a 33 bit *effective address* that is the zero-based index at which the memory is accessed.
@@ -351,7 +351,7 @@ The |DATADROP| instruction prevents further use of a passive data segment. This
    This restriction may be lifted in future versions.
 
 
-.. index:: ! control instruction, ! structured control, ! label, ! block, ! block type, ! branch, ! unwinding, result type, label index, function index, type index, vector, trap, function, table, function type, value type, type index
+.. index:: ! control instruction, ! structured control, ! label, ! block, ! block type, ! branch, ! unwinding, stack type, label index, function index, type index, vector, trap, function, table, function type, value type, type index
    pair: abstract syntax; instruction
    pair: abstract syntax; block type
    pair: block; type
diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index 45c2a0597..6112a7667 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -74,13 +74,13 @@ However, the special case of a type use that is syntactically empty or consists
      x,I'{:}\Ttypeuse_I &\Rightarrow& x & (\iff I' = \{\ILOCALS~(\epsilon)^\ast\}) \\
    \end{array} \\
    \production{block instruction} & \Tblockinstr_I &::=&
-     \text{block}~~I'{:}\Tlabel_I~~\X{bt}{:}\Tblocktype~~(\X{in}{:}\Tinstr_{I'})^\ast~~\text{end}~~\Tid^?
+     \text{block}~~I'{:}\Tlabel_I~~\X{bt}{:}\Tblocktype_I~~(\X{in}{:}\Tinstr_{I'})^\ast~~\text{end}~~\Tid^?
        \\ &&&\qquad \Rightarrow\quad \BLOCK~\X{bt}~\X{in}^\ast~\END
        \qquad\quad~~ (\iff \Tid^? = \epsilon \vee \Tid^? = \Tlabel) \\ &&|&
-     \text{loop}~~I'{:}\Tlabel_I~~\X{bt}{:}\Tblocktype~~(\X{in}{:}\Tinstr_{I'})^\ast~~\text{end}~~\Tid^?
+     \text{loop}~~I'{:}\Tlabel_I~~\X{bt}{:}\Tblocktype_I~~(\X{in}{:}\Tinstr_{I'})^\ast~~\text{end}~~\Tid^?
        \\ &&&\qquad \Rightarrow\quad \LOOP~\X{bt}~\X{in}^\ast~\END
        \qquad\qquad (\iff \Tid^? = \epsilon \vee \Tid^? = \Tlabel) \\ &&|&
-     \text{if}~~I'{:}\Tlabel_I~~\X{bt}{:}\Tblocktype~~(\X{in}_1{:}\Tinstr_{I'})^\ast~~
+     \text{if}~~I'{:}\Tlabel_I~~\X{bt}{:}\Tblocktype_I~~(\X{in}_1{:}\Tinstr_{I'})^\ast~~
        \text{else}~~\Tid_1^?~~(\X{in}_2{:}\Tinstr_{I'})^\ast~~\text{end}~~\Tid_2^?
        \\ &&&\qquad \Rightarrow\quad \IF~\X{bt}~\X{in}_1^\ast~\ELSE~\X{in}_2^\ast~\END
        \qquad (\iff \Tid_1^? = \epsilon \vee \Tid_1^? = \Tlabel, \Tid_2^? = \epsilon \vee \Tid_2^? = \Tlabel) \\
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index 42b310ddc..cd1bf31d6 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -308,7 +308,7 @@
 .. Modules, non-terminals
 
 .. |module| mathdef:: \xref{syntax/modules}{syntax-module}{\X{module}}
-.. |type| mathdef:: \xref{syntax/modules}{syntax-typedef}{\X{type}}
+.. |type| mathdef:: \xref{syntax/types}{syntax-functype}{\X{type}}
 .. |func| mathdef:: \xref{syntax/modules}{syntax-func}{\X{func}}
 .. |table| mathdef:: \xref{syntax/modules}{syntax-table}{\X{table}}
 .. |mem| mathdef:: \xref{syntax/modules}{syntax-mem}{\X{mem}}
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index f329a6779..07e4921b6 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -599,7 +599,7 @@ Memory Instructions
 
 * The memory :math:`C.\CMEMS[0]` must be defined in the context.
 
-* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than the :ref:`bit width <syntax-valtype>` of :math:`t` divided by :math:`8`.
+* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than the :ref:`bit width <syntax-numtype>` of :math:`t` divided by :math:`8`.
 
 * Then the instruction is valid with type :math:`[\I32] \to [t]`.
 
@@ -639,7 +639,7 @@ Memory Instructions
 
 * The memory :math:`C.\CMEMS[0]` must be defined in the context.
 
-* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than the :ref:`bit width <syntax-valtype>` of :math:`t` divided by :math:`8`.
+* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than the :ref:`bit width <syntax-numtype>` of :math:`t` divided by :math:`8`.
 
 * Then the instruction is valid with type :math:`[\I32~t] \to []`.
 
@@ -1124,7 +1124,7 @@ Expressions :math:`\expr` are classified by :ref:`result types <syntax-resulttyp
 :math:`\instr^\ast~\END`
 ........................
 
-* The instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with some :ref:`stack type <syntax-stacktype>` :math:`[] \to [t'^\ast]`.
+* The instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with some :ref:`stack type <syntax-stacktype>` :math:`[] \to [{t'}^\ast]`.
 
 * For each :ref:`operand type <syntax-opdtype>` :math:`t'_i` in :math:`{t'}^\ast` and corresponding :ref:`value type <syntax-valtype>` type :math:`t_i` in :math:`t^\ast`, :math:`t'_i` :ref:`matches <match-opdtype>` :math:`t_i`.
 

From 60c8c95809d6dd8b897b788fcc8c1f96462a3cd7 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Mon, 28 Jun 2021 19:55:50 +0200
Subject: [PATCH 024/285] [spec] Introduce semantic types

---
 document/core/appendix/properties.rst |   7 +-
 document/core/exec/instructions.rst   |  66 ++++++-----
 document/core/exec/modules.rst        | 163 +++++++++++++++++---------
 document/core/exec/runtime.rst        |  40 +++++--
 document/core/syntax/types.rst        |  82 +++++++++----
 document/core/util/macros.def         |   6 +
 document/core/valid/modules.rst       |   3 +
 document/core/valid/types.rst         | 160 +++++++++++++++++--------
 8 files changed, 356 insertions(+), 171 deletions(-)

diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index 749616b92..a5865aaf0 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -4,7 +4,9 @@
 Soundness
 ---------
 
-.. todo:: need to ensure wf of nondet types and operate wrt semantic types
+.. todo:: need to operate wrt semantic types
+.. todo:: define S |- t ok
+.. todo:: ensure wf of guessed valtypes
 
 The :ref:`type system <type-system>` of WebAssembly is *sound*, implying both *type safety* and *memory safety* with respect to the WebAssembly semantics. For example:
 
@@ -52,10 +54,11 @@ Results
 :ref:`Results <syntax-result>` :math:`\TRAP`
 ............................................
 
-* The result is valid with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`, for any sequence :math:`t^\ast` of :ref:`valid <valid-valtype>` :ref:`value types <syntax-valtype>`.
+* The result is valid with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`, for any sequence :math:`t^\ast` of :ref:`valid <valid-valtype>` :ref:`semantic <syntax-typeid>` :ref:`value types <syntax-valtype>`.
 
 .. math::
    \frac{
+     (S \vdashvaltype t \ok)^\ast
    }{
      S \vdashresult \TRAP : [t^\ast]
    }
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 2872970b6..0f51223bf 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -1568,9 +1568,9 @@ Control Instructions
 :math:`\BLOCK~\blocktype~\instr^\ast~\END`
 ..........................................
 
-1. Assert: due to :ref:`validation <valid-blocktype>`, :math:`\expand_F(\blocktype)` is defined.
+1. Assert: due to :ref:`validation <valid-blocktype>`, :math:`\expand_{S;F}(\blocktype)` is defined.
 
-2. Let :math:`[t_1^m] \to [t_2^n]` be the :ref:`function type <syntax-functype>` :math:`\expand_F(\blocktype)`.
+2. Let :math:`[t_1^m] \to [t_2^n]` be the :ref:`function type <syntax-functype>` :math:`\expand_{S;F}(\blocktype)`.
 
 3. Let :math:`L` be the label whose arity is :math:`n` and whose continuation is the end of the block.
 
@@ -1583,9 +1583,9 @@ Control Instructions
 .. math::
    ~\\[-1ex]
    \begin{array}{lcl}
-   F; \val^m~\BLOCK~\X{bt}~\instr^\ast~\END &\stepto&
-     F; \LABEL_n\{\epsilon\}~\val^m~\instr^\ast~\END
-     \\&&\quad (\iff \expand_F(\X{bt}) = [t_1^m] \to [t_2^n])
+   S; F; \val^m~\BLOCK~\X{bt}~\instr^\ast~\END &\stepto&
+     S; F; \LABEL_n\{\epsilon\}~\val^m~\instr^\ast~\END
+     \\&&\quad (\iff \expand_{S;F}(\X{bt}) = [t_1^m] \to [t_2^n])
    \end{array}
 
 
@@ -1594,9 +1594,9 @@ Control Instructions
 :math:`\LOOP~\blocktype~\instr^\ast~\END`
 .........................................
 
-1. Assert: due to :ref:`validation <valid-blocktype>`, :math:`\expand_F(\blocktype)` is defined.
+1. Assert: due to :ref:`validation <valid-blocktype>`, :math:`\expand_{S;F}(\blocktype)` is defined.
 
-2. Let :math:`[t_1^m] \to [t_2^n]` be the :ref:`function type <syntax-functype>` :math:`\expand_F(\blocktype)`.
+2. Let :math:`[t_1^m] \to [t_2^n]` be the :ref:`function type <syntax-functype>` :math:`\expand_{S;F}(\blocktype)`.
 
 3. Let :math:`L` be the label whose arity is :math:`m` and whose continuation is the start of the loop.
 
@@ -1609,9 +1609,9 @@ Control Instructions
 .. math::
    ~\\[-1ex]
    \begin{array}{lcl}
-   F; \val^m~\LOOP~\X{bt}~\instr^\ast~\END &\stepto&
-     F; \LABEL_m\{\LOOP~\X{bt}~\instr^\ast~\END\}~\val^m~\instr^\ast~\END
-     \\&&\quad (\iff \expand_F(\X{bt}) = [t_1^m] \to [t_2^n])
+   S; F; \val^m~\LOOP~\X{bt}~\instr^\ast~\END &\stepto&
+     S; F; \LABEL_m\{\LOOP~\X{bt}~\instr^\ast~\END\}~\val^m~\instr^\ast~\END
+     \\&&\quad (\iff \expand_{S;F}(\X{bt}) = [t_1^m] \to [t_2^n])
    \end{array}
 
 
@@ -1620,9 +1620,9 @@ Control Instructions
 :math:`\IF~\blocktype~\instr_1^\ast~\ELSE~\instr_2^\ast~\END`
 .............................................................
 
-1. Assert: due to :ref:`validation <valid-blocktype>`, :math:`\expand_F(\blocktype)` is defined.
+1. Assert: due to :ref:`validation <valid-blocktype>`, :math:`\expand_{S;F}(\blocktype)` is defined.
 
-2. Let :math:`[t_1^m] \to [t_2^n]` be the :ref:`function type <syntax-functype>` :math:`\expand_F(\blocktype)`.
+2. Let :math:`[t_1^m] \to [t_2^n]` be the :ref:`function type <syntax-functype>` :math:`\expand_{S;F}(\blocktype)`.
 
 3. Let :math:`L` be the label whose arity is :math:`n` and whose continuation is the end of the |IF| instruction.
 
@@ -1645,12 +1645,12 @@ Control Instructions
 .. math::
    ~\\[-1ex]
    \begin{array}{lcl}
-   F; \val^m~(\I32.\CONST~c)~\IF~\X{bt}~\instr_1^\ast~\ELSE~\instr_2^\ast~\END &\stepto&
-     F; \LABEL_n\{\epsilon\}~\val^m~\instr_1^\ast~\END
-     \\&&\quad (\iff c \neq 0 \wedge \expand_F(\X{bt}) = [t_1^m] \to [t_2^n]) \\
-   F; \val^m~(\I32.\CONST~c)~\IF~\X{bt}~\instr_1^\ast~\ELSE~\instr_2^\ast~\END &\stepto&
-     F; \LABEL_n\{\epsilon\}~\val^m~\instr_2^\ast~\END
-     \\&&\quad (\iff c = 0 \wedge \expand_F(\X{bt}) = [t_1^m] \to [t_2^n]) \\
+   S; F; \val^m~(\I32.\CONST~c)~\IF~\X{bt}~\instr_1^\ast~\ELSE~\instr_2^\ast~\END &\stepto&
+     S; F; \LABEL_n\{\epsilon\}~\val^m~\instr_1^\ast~\END
+     \\&&\quad (\iff c \neq 0 \wedge \expand_{S;F}(\X{bt}) = [t_1^m] \to [t_2^n]) \\
+   S; F; \val^m~(\I32.\CONST~c)~\IF~\X{bt}~\instr_1^\ast~\ELSE~\instr_2^\ast~\END &\stepto&
+     S; F; \LABEL_n\{\epsilon\}~\val^m~\instr_2^\ast~\END
+     \\&&\quad (\iff c = 0 \wedge \expand_{S;F}(\X{bt}) = [t_1^m] \to [t_2^n]) \\
    \end{array}
 
 
@@ -1888,37 +1888,39 @@ Control Instructions
 
 6. Assert: due to :ref:`validation <valid-call_indirect>`, :math:`F.\AMODULE.\MITYPES[y]` exists.
 
-7. Let :math:`\X{ft}_{\F{expect}}` be the :ref:`function type <syntax-functype>` :math:`F.\AMODULE.\MITYPES[y]`.
+7. Let :math:`\X{ta}` be the :ref:`type address <syntax-typeaddr>` :math:`F.\AMODULE.\MITYPES[y]`.
 
-8. Assert: due to :ref:`validation <valid-call_indirect>`, a value with :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+8. Let :math:`\X{ft}_{\F{expect}}` be the :ref:`function type <syntax-functype>` :math:`S.\STYPES[\X{ta}]`.
 
-9. Pop the value :math:`\I32.\CONST~i` from the stack.
+9. Assert: due to :ref:`validation <valid-call_indirect>`, a value with :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
 
-10. If :math:`i` is not smaller than the length of :math:`\X{tab}.\TIELEM`, then:
+10. Pop the value :math:`\I32.\CONST~i` from the stack.
+
+11. If :math:`i` is not smaller than the length of :math:`\X{tab}.\TIELEM`, then:
 
     a. Trap.
 
-11. Let :math:`r` be the :ref:`reference <syntax-ref>` :math:`\X{tab}.\TIELEM[i]`.
+12. Let :math:`r` be the :ref:`reference <syntax-ref>` :math:`\X{tab}.\TIELEM[i]`.
 
-12. If :math:`r` is :math:`\REFNULL~\X{ht}`, then:
+13. If :math:`r` is :math:`\REFNULL~\X{ht}`, then:
 
     a. Trap.
 
-13. Assert: due to :ref:`validation of table mutation <valid-table.set>`, :math:`r` is a :ref:`function reference <syntax-ref.func>`.
+14. Assert: due to :ref:`validation of table mutation <valid-table.set>`, :math:`r` is a :ref:`function reference <syntax-ref.func>`.
 
-14. Let :math:`\REFFUNCADDR~a` be the :ref:`function reference <syntax-ref.func>` :math:`r`.
+15. Let :math:`\REFFUNCADDR~a` be the :ref:`function reference <syntax-ref.func>` :math:`r`.
 
-15. Assert: due to :ref:`validation of table mutation <valid-table.set>`, :math:`S.\SFUNCS[a]` exists.
+16. Assert: due to :ref:`validation of table mutation <valid-table.set>`, :math:`S.\SFUNCS[a]` exists.
 
-16. Let :math:`\X{f}` be the :ref:`function instance <syntax-funcinst>` :math:`S.\SFUNCS[a]`.
+17. Let :math:`\X{f}` be the :ref:`function instance <syntax-funcinst>` :math:`S.\SFUNCS[a]`.
 
-17. Let :math:`\X{ft}_{\F{actual}}` be the :ref:`function type <syntax-functype>` :math:`\X{f}.\FITYPE`.
+18. Let :math:`\X{ft}_{\F{actual}}` be the :ref:`function type <syntax-functype>` :math:`\X{f}.\FITYPE`.
 
-18. If :math:`\X{ft}_{\F{actual}}` and :math:`\X{ft}_{\F{expect}}` differ, then:
+19. If :math:`\X{ft}_{\F{actual}}` and :math:`\X{ft}_{\F{expect}}` differ, then:
 
     a. Trap.
 
-19. :ref:`Invoke <exec-invoke>` the function instance at address :math:`a`.
+20. :ref:`Invoke <exec-invoke>` the function instance at address :math:`a`.
 
 .. math::
    ~\\[-1ex]
@@ -1930,7 +1932,7 @@ Control Instructions
      \begin{array}[t]{@{}r@{~}l@{}}
      (\iff & S.\STABLES[F.\AMODULE.\MITABLES[x]].\TIELEM[i] = \REFFUNCADDR~a \\
      \wedge & S.\SFUNCS[a] = f \\
-     \wedge & F.\AMODULE.\MITYPES[y] = f.\FITYPE)
+     \wedge & S \vdashfunctypematch S.\STYPES[F.\AMODULE.\MITYPES[y]] \matchesfunctype f.\FITYPE)
      \end{array}
    \\[1ex]
    \begin{array}{lcl@{\qquad}l}
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index cf0cf0874..b1024df41 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -155,7 +155,36 @@ The following auxiliary typing rules specify this typing relation relative to a
 Allocation
 ~~~~~~~~~~
 
-New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tableinst>`, :ref:`memories <syntax-meminst>`, and :ref:`globals <syntax-globalinst>` are *allocated* in a :ref:`store <syntax-store>` :math:`S`, as defined by the following auxiliary functions.
+New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tableinst>`, :ref:`memories <syntax-meminst>`, and :ref:`globals <syntax-globalinst>` are *allocated* in a :ref:`store <syntax-store>` :math:`S`, as defined by the following auxiliary functions.
+
+
+.. index:: type, type instance, type address, function type
+.. _alloc-type:
+
+:ref:`Types <syntax-typeinst>`
+..............................
+
+1. Let :math:`\functype` be the type to allocate and :math:`\moduleinst` its :ref:`module instance <syntax-moduleinst>`.
+
+2. Let :math:`a` be the first free :ref:`type address <syntax-typeaddr>` in :math:`S`.
+
+3. Assert: due to :ref:`validation <valid-module>`, any :ref:`type index <syntax-typeidx>` occurring in :math:`\functype` is smaller than the length of :math:`\moduleinst.MITYPES`.
+
+4. Let :math:`\typeinst` be the :ref:`type instance <syntax-typeinst>` obtained from :math:`\functype` by substituting each :ref:`type index <syntax-typeidx>` :math:`x` occurring in it with the :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.MITYPES[x]`.
+
+5. Append :math:`\typeinst` to the |STYPES| of :math:`S`.
+
+6. Return :math:`a`.
+
+.. math::
+   ~\\[-1ex]
+   \begin{array}{rlll}
+   \alloctype(S, \moduleinst, \functype) &=& S', \typeaddr \\[1ex]
+   \mbox{where:} \hfill \\
+   \typeaddr &=& |S.\STYPES| \\
+   \typeinst &=& \functype[\subst \moduleinst.\MITYPES] \\
+   S' &=& S \compose \{\STYPES~\typeinst\} \\
+   \end{array}
 
 
 .. index:: function, function instance, function address, module instance, function type
@@ -168,22 +197,27 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 
 2. Let :math:`a` be the first free :ref:`function address <syntax-funcaddr>` in :math:`S`.
 
-3. Let :math:`\functype` be the :ref:`function type <syntax-functype>` :math:`\moduleinst.\MITYPES[\func.\FTYPE]`.
+3. Let :math:`\typeaddr` be the :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.\MITYPES[\func.\FTYPE]`.
 
-4. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`\{ \FITYPE~\functype, \FIMODULE~\moduleinst, \FICODE~\func \}`.
+4. Let :math:`\functype` be the :ref:`function type <syntax-functype>` :math:`S.\STYPES[\typeaddr]`.
 
-5. Append :math:`\funcinst` to the |SFUNCS| of :math:`S`.
+5. Let :math:`\functype'` be the :ref:`function type <syntax-functype>`
+ obtained from :math:`\functype` by substituting each :ref:`type index <syntax-typeidx>` :math:`x` occurring in it with the :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.MITYPES[x]`.
 
-6. Return :math:`a`.
+6. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`\{ \FITYPE~\functype', \FIMODULE~\moduleinst, \FICODE~\func \}`.
+
+7. Append :math:`\funcinst` to the |SFUNCS| of :math:`S`.
+
+8. Return :math:`a`.
 
 .. math::
    ~\\[-1ex]
    \begin{array}{rlll}
-   \allocfunc(S, \func, \moduleinst) &=& S', \funcaddr \\[1ex]
+   \allocfunc(S, \func, \modulinst) &=& S', \funcaddr \\[1ex]
    \mbox{where:} \hfill \\
    \funcaddr &=& |S.\SFUNCS| \\
-   \functype &=& \moduleinst.\MITYPES[\func.\FTYPE] \\
-   \funcinst &=& \{ \FITYPE~\functype, \FIMODULE~\moduleinst, \FICODE~\func \} \\
+   \functype &=& S.\STYPES[\moduleinst.\MITYPES[\func.\FTYPE]] \\
+   \funcinst &=& \{ \FITYPE~\functype[\subst \moduleinst.\MITYPES], \FIMODULE~\moduleinst, \FICODE~\func \} \\
    S' &=& S \compose \{\SFUNCS~\funcinst\} \\
    \end{array}
 
@@ -194,7 +228,7 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 :ref:`Host Functions <syntax-hostfunc>`
 .......................................
 
-1. Let :math:`\hostfunc` be the :ref:`host function <syntax-hostfunc>` to allocate and :math:`\functype` its :ref:`function type <syntax-functype>`.
+1. Let :math:`\hostfunc` be the :ref:`host function <syntax-hostfunc>` to allocate and :math:`\functype` its :ref:`semantic <syntax-typeid>` :ref:`function type <syntax-functype>`.
 
 2. Let :math:`a` be the first free :ref:`function address <syntax-funcaddr>` in :math:`S`.
 
@@ -225,17 +259,20 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 :ref:`Tables <syntax-tableinst>`
 ................................
 
-1. Let :math:`\tabletype` be the :ref:`table type <syntax-tabletype>` to allocate and :math:`\reff` the initialization value.
+1. Let :math:`\tabletype` be the :ref:`semantic <syntax-typeid>` :ref:`table type <syntax-tabletype>` to allocate and :math:`\reff` the initialization value.
 
 2. Let :math:`(\{\LMIN~n, \LMAX~m^?\}~\reftype)` be the structure of :ref:`table type <syntax-tabletype>` :math:`\tabletype`.
 
-3. Let :math:`a` be the first free :ref:`table address <syntax-tableaddr>` in :math:`S`.
+3. Let :math:`\tabletype'` be the :ref:`table type <syntax-tabletype>`
+ obtained from :math:`\tabletype` by substituting each :ref:`type index <syntax-typeidx>` :math:`x` occurring in it with the :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.MITYPES[x]`.
 
-4. Let :math:`\tableinst` be the :ref:`table instance <syntax-tableinst>` :math:`\{ \TITYPE~\tabletype, \TIELEM~\reff^n \}` with :math:`n` elements set to :math:`\reff`.
+4. Let :math:`a` be the first free :ref:`table address <syntax-tableaddr>` in :math:`S`.
 
-5. Append :math:`\tableinst` to the |STABLES| of :math:`S`.
+5. Let :math:`\tableinst` be the :ref:`table instance <syntax-tableinst>` :math:`\{ \TITYPE~\tabletype', \TIELEM~\reff^n \}` with :math:`n` elements set to :math:`\reff`.
 
-6. Return :math:`a`.
+6. Append :math:`\tableinst` to the |STABLES| of :math:`S`.
+
+7. Return :math:`a`.
 
 .. math::
    \begin{array}{rlll}
@@ -254,7 +291,7 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 :ref:`Memories <syntax-meminst>`
 ................................
 
-1. Let :math:`\memtype` be the :ref:`memory type <syntax-memtype>` to allocate.
+1. Let :math:`\memtype` be the :ref:`semantic <syntax-typeid>` :ref:`memory type <syntax-memtype>` to allocate.
 
 2. Let :math:`\{\LMIN~n, \LMAX~m^?\}` be the structure of :ref:`memory type <syntax-memtype>` :math:`\memtype`.
 
@@ -268,7 +305,7 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 
 .. math::
    \begin{array}{rlll}
-   \allocmem(S, \memtype) &=& S', \memaddr \\[1ex]
+   \allocmem(S, \memtype, \moduleinst) &=& S', \memaddr \\[1ex]
    \mbox{where:} \hfill \\
    \memtype &=& \{\LMIN~n, \LMAX~m^?\} \\
    \memaddr &=& |S.\SMEMS| \\
@@ -283,7 +320,7 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 :ref:`Globals <syntax-globalinst>`
 ..................................
 
-1. Let :math:`\globaltype` be the :ref:`global type <syntax-globaltype>` to allocate and :math:`\val` the :ref:`value <syntax-val>` to initialize the global with.
+1. Let :math:`\globaltype` be the :ref:`semantic <syntax-typeid>` :ref:`global type <syntax-globaltype>` to allocate and :math:`\val` the :ref:`value <syntax-val>` to initialize the global with.
 
 2. Let :math:`a` be the first free :ref:`global address <syntax-globaladdr>` in :math:`S`.
 
@@ -309,7 +346,7 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 :ref:`Element segments <syntax-eleminst>`
 .........................................
 
-1. Let :math:`\reftype` be the elements' type and :math:`\reff^\ast` the vector of :ref:`references <syntax-ref>` to allocate.
+1. Let :math:`\reftype` be the elements':ref:`semantic <syntax-typeid>` type and :math:`\reff^\ast` the vector of :ref:`references <syntax-ref>` to allocate.
 
 2. Let :math:`a` be the first free :ref:`element address <syntax-elemaddr>` in :math:`S`.
 
@@ -441,54 +478,60 @@ and list of :ref:`reference <syntax-ref>` vectors for the module's :ref:`element
 
 1. Let :math:`\module` be the :ref:`module <syntax-module>` to allocate and :math:`\externval_{\F{im}}^\ast` the vector of :ref:`external values <syntax-externval>` providing the module's imports, :math:`\val^\ast` the initialization :ref:`values <syntax-val>` of the module's :ref:`globals <syntax-global>`, and :math:`(\reff^\ast)^\ast` the :ref:`reference <syntax-ref>` vectors of the module's :ref:`element segments <syntax-elem>`.
 
-2. For each :ref:`function <syntax-func>` :math:`\func_i` in :math:`\module.\MFUNCS`, do:
+2. For each :ref:`function type <syntax-functype>` :math:`\functype_i` in :math:`\module.\MTYPES`, do:
+
+   a. Let :math:`\typeaddr_i` be the :ref:`type address <syntax-typeaddr>` resulting from :ref:`allocating <alloc-type>` :math:`\functype_i` for the :ref:`\module instance <syntax-moduleinst>` :math:`\moduleinst` defined below.
+
+3. For each :ref:`function <syntax-func>` :math:`\func_i` in :math:`\module.\MFUNCS`, do:
 
    a. Let :math:`\funcaddr_i` be the :ref:`function address <syntax-funcaddr>` resulting from :ref:`allocating <alloc-func>` :math:`\func_i` for the :ref:`\module instance <syntax-moduleinst>` :math:`\moduleinst` defined below.
 
-3. For each :ref:`table <syntax-table>` :math:`\table_i` in :math:`\module.\MTABLES`, do:
+4. For each :ref:`table <syntax-table>` :math:`\table_i` in :math:`\module.\MTABLES`, do:
 
    a. Let :math:`\limits_i~t_i` be the :ref:`table type <syntax-tabletype>` :math:`\table_i.\TTYPE`.
 
    b. Let :math:`\tableaddr_i` be the :ref:`table address <syntax-tableaddr>` resulting from :ref:`allocating <alloc-table>` :math:`\table_i.\TTYPE`
    with initialization value :math:`\REFNULL~t_i`.
 
-4. For each :ref:`memory <syntax-mem>` :math:`\mem_i` in :math:`\module.\MMEMS`, do:
+5. For each :ref:`memory <syntax-mem>` :math:`\mem_i` in :math:`\module.\MMEMS`, do:
 
    a. Let :math:`\memaddr_i` be the :ref:`memory address <syntax-memaddr>` resulting from :ref:`allocating <alloc-mem>` :math:`\mem_i.\MTYPE`.
 
-5. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\MGLOBALS`, do:
+6. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\MGLOBALS`, do:
 
    a. Let :math:`\globaladdr_i` be the :ref:`global address <syntax-globaladdr>` resulting from :ref:`allocating <alloc-global>` :math:`\global_i.\GTYPE` with initializer value :math:`\val^\ast[i]`.
 
-6. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEMS`, do:
+7. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEMS`, do:
 
    a. Let :math:`\elemaddr_i` be the :ref:`element address <syntax-elemaddr>` resulting from :ref:`allocating <alloc-elem>` a :ref:`element instance <syntax-eleminst>` of :ref:`reference type <syntax-reftype>` :math:`\elem_i.\ETYPE` with contents :math:`(\reff^\ast)^\ast[i]`.
 
-7. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATAS`, do:
+8. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATAS`, do:
 
    a. Let :math:`\dataaddr_i` be the :ref:`data address <syntax-dataaddr>` resulting from :ref:`allocating <alloc-data>` a :ref:`data instance <syntax-datainst>` with contents :math:`\data_i.\DINIT`.
 
-8. Let :math:`\funcaddr^\ast` be the the concatenation of the :ref:`function addresses <syntax-funcaddr>` :math:`\funcaddr_i` in index order.
+9. Let :math:`\typeaddr^\ast` be the the concatenation of the :ref:`function addresses <syntax-typeaddr>` :math:`\typeaddr_i` in index order.
 
-9. Let :math:`\tableaddr^\ast` be the the concatenation of the :ref:`table addresses <syntax-tableaddr>` :math:`\tableaddr_i` in index order.
+10. Let :math:`\funcaddr^\ast` be the the concatenation of the :ref:`function addresses <syntax-funcaddr>` :math:`\funcaddr_i` in index order.
 
-10. Let :math:`\memaddr^\ast` be the the concatenation of the :ref:`memory addresses <syntax-memaddr>` :math:`\memaddr_i` in index order.
+11. Let :math:`\tableaddr^\ast` be the the concatenation of the :ref:`table addresses <syntax-tableaddr>` :math:`\tableaddr_i` in index order.
 
-11. Let :math:`\globaladdr^\ast` be the the concatenation of the :ref:`global addresses <syntax-globaladdr>` :math:`\globaladdr_i` in index order.
+12. Let :math:`\memaddr^\ast` be the the concatenation of the :ref:`memory addresses <syntax-memaddr>` :math:`\memaddr_i` in index order.
 
-12. Let :math:`\elemaddr^\ast` be the the concatenation of the :ref:`element addresses <syntax-elemaddr>` :math:`\elemaddr_i` in index order.
+13. Let :math:`\globaladdr^\ast` be the the concatenation of the :ref:`global addresses <syntax-globaladdr>` :math:`\globaladdr_i` in index order.
 
-13. Let :math:`\dataaddr^\ast` be the the concatenation of the :ref:`data addresses <syntax-dataaddr>` :math:`\dataaddr_i` in index order.
+14. Let :math:`\elemaddr^\ast` be the the concatenation of the :ref:`element addresses <syntax-elemaddr>` :math:`\elemaddr_i` in index order.
 
-14. Let :math:`\funcaddr_{\F{mod}}^\ast` be the list of :ref:`function addresses <syntax-funcaddr>` extracted from :math:`\externval_{\F{im}}^\ast`, concatenated with :math:`\funcaddr^\ast`.
+15. Let :math:`\dataaddr^\ast` be the the concatenation of the :ref:`data addresses <syntax-dataaddr>` :math:`\dataaddr_i` in index order.
 
-15. Let :math:`\tableaddr_{\F{mod}}^\ast` be the list of :ref:`table addresses <syntax-tableaddr>` extracted from :math:`\externval_{\F{im}}^\ast`, concatenated with :math:`\tableaddr^\ast`.
+16. Let :math:`\funcaddr_{\F{mod}}^\ast` be the list of :ref:`function addresses <syntax-funcaddr>` extracted from :math:`\externval_{\F{im}}^\ast`, concatenated with :math:`\funcaddr^\ast`.
 
-16. Let :math:`\memaddr_{\F{mod}}^\ast` be the list of :ref:`memory addresses <syntax-memaddr>` extracted from :math:`\externval_{\F{im}}^\ast`, concatenated with :math:`\memaddr^\ast`.
+17. Let :math:`\tableaddr_{\F{mod}}^\ast` be the list of :ref:`table addresses <syntax-tableaddr>` extracted from :math:`\externval_{\F{im}}^\ast`, concatenated with :math:`\tableaddr^\ast`.
 
-17. Let :math:`\globaladdr_{\F{mod}}^\ast` be the list of :ref:`global addresses <syntax-globaladdr>` extracted from :math:`\externval_{\F{im}}^\ast`, concatenated with :math:`\globaladdr^\ast`.
+18. Let :math:`\memaddr_{\F{mod}}^\ast` be the list of :ref:`memory addresses <syntax-memaddr>` extracted from :math:`\externval_{\F{im}}^\ast`, concatenated with :math:`\memaddr^\ast`.
 
-18. For each :ref:`export <syntax-export>` :math:`\export_i` in :math:`\module.\MEXPORTS`, do:
+19. Let :math:`\globaladdr_{\F{mod}}^\ast` be the list of :ref:`global addresses <syntax-globaladdr>` extracted from :math:`\externval_{\F{im}}^\ast`, concatenated with :math:`\globaladdr^\ast`.
+
+20. For each :ref:`export <syntax-export>` :math:`\export_i` in :math:`\module.\MEXPORTS`, do:
 
     a. If :math:`\export_i` is a function export for :ref:`function index <syntax-funcidx>` :math:`x`, then let :math:`\externval_i` be the :ref:`external value <syntax-externval>` :math:`\EVFUNC~(\funcaddr_{\F{mod}}^\ast[x])`.
 
@@ -500,11 +543,11 @@ and list of :ref:`reference <syntax-ref>` vectors for the module's :ref:`element
 
     e. Let :math:`\exportinst_i` be the :ref:`export instance <syntax-exportinst>` :math:`\{\EINAME~(\export_i.\ENAME), \EIVALUE~\externval_i\}`.
 
-19. Let :math:`\exportinst^\ast` be the the concatenation of the :ref:`export instances <syntax-exportinst>` :math:`\exportinst_i` in index order.
+21. Let :math:`\exportinst^\ast` be the the concatenation of the :ref:`export instances <syntax-exportinst>` :math:`\exportinst_i` in index order.
 
-20. Let :math:`\moduleinst` be the :ref:`module instance <syntax-moduleinst>` :math:`\{\MITYPES~(\module.\MTYPES),` :math:`\MIFUNCS~\funcaddr_{\F{mod}}^\ast,` :math:`\MITABLES~\tableaddr_{\F{mod}}^\ast,` :math:`\MIMEMS~\memaddr_{\F{mod}}^\ast,` :math:`\MIGLOBALS~\globaladdr_{\F{mod}}^\ast,` :math:`\MIEXPORTS~\exportinst^\ast\}`.
+22. Let :math:`\moduleinst` be the :ref:`module instance <syntax-moduleinst>` :math:`\{\MITYPES~\typeaddr^\ast,` :math:`\MIFUNCS~\funcaddr_{\F{mod}}^\ast,` :math:`\MITABLES~\tableaddr_{\F{mod}}^\ast,` :math:`\MIMEMS~\memaddr_{\F{mod}}^\ast,` :math:`\MIGLOBALS~\globaladdr_{\F{mod}}^\ast,` :math:`\MIEXPORTS~\exportinst^\ast\}`.
 
-21. Return :math:`\moduleinst`.
+23. Return :math:`\moduleinst`.
 
 
 .. math::
@@ -525,7 +568,7 @@ where:
    \export^\ast &=& \module.\MEXPORTS \\[1ex]
    \moduleinst &=& \{~
      \begin{array}[t]{@{}l@{}}
-     \MITYPES~\module.\MTYPES, \\
+     \MITYPES~\typeaddr^\ast, \\
      \MIFUNCS~\evfuncs(\externval_{\F{im}}^\ast)~\funcaddr^\ast, \\
      \MITABLES~\evtables(\externval_{\F{im}}^\ast)~\tableaddr^\ast, \\
      \MIMEMS~\evmems(\externval_{\F{im}}^\ast)~\memaddr^\ast, \\
@@ -534,19 +577,21 @@ where:
      \MIDATAS~\dataaddr^\ast, \\
      \MIEXPORTS~\exportinst^\ast ~\}
      \end{array} \\[1ex]
-   S_1, \funcaddr^\ast &=&
-     \allocfunc^\ast(S, \module.\MFUNCS, \moduleinst) \\
-   S_2, \tableaddr^\ast &=&
-     \alloctable^\ast(S_1, (\table.\TTYPE)^\ast, (\REFNULL~t)^\ast)
+   S_1, \typeaddr^\ast &=&
+     \alloctype^\ast(S, \module.\MTYPES, \moduleinst) \\
+   S_2, \funcaddr^\ast &=&
+     \allocfunc^\ast(S_1, \module.\MFUNCS, \moduleinst) \\
+   S_3, \tableaddr^\ast &=&
+     \alloctable^\ast(S_2, (\table.\TTYPE)^\ast, (\REFNULL~t)^\ast)
      \quad (\where (\table.\TTYPE)^\ast = (\limits~t)^\ast) \\
-   S_3, \memaddr^\ast &=&
-     \allocmem^\ast(S_2, (\mem.\MTYPE)^\ast) \\
-   S_4, \globaladdr^\ast &=&
+   S_4, \memaddr^\ast &=&
+     \allocmem^\ast(S_3, (\mem.\MTYPE)^\ast) \\
+   S_5, \globaladdr^\ast &=&
      \allocglobal^\ast(S_3, (\global.\GTYPE)^\ast, \val^\ast) \\
-   S_5, \elemaddr^\ast &=&
-     \allocelem^\ast(S_4, (\elem.\ETYPE)^\ast, (\reff^\ast)^\ast) \\
+   S_6, \elemaddr^\ast &=&
+     \allocelem^\ast(S_5, (\elem.\ETYPE)^\ast, (\reff^\ast)^\ast) \\
    S', \dataaddr^\ast &=&
-     \allocdata^\ast(S_5, (\data.\DINIT)^\ast) \\
+     \allocdata^\ast(S_6, (\data.\DINIT)^\ast) \\
    \exportinst^\ast &=&
      \{ \EINAME~(\export.\ENAME), \EIVALUE~\externval_{\F{ex}} \}^\ast \\[1ex]
    \evfuncs(\externval_{\F{ex}}^\ast) &=& (\moduleinst.\MIFUNCS[x])^\ast
@@ -581,7 +626,7 @@ Here, the notation :math:`\F{allocx}^\ast` is shorthand for multiple :ref:`alloc
 Moreover, if the dots :math:`\dots` are a sequence :math:`A^n` (as for globals or tables), then the elements of this sequence are passed to the allocation function pointwise.
 
 .. note::
-   The definition of module allocation is mutually recursive with the allocation of its associated functions, because the resulting module instance :math:`\moduleinst` is passed to the function allocator as an argument, in order to form the necessary closures.
+   The definition of module allocation is mutually recursive with the allocation of its associated types and functions, because the resulting module instance :math:`\moduleinst` is passed to the allocators as an argument, in order to form the necessary closures.
    In an implementation, this recursion is easily unraveled by mutating one or the other in a secondary step.
 
 
@@ -615,7 +660,9 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
       i. Fail.
 
-   b. If :math:`\externtype_i` does not :ref:`match <match-externtype>` :math:`\externtype'_i`, then:
+   b. Let :math:`\externtype''_i` be the :ref:`semantic <syntax-typeid>` :ref:`external type <syntax-externtype>` obtained from :math:`\externtype'_i` by :ref:`substituting <notation-subst>` the :ref:`type indices <syntax-typeidx>` defined in :math:`\module` with the :ref:`type addresses <syntax-typeaddr>` they map to in :math:`\moduleinst.\MITYPES` defined below.
+
+   c. If :math:`\externtype_i` does not :ref:`match <match-externtype>` :math:`\externtype''_i`, then:
 
       i. Fail.
 
@@ -709,8 +756,8 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
      \end{array} \\
    &(\iff
      & \vdashmodule \module : \externtype_{\F{im}}^k \to \externtype_{\F{ex}}^\ast \\
-     &\wedge& (S \vdashexternval \externval : \externtype)^k \\
-     &\wedge& (\vdashexterntypematch \externtype \matchesexterntype \externtype_{\F{im}})^k \\[1ex]
+     &\wedge& (S' \vdashexternval \externval : \externtype)^k \\
+     &\wedge& (S' \vdashexterntypematch \externtype \matchesexterntype \externtype_{\F{im}}[\subst \moduleinst.\MITABLES])^k \\[1ex]
      &\wedge& \module.\MGLOBALS = \global^\ast \\
      &\wedge& \module.\MELEMS = \elem^n \\
      &\wedge& \module.\MDATAS = \data^m \\
@@ -741,9 +788,13 @@ where:
    \end{array}
 
 .. note::
-   Module :ref:`allocation <alloc-module>` and the :ref:`evaluation <exec-expr>` of :ref:`global <syntax-global>` initializers and :ref:`element segments <syntax-elem>` are mutually recursive because the global initialization :ref:`values <syntax-val>` :math:`\val^\ast` and element segment contents :math:`(\reff^\ast)^\ast` are passed to the module allocator while depending on the module instance :math:`\moduleinst` and store :math:`S'` returned by allocation.
-   However, this recursion is just a specification device.
-   In practice, the initialization values can :ref:`be determined <exec-initvals>` beforehand by staging module allocation such that first, the module's own :math:`function instances <syntax-funcinst>` are pre-allocated in the store, then the initializer expressions are evaluated, then the rest of the module instance is allocated, and finally the new function instances' :math:`\AMODULE` fields are set to that module instance.
+   Checking import types assumes that the :ref:`module instance <syntax-moduleinst>` has already been :ref:`allocated <alloc-module>` and the resulting :ref:`type addresses <syntax-typeaddr>` are available, in order to be substituted for the local :ref:`type indices <syntax-typeidx>` and both types are consistently :ref:`semantic <syntax-typeid>`.
+   However, this forward reference merely is a way to simplify the specification.
+   In practice, it can be implemented by staging module allocation such that the module's own :math:`type instances <syntax-typeinst>` are pre-allocated in the store before checking imports, and discarded in case the imports fail to type-check.
+
+   Similarly, module :ref:`allocation <alloc-module>` and the :ref:`evaluation <exec-expr>` of :ref:`global <syntax-global>` initializers and :ref:`element segments <syntax-elem>` are mutually recursive because the global initialization :ref:`values <syntax-val>` :math:`\val^\ast` and element segment contents :math:`(\reff^\ast)^\ast` are passed to the module allocator while depending on the module instance :math:`\moduleinst` and store :math:`S'` returned by allocation.
+   Again, this recursion is just a specification device.
+   In practice, the initialization values can :ref:`be determined <exec-initvals>` beforehand by staging module allocation further such that first, the module's own :math:`function instances <syntax-funcinst>` are pre-allocated in the store, then the initializer expressions are evaluated, then the rest of the module instance is allocated, and finally the new function instances' :math:`\AMODULE` fields are set to that module instance.
    This is possible because :ref:`validation <valid-module>` ensures that initialization expressions cannot actually call a function, only take their reference.
 
    All failure conditions are checked before any observable mutation of the store takes place.
diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index 5f042cd55..24f275649 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -85,7 +85,7 @@ It is either a sequence of :ref:`values <syntax-val>` or a :ref:`trap <syntax-tr
    In the current version of WebAssembly, a result can consist of at most one value.
 
 
-.. index:: ! store, function instance, table instance, memory instance, global instance, module, allocation
+.. index:: ! store, type instance, function instance, table instance, memory instance, global instance, module, allocation
    pair: abstract syntax; store
 .. _syntax-store:
 .. _store:
@@ -94,7 +94,7 @@ Store
 ~~~~~
 
 The *store* represents all global state that can be manipulated by WebAssembly programs.
-It consists of the runtime representation of all *instances* of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tableinst>`, :ref:`memories <syntax-meminst>`, and :ref:`globals <syntax-globalinst>`, :ref:`element segments <syntax-eleminst>`, and :ref:`data segments <syntax-datainst>` that have been :ref:`allocated <alloc>` during the life time of the abstract machine. [#gc]_
+It consists of the runtime representation of all *instances* of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tableinst>`, :ref:`memories <syntax-meminst>`, and :ref:`globals <syntax-globalinst>`, :ref:`element segments <syntax-eleminst>`, and :ref:`data segments <syntax-datainst>` that have been :ref:`allocated <alloc>` during the life time of the abstract machine. [#gc]_
 
 It is an invariant of the semantics that no element or data instance is :ref:`addressed <syntax-addr>` from anywhere else but the owning module instances.
 
@@ -104,6 +104,7 @@ Syntactically, the store is defined as a :ref:`record <notation-record>` listing
    \begin{array}{llll}
    \production{(store)} & \store &::=& \{~
      \begin{array}[t]{l@{~}ll}
+     \STYPES & \typeinst^\ast, \\
      \SFUNCS & \funcinst^\ast, \\
      \STABLES & \tableinst^\ast, \\
      \SMEMS & \meminst^\ast, \\
@@ -126,6 +127,7 @@ Convention
 
 
 .. index:: ! address, store, function instance, table instance, memory instance, global instance, element instance, data instance, embedder
+   pair: abstract syntax; type address
    pair: abstract syntax; function address
    pair: abstract syntax; table address
    pair: abstract syntax; memory address
@@ -133,6 +135,7 @@ Convention
    pair: abstract syntax; element address
    pair: abstract syntax; data address
    pair: abstract syntax; host address
+   pair: type; address
    pair: function; address
    pair: table; address
    pair: memory; address
@@ -140,6 +143,7 @@ Convention
    pair: element; address
    pair: data; address
    pair: host; address
+.. _syntax-typeaddr:
 .. _syntax-funcaddr:
 .. _syntax-tableaddr:
 .. _syntax-memaddr:
@@ -152,7 +156,7 @@ Convention
 Addresses
 ~~~~~~~~~
 
-:ref:`Function instances <syntax-funcinst>`, :ref:`table instances <syntax-tableinst>`, :ref:`memory instances <syntax-meminst>`, and :ref:`global instances <syntax-globalinst>`, :ref:`element instances <syntax-eleminst>`, and :ref:`data instances <syntax-datainst>` in the :ref:`store <syntax-store>` are referenced with abstract *addresses*.
+:ref:`Type instances <syntax-typeinst>`, :ref:`function instances <syntax-funcinst>`, :ref:`table instances <syntax-tableinst>`, :ref:`memory instances <syntax-meminst>`, and :ref:`global instances <syntax-globalinst>`, :ref:`element instances <syntax-eleminst>`, and :ref:`data instances <syntax-datainst>` in the :ref:`store <syntax-store>` are referenced with abstract *addresses*.
 These are simply indices into the respective store component.
 In addition, an :ref:`embedder <embedder>` may supply an uninterpreted set of *host addresses*.
 
@@ -160,6 +164,8 @@ In addition, an :ref:`embedder <embedder>` may supply an uninterpreted set of *h
    \begin{array}{llll}
    \production{(address)} & \addr &::=&
      0 ~|~ 1 ~|~ 2 ~|~ \dots \\
+   \production{(type address)} & \typeaddr &::=&
+     \addr \\
    \production{(function address)} & \funcaddr &::=&
      \addr \\
    \production{(table address)} & \tableaddr &::=&
@@ -191,7 +197,7 @@ even where this identity is not observable from within WebAssembly code itself
    hence logical addresses can be arbitrarily large natural numbers.
 
 
-.. index:: ! instance, function type, function instance, table instance, memory instance, global instance, element instance, data instance, export instance, table address, memory address, global address, element address, data address, index, name
+.. index:: ! instance, function type, type instance, function instance, table instance, memory instance, global instance, element instance, data instance, export instance, table address, memory address, global address, element address, data address, index, name
    pair: abstract syntax; module instance
    pair: module; instance
 .. _syntax-moduleinst:
@@ -207,7 +213,7 @@ and collects runtime representations of all entities that are imported, defined,
    \begin{array}{llll}
    \production{(module instance)} & \moduleinst &::=& \{
      \begin{array}[t]{l@{~}ll}
-     \MITYPES & \functype^\ast, \\
+     \MITYPES & \typeaddr^\ast, \\
      \MIFUNCS & \funcaddr^\ast, \\
      \MITABLES & \tableaddr^\ast, \\
      \MIMEMS & \memaddr^\ast, \\
@@ -219,11 +225,29 @@ and collects runtime representations of all entities that are imported, defined,
    \end{array}
 
 Each component references runtime instances corresponding to respective declarations from the original module -- whether imported or defined -- in the order of their static :ref:`indices <syntax-index>`.
-:ref:`Function instances <syntax-funcinst>`, :ref:`table instances <syntax-tableinst>`, :ref:`memory instances <syntax-meminst>`, and :ref:`global instances <syntax-globalinst>` are referenced with an indirection through their respective :ref:`addresses <syntax-addr>` in the :ref:`store <syntax-store>`.
+:ref:`Type instances <syntax-typeinst>`, :ref:`function instances <syntax-funcinst>`, :ref:`table instances <syntax-tableinst>`, :ref:`memory instances <syntax-meminst>`, and :ref:`global instances <syntax-globalinst>` are referenced with an indirection through their respective :ref:`addresses <syntax-addr>` in the :ref:`store <syntax-store>`.
 
 It is an invariant of the semantics that all :ref:`export instances <syntax-exportinst>` in a given module instance have different :ref:`names <syntax-name>`.
 
 
+.. index:: ! type instance, function type, module
+   pair: abstract syntax; function instance
+   pair: function; instance
+.. _syntax-typeinst:
+
+Type Instances
+~~~~~~~~~~~~~~
+
+A *type instance* is the runtime representation of a :ref:`function type <syntax-functype>`.
+It is a :ref:`semantic type <syntax-typeid>` equivalent to the respective syntactic type that appeared in the module.
+
+.. math::
+   \begin{array}{llll}
+   \production{(type instance)} & \typeinst &::=&
+     \functype
+   \end{array}
+
+
 .. index:: ! function instance, module instance, function, closure, module, ! host function, invocation
    pair: abstract syntax; function instance
    pair: function; instance
@@ -508,8 +532,8 @@ Conventions
 
 .. math::
    \begin{array}{lll}
-   \expand_F(\typeidx) &=& F.\AMODULE.\MITYPES[\typeidx] \\
-   \expand_F([\valtype^?]) &=& [] \to [\valtype^?] \\
+   \expand_{S;F}(\typeidx) &=& S.\STYPES[F.\AMODULE.\MITYPES[\typeidx]] \\
+   \expand_{S;F}([\valtype^?]) &=& [] \to [\valtype^?] \\
    \end{array}
 
 
diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index ac8b224c5..e7675b4f7 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -9,39 +9,45 @@ Various entities in WebAssembly are classified by types.
 Types are checked during :ref:`validation <valid>`, :ref:`instantiation <exec-instantiation>`, and possibly :ref:`execution <syntax-call_indirect>`.
 
 
-.. index:: ! number type, integer, floating-point, IEEE 754, bit width, memory
-   pair: abstract syntax; number type
-   pair: number; type
-.. _syntax-numtype:
 
-Number Types
-~~~~~~~~~~~~
+.. index:: ! type identifier, type index, type address
+   pair: abstract syntax; type identifier
+.. _syntax-typeid:
 
-*Number types* classify numeric values.
+Type Identifiers
+~~~~~~~~~~~~~~~~
+
+Types such as :ref:`function types <syntax-functypes>` are not embedded directly into other types, such as :ref:`reference types <syntax-reftype>`.
+Instead, they are referred to indirectly.
+
+In a :ref:`module <syntax-module>` and during validation, this indirection is expressed through a :ref:`type index <syntax-typeidx>`, whose meaning is confined to one module.
+During instantiation and execution, where types from multiple modules may interact, it is expressed through :ref:`type addresses <syntax-typeaddr>` that refer to the global :ref:`store <store>`.
+
+The type grammar hence is conceptually parameterized by its interpretation of :ref:`type identifiers <syntax-typeid>`.
 
 .. math::
    \begin{array}{llll}
-   \production{number type} & \numtype &::=&
-     \I32 ~|~ \I64 ~|~ \F32 ~|~ \F64 \\
+   \production{type identifier} & \typeid &::=&
+     \typeidx ~|~ \typeaddr
    \end{array}
 
-The types |I32| and |I64| classify 32 and 64 bit integers, respectively.
-Integers are not inherently signed or unsigned, their interpretation is determined by individual operations.
+Types represented with type indices are referred to as *syntactic types*,
+whereas types represented with type addresses are referred to as *semantic types*.
+It is an invariant of the semantics that no syntactic type refers to a semantic type and vice versa, i.e., both universes are disjoint.
+Syntactic types are transformed into semantic types during module :ref:`instantiation <exec-instantiation>`.
 
-The types |F32| and |F64| classify 32 and 64 bit floating-point data, respectively.
-They correspond to the respective binary floating-point representations, also known as *single* and *double* precision, as defined by the |IEEE754|_ standard (Section 3.3).
 
-Number types are *transparent*, meaning that their bit patterns can be observed.
-Values of number type can be stored in :ref:`memories <syntax-mem>`.
+.. _notation-subst:
 
-Conventions
-...........
+Convention
+..........
 
-* The notation :math:`|t|` denotes the *bit width* of a number type :math:`t`.
-  That is, :math:`|\I32| = |\F32| = 32` and :math:`|\I64| = |\F64| = 64`.
+If :math:`t` is some syntactic type, then :math:`t[x^\ast \subst a^\ast]` denotes the semantic type obtained by parallel substitution of :ref:`type indices <syntax-typeidx>` :math:`x^\ast` with :ref:`type addresses <typeaddr>` :math:`a^\ast`, provided :math:`|x^\ast| = |a^\ast|`.
+
+Furthermore, :math:`t[\subst a^\ast]` is shorthand for the substitution :math:`t[x^\ast \subst a^\ast]` where :math:`x^\ast = 0 \cdots (|a^\ast| - 1)`.
 
 
-.. index:: ! heap type, store, type index
+.. index:: ! heap type, store, type identifier
    pair: abstract syntax; heap type
 .. _syntax-heaptype:
 
@@ -53,14 +59,14 @@ Heap Types
 .. math::
    \begin{array}{llll}
    \production{heap type} & \heaptype &::=&
-     \FUNC ~|~ \EXTERN ~|~ \typeidx \\
+     \FUNC ~|~ \EXTERN ~|~ \typeid \\
    \end{array}
 
 The type |FUNC| denotes the infinite union of all types of :ref:`functions <syntax-func>`, regardless of their concrete :ref:`function types <syntax-functype>`.
 
 The type |EXTERN| denotes the infinite union of all objects owned by the :ref:`embedder <embedder>` and that can be passed into WebAssembly under this type.
 
-A *concrete* heap type consists of a :ref:`type index <syntax-typeidx>` and classifies an object of the respective :ref:`type <syntax-type>` defined in the module.
+A *concrete* heap type consists of a :ref:`type identifier <syntax-typeid>` and classifies an object of the respective :ref:`type <syntax-type>` defined in some module.
 
 
 .. index:: ! reference type, heap type, reference, table, function, function type, null
@@ -88,6 +94,38 @@ Reference types are *opaque*, meaning that neither their size nor their bit patt
 Values of reference type can be stored in :ref:`tables <syntax-table>`.
 
 
+.. index:: ! number type, integer, floating-point, IEEE 754, bit width, memory
+   pair: abstract syntax; number type
+   pair: number; type
+.. _syntax-numtype:
+
+Number Types
+~~~~~~~~~~~~
+
+*Number types* classify numeric values.
+
+.. math::
+   \begin{array}{llll}
+   \production{number type} & \numtype &::=&
+     \I32 ~|~ \I64 ~|~ \F32 ~|~ \F64 \\
+   \end{array}
+
+The types |I32| and |I64| classify 32 and 64 bit integers, respectively.
+Integers are not inherently signed or unsigned, their interpretation is determined by individual operations.
+
+The types |F32| and |F64| classify 32 and 64 bit floating-point data, respectively.
+They correspond to the respective binary floating-point representations, also known as *single* and *double* precision, as defined by the |IEEE754|_ standard (Section 3.3).
+
+Number types are *transparent*, meaning that their bit patterns can be observed.
+Values of number type can be stored in :ref:`memories <syntax-mem>`.
+
+Conventions
+...........
+
+* The notation :math:`|t|` denotes the *bit width* of a number type :math:`t`.
+  That is, :math:`|\I32| = |\F32| = 32` and :math:`|\I64| = |\F64| = 64`.
+
+
 .. index:: ! value type, number type, reference type, ! bottom type
    pair: abstract syntax; value type
    pair: value; type
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index 24e077401..a84357457 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -97,6 +97,7 @@
 
 .. Notation for Sequences & Records
 
+.. |subst| mathdef:: \xref{syntax/conventions}{notation-subst}{\mathrel{\mathbf{:=}}}
 .. |slice| mathdef:: \xref{syntax/conventions}{notation-slice}{\mathrel{\mathbf{:}}}
 .. |with| mathdef:: \xref{syntax/conventions}{notation-replace}{\mathrel{\mbox{with}}}
 .. |concat| mathdef:: \xref{syntax/conventions}{notation-concat}{\F{concat}}
@@ -200,6 +201,7 @@
 
 .. Types, non-terminals
 
+.. |typeid| mathdef:: \xref{syntax/types}{syntax-typeid}{\X{typeid}}
 .. |numtype| mathdef:: \xref{syntax/types}{syntax-numtype}{\X{numtype}}
 .. |heaptype| mathdef:: \xref{syntax/types}{syntax-heaptype}{\X{heaptype}}
 .. |reftype| mathdef:: \xref{syntax/types}{syntax-reftype}{\X{reftype}}
@@ -808,6 +810,7 @@
 
 .. Judgments
 
+.. |vdashtypeid| mathdef:: \xref{valid/types}{valid-typeid}{\vdash}
 .. |vdashnumtype| mathdef:: \xref{valid/types}{valid-numtype}{\vdash}
 .. |vdashheaptype| mathdef:: \xref{valid/types}{valid-heaptype}{\vdash}
 .. |vdashreftype| mathdef:: \xref{valid/types}{valid-reftype}{\vdash}
@@ -864,6 +867,7 @@
 
 .. Allocation
 
+.. |alloctype| mathdef:: \xref{exec/modules}{alloc-type}{\F{alloctype}}
 .. |allocfunc| mathdef:: \xref{exec/modules}{alloc-func}{\F{allocfunc}}
 .. |allochostfunc| mathdef:: \xref{exec/modules}{alloc-hostfunc}{\F{allochostfunc}}
 .. |alloctable| mathdef:: \xref{exec/modules}{alloc-table}{\F{alloctable}}
@@ -880,6 +884,7 @@
 .. Addresses, non-terminals
 
 .. |addr| mathdef:: \xref{exec/runtime}{syntax-addr}{\X{addr}}
+.. |typeaddr| mathdef:: \xref{exec/runtime}{syntax-typeaddr}{\X{typeaddr}}
 .. |funcaddr| mathdef:: \xref{exec/runtime}{syntax-funcaddr}{\X{funcaddr}}
 .. |tableaddr| mathdef:: \xref{exec/runtime}{syntax-tableaddr}{\X{tableaddr}}
 .. |memaddr| mathdef:: \xref{exec/runtime}{syntax-memaddr}{\X{memaddr}}
@@ -932,6 +937,7 @@
 .. |externval| mathdef:: \xref{exec/runtime}{syntax-externval}{\X{externval}}
 
 .. |moduleinst| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\X{moduleinst}}
+.. |typeinst| mathdef:: \xref{exec/runtime}{syntax-typeinst}{\X{typeinst}}
 .. |funcinst| mathdef:: \xref{exec/runtime}{syntax-funcinst}{\X{funcinst}}
 .. |tableinst| mathdef:: \xref{exec/runtime}{syntax-tableinst}{\X{tableinst}}
 .. |meminst| mathdef:: \xref{exec/runtime}{syntax-meminst}{\X{meminst}}
diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index 1d28153c6..7c9eccb0b 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -516,6 +516,9 @@ that is, its components can only refer to definitions that appear in the module
 Consequently, no initial :ref:`context <context>` is required.
 Instead, the context :math:`C` for validation of the module's content is constructed from the definitions in the module.
 
+The :ref:`external types <syntax-externtype>` classifying a module may contain free :ref:`type indices <syntax-typeidx>` that refer to types defined within the module.
+
+
 * Let :math:`\module` be the module to validate.
 
 * Let :math:`C` be a :ref:`context <context>` where:
diff --git a/document/core/valid/types.rst b/document/core/valid/types.rst
index da276506c..238f636ec 100644
--- a/document/core/valid/types.rst
+++ b/document/core/valid/types.rst
@@ -9,24 +9,36 @@ Moreover, :ref:`block types <syntax-blocktype>` are converted to plain :ref:`fun
 On most types, a simple notion of subtyping is defined that is applicable in validation rules or during :ref:`module instantiation <exec-instantiation>`.
 
 
-.. index:: number type
-   pair: validation; number type
-   single: abstract syntax; number type
-.. _valid-numtype:
+.. index:: type identifier, type index
+   pair: validation; type identifier
+   single: abstract syntax; type identifier
+.. _valid-typeid:
 
-Number Types
-~~~~~~~~~~~~
+Type Identifiers
+~~~~~~~~~~~~~~~~
 
-:ref:`Number types <syntax-numtype>` are always valid.
+During validation, :ref:`type identifiers <syntax-typeid>` are represented as :ref:`type indices <syntax-typeidx>`, which are converted to plain :ref:`function types <syntax-functype>` by the following rule.
+
+:math:`\typeid`
+...............
+
+* The type :math:`C.\CTYPES[\typeidx]` must be defined in the context.
+
+* Then the type identifier is valid as :ref:`function type <syntax-functype>` :math:`C.\CTYPES[\typeidx]`.
 
 .. math::
    \frac{
+     C.\CTYPES[\typeidx] = \functype
    }{
-     C \vdashnumtype \numtype \ok
+     C \vdashtypeid \typeidx : \functype
    }
 
+.. note::
+   Validity of :ref:`semantic types <syntax-typeid>` never needs to be checked during validation.
+   It only needs to be :ref:`defined <valid-typeinst>` as part of :ref:`store validity <valid-store>`, an auxiliary notion for proving :ref:`soundness <soundness>` of the type system.
 
-.. index:: heap type
+
+.. index:: heap type, type identifier
    pair: validation; heap type
    single: abstract syntax; heap type
 .. _valid-heaptype:
@@ -34,7 +46,7 @@ Number Types
 Heap Types
 ~~~~~~~~~~
 
-Concrete :ref:`Heap types <syntax-heaptype>` are only valid when the :ref:`type index <syntax-typeidx>` is.
+Concrete :ref:`Heap types <syntax-heaptype>` are only valid when the :ref:`type identifier <syntax-typeid>` is.
 
 :math:`\FUNC`
 .............
@@ -58,18 +70,18 @@ Concrete :ref:`Heap types <syntax-heaptype>` are only valid when the :ref:`type
      C \vdashheaptype \EXTERN \ok
    }
 
-:math:`\typeidx`
-................
+:math:`\typeid`
+...............
 
-* The type :math:`C.\CTYPES[\typeidx]` must be defined in the context.
+* The type identifier :math:`\typeid` must be valid.
 
 * Then the heap type is valid.
 
 .. math::
    \frac{
-     C.\CTYPES[\typeidx] = \functype
+     C \vdashtypeid \typeid : \functype
    }{
-     C \vdashheaptype \typeidx \ok
+     C \vdashheaptype \typeid \ok
    }
 
 
@@ -98,6 +110,23 @@ Reference Types
    }
 
 
+.. index:: number type
+   pair: validation; number type
+   single: abstract syntax; number type
+.. _valid-numtype:
+
+Number Types
+~~~~~~~~~~~~
+
+:ref:`Number types <syntax-numtype>` are always valid.
+
+.. math::
+   \frac{
+   }{
+     C \vdashnumtype \numtype \ok
+   }
+
+
 .. index:: value type, reference type, heap type, bottom type
    pair: validation; value type
    single: abstract syntax; value type
@@ -389,25 +418,6 @@ External Types
 Value Subtyping
 ~~~~~~~~~~~~~~~
 
-.. index:: number type
-
-.. _match-numtype:
-
-Number Types
-............
-
-A :ref:`number type <syntax-numtype>` :math:`\numtype_1` matches a :ref:`number type <syntax-numtype>` :math:`\numtype_2` if and only if:
-
-* Both :math:`\numtype_1` and :math:`\numtype_2` are the same.
-
-.. math::
-   ~\\[-1ex]
-   \frac{
-   }{
-     \vdashnumtypematch \numtype \matchesvaltype \numtype
-   }
-
-
 .. index:: heap type
 
 .. _match-heaptype:
@@ -419,9 +429,9 @@ A :ref:`heap type <syntax-heaptype>` :math:`\heaptype_1` matches a :ref:`heap ty
 
 * Either both :math:`\heaptype_1` and :math:`\heaptype_2` are the same.
 
-* Or :math:`\heaptype_1` is a :ref:`type index <syntax-typeidx>` that defines a function type and :math:`\heaptype_2` is :math:`FUNC`.
+* Or :math:`\heaptype_1` is a :ref:`type identifier <syntax-typeid>` that defines a function type and :math:`\heaptype_2` is :math:`FUNC`.
 
-* Or :math:`\heaptype_1` is a :ref:`type index <syntax-typeidx>` that defines a function type :math:`\functype_1`, and :math:`\heaptype_2` is a :ref:`type index <syntax-typeidx>` that defines a function type :math:`\functype_2`, and :math:`\functype_1` :ref:`matches <match-functype>` :math:`\functype_2`.
+* Or :math:`\heaptype_1` is a :ref:`type identifier <syntax-typeid>` that defines a function type :math:`\functype_1`, and :math:`\heaptype_2` is a :ref:`type identifier <syntax-typeid>` that defines a function type :math:`\functype_2`, and :math:`\functype_1` :ref:`matches <match-functype>` :math:`\functype_2`.
 
 .. math::
    ~\\[-1ex]
@@ -431,19 +441,19 @@ A :ref:`heap type <syntax-heaptype>` :math:`\heaptype_1` matches a :ref:`heap ty
    }
    ~\\
    \frac{
-     C.\CTYPES[\typeidx] = \functype
+     C \vdashtypeid \typeid : \functype
    }{
-     C \vdashheaptypematch \typeidx \matchesheaptype \FUNC
+     C \vdashheaptypematch \typeid \matchesheaptype \FUNC
    }
    ~\\
    \frac{
-     C.\CTYPES[\typeidx_1] = \functype_1
+     C \vdashtypeid \typeid : \functype_1
      \qquad
-     C.\CTYPES[\typeidx_2] = \functype_2
+     C \vdashtypeid \typeid : \functype_2
      \qquad
      C \vdashfunctypematch \functype_1 \matchesfunctype \functype_2
    }{
-     C \vdashheaptypematch \typeidx_1 \matchesheaptype \typeidx_2
+     C \vdashheaptypematch \typeid_1 \matchesheaptype \typeid_2
    }
 
 
@@ -475,6 +485,25 @@ A :ref:`reference type <syntax-reftype>` :math:`\REF~\NULL_1^?~heaptype_1` match
    }
 
 
+.. index:: number type
+
+.. _match-numtype:
+
+Number Types
+............
+
+A :ref:`number type <syntax-numtype>` :math:`\numtype_1` matches a :ref:`number type <syntax-numtype>` :math:`\numtype_2` if and only if:
+
+* Both :math:`\numtype_1` and :math:`\numtype_2` are the same.
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+   }{
+     \vdashnumtypematch \numtype \matchesvaltype \numtype
+   }
+
+
 .. index:: value type, number type, reference type
 
 .. _match-valtype:
@@ -561,7 +590,28 @@ When :ref:`instantiating <exec-module>` a module,
 :ref:`external values <syntax-externval>` must be provided whose :ref:`types <valid-externval>` are *matched* against the respective :ref:`external types <syntax-externtype>` classifying each import.
 In some cases, this allows for a simple form of subtyping, as defined here.
 
-.. todo:: this requires semantics types
+Unlike subtyping invoked during :ref:`validation <valid>`,
+import matching operates on :ref:`semantic types <syntax-typeid>` during :ref:`instantiation <exec-instantiation>`,
+and hence operates relative to a :ref:`store <store>` :math:`S` instead of a :ref:`context <context>` :math:`C`.
+
+To this end, all subtyping rules defined above on *syntactic* types are extended to semantic types by replacing :math:`S` with :ref:`context <context>` :math:`C`, and defining validity of semantic :ref:`type identifiers <syntax-typeid>` as follows.
+
+.. index:: type, type instance, type address
+.. _valid-typeinst:
+
+Type Addresses
+..............
+
+* The type :math:`S.\STYPES[\typeaddr]` must be defined in the store.
+
+* Then the type address is valid as :ref:`function type <syntax-functype>` :math:`S.\STYPES[\typeaddr]`.
+
+.. math::
+   \frac{
+     S.\STYPES[\typeaddr] = \functype
+   }{
+     S \vdashtypeid \typeaddr : \functype
+   }
 
 
 .. index:: limits
@@ -611,13 +661,14 @@ Functions
 
 An :ref:`external type <syntax-externtype>` :math:`\ETFUNC~\functype_1` matches :math:`\ETFUNC~\functype_2` if and only if:
 
-* Both :math:`\functype_1` and :math:`\functype_2` are the same.
+* The :ref:`function type <syntax-functype>` :math:`\functype_1` :ref:matches <match-functype>` :math:`\functype_2`.
 
 .. math::
    ~\\[-1ex]
    \frac{
+     S \vdashfunctypematch \functype_1 \matchesfunctype \functype_2
    }{
-     \vdashexterntypematch \ETFUNC~\functype \matchesexterntype \ETFUNC~\functype
+     S \vdashexterntypematch \ETFUNC~\functype_1 \matchesexterntype \ETFUNC~\functype_2
    }
 
 
@@ -631,13 +682,17 @@ An :ref:`external type <syntax-externtype>` :math:`\ETTABLE~(\limits_1~\reftype_
 
 * Limits :math:`\limits_1` :ref:`match <match-limits>` :math:`\limits_2`.
 
-* Both :math:`\reftype_1` and :math:`\reftype_2` are the same.
+* The :ref:`reference type <syntax-reftype>` :math:`\reftype_1` matches :math:`\reftype_2`, and vice versa.
 
 .. math::
    \frac{
      \vdashlimitsmatch \limits_1 \matcheslimits \limits_2
+     \qquad
+     S \vdashreftypematch \reftype_1 \matchesreftype \reftype_2
+     \qquad
+     S \vdashreftypematch \reftype_2 \matchesreftype \reftype_1
    }{
-     \vdashexterntypematch \ETTABLE~(\limits_1~\reftype) \matchesexterntype \ETTABLE~(\limits_2~\reftype)
+     S \vdashexterntypematch \ETTABLE~(\limits_1~\reftype_1) \matchesexterntype \ETTABLE~(\limits_2~\reftype_2)
    }
 
 
@@ -655,7 +710,7 @@ An :ref:`external type <syntax-externtype>` :math:`\ETMEM~\limits_1` matches :ma
    \frac{
      \vdashlimitsmatch \limits_1 \matcheslimits \limits_2
    }{
-     \vdashexterntypematch \ETMEM~\limits_1 \matchesexterntype \ETMEM~\limits_2
+     S \vdashexterntypematch \ETMEM~\limits_1 \matchesexterntype \ETMEM~\limits_2
    }
 
 
@@ -667,19 +722,22 @@ Globals
 
 An :ref:`external type <syntax-externtype>` :math:`\ETGLOBAL~(\mut_1~t_1)` matches :math:`\ETGLOBAL~(\mut_2~t_2)` if and only if:
 
-* Either both :math:`\mut_1` and :math:`\mut_2` are |MVAR| and :math:`t_1` and :math:`t_2` are the same.
+* Either both :math:`\mut_1` and :math:`\mut_2` are |MVAR| and :math:`t_1` :ref:`matches <match-valtype>` :math:`t_2` and vice versa.
  
 * Or both :math:`\mut_1` and :math:`\mut_2` are |MCONST| and :math:`t_1` :ref:`matches <match-valtype>` :math:`t_2`.
 
 .. math::
    ~\\[-1ex]
    \frac{
+     S \vdashvaltypematch t_1 \matchesvaltype t_2
+     \qquad
+     S \vdashvaltypematch t_2 \matchesvaltype t_1
    }{
-     \vdashexterntypematch \ETGLOBAL~(\MVAR~t) \matchesexterntype \ETGLOBAL~(\MVAR~t)
+     S \vdashexterntypematch \ETGLOBAL~(\MVAR~t_1) \matchesexterntype \ETGLOBAL~(\MVAR~t_2)
    }
    \qquad
    \frac{
-     \vdashvaltypematch t_1 \matchesvaltype t_2
+     S \vdashvaltypematch t_1 \matchesvaltype t_2
    }{
-     \vdashexterntypematch \ETGLOBAL~(\MCONST~t_1) \matchesexterntype \ETGLOBAL~(\MCONST~t_2)
+     S \vdashexterntypematch \ETGLOBAL~(\MCONST~t_1) \matchesexterntype \ETGLOBAL~(\MCONST~t_2)
    }

From 2e629bc63aad31982d8941a4263e4ecacae00c94 Mon Sep 17 00:00:00 2001
From: Asumu Takikawa <asumu@igalia.com>
Date: Fri, 16 Jul 2021 01:32:03 -0700
Subject: [PATCH 025/285] Create Github Actions workflow for CI (#1344)

This addresses issue #1342 for spec publishing.

The added workflow will run on commit and PRs and will
run CI for both reference interpreter build/test and
for building the spec documents.

It will also publish them to the gh-pages branch.
---
 .github/workflows/main.yml               |  91 +++++++++++++++++++++++
 .travis.yml                              |  38 ----------
 README.md                                |   2 +-
 deploy_key.enc                           | Bin 3248 -> 0 bytes
 document/travis-deploy.sh                |  80 --------------------
 interpreter/meta/travis/build-test.sh    |  10 ---
 interpreter/meta/travis/install-ocaml.sh |  46 ------------
 7 files changed, 92 insertions(+), 175 deletions(-)
 create mode 100644 .github/workflows/main.yml
 delete mode 100644 .travis.yml
 delete mode 100644 deploy_key.enc
 delete mode 100755 document/travis-deploy.sh
 delete mode 100755 interpreter/meta/travis/build-test.sh
 delete mode 100755 interpreter/meta/travis/install-ocaml.sh

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
new file mode 100644
index 000000000..1386b4c67
--- /dev/null
+++ b/.github/workflows/main.yml
@@ -0,0 +1,91 @@
+name: CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  ref-interpreter:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup OCaml
+        uses: ocaml/setup-ocaml@v2
+        with:
+          ocaml-compiler: 4.12.x
+      - run: opam install --yes ocamlbuild.0.14.0
+      - run: cd interpreter && opam exec make all
+
+  build-js-api-spec:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Build JS API bikeshed
+        uses: netwerk-digitaal-erfgoed/bikeshed-action@v1
+        with:
+          source: "document/js-api/index.bs"
+          destination: "document/js-api/index.html"
+      - uses: actions/upload-artifact@v2
+        with:
+          name: js-api-rendered
+          path: document/js-api
+
+  build-web-api-spec:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Build JS API bikeshed
+        uses: netwerk-digitaal-erfgoed/bikeshed-action@v1
+        with:
+          source: "document/web-api/index.bs"
+          destination: "document/web-api/index.html"
+      - uses: actions/upload-artifact@v2
+        with:
+          name: web-api-rendered
+          path: document/web-api
+
+  build-core-spec:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: "recursive"
+      - run: pip install bikeshed && bikeshed update
+      - run: pip install six
+      - run: sudo apt-get update -y && sudo apt-get install -y latexmk texlive-latex-recommended texlive-latex-extra texlive-fonts-recommended
+      - run: pip install sphinx==3.5.2
+      - run: cd document/core && make all
+      - uses: actions/upload-artifact@v2
+        with:
+          name: core-api-rendered
+          path: document/core/_build/html
+
+  publish-spec:
+    runs-on: ubuntu-latest
+    needs: [build-core-spec, build-js-api-spec, build-web-api-spec]
+    steps:
+      - uses: actions/checkout@v2
+      - run: mkdir _output && cp document/index.html _output/index.html
+      - uses: actions/download-artifact@v2
+        with:
+          name: js-api-rendered
+          path: _output/js-api
+      - uses: actions/download-artifact@v2
+        with:
+          name: web-api-rendered
+          path: _output/web-api
+      - uses: actions/download-artifact@v2
+        with:
+          name: core-api-rendered
+          path: _output/core
+      - name: Publish HTML to GitHub Pages
+        if: github.ref == 'refs/heads/master'
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          publish_dir: ./_output
+          github_token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index b498e6cef..000000000
--- a/.travis.yml
+++ /dev/null
@@ -1,38 +0,0 @@
-language: python
-python:
-  - "3.7"
-dist: bionic
-
-addons:
-  apt:
-    sources:
-      - sourceline: 'ppa:avsm/ppa'
-      - sourceline: 'deb https://dl.yarnpkg.com/debian/ stable main'
-        key_url: 'https://dl.yarnpkg.com/debian/pubkey.gpg'
-    update: true
-    packages:
-      - opam
-      - texlive-full
-      - yarn
-
-install:
-  - opam init --auto-setup --compiler=4.07.1
-  - eval $(opam env)
-  - opam --version
-  - ocaml --version
-  - opam install --yes ocamlbuild.0.14.0
-  - pip install Sphinx==3.5.2
-  - git clone https://github.com/tabatkins/bikeshed.git
-  - pip install --editable $PWD/bikeshed
-  - bikeshed update
-
-script:
-  - ./interpreter/meta/travis/build-test.sh
-  - bash ./document/travis-deploy.sh
-
-os: linux
-
-env:
-  global:
-    - ENCRYPTION_LABEL: "304454be9d6c"
-    - COMMIT_AUTHOR_EMAIL: "noreply@webassembly.org"
diff --git a/README.md b/README.md
index 83cdc4da6..ab9cd9959 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-[![Build Status](https://travis-ci.org/WebAssembly/spec.svg?branch=master)](https://travis-ci.org/WebAssembly/spec)
+![Build Status](https://github.com/WebAssembly/spec/actions/workflows/main.yml/badge.svg)
 
 # spec
 
diff --git a/deploy_key.enc b/deploy_key.enc
deleted file mode 100644
index b6d3e2f19771652a9711760b1712a77fe1b4e579..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3248
zcmV;h3{UeoaMr!6kTNmX>{8Y#<|(CVbO6TJr-;79Ag-eBM!B~g(FTQ5ldW}>C6w#F
z7?FSyFeYZ$v_V^lQFEF>+7k9B7m`7vS_SQ$;wWv|QOclL{NpaXb;g5ti(%WUt|3;5
z3CA#OrS)XS){2AUta7q}MSm<K-}SdEI9WFQcH&@184mSS`NOI;0O<r~fD&qO4q!AX
zjJ9%~6{h6R4CI=-mm#b|m->hT<oPpiiW2OvHa({fM#dP85_DRer+3dM1{)E0@r>Jq
zo{c?28()!ibPsqvTfOAA!4zOONU^F*gLcD(DrJbnNphXRZ3yC#LaPJi{CC$C(2A_7
zNaF$Iwo+ftMAzTpRFW1@B>=0mk{V^}DS!4rt3&v*?r8!}EfiTzY#jX?%ckauU9h@W
zx(fD`Pk=~T7D1zi5Xgo-F3df<=bCbjU<xh+mSjXXi;p<(on|*$EZB)kNobCaF`i+M
z&@fBDFcK+g36ZwQvcL;Kdvn7@Scq3o-DybcBaCNMC|r;b4<HgpStTJeH#iA1`WZ(`
z)_qGdFH7RIm0G4szgQdw1iFC&)1X#mw_E5ffH7!1Q1olDbjke;kUNJs&};*GY4~;y
z$dC3Yun4m$a6uFWTLdAllv9qZ@yj3I`KuFO8nzfV$Ji07rI~ko30GP`)Sbu9><?%=
zm!`R&G0m-0e0^m4vyE3XrZsMP8<OsoC8OVsPR0iP@4tGcYwQ8AlLcah#`Wa6&~0Bu
zdo!Q_a(6mmDg+*b*<8}9p<Uf@FQ19#DSl|I1H#J(3z(JT=<D6D(}i@|s5*Cd#v@K?
zRs6B*%%-^fFeI+<1cPL;sq>0(ZD&z`12ST)Xxn<2-%!cB^F0IoG~-*{lROB{l$8;>
zQYD6uvZB!WjR97=Gm5k(nd?fS-skc&EK?_V8WnS+v(_4N1NbVfWy{T9c3+w+eKW@y
z`gzb1V%Tr>ul(ay+I}7y2o4<>nNeC`_9<4dQwbaZcv=lR5j&@)QY$OIg__IEl?CzP
zj*w)N-7!X;zax-wu2%HYp<K-&!7Ip=ZBhZUyAOzn^nS)2d3%)(ExvW5=FHHdf+2YJ
zF_3ovIs5tqT;02USmxOY`Z6^o#h4C<KF$&_26@DRpAc8-iKB4Ks}wK@Ka^b(x+e_9
zFiU_)4)uk16(SZa8nH|C&TF_>X17nK^l2cLppXhM>Q8<9AmF4V+?wF~S-rGWRU;<&
zEfi}`>wt%Un_w@H!oNoZ>x+M|o6OWL0ZWAvCDS3ci~T8hKI0BHLyhmaX>a@YdQN<X
zxEr}mlo#&tLdlH~tWPl(mFl4AwO+hB3zBd-^RstN3aG$#1w@V3DmN%)Jn(q7hWuxj
zqFkRoy?EqS50odC7@6K#`_OAz_x2j|<`V^<Ct6n$P0DWdYOM}M|EIh>K^9SJORstB
zfvrm3TfM$`MMQQXp+4m=U~?Y#8>LXJEJKe+QT3ai?lI{90Zbd!SJdk4H(U1tebkQS
zEl<Mce+s4Fuz8iq%fRGlLW!l(f{|N~So8qGDu<3<?;dEaiIKV*v!s4B4v0(mEhVJ`
zwcD=s<|lneFL~+g6S(x#>H@QyluL-tMcF~ED_;l>!0Ijv*4gtnDwmLYV{a3@tjZ`D
zFgG=OkZ90lfbv6>Fy&2v?<P<#yQSO4C}_`ZoNU8=Hsks}l8&UIVkTBfa0K7uuuo#W
zsIA5K+)Rdk`^G`jbQv)CNXi8P;veOYeB<<6j9D;lNui-@nM2KzLc7g7PV8q@Ml2xj
zmUKb~HGbHQEshwVtFNdy#{If+p8`@@6QfuoM7Il-qo$wphO9X7U6X30>b=c~Y_N9G
zUi9};vfpk;9dPn4FMkaR{o~<Ryy7Qt#bL*FX$}$UpU)YnpS7bBRL&f&TaHE%fq66M
zevCMnR7Sf*V7MkjfJ1c=8qUe*<%=KLjZ3HQP)1c4xNP4dnyV!MS<8^k+f%BV0(uVx
zg<Y0O`l;Cf{uMZaYrZGk>nn&h!a-?Sdb%SZ)!fI~GWnk~X{F~0*MZTR*=jmm-h1@t
zDL!$f-TC0j9#3k6yGm=yVm`^%@wfi3bq#*03KSe>$d+&xjHOcMc8uJt8)hN2{SBal
z4ob$b$`dj=o#p1YnW?UI^y<BIV$DsT9R^EQ=e(O<GV*z-3A={4hh}Sa{+sJ1pl@U<
z$DWNcL6_~<u>Z;rkMjLI{F#<8G09bp2NC-f7?!MtUZ(JwIdFlSzu%EdX7u+as(dHl
z58QQZ`uk&2UcuOD{=l^SW7lb<lcO+Mupc-q-8_}M)C=Ms_b$Nzz=<6v0Fo`F?VG_V
zsji^b6jtc{J**{E=3I!s3=YG8h+^PPF}mS8lPHe2T{#YPLhb*G0w!r0?;%nc5YqrS
zn@rqYKB7vJIqpU5Dt!%yVyu?d)tBIGkh$1Y4$qiZl_7$~VL?!Fvm(p!IXM#4OTXce
zAF-|VU4KIwBeKM$IsR$?9zaE$de5ghxj{a<F9#_i7H-nmlYAo`%tw21AV)7I7HH*p
zoqXE>UC)YQ<k{LZT45;N#^cJZ1V{uIT+7W?aq3X1a_!i)()Lq#j9g*mYb}0{o8EnB
zENC9yh#=iphs$!Vn6fM}ixe*sR#vCFyI7g*6%*-3!7b0YY)PJPZClA8nn!)|ea5%Y
zKqH@hAH~n-ct@%R&%)xfsgzBARI>xLZoD(4yfjbALj)ocgYIM<xN5H*RS5*z?5!lN
zl(mTk-Ar{<rquI{A(>0ZYz?(TpdH^*N^lP&fD?>5S3l5d9vDe0MYX}=L@v0ac*d^h
zMC3X&i8_TGc*nis1+Hbb@FGCYM0^b7+Ks%np4Yi`?%nMj<SL~DZp7^}&W{LG1MfY(
z3#g|MnQGQ~zdA2EK(bST633As#}_O>TjK}kiD^peA^u+*e>(aKEP(B~>~mZq#KO^e
z%~M*@SsY^h6(tY`GdMou`@})%F*bIbRNZ>mC~Kmlo-i?%UtfW#dT*z*Rcd<pLMf>L
zpk60TCgJqxKBvX~s$%Shh(AI%*I`@P2!X_@lhC_lv0_yIg<O4uO{61`!Zl*{a$2m0
z!7IbtzEhasmMW~2ZQl%qdGKv#9IPvlI%{l%5)r4lBz{6JnPxU*#YH&d2o}{^X0M!)
zQI*TUH?99Vok|em{n>6%&*TKAQRPZQNW>=_H-#1pBvjD+m{Zb}zcH8nbpNqr9whn4
zA=y)BHKQ-DrD~ATW$s5sLj-tJ#cf~=mO{+4YNwZc;4(}zeG0i5iXTW*#VVOL90%~C
zVKMQHgk?j=XH43>K+-CeY3%JXI)VIB$Ad;DSsk-VJs=GfjP+|s{r){_ozCKbFDNi|
zfEk3yUlIo}(x+SiFz(8%;%1%!B5`O|M9Tgg3bui&lu)v`(ydUn{aib=ktlW8MU&;r
zQ+2LIr_4e3%GTLQ5?58orh7HmWd&Z&T0Uz!9~Ha`K^gp=fQ`FR=0~z|>MuzT4#e%&
zBXJPHh`^tE;|zIgNiR(*kU@PB&}J%3Coh;M^QnC8vP7h%*_Gozd?$RZWr_#dXYF>u
zT>^8L;b}KO+gPONfMBv1ae%Hy6R+;S^w+Ng{zo&nGB`o<^fxC>{v`=!WnoSACN9e?
z!P}dgK-N^z<xF;8SlnAF837Zz<Y`TokGZSge!d3h$98#@1vvusrckzk(rsZ>=5p%-
zjAkKdA-dFrZxs{<7wntcycPzJOC})W{%YX>7&0{p8S%XXI0{sJi2me-X!z#kb@^(L
zIrTxbTFMXTi!+maqh2OdhC54A&#rQ{4~>UL|6E*af1FP^b#OX~#=VRt;}}z+FhX7&
z(?0)PAKjGZ*g(dZNg81514!QK;bQWS0-qDq&xgnv8vdcEkLzW9YdU7Q`jSwWHd*~b
zqQ?O;jM%iLY>Zw*$r*lZ<SCraU;-j^-!P55s)`-2s}okzcsze!r-{xeh8F_Ou%P~e
z487d4R`rl0s48n)6pQ<vMcGjZ^Y+2{^DF{s+*JN(#|0c7jAm-^H%(P2MRlC@|BF*Z
zE&Ko*B7ih9Wo4ja@`5Xbtc9y$6YEnh<n$4$ef%h*Ar2GwR>~?dz)vtCi6GqzmKd+b
z!(zZgpXf?*+wbzsxQ&XJ3)2p#3|IEa$pe0b>QbH=rr|j)yS-i=SFADE7tJ`oCmN@}
zL{UA^mr)_ZWdcbz>BGLSKFnFY^oV4EXulUCv6iQUG?d~nuNbxQiWI`F1pbLxAfG^h
iY#Pu|2q&8>`3}#6q-2Cz`ZEbT?K&=q;2asiqpF?e?>4gl

diff --git a/document/travis-deploy.sh b/document/travis-deploy.sh
deleted file mode 100755
index 832d025b5..000000000
--- a/document/travis-deploy.sh
+++ /dev/null
@@ -1,80 +0,0 @@
-#!/bin/bash
-
-# Adapted from https://github.com/heycam/webidl/blob/master/deploy.sh
-
-set -e # Exit with nonzero exit code if anything fails
-
-SOURCE_BRANCH="master"
-TARGET_BRANCH="gh-pages"
-
-function doCompile {
-  # TODO(littledan): Integrate with document/deploy.sh
-  (cd document; make)
-}
-
-# Pull requests and commits to other branches shouldn't try to deploy, just build to verify
-if [[ "$TRAVIS_PULL_REQUEST" != "false" || "$TRAVIS_BRANCH" != "$SOURCE_BRANCH" ]]; then
-  echo "Skipping deploy; just doing a build."
-  doCompile
-  exit 0
-fi
-
-# Save some useful information
-REPO=`git config remote.origin.url`
-SSH_REPO=${REPO/https:\/\/github.com\//git@github.com:}
-SHA=`git rev-parse --verify HEAD`
-
-# Get the deploy key by using Travis's stored variables to decrypt deploy_key.enc
-ENCRYPTED_KEY_VAR="encrypted_${ENCRYPTION_LABEL}_key"
-ENCRYPTED_IV_VAR="encrypted_${ENCRYPTION_LABEL}_iv"
-ENCRYPTED_KEY=${!ENCRYPTED_KEY_VAR}
-ENCRYPTED_IV=${!ENCRYPTED_IV_VAR}
-openssl aes-256-cbc -K $ENCRYPTED_KEY -iv $ENCRYPTED_IV -in deploy_key.enc -out deploy_key -d || true
-chmod 600 deploy_key
-eval `ssh-agent -s`
-ssh-add deploy_key || true
-
-# DON'T MOVE ABOVE AS IT WILL REVEAL KEYS!
-# Turn on logging from here on.
-set -x
-
-# Clone the existing gh-pages for this repo into _build/
-# Create a new empty branch if gh-pages doesn't exist yet (should only happen
-# on first deploy).
-# Clean document/*/_build.
-(cd document; make clean)
-# Ensure no checkout in _build.
-rm -rf document/_build
-# Clone a second checkout of our repo to _build.
-git clone $REPO document/_build
-(
-  # Checkout a parentless branch of gh-pages.
-  cd document/_build
-  git checkout $TARGET_BRANCH || git checkout --orphan $TARGET_BRANCH
-
-  # Clean out existing contents (to be replaced with output from the build
-  # that happens after this).
-  rm -rf ./*
-)
-
-# Run our compile script (output into _build).
-doCompile
-
-# Set user info on the gh-pages repo in _build.
-cd document/_build
-git config user.name "Travis CI"
-git config user.email "$COMMIT_AUTHOR_EMAIL"
-
-# If there are no changes to the compiled out (e.g. this is a README update) then just bail.
-if [[ -z "$(git status --porcelain)" ]]; then
-  echo "No changes to the output on this push; exiting."
-  exit 0
-fi
-
-# Commit the "changes", i.e. the new version.
-# The delta will show diffs between new and old versions.
-git add --all .
-git commit -m "Deploy to GitHub Pages: ${SHA}"
-
-# Now that we're all set up, we can push.
-git push $SSH_REPO $TARGET_BRANCH
diff --git a/interpreter/meta/travis/build-test.sh b/interpreter/meta/travis/build-test.sh
deleted file mode 100755
index 622962cab..000000000
--- a/interpreter/meta/travis/build-test.sh
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/bin/bash
-
-set -e
-set -x
-
-# Move to a location relative to the script so it runs
-# from anywhere.
-cd $(dirname ${BASH_SOURCE[0]})/../..
-
-make all
diff --git a/interpreter/meta/travis/install-ocaml.sh b/interpreter/meta/travis/install-ocaml.sh
deleted file mode 100755
index fa2c6c4f4..000000000
--- a/interpreter/meta/travis/install-ocaml.sh
+++ /dev/null
@@ -1,46 +0,0 @@
-#!/bin/bash
-
-set -e
-
-download_from_gh_archive() {
-  local project=$1;
-  local version=$2;
-  local sha=$3;
-
-  curl https://github.com/ocaml/${project}/archive/${version}.tar.gz -OL
-  CHECKSUM=$(shasum -a 256 ${version}.tar.gz | awk '{ print $1 }')
-  if [ ${CHECKSUM} != ${sha} ]; then
-    echo "Bad checksum ${project} download checksum!"
-    exit 1
-  fi
-  tar xfz ${version}.tar.gz
-}
-
-# Move to a location relative to the script so it runs
-# from anywhere. Go three levels down to get out of interpreter/
-# and into the top-level dir, since we'll run ocamlbuild
-# inside of interpreter/ and it goes pear-shaped if it
-# encounters ocaml's own build directory.
-cd $(dirname ${BASH_SOURCE[0]})/../../..
-
-PREFIX=$PWD/ocaml/install
-
-rm -rf ocaml
-mkdir ocaml
-cd ocaml
-mkdir install
-
-download_from_gh_archive ocaml 4.05.0 e5d8a6f629020c580473d8afcfcb06c3966d01929f7b734f41dc0c737cd8ea3f
-cd ocaml-4.05.0
-./configure -prefix ${PREFIX}
-make world.opt
-make install
-cd ..
-
-PATH=${PREFIX}/bin:${PATH}
-
-download_from_gh_archive ocamlbuild 0.11.0 1717edc841c9b98072e410f1b0bc8b84444b4b35ed3b4949ce2bec17c60103ee
-cd ocamlbuild-0.11.0
-make configure
-make
-make install

From 887e5de32bff194fd88e3ba5ffee52872764d031 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Sat, 24 Jul 2021 14:21:59 +0200
Subject: [PATCH 026/285] Simplify func context

---
 interpreter/util/lib.ml    |  9 +++++++++
 interpreter/util/lib.mli   |  3 +++
 interpreter/valid/valid.ml | 15 +++++++--------
 3 files changed, 19 insertions(+), 8 deletions(-)

diff --git a/interpreter/util/lib.ml b/interpreter/util/lib.ml
index 23bace335..7becaf1f6 100644
--- a/interpreter/util/lib.ml
+++ b/interpreter/util/lib.ml
@@ -153,6 +153,15 @@ struct
   and mapi' f i = function
     | [] -> []
     | x::xs -> f i x :: mapi' f (Int32.add i 1l) xs
+
+  let rec index_where p xs = index_where' p xs 0l
+  and index_where' p xs i =
+    match xs with
+    | [] -> None
+    | x::xs' when p x -> Some i
+    | x::xs' -> index_where' p xs' (Int32.add i 1l)
+
+  let index_of x = index_where ((=) x)
 end
 
 module Array32 =
diff --git a/interpreter/util/lib.mli b/interpreter/util/lib.mli
index bde64f1da..1b2604437 100644
--- a/interpreter/util/lib.mli
+++ b/interpreter/util/lib.mli
@@ -37,6 +37,9 @@ sig
   val take : int32 -> 'a list -> 'a list (* raises Failure *)
   val drop : int32 -> 'a list -> 'a list (* raises Failure *)
   val mapi : (int32 -> 'a -> 'b) -> 'a list -> 'b list
+
+  val index_of : 'a -> 'a list -> int32 option
+  val index_where : ('a -> bool) -> 'a list -> int32 option
 end
 
 module Array32 :
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index f40b46eae..5a47b11fa 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -18,7 +18,7 @@ let require b at s = if not b then error at s
 type context =
 {
   types : def_type list;
-  funcs : syn_var list;
+  funcs : func_type list;
   tables : table_type list;
   memories : memory_type list;
   globals : global_type list;
@@ -42,7 +42,7 @@ let lookup category list x =
     error x.at ("unknown " ^ category ^ " " ^ I32.to_string_u x.it)
 
 let type_ (c : context) x = lookup "type" c.types x
-let func_var (c : context) x = lookup "function" c.funcs x
+let func (c : context) x = lookup "function" c.funcs x
 let table (c : context) x = lookup "table" c.tables x
 let memory (c : context) x = lookup "memory" c.memories x
 let global (c : context) x = lookup "global" c.globals x
@@ -55,8 +55,6 @@ let func_type (c : context) x =
   match type_ c x with
   | FuncDefType ft -> ft
 
-let func (c : context) x = func_type c (func_var c x @@ x.at)
-
 let refer category (s : Free.Set.t) x =
   if not (Free.Set.mem x.it s) then
     error x.at
@@ -534,7 +532,8 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : op_type
     [RefType (Nullable, t)] --> [RefType (NonNullable, t)]
 
   | RefFunc x ->
-    let y = func_var c x in
+    let ft = func c x in
+    let y = Lib.Option.force (Lib.List32.index_of (FuncDefType ft) c.types) in
     refer_func c x;
     [] --> [RefType (NonNullable, DefHeapType (SynVar y))]
 
@@ -683,8 +682,8 @@ let check_import (im : import) (c : context) : context =
   let {module_name = _; item_name = _; idesc} = im.it in
   match idesc.it with
   | FuncImport x ->
-    ignore (func_type c x);
-    {c with funcs = x.it :: c.funcs}
+    let ft = func_type c x in
+    {c with funcs = ft :: c.funcs}
   | TableImport tt ->
     check_table_type c tt idesc.at;
     {c with tables = tt :: c.tables}
@@ -723,7 +722,7 @@ let check_module (m : module_) =
   in
   let c1 =
     { c0 with
-      funcs = c0.funcs @ List.map (fun f -> ignore (func_type c0 f.it.ftype); f.it.ftype.it) funcs;
+      funcs = c0.funcs @ List.map (fun f -> func_type c0 f.it.ftype) funcs;
       tables = c0.tables @ List.map (fun tab -> tab.it.ttype) tables;
       memories = c0.memories @ List.map (fun mem -> mem.it.mtype) memories;
       elems = List.map (fun elem -> elem.it.etype) elems;

From 725c2457355c94c5bcdac24ea087f4928bb7b66c Mon Sep 17 00:00:00 2001
From: Nick Fitzgerald <fitzgen@gmail.com>
Date: Mon, 26 Jul 2021 09:55:40 -0700
Subject: [PATCH 027/285] [spec] Fix `table.grow` signature in appendix (#1349)

---
 document/core/appendix/gen-index-instructions.py | 2 +-
 document/core/appendix/index-instructions.rst    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/appendix/gen-index-instructions.py b/document/core/appendix/gen-index-instructions.py
index 6191a07b8..c1f3e1090 100755
--- a/document/core/appendix/gen-index-instructions.py
+++ b/document/core/appendix/gen-index-instructions.py
@@ -328,7 +328,7 @@ def Instruction(name, opcode, type=None, validation=None, execution=None, operat
     Instruction(r'\TABLEINIT~x~y', r'\hex{FC}~\hex{0C}', r'[\I32~\I32~\I32] \to []', r'valid-table.init', r'exec-table.init'),
     Instruction(r'\ELEMDROP~x', r'\hex{FC}~\hex{0D}', r'[] \to []', r'valid-elem.drop', r'exec-elem.drop'),
     Instruction(r'\TABLECOPY~x~y', r'\hex{FC}~\hex{0E}', r'[\I32~\I32~\I32] \to []', r'valid-table.copy', r'exec-table.copy'),
-    Instruction(r'\TABLEGROW~x', r'\hex{FC}~\hex{0F}', r'[t~\I32] \to []', r'valid-table.grow', r'exec-table.grow'),
+    Instruction(r'\TABLEGROW~x', r'\hex{FC}~\hex{0F}', r'[t~\I32] \to [\I32]', r'valid-table.grow', r'exec-table.grow'),
     Instruction(r'\TABLESIZE~x', r'\hex{FC}~\hex{10}', r'[] \to [\I32]', r'valid-table.size', r'exec-table.size'),
     Instruction(r'\TABLEFILL~x', r'\hex{FC}~\hex{11}', r'[\I32~t~\I32] \to []', r'valid-table.fill', r'exec-table.fill'),
 ]
diff --git a/document/core/appendix/index-instructions.rst b/document/core/appendix/index-instructions.rst
index 55bf8fb98..6c8ae29dd 100644
--- a/document/core/appendix/index-instructions.rst
+++ b/document/core/appendix/index-instructions.rst
@@ -276,7 +276,7 @@ Instruction                                Binary Opcode              Type
 :math:`\TABLEINIT~x~y`                     :math:`\hex{FC}~\hex{0C}`  :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-table.init>`     :ref:`execution <exec-table.init>`                             
 :math:`\ELEMDROP~x`                        :math:`\hex{FC}~\hex{0D}`  :math:`[] \to []`                              :ref:`validation <valid-elem.drop>`      :ref:`execution <exec-elem.drop>`                              
 :math:`\TABLECOPY~x~y`                     :math:`\hex{FC}~\hex{0E}`  :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-table.copy>`     :ref:`execution <exec-table.copy>`                             
-:math:`\TABLEGROW~x`                       :math:`\hex{FC}~\hex{0F}`  :math:`[t~\I32] \to []`                        :ref:`validation <valid-table.grow>`     :ref:`execution <exec-table.grow>`                             
+:math:`\TABLEGROW~x`                       :math:`\hex{FC}~\hex{0F}`  :math:`[t~\I32] \to [\I32]`                    :ref:`validation <valid-table.grow>`     :ref:`execution <exec-table.grow>`                             
 :math:`\TABLESIZE~x`                       :math:`\hex{FC}~\hex{10}`  :math:`[] \to [\I32]`                          :ref:`validation <valid-table.size>`     :ref:`execution <exec-table.size>`                             
 :math:`\TABLEFILL~x`                       :math:`\hex{FC}~\hex{11}`  :math:`[\I32~t~\I32] \to []`                   :ref:`validation <valid-table.fill>`     :ref:`execution <exec-table.fill>`                             
 =========================================  =========================  =============================================  =======================================  ===============================================================

From 46cf27ce076e1213e45b89ffdc99df4499b3cb33 Mon Sep 17 00:00:00 2001
From: Asumu Takikawa <asumu@igalia.com>
Date: Fri, 16 Jul 2021 12:35:33 -0700
Subject: [PATCH 028/285] [CI] Adjust JS/Web API build to use latest bikeshed

Also avoids uploading unnecessary files during publish.
---
 .github/workflows/main.yml | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 1386b4c67..7952079e5 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -25,29 +25,23 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - name: Build JS API bikeshed
-        uses: netwerk-digitaal-erfgoed/bikeshed-action@v1
-        with:
-          source: "document/js-api/index.bs"
-          destination: "document/js-api/index.html"
+      - run: pip install bikeshed && bikeshed update
+      - run: bikeshed spec "document/js-api/index.bs" "document/js-api/index.html"
       - uses: actions/upload-artifact@v2
         with:
           name: js-api-rendered
-          path: document/js-api
+          path: document/js-api/index.html
 
   build-web-api-spec:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - name: Build JS API bikeshed
-        uses: netwerk-digitaal-erfgoed/bikeshed-action@v1
-        with:
-          source: "document/web-api/index.bs"
-          destination: "document/web-api/index.html"
+      - run: pip install bikeshed && bikeshed update
+      - run: bikeshed spec "document/web-api/index.bs" "document/web-api/index.html"
       - uses: actions/upload-artifact@v2
         with:
           name: web-api-rendered
-          path: document/web-api
+          path: document/web-api/index.html
 
   build-core-spec:
     runs-on: ubuntu-latest

From ab5ad7fa54e8c83d307642d7657c8c79d61dbdf2 Mon Sep 17 00:00:00 2001
From: Daulet Dulanov <dulanov@gmail.com>
Date: Tue, 3 Aug 2021 16:48:06 +0200
Subject: [PATCH 029/285] [spec] Fix type of `if` instruction in index (#1350)

---
 document/core/appendix/gen-index-instructions.py | 2 +-
 document/core/appendix/index-instructions.rst    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/appendix/gen-index-instructions.py b/document/core/appendix/gen-index-instructions.py
index c1f3e1090..713da71d2 100755
--- a/document/core/appendix/gen-index-instructions.py
+++ b/document/core/appendix/gen-index-instructions.py
@@ -65,7 +65,7 @@ def Instruction(name, opcode, type=None, validation=None, execution=None, operat
     Instruction(r'\NOP', r'\hex{01}', r'[] \to []', r'valid-nop', r'exec-nop'),
     Instruction(r'\BLOCK~\X{bt}', r'\hex{02}', r'[t_1^\ast] \to [t_2^\ast]', r'valid-block', r'exec-block'),
     Instruction(r'\LOOP~\X{bt}', r'\hex{03}', r'[t_1^\ast] \to [t_2^\ast]', r'valid-loop', r'exec-loop'),
-    Instruction(r'\IF~\X{bt}', r'\hex{04}', r'[t_1^\ast] \to [t_2^\ast]', r'valid-if', r'exec-if'),
+    Instruction(r'\IF~\X{bt}', r'\hex{04}', r'[t_1^\ast~\I32] \to [t_2^\ast]', r'valid-if', r'exec-if'),
     Instruction(r'\ELSE', r'\hex{05}'),
     Instruction(None, r'\hex{06}'),
     Instruction(None, r'\hex{07}'),
diff --git a/document/core/appendix/index-instructions.rst b/document/core/appendix/index-instructions.rst
index 6c8ae29dd..6e424f659 100644
--- a/document/core/appendix/index-instructions.rst
+++ b/document/core/appendix/index-instructions.rst
@@ -13,7 +13,7 @@ Instruction                                Binary Opcode              Type
 :math:`\NOP`                               :math:`\hex{01}`           :math:`[] \to []`                              :ref:`validation <valid-nop>`            :ref:`execution <exec-nop>`                                    
 :math:`\BLOCK~\X{bt}`                      :math:`\hex{02}`           :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-block>`          :ref:`execution <exec-block>`                                  
 :math:`\LOOP~\X{bt}`                       :math:`\hex{03}`           :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-loop>`           :ref:`execution <exec-loop>`                                   
-:math:`\IF~\X{bt}`                         :math:`\hex{04}`           :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-if>`             :ref:`execution <exec-if>`                                     
+:math:`\IF~\X{bt}`                         :math:`\hex{04}`           :math:`[t_1^\ast~\I32] \to [t_2^\ast]`         :ref:`validation <valid-if>`             :ref:`execution <exec-if>`                                     
 :math:`\ELSE`                              :math:`\hex{05}`                                                                                                                                                                  
 (reserved)                                 :math:`\hex{06}`                                                                                                                                                                  
 (reserved)                                 :math:`\hex{07}`                                                                                                                                                                  

From e8d29098d795e4f2df818b3936e204d5849a288d Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@dfinity.org>
Date: Fri, 6 Aug 2021 18:31:46 +0200
Subject: [PATCH 030/285] [spec] Add concrete ref types (#49)

---
 document/core/appendix/index-rules.rst |  27 +-
 document/core/appendix/index-types.rst |   9 +-
 document/core/appendix/properties.rst  |  14 +-
 document/core/binary/instructions.rst  |   2 +-
 document/core/binary/types.rst         |  26 +-
 document/core/exec/modules.rst         |   2 +-
 document/core/exec/runtime.rst         |   1 +
 document/core/syntax/instructions.rst  |   2 +-
 document/core/syntax/modules.rst       |   2 +-
 document/core/syntax/types.rst         |  36 ++-
 document/core/text/instructions.rst    |   8 +-
 document/core/text/modules.rst         |  26 +-
 document/core/text/types.rst           |  70 +++--
 document/core/util/macros.def          |  51 ++-
 document/core/valid/index.rst          |   1 +
 document/core/valid/instructions.rst   |  52 +--
 document/core/valid/matching.rst       | 347 ++++++++++++++++++++
 document/core/valid/modules.rst        |  76 +++--
 document/core/valid/types.rst          | 417 ++++++++++---------------
 interpreter/binary/decode.ml           |  26 +-
 interpreter/binary/encode.ml           |   8 +-
 21 files changed, 824 insertions(+), 379 deletions(-)
 create mode 100644 document/core/valid/matching.rst

diff --git a/document/core/appendix/index-rules.rst b/document/core/appendix/index-rules.rst
index dde34900e..755142184 100644
--- a/document/core/appendix/index-rules.rst
+++ b/document/core/appendix/index-rules.rst
@@ -13,13 +13,13 @@ Typing of Static Constructs
 ===============================================  ===============================================================================
 Construct                                        Judgement
 ===============================================  ===============================================================================
-:ref:`Limits <valid-limits>`                     :math:`\vdashlimits \limits : k`
-:ref:`Function type <valid-functype>`            :math:`\vdashfunctype \functype \ok`
-:ref:`Block type <valid-blocktype>`              :math:`\vdashblocktype \blocktype \ok`
-:ref:`Table type <valid-tabletype>`              :math:`\vdashtabletype \tabletype \ok`
-:ref:`Memory type <valid-memtype>`               :math:`\vdashmemtype \memtype \ok`
-:ref:`Global type <valid-globaltype>`            :math:`\vdashglobaltype \globaltype \ok`
-:ref:`External type <valid-externtype>`          :math:`\vdashexterntype \externtype \ok`
+:ref:`Limits <valid-limits>`                     :math:`C \vdashlimits \limits : k`
+:ref:`Function type <valid-functype>`            :math:`C \vdashfunctype \functype \ok`
+:ref:`Block type <valid-blocktype>`              :math:`C \vdashblocktype \blocktype \ok`
+:ref:`Table type <valid-tabletype>`              :math:`C \vdashtabletype \tabletype \ok`
+:ref:`Memory type <valid-memtype>`               :math:`C \vdashmemtype \memtype \ok`
+:ref:`Global type <valid-globaltype>`            :math:`C \vdashglobaltype \globaltype \ok`
+:ref:`External type <valid-externtype>`          :math:`C \vdashexterntype \externtype \ok`
 :ref:`Instruction <valid-instr>`                 :math:`S;C \vdashinstr \instr : \functype`
 :ref:`Instruction sequence <valid-instr-seq>`    :math:`S;C \vdashinstrseq \instr^\ast : \functype`
 :ref:`Expression <valid-expr>`                   :math:`C \vdashexpr \expr : \resulttype`
@@ -83,8 +83,17 @@ Matching
 ===============================================  ===============================================================================
 Construct                                        Judgement
 ===============================================  ===============================================================================
-:ref:`External type <match-externtype>`          :math:`\vdashexterntypematch \externtype_1 \matchesexterntype \externtype_2`
-:ref:`Limits <match-limits>`                     :math:`\vdashlimitsmatch \limits_1 \matcheslimits \limits_2`
+:ref:`Number type <match-numtype>`               :math:`C \vdashnumtypematch \numtype_1 \matchesnumtype \numtype_2`
+:ref:`Heap type <match-heaptype>`                :math:`C \vdashheaptypematch \heaptype_1 \matchesheaptype \heaptype_2`
+:ref:`Reference type <match-reftype>`            :math:`C \vdashreftypematch \reftype_1 \matchesreftype \reftype_2`
+:ref:`Value type <match-valtype>`                :math:`C \vdashvaltypematch \valtype_1 \matchesvaltype \valtype_2`
+:ref:`Result type <match-resulttype>`            :math:`C \vdashresulttypematch \resulttype_1 \matchesresulttype \resulttype_2`
+:ref:`Function type <match-functype>`            :math:`C \vdashfunctypematch \functype_1 \matchesfunctype \functype_2`
+:ref:`Table type <match-tabletype>`              :math:`C \vdashtabletypematch \tabletype_1 \matchestabletype \tabletype_2`
+:ref:`Memory type <match-memtype>`               :math:`C \vdashmemtypematch \memtype_1 \matchesmemtype \memtype_2`
+:ref:`Global type <match-globaltype>`            :math:`C \vdashglobaltypematch \globaltype_1 \matchesglobaltype \globaltype_2`
+:ref:`External type <match-externtype>`          :math:`C \vdashexterntypematch \externtype_1 \matchesexterntype \externtype_2`
+:ref:`Limits <match-limits>`                     :math:`C \vdashlimitsmatch \limits_1 \matcheslimits \limits_2`
 ===============================================  ===============================================================================
 
 
diff --git a/document/core/appendix/index-types.rst b/document/core/appendix/index-types.rst
index fd38fe205..90a411934 100644
--- a/document/core/appendix/index-types.rst
+++ b/document/core/appendix/index-types.rst
@@ -13,9 +13,12 @@ Category                                  Constructor
 :ref:`Number type <syntax-numtype>`       |F32|                                        :math:`\hex{7D}` (-3 as |Bs7|)
 :ref:`Number type <syntax-numtype>`       |F64|                                        :math:`\hex{7C}` (-4 as |Bs7|)
 (reserved)                                                                             :math:`\hex{7B}` .. :math:`\hex{71}`
-:ref:`Reference type <syntax-reftype>`    |FUNCREF|                                    :math:`\hex{70}` (-16 as |Bs7|)
-:ref:`Reference type <syntax-reftype>`    |EXTERNREF|                                  :math:`\hex{6F}` (-17 as |Bs7|)
-(reserved)                                                                             :math:`\hex{6E}` .. :math:`\hex{61}`
+:ref:`Heap type <syntax-heaptype>`        |FUNC|                                       :math:`\hex{70}` (-16 as |Bs7|)
+:ref:`Heap type <syntax-heaptype>`        |EXTERN|                                     :math:`\hex{6F}` (-17 as |Bs7|)
+(reserved)                                                                             :math:`\hex{6E}` .. :math:`\hex{6D}`
+:ref:`Reference type <syntax-reftype>`    |REF| |NULL|                                 :math:`\hex{6C}` (-20 as |Bs7|)
+:ref:`Reference type <syntax-reftype>`    |REF|                                        :math:`\hex{6B}` (-21 as |Bs7|)
+(reserved)                                                                             :math:`\hex{6A}` .. :math:`\hex{61}`
 :ref:`Function type <syntax-functype>`    :math:`[\valtype^\ast] \to [\valtype^\ast]`  :math:`\hex{60}` (-32 as |Bs7|)
 (reserved)                                                                             :math:`\hex{5F}` .. :math:`\hex{41}`
 :ref:`Result type <syntax-resulttype>`    :math:`[\epsilon]`                           :math:`\hex{40}` (-64 as |Bs7|)
diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index cf1fd0fbc..7aa010999 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -4,6 +4,10 @@
 Soundness
 ---------
 
+.. todo:: need to operate wrt semantic types
+.. todo:: define "S \vdash t ok"
+.. todo:: ensure wf of guessed valtypes
+
 The :ref:`type system <type-system>` of WebAssembly is *sound*, implying both *type safety* and *memory safety* with respect to the WebAssembly semantics. For example:
 
 * All types declared and derived during validation are respected at run time;
@@ -50,7 +54,7 @@ Results
 :ref:`Results <syntax-result>` :math:`\TRAP`
 ............................................
 
-* The result is valid with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`, for any sequence :math:`t^\ast` of :ref:`value types <syntax-valtype>`.
+* The result is valid with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`, for any sequence :math:`t^\ast` of :ref:`valid <valid-valtype>` :ref:`value types <syntax-valtype>`.
 
 .. math::
    \frac{
@@ -221,6 +225,8 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 
 * Then the table instance is valid with :ref:`table type <syntax-tabletype>` :math:`\limits~t`.
 
+.. todo:: reftypematch needs C
+
 .. math::
    \frac{
      \vdashtabletype \limits~t \ok
@@ -229,7 +235,7 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
      \qquad
      (S \vdash \reff : t')^n
      \qquad
-     (\vdashreftypematch t' \matchesvaltype t)^n
+     (C \vdashreftypematch t' \matchesvaltype t)^n
    }{
      S \vdashtableinst \{ \TITYPE~(\limits~t), \TIELEM~\reff^n \} : \limits~t
    }
@@ -297,11 +303,13 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 
 * Then the table instance is valid.
 
+.. todo:: reftypematch needs C
+
 .. math::
    \frac{
      (S \vdash \reff : t')^\ast
      \qquad
-     (\vdashreftypematch t' \matchesvaltype t)^\ast
+     (C \vdashreftypematch t' \matchesvaltype t)^\ast
    }{
      S \vdasheleminst \{ \EITYPE~t, \EIELEM~\reff^\ast \} \ok
    }
diff --git a/document/core/binary/instructions.rst b/document/core/binary/instructions.rst
index 9c789978a..897246972 100644
--- a/document/core/binary/instructions.rst
+++ b/document/core/binary/instructions.rst
@@ -88,7 +88,7 @@ Reference Instructions
 .. math::
    \begin{array}{llclll}
    \production{instruction} & \Binstr &::=& \dots \\ &&|&
-     \hex{D0}~~t{:}\Breftype &\Rightarrow& \REFNULL~t \\ &&|&
+     \hex{D0}~~t{:}\Bheaptype &\Rightarrow& \REFNULL~t \\ &&|&
      \hex{D1} &\Rightarrow& \REFISNULL \\ &&|&
      \hex{D2}~~x{:}\Bfuncidx &\Rightarrow& \REFFUNC~x \\
    \end{array}
diff --git a/document/core/binary/types.rst b/document/core/binary/types.rst
index 975f17ad6..e9adc4df9 100644
--- a/document/core/binary/types.rst
+++ b/document/core/binary/types.rst
@@ -29,6 +29,24 @@ Number Types
    \end{array}
 
 
+.. index:: heap type
+   pair: binary format; heap type
+.. _binary-heaptype:
+
+Heap Types
+~~~~~~~~~~
+
+:ref:`Heap types <syntax-reftype>` are encoded as either a single byte, or as a :ref:`type index <binary-typeidx>` encoded as a positive :ref:`signed integer <binary-sint>`.
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{heap type} & \Bheaptype &::=&
+     \hex{6F} &\Rightarrow& \EXTERN \\ &&|&
+     \hex{70} &\Rightarrow& \FUNC \\ &&|&
+     x{:}\Bs33 &\Rightarrow& x & (\iff x \geq 0) \\
+   \end{array}
+
+
 .. index:: reference type
    pair: binary format; reference type
 .. _binary-reftype:
@@ -36,13 +54,15 @@ Number Types
 Reference Types
 ~~~~~~~~~~~~~~~
 
-:ref:`Reference types <syntax-reftype>` are also encoded by a single byte.
+:ref:`Reference types <syntax-reftype>` are either encoded by a single byte followed by a :ref:`heap type <binary-heaptype>`, or, as a short form, directly as a non-index heap type.
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
    \production{reference type} & \Breftype &::=&
-     \hex{70} &\Rightarrow& \FUNCREF \\ &&|&
-     \hex{6F} &\Rightarrow& \EXTERNREF \\
+     \hex{6B}~~\X{ht}{:}\Bheaptype &\Rightarrow& \REF~\X{ht} \\ &&|&
+     \hex{6C}~~\X{ht}{:}\Bheaptype &\Rightarrow& \REF~\NULL~\X{ht} \\ &&|&
+     \hex{6F} &\Rightarrow& \EXTERNREF \\ &&|&
+     \hex{70} &\Rightarrow& \FUNCREF \\
    \end{array}
 
 
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index cf0cf0874..2547aa49a 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -3,7 +3,7 @@ Modules
 
 For modules, the execution semantics primarily defines :ref:`instantiation <exec-instantiation>`, which :ref:`allocates <alloc>` instances for a module and its contained definitions, initializes :ref:`tables <syntax-table>` and :ref:`memories <syntax-mem>` from contained :ref:`element <syntax-elem>` and :ref:`data <syntax-data>` segments, and invokes the :ref:`start function <syntax-start>` if present. It also includes :ref:`invocation <exec-invocation>` of exported functions.
 
-Instantiation depends on a number of auxiliary notions for :ref:`type-checking imports <exec-import>` and :ref:`allocating <alloc>` instances.
+Instantiation depends on a number of auxiliary notions for :ref:`type-checking imports <match-externtype>` and :ref:`allocating <alloc>` instances.
 
 
 .. index:: external value, external type, validation, import, store
diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index 02b90c012..5f042cd55 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -13,6 +13,7 @@ Runtime Structure
 .. _syntax-ref:
 .. _syntax-ref.extern:
 .. _syntax-val:
+.. _syntax-null:
 
 Values
 ~~~~~~
diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index 9c582d64c..ed3aff9c4 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -434,7 +434,7 @@ Forward branches require operands according to the output of the targeted block'
 Backward branches require operands according to the input of the targeted block's type, i.e., represent the values consumed by the restarted block.
 
 The |CALL| instruction invokes another :ref:`function <syntax-func>`, consuming the necessary arguments from the stack and returning the result values of the call.
-The |CALLINDIRECT| instruction calls a function indirectly through an operand indexing into a :ref:`table <syntax-table>` that is denoted by a :ref:`table index <syntax-tableidx>` and must have type |FUNCREF|.
+The |CALLINDIRECT| instruction calls a function indirectly through an operand indexing into a :ref:`table <syntax-table>` that is denoted by a :ref:`table index <syntax-tableidx>` and must contain :ref:`function references <syntax-reftype>`.
 Since it may contain functions of heterogeneous type,
 the callee is dynamically checked against the :ref:`function type <syntax-functype>` indexed by the instruction's second immediate, and the call is aborted with a :ref:`trap <trap>` if it does not match.
 
diff --git a/document/core/syntax/modules.rst b/document/core/syntax/modules.rst
index cfd8935aa..f51a504f0 100644
--- a/document/core/syntax/modules.rst
+++ b/document/core/syntax/modules.rst
@@ -273,7 +273,7 @@ The |EOFFSET| is given by a :ref:`constant <valid-constant>` :ref:`expression <s
 Element segments are referenced through :ref:`element indices <syntax-elemidx>`.
 
 .. note::
-   In the current version of WebAssembly, only tables of element type |FUNCREF| can be initialized with an element segment.
+   In the current version of WebAssembly, only tables whose elements are :ref:`function references <syntax-reftype>` can be initialized with an element segment.
    This limitation may be lifted in the future.
 
 
diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index 858fbc1a4..ac8b224c5 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -41,7 +41,29 @@ Conventions
   That is, :math:`|\I32| = |\F32| = 32` and :math:`|\I64| = |\F64| = 64`.
 
 
-.. index:: ! reference type, reference, table, function, function type, null
+.. index:: ! heap type, store, type index
+   pair: abstract syntax; heap type
+.. _syntax-heaptype:
+
+Heap Types
+~~~~~~~~~~
+
+*Heap types* classify objects in the runtime :ref:`store <store>`.
+
+.. math::
+   \begin{array}{llll}
+   \production{heap type} & \heaptype &::=&
+     \FUNC ~|~ \EXTERN ~|~ \typeidx \\
+   \end{array}
+
+The type |FUNC| denotes the infinite union of all types of :ref:`functions <syntax-func>`, regardless of their concrete :ref:`function types <syntax-functype>`.
+
+The type |EXTERN| denotes the infinite union of all objects owned by the :ref:`embedder <embedder>` and that can be passed into WebAssembly under this type.
+
+A *concrete* heap type consists of a :ref:`type index <syntax-typeidx>` and classifies an object of the respective :ref:`type <syntax-type>` defined in the module.
+
+
+.. index:: ! reference type, heap type, reference, table, function, function type, null
    pair: abstract syntax; reference type
    pair: reference; type
 .. _syntax-reftype:
@@ -49,26 +71,28 @@ Conventions
 Reference Types
 ~~~~~~~~~~~~~~~
 
-*Reference types* classify first-class references to objects in the runtime :ref:`store <store>`.
+*Reference types* classify :ref:`values <syntax-value>` that are first-class references to objects in the runtime :ref:`store <store>`.
 
 .. math::
    \begin{array}{llll}
    \production{reference type} & \reftype &::=&
-     \FUNCREF ~|~ \EXTERNREF \\
+     \REF~\NULL^?~\heaptype \\
    \end{array}
 
-The type |FUNCREF| denotes the infinite union of all references to :ref:`functions <syntax-func>`, regardless of their :ref:`function types <syntax-functype>`.
+A reference type is characterised by the :ref:`heap type <syntax-heaptype>` it points to.
 
-The type |EXTERNREF| denotes the infinite union of all references to objects owned by the :ref:`embedder <embedder>` and that can be passed into WebAssembly under this type.
+In addition, a reference type of the form :math:`\REF \NULL \X{ht}` is *nullable*, meaning that it can either be a proper reference to :math:`\X{ht}` or :ref:`null <syntax-null>`.
+Other references are *non-null*.
 
 Reference types are *opaque*, meaning that neither their size nor their bit pattern can be observed.
 Values of reference type can be stored in :ref:`tables <syntax-table>`.
 
 
-.. index:: ! value type, number type, reference type
+.. index:: ! value type, number type, reference type, ! bottom type
    pair: abstract syntax; value type
    pair: value; type
 .. _syntax-valtype:
+.. _syntax-bottype:
 
 Value Types
 ~~~~~~~~~~~
diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index 6112a7667..0c350d000 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -70,7 +70,7 @@ However, the special case of a type use that is syntactically empty or consists
    \begin{array}[t]{@{}c@{}} ::= \\ | \\ \end{array}
    &
    \begin{array}[t]{@{}lcll@{}}
-     (t{:}\Tresult)^? &\Rightarrow& t^? \\
+     (t{:}\Tresult_I)^? &\Rightarrow& t^? \\
      x,I'{:}\Ttypeuse_I &\Rightarrow& x & (\iff I' = \{\ILOCALS~(\epsilon)^\ast\}) \\
    \end{array} \\
    \production{block instruction} & \Tblockinstr_I &::=&
@@ -128,9 +128,9 @@ The :math:`\text{else}` keyword of an :math:`\text{if}` instruction can be omitt
 .. math::
    \begin{array}{llclll}
    \production{block instruction} &
-     \text{if}~~\Tlabel~~\Tblocktype~~\Tinstr^\ast~~\text{end}
+     \text{if}~~\Tlabel~~\Tblocktype_I~~\Tinstr^\ast~~\text{end}
        &\equiv&
-     \text{if}~~\Tlabel~~\Tblocktype~~\Tinstr^\ast~~\text{else}~~\text{end}
+     \text{if}~~\Tlabel~~\Tblocktype_I~~\Tinstr^\ast~~\text{else}~~\text{end}
    \end{array}
 
 Also, for backwards compatibility, the table index to :math:`\text{call\_indirect}` can be omitted, defaulting to :math:`0`.
@@ -178,7 +178,7 @@ Parametric Instructions
    \begin{array}{llclll}
    \production{instruction} & \Tplaininstr_I &::=& \dots \\ &&|&
      \text{drop} &\Rightarrow& \DROP \\ &&|&
-     \text{select}~((t{:}\Tresult)^\ast)^? &\Rightarrow& \SELECT~(t^\ast)^? \\
+     \text{select}~((t{:}\Tresult_I)^\ast)^? &\Rightarrow& \SELECT~(t^\ast)^? \\
    \end{array}
 
 
diff --git a/document/core/text/modules.rst b/document/core/text/modules.rst
index 848f6880b..d9e759849 100644
--- a/document/core/text/modules.rst
+++ b/document/core/text/modules.rst
@@ -72,8 +72,8 @@ Type definitions can bind a symbolic :ref:`type identifier <text-id>`.
 
 .. math::
    \begin{array}{llclll}
-   \production{type definition} & \Ttype &::=&
-     \text{(}~\text{type}~~\Tid^?~~\X{ft}{:}\Tfunctype~\text{)}
+   \production{type definition} & \Ttype_I &::=&
+     \text{(}~\text{type}~~\Tid^?~~\X{ft}{:}\Tfunctype_I~\text{)}
        &\Rightarrow& \X{ft} \\
    \end{array}
 
@@ -167,11 +167,11 @@ The descriptors in imports can bind a symbolic function, table, memory, or globa
    \production{import description} & \Timportdesc_I &::=&
      \text{(}~\text{func}~~\Tid^?~~x,I'{:}\Ttypeuse_I~\text{)}
        &\Rightarrow& \IDFUNC~x \\ &&|&
-     \text{(}~\text{table}~~\Tid^?~~\X{tt}{:}\Ttabletype~\text{)}
+     \text{(}~\text{table}~~\Tid^?~~\X{tt}{:}\Ttabletype_I~\text{)}
        &\Rightarrow& \IDTABLE~\X{tt} \\ &&|&
-     \text{(}~\text{memory}~~\Tid^?~~\X{mt}{:}\Tmemtype~\text{)}
+     \text{(}~\text{memory}~~\Tid^?~~\X{mt}{:}\Tmemtype_I~\text{)}
        &\Rightarrow& \IDMEM~~\X{mt} \\ &&|&
-     \text{(}~\text{global}~~\Tid^?~~\X{gt}{:}\Tglobaltype~\text{)}
+     \text{(}~\text{global}~~\Tid^?~~\X{gt}{:}\Tglobaltype_I~\text{)}
        &\Rightarrow& \IDGLOBAL~\X{gt} \\
    \end{array}
 
@@ -198,11 +198,11 @@ Function definitions can bind a symbolic :ref:`function identifier <text-id>`, a
    \begin{array}{llclll}
    \production{function} & \Tfunc_I &::=&
      \text{(}~\text{func}~~\Tid^?~~x,I'{:}\Ttypeuse_I~~
-     (t{:}\Tlocal)^\ast~~(\X{in}{:}\Tinstr_{I''})^\ast~\text{)} \\ &&& \qquad
+     (t{:}\Tlocal_I)^\ast~~(\X{in}{:}\Tinstr_{I''})^\ast~\text{)} \\ &&& \qquad
        \Rightarrow\quad \{ \FTYPE~x, \FLOCALS~t^\ast, \FBODY~\X{in}^\ast~\END \} \\ &&& \qquad\qquad\qquad
        (\iff I'' = I' \compose \{\ILOCALS~\F{id}(\Tlocal)^\ast\} \idcwellformed) \\[1ex]
-   \production{local} & \Tlocal &::=&
-     \text{(}~\text{local}~~\Tid^?~~t{:}\Tvaltype~\text{)}
+   \production{local} & \Tlocal_I &::=&
+     \text{(}~\text{local}~~\Tid^?~~t{:}\Tvaltype_I~\text{)}
        \quad\Rightarrow\quad t \\
    \end{array}
 
@@ -265,7 +265,7 @@ Table definitions can bind a symbolic :ref:`table identifier <text-id>`.
 .. math::
    \begin{array}{llclll}
    \production{table} & \Ttable_I &::=&
-     \text{(}~\text{table}~~\Tid^?~~\X{tt}{:}\Ttabletype~\text{)}
+     \text{(}~\text{table}~~\Tid^?~~\X{tt}{:}\Ttabletype_I~\text{)}
        &\Rightarrow& \{ \TTYPE~\X{tt} \} \\
    \end{array}
 
@@ -334,7 +334,7 @@ Memory definitions can bind a symbolic :ref:`memory identifier <text-id>`.
 .. math::
    \begin{array}{llclll}
    \production{memory} & \Tmem_I &::=&
-     \text{(}~\text{memory}~~\Tid^?~~\X{mt}{:}\Tmemtype~\text{)}
+     \text{(}~\text{memory}~~\Tid^?~~\X{mt}{:}\Tmemtype_I~\text{)}
        &\Rightarrow& \{ \MTYPE~\X{mt} \} \\
    \end{array}
 
@@ -394,7 +394,7 @@ Global definitions can bind a symbolic :ref:`global identifier <text-id>`.
 .. math::
    \begin{array}{llclll}
    \production{global} & \Tglobal_I &::=&
-     \text{(}~\text{global}~~\Tid^?~~\X{gt}{:}\Tglobaltype~~e{:}\Texpr_I~\text{)}
+     \text{(}~\text{global}~~\Tid^?~~\X{gt}{:}\Tglobaltype_I~~e{:}\Texpr_I~\text{)}
        &\Rightarrow& \{ \GTYPE~\X{gt}, \GINIT~e \} \\
    \end{array}
 
@@ -505,7 +505,7 @@ Element segments allow for an optional :ref:`table index <text-tableidx>` to ide
      \text{(}~\text{elem}~~\Tid^?~~\text{declare}~~(et, y^\ast){:}\Telemlist_I~\text{)} \\ &&& \qquad
        \Rightarrow\quad \{ \ETYPE~et, \EINIT~y^\ast, \EMODE~\EDECLARATIVE \} \\
    \production{element list} & \Telemlist_I &::=&
-     t{:}\Treftype~~y^\ast{:}\Tvec(\Telemexpr_I) \qquad\Rightarrow\quad ( \ETYPE~t, \EINIT~y^\ast ) \\
+     t{:}\Treftype_I~~y^\ast{:}\Tvec(\Telemexpr_I) \qquad\Rightarrow\quad ( \ETYPE~t, \EINIT~y^\ast ) \\
    \production{element expression} & \Telemexpr_I &::=&
      \text{(}~\text{item}~~e{:}\Texpr_I~\text{)}
        \quad\Rightarrow\quad e \\
@@ -641,7 +641,7 @@ The name serves a documentary role only.
    \production{module field} & \Tmodulefield_I &
    \begin{array}[t]{@{}clll}
    ::=&
-     \X{ty}{:}\Ttype &\Rightarrow& \{\MTYPES~\X{ty}\} \\ |&
+     \X{ty}{:}\Ttype_I &\Rightarrow& \{\MTYPES~\X{ty}\} \\ |&
      \X{im}{:}\Timport_I &\Rightarrow& \{\MIMPORTS~\X{im}\} \\ |&
      \X{fn}{:}\Tfunc_I &\Rightarrow& \{\MFUNCS~\X{fn}\} \\ |&
      \X{ta}{:}\Ttable_I &\Rightarrow& \{\MTABLES~\X{ta}\} \\ |&
diff --git a/document/core/text/types.rst b/document/core/text/types.rst
index 6d4ee3758..17a3f46a6 100644
--- a/document/core/text/types.rst
+++ b/document/core/text/types.rst
@@ -14,7 +14,7 @@ Number Types
 
 .. math::
    \begin{array}{llcll@{\qquad\qquad}l}
-   \production{number type} & \Tnumtype &::=&
+   \production{number type} & \Tnumtype_I &::=&
      \text{i32} &\Rightarrow& \I32 \\ &&|&
      \text{i64} &\Rightarrow& \I64 \\ &&|&
      \text{f32} &\Rightarrow& \F32 \\ &&|&
@@ -22,22 +22,48 @@ Number Types
    \end{array}
 
 
+.. index:: heap type
+   pair: text format; heap type
+.. _text-heaptype:
+
+Heap Types
+~~~~~~~~~~
+
+.. math::
+   \begin{array}{llcll@{\qquad\qquad}l}
+   \production{heap type} & \Theaptype_I &::=&
+     \text{func} &\Rightarrow& \FUNC \\ &&|&
+     \text{extern} &\Rightarrow& \EXTERN \\ &&|&
+     x{:}\Ttypeidx_I &\Rightarrow& x \\
+   \end{array}
+
+
 .. index:: reference type
    pair: text format; reference type
 .. _text-reftype:
-.. _text-heaptype:
 
 Reference Types
 ~~~~~~~~~~~~~~~
 
 .. math::
    \begin{array}{llcll@{\qquad\qquad}l}
-   \production{reference type} & \Treftype &::=&
-     \text{funcref} &\Rightarrow& \FUNCREF \\ &&|&
-     \text{externref} &\Rightarrow& \EXTERNREF \\
-   \production{heap type} & \Theaptype &::=&
-     \text{func} &\Rightarrow& \FUNCREF \\ &&|&
-     \text{extern} &\Rightarrow& \EXTERNREF \\
+   \production{reference type} & \Treftype_I &::=&
+     \text{(}~\text{ref}~~\X{ht}{:}\Theaptype~\text{)}
+       &\Rightarrow& \REF~\X{ht} \\ &&|&
+     \text{(}~\text{ref}~~\text{null}~~\X{ht}{:}\Theaptype~\text{)}
+       &\Rightarrow& \REF~\NULL~\X{ht} \\
+   \end{array}
+
+Abbreviations
+.............
+
+There are shorthands for references to abstract heap types.
+
+.. math::
+   \begin{array}{llclll}
+   \production{reference type} &
+     \text{funcref} &\equiv& \text{(}~\text{ref}~~\text{null}~~\text{func}~\text{)} \\
+     \text{externref} &\equiv& \text{(}~\text{ref}~~\text{null}~~\text{extern}~\text{)} \\
    \end{array}
 
 
@@ -50,9 +76,9 @@ Value Types
 
 .. math::
    \begin{array}{llcll@{\qquad\qquad}l}
-   \production{value type} & \Tvaltype &::=&
-     t{:}\Tnumtype &\Rightarrow& t \\ &&|&
-     t{:}\Treftype &\Rightarrow& t \\
+   \production{value type} & \Tvaltype_I &::=&
+     t{:}\Tnumtype_I &\Rightarrow& t \\ &&|&
+     t{:}\Treftype_I &\Rightarrow& t \\
    \end{array}
 
 
@@ -67,14 +93,14 @@ Function Types
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
-   \production{function type} & \Tfunctype &::=&
-     \text{(}~\text{func}~~t_1^\ast{:\,}\Tvec(\Tparam)~~t_2^\ast{:\,}\Tvec(\Tresult)~\text{)}
+   \production{function type} & \Tfunctype_I &::=&
+     \text{(}~\text{func}~~t_1^\ast{:\,}\Tvec(\Tparam_I)~~t_2^\ast{:\,}\Tvec(\Tresult_I)~\text{)}
        &\Rightarrow& [t_1^\ast] \to [t_2^\ast] \\
-   \production{parameter} & \Tparam &::=&
-     \text{(}~\text{param}~~\Tid^?~~t{:}\Tvaltype~\text{)}
+   \production{parameter} & \Tparam_I &::=&
+     \text{(}~\text{param}~~\Tid^?~~t{:}\Tvaltype_I~\text{)}
        &\Rightarrow& t \\
-   \production{result} & \Tresult &::=&
-     \text{(}~\text{result}~~t{:}\Tvaltype~\text{)}
+   \production{result} & \Tresult_I &::=&
+     \text{(}~\text{result}~~t{:}\Tvaltype_I~\text{)}
        &\Rightarrow& t \\
    \end{array}
 
@@ -119,7 +145,7 @@ Memory Types
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
-   \production{memory type} & \Tmemtype &::=&
+   \production{memory type} & \Tmemtype_I &::=&
      \X{lim}{:}\Tlimits &\Rightarrow& \X{lim} \\
    \end{array}
 
@@ -133,8 +159,8 @@ Table Types
 
 .. math::
    \begin{array}{llclll}
-   \production{table type} & \Ttabletype &::=&
-     \X{lim}{:}\Tlimits~~\X{et}{:}\Treftype &\Rightarrow& \X{lim}~\X{et} \\
+   \production{table type} & \Ttabletype_I &::=&
+     \X{lim}{:}\Tlimits~~\X{et}{:}\Treftype_I &\Rightarrow& \X{lim}~\X{et} \\
    \end{array}
 
 
@@ -148,7 +174,7 @@ Global Types
 
 .. math::
    \begin{array}{llclll}
-   \production{global type} & \Tglobaltype &::=&
+   \production{global type} & \Tglobaltype_I &::=&
      t{:}\Tvaltype &\Rightarrow& \MCONST~t \\ &&|&
-     \text{(}~\text{mut}~~t{:}\Tvaltype~\text{)} &\Rightarrow& \MVAR~t \\
+     \text{(}~\text{mut}~~t{:}\Tvaltype_I~\text{)} &\Rightarrow& \MVAR~t \\
    \end{array}
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index 0a7a9cf77..a4d950e9e 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -179,8 +179,12 @@
 .. |F32| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{f32}}
 .. |F64| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{f64}}
 
-.. |FUNCREF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{funcref}}
-.. |EXTERNREF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{externref}}
+.. |REF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{ref}}
+.. |NULL| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{null}}
+.. |FUNC| mathdef:: \xref{syntax/types}{syntax-heaptype}{\K{func}}
+.. |EXTERN| mathdef:: \xref{syntax/types}{syntax-heaptype}{\K{extern}}
+.. |FUNCREF| mathdef:: \xref{syntax/types}{syntax-heaptype}{\K{funcref}}
+.. |EXTERNREF| mathdef:: \xref{syntax/types}{syntax-heaptype}{\K{externref}}
 
 .. |MVAR| mathdef:: \xref{syntax/types}{syntax-mut}{\K{var}}
 .. |MCONST| mathdef:: \xref{syntax/types}{syntax-mut}{\K{const}}
@@ -197,6 +201,7 @@
 .. Types, non-terminals
 
 .. |numtype| mathdef:: \xref{syntax/types}{syntax-numtype}{\X{numtype}}
+.. |heaptype| mathdef:: \xref{syntax/types}{syntax-heaptype}{\X{heaptype}}
 .. |reftype| mathdef:: \xref{syntax/types}{syntax-reftype}{\X{reftype}}
 .. |valtype| mathdef:: \xref{syntax/types}{syntax-valtype}{\X{valtype}}
 .. |resulttype| mathdef:: \xref{syntax/types}{syntax-resulttype}{\X{resulttype}}
@@ -500,6 +505,7 @@
 .. Types, non-terminals
 
 .. |Bnumtype| mathdef:: \xref{binary/types}{binary-numtype}{\B{numtype}}
+.. |Bheaptype| mathdef:: \xref{binary/types}{binary-heaptype}{\B{heaptype}}
 .. |Breftype| mathdef:: \xref{binary/types}{binary-reftype}{\B{reftype}}
 .. |Bvaltype| mathdef:: \xref{binary/types}{binary-valtype}{\B{valtype}}
 .. |Bresulttype| mathdef:: \xref{binary/types}{binary-resulttype}{\B{resulttype}}
@@ -661,8 +667,8 @@
 .. Types, non-terminals
 
 .. |Tnumtype| mathdef:: \xref{text/types}{text-numtype}{\T{numtype}}
-.. |Treftype| mathdef:: \xref{text/types}{text-reftype}{\T{reftype}}
 .. |Theaptype| mathdef:: \xref{text/types}{text-heaptype}{\T{heaptype}}
+.. |Treftype| mathdef:: \xref{text/types}{text-reftype}{\T{reftype}}
 .. |Tvaltype| mathdef:: \xref{text/types}{text-valtype}{\T{valtype}}
 .. |Tfunctype| mathdef:: \xref{text/types}{text-functype}{\T{functype}}
 
@@ -774,8 +780,17 @@
 .. |ok| mathdef:: \mathrel{\mbox{ok}}
 .. |const| mathdef:: \xref{valid/instructions}{valid-constant}{\mathrel{\mbox{const}}}
 
-.. |matchesvaltype| mathdef:: \xref{valid/types}{match-valtype}{\leq}
-.. |matchesresulttype| mathdef:: \xref{valid/types}{match-resulttype}{\leq}
+.. |matchesnumtype| mathdef:: \xref{valid/matching}{match-numtype}{\leq}
+.. |matchesheaptype| mathdef:: \xref{valid/matching}{match-heaptype}{\leq}
+.. |matchesreftype| mathdef:: \xref{valid/matching}{match-reftype}{\leq}
+.. |matchesvaltype| mathdef:: \xref{valid/matching}{match-valtype}{\leq}
+.. |matchesresulttype| mathdef:: \xref{valid/matching}{match-resulttype}{\leq}
+.. |matchesfunctype| mathdef:: \xref{valid/matching}{match-functype}{\leq}
+.. |matchestabletype| mathdef:: \xref{valid/matching}{match-tabletype}{\leq}
+.. |matchesmemtype| mathdef:: \xref{valid/matching}{match-memtype}{\leq}
+.. |matchesglobaltype| mathdef:: \xref{valid/matching}{match-globaltype}{\leq}
+.. |matchesexterntype| mathdef:: \xref{exec/matching}{match-externtype}{\leq}
+.. |matcheslimits| mathdef:: \xref{exec/matching}{match-limits}{\leq}
 
 
 .. Contexts
@@ -795,6 +810,11 @@
 
 .. Judgments
 
+.. |vdashnumtype| mathdef:: \xref{valid/types}{valid-numtype}{\vdash}
+.. |vdashheaptype| mathdef:: \xref{valid/types}{valid-heaptype}{\vdash}
+.. |vdashreftype| mathdef:: \xref{valid/types}{valid-reftype}{\vdash}
+.. |vdashvaltype| mathdef:: \xref{valid/types}{valid-valtype}{\vdash}
+.. |vdashresulttype| mathdef:: \xref{valid/types}{valid-resulttype}{\vdash}
 .. |vdashlimits| mathdef:: \xref{valid/types}{valid-limits}{\vdash}
 .. |vdashblocktype| mathdef:: \xref{valid/types}{valid-blocktype}{\vdash}
 .. |vdashfunctype| mathdef:: \xref{valid/types}{valid-functype}{\vdash}
@@ -803,10 +823,17 @@
 .. |vdashglobaltype| mathdef:: \xref{valid/types}{valid-globaltype}{\vdash}
 .. |vdashexterntype| mathdef:: \xref{valid/types}{valid-externtype}{\vdash}
 
-.. |vdashnumtypematch| mathdef:: \xref{valid/types}{match-numtype}{\vdash}
-.. |vdashreftypematch| mathdef:: \xref{valid/types}{match-reftype}{\vdash}
-.. |vdashvaltypematch| mathdef:: \xref{valid/types}{match-valtype}{\vdash}
-.. |vdashresulttypematch| mathdef:: \xref{valid/types}{match-resulttype}{\vdash}
+.. |vdashnumtypematch| mathdef:: \xref{valid/matching}{match-numtype}{\vdash}
+.. |vdashheaptypematch| mathdef:: \xref{valid/matching}{match-heaptype}{\vdash}
+.. |vdashreftypematch| mathdef:: \xref{valid/matching}{match-reftype}{\vdash}
+.. |vdashvaltypematch| mathdef:: \xref{valid/matching}{match-valtype}{\vdash}
+.. |vdashresulttypematch| mathdef:: \xref{valid/matching}{match-resulttype}{\vdash}
+.. |vdashfunctypematch| mathdef:: \xref{valid/matching}{match-functype}{\vdash}
+.. |vdashtabletypematch| mathdef:: \xref{valid/matching}{match-tabletype}{\vdash}
+.. |vdashmemtypematch| mathdef:: \xref{valid/matching}{match-memtype}{\vdash}
+.. |vdashglobaltypematch| mathdef:: \xref{valid/matching}{match-globaltype}{\vdash}
+.. |vdashexterntypematch| mathdef:: \xref{exec/matching}{match-externtype}{\vdash}
+.. |vdashlimitsmatch| mathdef:: \xref{exec/matching}{match-limits}{\vdash}
 
 .. |vdashinstr| mathdef:: \xref{valid/instructions}{valid-instr}{\vdash}
 .. |vdashinstrseq| mathdef:: \xref{valid/instructions}{valid-instr-seq}{\vdash}
@@ -814,6 +841,7 @@
 .. |vdashexprconst| mathdef:: \xref{valid/instructions}{valid-constant}{\vdash}
 .. |vdashinstrconst| mathdef:: \xref{valid/instructions}{valid-constant}{\vdash}
 
+.. |vdashtypes| mathdef:: \xref{valid/modules}{valid-types}{\vdash}
 .. |vdashfunc| mathdef:: \xref{valid/modules}{valid-func}{\vdash}
 .. |vdashtable| mathdef:: \xref{valid/modules}{valid-table}{\vdash}
 .. |vdashmem| mathdef:: \xref{valid/modules}{valid-mem}{\vdash}
@@ -837,8 +865,6 @@
 
 .. |stepto| mathdef:: \xref{exec/conventions}{formal-notation}{\hookrightarrow}
 .. |extendsto| mathdef:: \xref{appendix/properties}{extend}{\preceq}
-.. |matchesexterntype| mathdef:: \xref{exec/modules}{match-externtype}{\leq}
-.. |matcheslimits| mathdef:: \xref{exec/modules}{match-limits}{\leq}
 
 
 .. Allocation
@@ -1092,9 +1118,6 @@
 
 .. |vdashexternval| mathdef:: \xref{exec/modules}{valid-externval}{\vdash}
 
-.. |vdashlimitsmatch| mathdef:: \xref{exec/modules}{match-limits}{\vdash}
-.. |vdashexterntypematch| mathdef:: \xref{exec/modules}{match-externtype}{\vdash}
-
 
 .. Soundness
 .. ---------
diff --git a/document/core/valid/index.rst b/document/core/valid/index.rst
index 34cf3b906..cd5fce186 100644
--- a/document/core/valid/index.rst
+++ b/document/core/valid/index.rst
@@ -8,5 +8,6 @@ Validation
 
    conventions
    types
+   matching
    instructions
    modules
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 2594a1e03..9478e96c4 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -201,17 +201,19 @@ Reference Instructions
 
 * The function :math:`C.\CFUNCS[x]` must be defined in the context.
 
+* There must exist a :ref:`type index <syntax-typeidx>` :math:`y` such that :math:`C.\CTYPES[y]` is the same :ref:`function type <syntax-functype>` as :math:`C.\CFUNCS[x]`.
+
 * The :ref:`function index <syntax-funcidx>` :math:`x` must be contained in :math:`C.\CREFS`.
 
-* The instruction is valid with type :math:`[] \to [\FUNCREF]`.
+* The instruction is valid with type :math:`[] \to [(\REF~y)]`.
 
 .. math::
    \frac{
-     C.\CFUNCS[x] = \functype
+     C.\CFUNCS[x] = C.\CTYPES[y]
      \qquad
      x \in C.\CREFS
    }{
-     C \vdashinstr \REFFUNC~x : [] \to [\FUNCREF]
+     C \vdashinstr \REFFUNC~x : [] \to [(\REF~y)]
    }
 
 
@@ -248,22 +250,27 @@ Parametric Instructions
 
 * If :math:`t^\ast` is present, then:
 
+  * The :ref:`result type <syntax-resulttype>` :math:`[t^\ast]` must be :ref:`valid <valid-resulttype>`.
+
   * The length of :math:`t^\ast` must be :math:`1`.
 
   * Then the instruction is valid with type :math:`[t^\ast~t^\ast~\I32] \to [t^\ast]`.
 
 * Else:
 
-  * The instruction is valid with type :math:`[t~t~\I32] \to [t]`, for any :ref:`value type <syntax-valtype>` :math:`t` that :ref:`matches <match-valtype>` some :ref:`number type <syntax-numtype>`.
+  * The instruction is valid with type :math:`[t~t~\I32] \to [t]`, for any :ref:`valid <valid-valtype>` :ref:`value type <syntax-valtype>` :math:`t` that :ref:`matches <match-valtype>` some :ref:`number type <syntax-numtype>`.
 
 .. math::
    \frac{
+     C \vdashresulttype [t] \ok
    }{
      C \vdashinstr \SELECT~t : [t~t~\I32] \to [t]
    }
    \qquad
    \frac{
-     \vdashvaltypematch t \matchesvaltype \numtype
+     C \vdashresulttype [t] \ok
+     \qquad
+     C \vdashresulttypematch [t] \matchesresulttype [\numtype]
    }{
      C \vdashinstr \SELECT : [t~t~\I32] \to [t]
    }
@@ -501,7 +508,7 @@ Table Instructions
      \qquad
      C.\CTABLES[x] = \limits_2~t_2
      \qquad
-     \vdashreftypematch t_2 \matchesvaltype t_1
+     C \vdashreftypematch t_2 \matchesvaltype t_1
    }{
      C \vdashinstr \TABLECOPY~x~y : [\I32~\I32~\I32] \to []
    }
@@ -530,7 +537,7 @@ Table Instructions
      \qquad
      C.\CELEMS[y] = t_2
      \qquad
-     \vdashreftypematch t_2 \matchesvaltype t_1
+     C \vdashreftypematch t_2 \matchesvaltype t_1
    }{
      C \vdashinstr \TABLEINIT~x~y : [\I32~\I32~\I32] \to []
    }
@@ -778,10 +785,11 @@ Control Instructions
 :math:`\UNREACHABLE`
 ....................
 
-* The instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
+* The instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`, for any sequences of :ref:`valid <valid-valtype>` :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
 .. math::
    \frac{
+     C \vdashfunctype [t_1^\ast] \to [t_2^\ast] \ok
    }{
      C \vdashinstr \UNREACHABLE : [t_1^\ast] \to [t_2^\ast]
    }
@@ -885,11 +893,13 @@ Control Instructions
 
 * Let :math:`[t^\ast]` be the :ref:`result type <syntax-resulttype>` :math:`C.\CLABELS[l]`.
 
-* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
+* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`, for any sequences of :ref:`valid <valid-valtype>` :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
 .. math::
    \frac{
      C.\CLABELS[l] = [t^\ast]
+     \qquad
+     C \vdashfunctype [t_1^\ast] \to [t_2^\ast] \ok
    }{
      C \vdashinstr \BR~l : [t_1^\ast~t^\ast] \to [t_2^\ast]
    }
@@ -942,13 +952,15 @@ Control Instructions
   * For all :math:`l_i` in :math:`l^\ast`,
     the result type :math:`[t^\ast]` :ref:`matches <match-resulttype>` :math:`C.\CLABELS[l_i]`.
 
-* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast~\I32] \to [t_2^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
+* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast~\I32] \to [t_2^\ast]`, for any sequences of :ref:`valid <valid-valtype>` :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
 .. math::
    \frac{
-     (\vdashresulttypematch [t^\ast] \matchesresulttype C.\CLABELS[l])^\ast
+     (C \vdashresulttypematch [t^\ast] \matchesresulttype C.\CLABELS[l])^\ast
      \qquad
-     \vdashresulttypematch [t^\ast] \matchesresulttype C.\CLABELS[l_N]
+     C \vdashresulttypematch [t^\ast] \matchesresulttype C.\CLABELS[l_N]
+     \qquad
+     C \vdashfunctype [t_1^\ast] \to [t_2^\ast] \ok
    }{
      C \vdashinstr \BRTABLE~l^\ast~l_N : [t_1^\ast~t^\ast~\I32] \to [t_2^\ast]
    }
@@ -972,11 +984,13 @@ Control Instructions
 
 * Let :math:`[t^\ast]` be the :ref:`result type <syntax-resulttype>` of :math:`C.\CRETURN`.
 
-* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
+* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`, for any sequences of :ref:`valid <valid-valtype>` :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
 .. math::
    \frac{
      C.\CRETURN = [t^\ast]
+     \qquad
+     C \vdashfunctype [t_1^\ast] \to [t_2^\ast] \ok
    }{
      C \vdashinstr \RETURN : [t_1^\ast~t^\ast] \to [t_2^\ast]
    }
@@ -1015,7 +1029,7 @@ Control Instructions
 
 * Let :math:`\limits~t` be the :ref:`table type <syntax-tabletype>` :math:`C.\CTABLES[x]`.
 
-* The :ref:`reference type <syntax-reftype>` :math:`t` must :ref:`match <match-reftype>` type |FUNCREF|.
+* The :ref:`reference type <syntax-reftype>` :math:`t` must :ref:`match <match-reftype>` type :math:`\REF~\NULL~\FUNC`.
 
 * The type :math:`C.\CTYPES[y]` must be defined in the context.
 
@@ -1027,7 +1041,7 @@ Control Instructions
    \frac{
      C.\CTABLES[x] = \limits~t
      \qquad
-     \vdashvaltypematch t \leq \FUNCREF
+     C \vdashvaltypematch t \matchesreftype \REF~\NULL~\FUNC
      \qquad
      C.\CTYPES[y] = [t_1^\ast] \to [t_2^\ast]
    }{
@@ -1077,7 +1091,7 @@ Non-empty Instruction Sequence: :math:`\instr^\ast~\instr_N`
    \frac{
      C \vdashinstrseq \instr^\ast : [t_1^\ast] \to [t_0^\ast~{t'}^\ast]
      \qquad
-     (\vdashvaltypematch t' \matchesvaltype t)^\ast
+     (C \vdashvaltypematch t' \matchesvaltype t)^\ast
      \qquad
      C \vdashinstr \instr_N : [t^\ast] \to [t_3^\ast]
    }{
@@ -1102,7 +1116,7 @@ Expressions :math:`\expr` are classified by :ref:`result types <syntax-resulttyp
 
 * The instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with some :ref:`type <syntax-functype>` :math:`[] \to [{t'}^\ast]`.
 
-* For each :ref:`value type <syntax-valtype>` :math:`t'_i` in :math:`{t'}^\ast` and corresponding :ref:`value type <syntax-valtype>` type :math:`t_i` in :math:`t^\ast`, :math:`t'_i` :ref:`matches <match-valtype>` :math:`t_i`.
+* For each :ref:`value type <syntax-valtype>` :math:`t'_i` in :math:`{t'}^\ast` and corresponding :ref:`valid <valid-valtype>` :ref:`value type <syntax-valtype>` type :math:`t_i` in :math:`t^\ast`, :math:`t'_i` :ref:`matches <match-valtype>` :math:`t_i`.
 
 * Then the expression is valid with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`.
 
@@ -1110,7 +1124,9 @@ Expressions :math:`\expr` are classified by :ref:`result types <syntax-resulttyp
    \frac{
      C \vdashinstrseq \instr^\ast : [] \to [{t'}^\ast]
      \qquad
-     (\vdashvaltypematch t' \matchesvaltype t)^\ast
+     C \vdashresulttype [t^\ast] \ok
+     \qquad
+     (C \vdashvaltypematch t' \matchesvaltype t)^\ast
    }{
      C \vdashexpr \instr^\ast~\END : [t^\ast]
    }
diff --git a/document/core/valid/matching.rst b/document/core/valid/matching.rst
new file mode 100644
index 000000000..5f502507d
--- /dev/null
+++ b/document/core/valid/matching.rst
@@ -0,0 +1,347 @@
+.. index:: ! matching, subtyping
+
+Matching
+--------
+
+On most types, a simple notion of subtyping is defined that is applicable in validation rules or during :ref:`module instantiation <exec-instantiation>` when checking the types of imports.
+
+.. todo:: externtype matching is used on semantic types; need to define how to reinterpret C for semantic types
+
+
+.. index:: number type
+.. _match-numtype:
+
+Number Types
+~~~~~~~~~~~~
+
+A :ref:`number type <syntax-numtype>` :math:`\numtype_1` matches a :ref:`number type <syntax-numtype>` :math:`\numtype_2` if and only if:
+
+* Both :math:`\numtype_1` and :math:`\numtype_2` are the same.
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+   }{
+     C \vdashnumtypematch \numtype \matchesvaltype \numtype
+   }
+
+
+.. index:: heap type
+.. _match-heaptype:
+
+Heap Types
+~~~~~~~~~~
+
+A :ref:`heap type <syntax-heaptype>` :math:`\heaptype_1` matches a :ref:`heap type <syntax-heaptype>` :math:`\heaptype_2` if and only if:
+
+* Either both :math:`\heaptype_1` and :math:`\heaptype_2` are the same.
+
+* Or :math:`\heaptype_1` is a :ref:`type index <syntax-typeidx>` that defines a function type and :math:`\heaptype_2` is :math:`FUNC`.
+
+* Or :math:`\heaptype_1` is a :ref:`type index <syntax-typeidx>` that defines a function type :math:`\functype_1`, and :math:`\heaptype_2` is a :ref:`type index <syntax-typeidx>` that defines a function type :math:`\functype_2`, and :math:`\functype_1` :ref:`matches <match-functype>` :math:`\functype_2`.
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+   }{
+     C \vdashheaptypematch \heaptype \matchesheaptype \heaptype
+   }
+   \qquad
+   \frac{
+     C.\CTYPES[\typeidx] = \functype
+   }{
+     C \vdashheaptypematch \typeidx \matchesheaptype \FUNC
+   }
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+     C.\CTYPES[\typeidx_1] = \functype_1
+     \qquad
+     C.\CTYPES[\typeidx_2] = \functype_2
+     \qquad
+     C \vdashfunctypematch \functype_1 \matchesfunctype \functype_2
+   }{
+     C \vdashheaptypematch \typeidx_1 \matchesheaptype \typeidx_2
+   }
+
+
+.. index:: reference type
+.. _match-reftype:
+
+Reference Types
+~~~~~~~~~~~~~~~
+
+A :ref:`reference type <syntax-reftype>` :math:`\REF~\NULL_1^?~heaptype_1` matches a :ref:`reference type <syntax-reftype>` :math:`\REF~\NULL_2^?~heaptype_2` if and only if:
+
+* The :ref:`heap type <syntax-heaptype>` :math:`\heaptype_1` :ref:`matches <match-heaptype>` :math:`\heaptype_2`.
+
+* :math:`\NULL_1` is absent or :math:`\NULL_2` is present.
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+     C \vdashheaptypematch \heaptype_1 \matchesheaptype \heaptype_2
+   }{
+     C \vdashreftypematch \REF~\heaptype_1 \matchesreftype \REF~\heaptype_2
+   }
+   \qquad
+   \frac{
+     C \vdashheaptypematch \heaptype_1 \matchesheaptype \heaptype_2
+   }{
+     C \vdashreftypematch \REF~\NULL~\heaptype_1 \matchesreftype \REF~\NULL^?~\heaptype_2
+   }
+
+
+.. index:: value type, number type, reference type
+.. _match-valtype:
+
+Value Types
+~~~~~~~~~~~
+
+A :ref:`value type <syntax-valtype>` :math:`\valtype_1` matches a :ref:`value type <syntax-valtype>` :math:`\valtype_2` if and only if:
+
+* Either both :math:`\valtype_1` and :math:`\valtype_2` are :ref:`number types <syntax-numtype>` and :math:`\valtype_1` :ref:`matches <match-numtype>` :math:`\valtype_2`.
+
+* Or both :math:`\valtype_1` and :math:`\valtype_2` are :ref:`reference types <syntax-reftype>` and :math:`\valtype_1` :ref:`matches <match-reftype>` :math:`\valtype_2`.
+
+* Or :math:`\valtype_1` is :math:`\BOT`.
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+   }{
+     C \vdashvaltypematch \BOT \matchesvaltype \valtype
+   }
+
+
+.. index:: result type, value type
+.. _match-resulttype:
+
+Result Types
+~~~~~~~~~~~~
+
+Subtyping is lifted to :ref:`result types <syntax-resulttype>` in a pointwise manner.
+That is, a :ref:`result type <syntax-resulttype>` :math:`[t_1^\ast]` matches a :ref:`result type <syntax-resulttype>` :math:`[t_2^\ast]` if and only if:
+
+* Every :ref:`value type <syntax-valtype>` :math:`t_1` in :math:`[t_1^\ast]` :ref:`matches <match-valtype>` the corresponding :ref:`value type <syntax-valtype>` :math:`t_2` in :math:`[t_2^\ast]`.
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+     (C \vdashvaltypematch t_1 \matchesvaltype t_2)^\ast
+   }{
+     C \vdashresulttypematch [t_1^\ast] \matchesresulttype [t_2^\ast]
+   }
+
+
+.. index:: function type, result type
+.. _match-functype:
+
+Function Types
+~~~~~~~~~~~~~~
+
+Subtyping is also defined for :ref:`function types <syntax-functype>`.
+However, it is required that they match in both directions, effectively demanding type equivalence.
+That is, a :ref:`function type <syntax-functype>` :math:`[t_{11}^\ast] \to [t_{12}^\ast]` matches a type :math:`[t_{21}^ast] \to [t_{22}^\ast]` if and only if:
+
+* The :ref:`result type <syntax-resulttype>` :math:`[t_{11}^\ast]` :ref:`matches <match-resulttype>` :math:`[t_{21}^\ast]`, and vice versa.
+
+* The :ref:`result type <syntax-resulttype>` :math:`[t_{12}^\ast]` :ref:`matches <match-resulttype>` :math:`[t_{22}^\ast]`, and vice versa.
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+     \begin{array}{@{}c@{}}
+     C \vdashresulttypematch [t_{11}^\ast] \matchesresulttype [t_{21}^\ast]
+     \qquad
+     C \vdashresulttypematch [t_{12}^\ast] \matchesresulttype [t_{22}^\ast]
+     \\
+     C \vdashresulttypematch [t_{21}^\ast] \matchesresulttype [t_{11}^\ast]
+     \qquad
+     C \vdashresulttypematch [t_{22}^\ast] \matchesresulttype [t_{12}^\ast]
+     \end{array}
+   }{
+     C \vdashfunctypematch [t_{11}^\ast] \to [t_{12}^\ast] \matchesfunctype [t_{21}^\ast] \to [t_{22}^\ast]
+   }
+
+.. note::
+   In future versions of WebAssembly, subtyping on function types may be relaxed to support co- and contra-variance.
+
+
+.. index:: limits
+.. _match-limits:
+
+Limits
+~~~~~~
+
+:ref:`Limits <syntax-limits>` :math:`\{ \LMIN~n_1, \LMAX~m_1^? \}` match limits :math:`\{ \LMIN~n_2, \LMAX~m_2^? \}` if and only if:
+
+* :math:`n_1` is larger than or equal to :math:`n_2`.
+
+* Either:
+
+  * :math:`m_2^?` is empty.
+
+* Or:
+
+  * Both :math:`m_1^?` and :math:`m_2^?` are non-empty.
+
+  * :math:`m_1` is smaller than or equal to :math:`m_2`.
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+     n_1 \geq n_2
+   }{
+     C \vdashlimitsmatch \{ \LMIN~n_1, \LMAX~m_1^? \} \matcheslimits \{ \LMIN~n_2, \LMAX~\epsilon \}
+   }
+   \quad
+   \frac{
+     n_1 \geq n_2
+     \qquad
+     m_1 \leq m_2
+   }{
+     C \vdashlimitsmatch \{ \LMIN~n_1, \LMAX~m_1 \} \matcheslimits \{ \LMIN~n_2, \LMAX~m_2 \}
+   }
+
+
+.. index:: table type, limits, element type
+.. _match-tabletype:
+
+Table Types
+~~~~~~~~~~~
+
+A :ref:`table type <syntax-tabletype>` :math:`(\limits_1~\reftype_1)` matches :math:`(\limits_2~\reftype_2)` if and only if:
+
+* Limits :math:`\limits_1` :ref:`match <match-limits>` :math:`\limits_2`.
+
+* The :ref:`reference type <syntax-reftype>` :math:`\reftype_1` :ref:`matches <match-reftype>` :math:`\reftype_2`, and vice versa.
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+     C \vdashlimitsmatch \limits_1 \matcheslimits \limits_2
+     \qquad
+     C \vdashreftypematch \reftype_1 \matchesreftype \reftype_2
+     \qquad
+     C \vdashreftypematch \reftype_2 \matchesreftype \reftype_1
+   }{
+     C \vdashtabletypematch \limits_1~\reftype_1 \matchestabletype \limits_2~\reftype_2
+   }
+
+
+.. index:: memory type, limits
+.. _match-memtype:
+
+Memory Types
+~~~~~~~~~~~~
+
+A :ref:`memory type <syntax-memtype>` :math:`\limits_1` matches :math:`\limits_2` if and only if:
+
+* Limits :math:`\limits_1` :ref:`match <match-limits>` :math:`\limits_2`.
+
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+     C \vdashlimitsmatch \limits_1 \matcheslimits \limits_2
+   }{
+     C \vdashmemtypematch \limits_1 \matchesmemtype \limits_2
+   }
+
+
+.. index:: global type, value type, mutability
+.. _match-globaltype:
+
+Global Types
+~~~~~~~~~~~~
+
+A :ref:`global type <syntax-globaltype>` :math:`(\mut_1~t_1)` matches :math:`(\mut_2~t_2)` if and only if:
+
+* Either both :math:`\mut_1` and :math:`\mut_2` are |MVAR| and :math:`t_1` and :math:`t_2` are the same.
+ 
+* Or both :math:`\mut_1` and :math:`\mut_2` are |MCONST| and :math:`t_1` :ref:`matches <match-valtype>` :math:`t_2`.
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+   }{
+     C \vdashglobaltypematch \MVAR~t \matchesglobaltype \MVAR~t
+   }
+   \qquad
+   \frac{
+     C \vdashvaltypematch t_1 \matchesvaltype t_2
+   }{
+     C \vdashglobaltypematch \MCONST~t_1 \matchesglobaltype \MCONST~t_2
+   }
+
+
+.. index:: external type, function type, table type, memory type, global type
+.. _match-externtype:
+
+External Types
+~~~~~~~~~~~~~~
+
+Functions
+.........
+
+An :ref:`external type <syntax-externtype>` :math:`\ETFUNC~\functype_1` matches :math:`\ETFUNC~\functype_2` if and only if:
+
+* Function type :math:`\functype_1` :ref:`matches <match-functype>` :math:`\functype_2`.
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+     C \vdashfunctypematch \functype_1 \matchesfunctype \functype_2
+   }{
+     C \vdashexterntypematch \ETFUNC~\functype_1 \matchesexterntype \ETFUNC~\functype_2
+   }
+
+
+Tables
+......
+
+An :ref:`external type <syntax-externtype>` :math:`\ETTABLE~\tabletype_1` matches :math:`\ETTABLE~\tabletype_2` if and only if:
+
+* Table type :math:`\tabletype_1` :ref:`matches <match-tabletype>` :math:`\tabletype_2`.
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+     C \vdashtabletypematch \tabletype_1 \matchestabletype \tabletype_2
+   }{
+     C \vdashexterntypematch \ETTABLE~\tabletype_1 \matchesexterntype \ETTABLE~\tabletype_2
+   }
+
+
+Memories
+........
+
+An :ref:`external type <syntax-externtype>` :math:`\ETMEM~\memtype_1` matches :math:`\ETMEM~\memtype_2` if and only if:
+
+* Memory type :math:`\memtype_1` :ref:`matches <match-memtype>` :math:`\memtype_2`.
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+     C \vdashmemtypematch \memtype_1 \matchesmemtype \memtype_2
+   }{
+     C \vdashexterntypematch \ETMEM~\memtype_1 \matchesexterntype \ETMEM~\memtype_2
+   }
+
+
+Globals
+.......
+
+An :ref:`external type <syntax-externtype>` :math:`\ETGLOBAL~\globaltype_1` matches :math:`\ETGLOBAL~\globaltype_2` if and only if:
+
+* Global type :math:`\globaltype_1` :ref:`matches <match-globaltype>` :math:`\globaltype_2`.
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+     C \vdashglobaltypematch \globaltype_1 \matchesglobaltype \globaltype_2
+   }{
+     C \vdashexterntypematch \ETGLOBAL~\globaltype_1 \matchesexterntype \ETGLOBAL~\globaltype_2
+   }
diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index 875464937..1d28153c6 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -67,7 +67,7 @@ Tables :math:`\table` are classified by :ref:`table types <syntax-tabletype>`.
 
 .. math::
    \frac{
-     \vdashtabletype \tabletype \ok
+     C \vdashtabletype \tabletype \ok
    }{
      C \vdashtable \{ \TTYPE~\tabletype \} : \tabletype
    }
@@ -92,7 +92,7 @@ Memories :math:`\mem` are classified by :ref:`memory types <syntax-memtype>`.
 
 .. math::
    \frac{
-     \vdashmemtype \memtype \ok
+     C \vdashmemtype \memtype \ok
    }{
      C \vdashmem \{ \MTYPE~\memtype \} : \memtype
    }
@@ -122,7 +122,7 @@ Globals :math:`\global` are classified by :ref:`global types <syntax-globaltype>
 
 .. math::
    \frac{
-     \vdashglobaltype \mut~t \ok
+     C \vdashglobaltype \mut~t \ok
      \qquad
      C \vdashexpr \expr : [t]
      \qquad
@@ -147,6 +147,8 @@ Element segments :math:`\elem` are classified by the :ref:`reference type <synta
 :math:`\{ \ETYPE~t, \EINIT~e^\ast, \EMODE~\elemmode \}`
 .......................................................
 
+* The :ref:`reference type <syntax-reftype>` :math:`t` must be :ref:`valid <valid-reftype>`.
+
 * For each :math:`e_i` in :math:`e^\ast`,
 
   * The expression :math:`e_i` must be :ref:`valid <valid-expr>`.
@@ -155,20 +157,22 @@ Element segments :math:`\elem` are classified by the :ref:`reference type <synta
 
 * The element mode :math:`\elemmode` must be valid with some :ref:`reference type <syntax-reftype>` :math:`t'`.
 
-* The :ref:`reference type <syntax-reftype>` :math:`t` must :ref:`match <match-reftype>` the reference type :math:`t'`.
+* The reference type :math:`t` must :ref:`match <match-reftype>` the reference type :math:`t'`.
 
 * Then the element segment is valid with :ref:`reference type <syntax-reftype>` :math:`t`.
 
 
 .. math::
    \frac{
+     C \vdashreftype t \ok
+     \qquad
      (C \vdashexpr e \ok)^\ast
      \qquad
      (C \vdashexprconst e \const)^\ast
      \qquad
      C \vdashelemmode \elemmode : t'
      \qquad
-     \vdashreftypematch t \matchesvaltype t'
+     C \vdashreftypematch t \matchesreftype t'
    }{
      C \vdashelem \{ \ETYPE~t, \EINIT~e^\ast, \EMODE~\elemmode \} : t
    }
@@ -179,10 +183,11 @@ Element segments :math:`\elem` are classified by the :ref:`reference type <synta
 :math:`\EPASSIVE`
 .................
 
-* The element mode is valid with any :ref:`reference type <syntax-reftype>`.
+* The element mode is valid with any :ref:`valid <valid-reftype>` :ref:`reference type <syntax-reftype>`.
 
 .. math::
    \frac{
+     C \vdashreftype \reftype \ok
    }{
      C \vdashelemmode \EPASSIVE : \reftype
    }
@@ -217,10 +222,11 @@ Element segments :math:`\elem` are classified by the :ref:`reference type <synta
 :math:`\EDECLARATIVE`
 .....................
 
-* The element mode is valid with any :ref:`reference type <syntax-reftype>`.
+* The element mode is valid with any :ref:`valid <valid-reftype>` :ref:`reference type <syntax-reftype>`.
 
 .. math::
    \frac{
+     C \vdashreftype \reftype \ok
    }{
      C \vdashelemmode \EDECLARATIVE : \reftype
    }
@@ -436,7 +442,7 @@ Imports :math:`\import` and import descriptions :math:`\importdesc` are classifi
 :math:`\IDFUNC~x`
 .................
 
-* The function :math:`C.\CTYPES[x]` must be defined in the context.
+* The function type :math:`C.\CTYPES[x]` must be defined in the context.
 
 * Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[x]`.
 
@@ -459,7 +465,7 @@ Imports :math:`\import` and import descriptions :math:`\importdesc` are classifi
 
 .. math::
    \frac{
-     \vdashtable \tabletype \ok
+     C \vdashtable \tabletype \ok
    }{
      C \vdashimportdesc \IDTABLE~\tabletype : \ETTABLE~\tabletype
    }
@@ -474,7 +480,7 @@ Imports :math:`\import` and import descriptions :math:`\importdesc` are classifi
 
 .. math::
    \frac{
-     \vdashmemtype \memtype \ok
+     C \vdashmemtype \memtype \ok
    }{
      C \vdashimportdesc \IDMEM~\memtype : \ETMEM~\memtype
    }
@@ -489,7 +495,7 @@ Imports :math:`\import` and import descriptions :math:`\importdesc` are classifi
 
 .. math::
    \frac{
-     \vdashglobaltype \globaltype \ok
+     C \vdashglobaltype \globaltype \ok
    }{
      C \vdashimportdesc \IDGLOBAL~\globaltype : \ETGLOBAL~\globaltype
    }
@@ -540,21 +546,26 @@ Instead, the context :math:`C` for validation of the module's content is constru
 
   * :math:`C.\CREFS` is the set :math:`\freefuncidx(\module \with \MFUNCS = \epsilon \with \MSTART = \epsilon)`, i.e., the set of :ref:`function indices <syntax-funcidx>` occurring in the module, except in its :ref:`functions <syntax-func>` or :ref:`start function <syntax-start>`.
 
-* Let :math:`C'` be the :ref:`context <context>` where:
+* For each function type :math:`\functype_i` in :math:`\module.\MTYPES`:
+
+  * Let :math:`C'_i` be the :ref:`context <context>` where :math:`C'_i.\CTYPES` is :math:`C.\CTYPES[0 \slice i]` and all other fields are empty.
+
+  * The function  :math:`\functype_i` must be :ref:`valid <valid-functype>` under context :math:`C'_i`.
+
+* Let :math:`C''` be the :ref:`context <context>` where:
 
-  * :math:`C'.\CGLOBALS` is the sequence :math:`\etglobals(\X{it}^\ast)`,
+  * :math:`C''.\CGLOBALS` is the sequence :math:`\etglobals(\X{it}^\ast)`,
 
-  * :math:`C'.\CFUNCS` is the same as :math:`C.\CFUNCS`,
+  * :math:`C''.\CTYPES` is the same as :math:`C.\CTYPES`,
 
-  * :math:`C'.\CREFS` is the same as :math:`C.\CREFS`,
+  * :math:`C''.\CFUNCS` is the same as :math:`C.\CFUNCS`,
+
+  * :math:`C''.\CREFS` is the same as :math:`C.\CREFS`,
 
   * all other fields are empty.
 
 * Under the context :math:`C`:
 
-  * For each :math:`\functype_i` in :math:`\module.\MTYPES`,
-    the :ref:`function type <syntax-functype>` :math:`\functype_i` must be :ref:`valid <valid-functype>`.
-
   * For each :math:`\func_i` in :math:`\module.\MFUNCS`,
     the definition :math:`\func_i` must be :ref:`valid <valid-func>` with a :ref:`function type <syntax-functype>` :math:`\X{ft}_i`.
 
@@ -566,7 +577,7 @@ Instead, the context :math:`C` for validation of the module's content is constru
 
   * For each :math:`\global_i` in :math:`\module.\MGLOBALS`:
 
-    * Under the context :math:`C'`,
+    * Under the context :math:`C''`,
       the definition :math:`\global_i` must be :ref:`valid <valid-global>` with a :ref:`global type <syntax-globaltype>` :math:`\X{gt}_i`.
 
   * For each :math:`\elem_i` in :math:`\module.\MELEMS`,
@@ -607,7 +618,7 @@ Instead, the context :math:`C` for validation of the module's content is constru
 .. math::
    \frac{
      \begin{array}{@{}c@{}}
-     (\vdashfunctype \type \ok)^\ast
+     \vdashtypes \type^\ast \ok
      \quad
      (C \vdashfunc \func : \X{ft})^\ast
      \quad
@@ -615,7 +626,7 @@ Instead, the context :math:`C` for validation of the module's content is constru
      \quad
      (C \vdashmem \mem : \X{mt})^\ast
      \quad
-     (C' \vdashglobal \global : \X{gt})^\ast
+     (C'' \vdashglobal \global : \X{gt})^\ast
      \\
      (C \vdashelem \elem : \X{rt})^\ast
      \quad
@@ -639,7 +650,9 @@ Instead, the context :math:`C` for validation of the module's content is constru
      \\
      C = \{ \CTYPES~\type^\ast, \CFUNCS~\X{ift}^\ast\,\X{ft}^\ast, \CTABLES~\X{itt}^\ast\,\X{tt}^\ast, \CMEMS~\X{imt}^\ast\,\X{mt}^\ast, \CGLOBALS~\X{igt}^\ast\,\X{gt}^\ast, \CELEMS~\X{rt}^\ast, \CDATAS~{\ok}^n, \CREFS~x^\ast \}
      \\
-     C' = \{ \CGLOBALS~\X{igt}^\ast, \CFUNCS~(C.\CFUNCS), \CREFS~(C.\CREFS) \}
+     (C' = \{ \CTYPES~\type^\ast \})^\ast
+     \\
+     C'' = \{ \CTYPES~\type^\ast, \CGLOBALS~\X{igt}^\ast, \CFUNCS~(C.\CFUNCS), \CREFS~(C.\CREFS) \}
      \qquad
      |C.\CMEMS| \leq 1
      \qquad
@@ -663,6 +676,25 @@ Instead, the context :math:`C` for validation of the module's content is constru
      \vdashmodule \module : \X{it}^\ast \to \X{et}^\ast
    }
 
+.. _valid-types:
+
+where:
+
+.. math::
+   \frac{
+     \vdashtypes \type^\ast \ok
+     \qquad
+     \{\CTYPES~\type^\ast\} \vdashtypes \type \ok
+   }{
+     \vdashtypes \type^\ast~\type \ok
+   }
+   \qquad
+   \frac{
+   }{
+     \vdashtypes \epsilon \ok
+   }
+
+
 .. note::
    Most definitions in a module -- particularly functions -- are mutually recursive.
    Consequently, the definition of the :ref:`context <context>` :math:`C` in this rule is recursive:
diff --git a/document/core/valid/types.rst b/document/core/valid/types.rst
index 1b790bb46..1fd575b1a 100644
--- a/document/core/valid/types.rst
+++ b/document/core/valid/types.rst
@@ -1,14 +1,147 @@
 Types
 -----
 
-Most :ref:`types <syntax-type>` are universally valid.
-However, restrictions apply to :ref:`function types <syntax-functype>` as well as the :ref:`limits <syntax-limits>` of :ref:`table types <syntax-tabletype>` and :ref:`memory types <syntax-memtype>`, which must be checked during validation.
-
-On :ref:`value types <syntax-valtype>`, a simple notion of subtyping is defined.
+Simple :ref:`types <syntax-type>`, such as :ref:`number types <syntax-numtype>` are universally valid.
+However, restrictions apply to most other types, such as :ref:`reference types <syntax-reftype>`, :ref:`function types <syntax-functype>`, as well as the :ref:`limits <syntax-limits>` of :ref:`table types <syntax-tabletype>` and :ref:`memory types <syntax-memtype>`, which must be checked during validation.
 
 Moreover, :ref:`block types <syntax-blocktype>` are converted to plain :ref:`function types <syntax-functype>` for ease of processing.
 
 
+.. index:: number type
+   pair: validation; number type
+   single: abstract syntax; number type
+.. _valid-numtype:
+
+Number Types
+~~~~~~~~~~~~
+
+:ref:`Number types <syntax-numtype>` are always valid.
+
+.. math::
+   \frac{
+   }{
+     C \vdashnumtype \numtype \ok
+   }
+
+
+.. index:: heap type
+   pair: validation; heap type
+   single: abstract syntax; heap type
+.. _valid-heaptype:
+
+Heap Types
+~~~~~~~~~~
+
+Concrete :ref:`Heap types <syntax-heaptype>` are only valid when the :ref:`type index <syntax-typeidx>` is.
+
+:math:`\FUNC`
+.............
+
+* The heap type is valid.
+
+.. math::
+   \frac{
+   }{
+     C \vdashheaptype \FUNC \ok
+   }
+
+:math:`\EXTERN`
+...............
+
+* The heap type is valid.
+
+.. math::
+   \frac{
+   }{
+     C \vdashheaptype \EXTERN \ok
+   }
+
+:math:`\typeidx`
+................
+
+* The type :math:`C.\CTYPES[\typeidx]` must be defined in the context.
+
+* Then the heap type is valid.
+
+.. math::
+   \frac{
+     C.\CTYPES[\typeidx] = \functype
+   }{
+     C \vdashheaptype \typeidx \ok
+   }
+
+
+.. index:: reference type, heap type
+   pair: validation; reference type
+   single: abstract syntax; reference type
+.. _valid-reftype:
+
+Reference Types
+~~~~~~~~~~~~~~~
+
+:ref:`Reference types <syntax-reftype>` are valid when the referenced :ref:`heap type <syntax-heaptype>` is.
+
+:math:`\REF~\NULL^?~\heaptype`
+..............................
+
+* The heap type :math:`\heaptype` must be :ref:`valid <valid-heaptype>`.
+
+* Then the reference type is valid.
+
+.. math::
+   \frac{
+     C \vdashreftype \heaptype \ok
+   }{
+     C \vdashreftype \REF~\NULL^?~\heaptype \ok
+   }
+
+
+.. index:: value type, reference type, heap type, bottom type
+   pair: validation; value type
+   single: abstract syntax; value type
+.. _valid-valtype:
+.. _valid-bottype:
+
+Value Types
+~~~~~~~~~~~
+
+Valid :ref:`value types <syntax-valtype>` are either valid :ref:`number type <valid-numtype>`,  :ref:`reference type <valid-reftype>`, or the :ref:`bottom type <syntax-bottype>`.
+
+:math:`\BOT`
+............
+
+* The value type is valid.
+
+.. math::
+   \frac{
+   }{
+     C \vdashvaltype \BOT \ok
+   }
+
+
+.. index:: result type, value type
+   pair: validation; result type
+   single: abstract syntax; result type
+.. _valid-resulttype:
+
+Result Types
+~~~~~~~~~~~~
+
+:math:`[t^\ast]`
+................
+
+* Each :ref:`value type <syntax-valtype>` :math:`t_i` in the type sequence :math:`t^\ast` must be :ref:`valid <valid-valtype>`.
+
+* Then the result type is valid.
+
+.. math::
+   \frac{
+     (C \vdashvaltype t \ok)^\ast
+   }{
+     C \vdashresulttype [t^\ast] \ok
+   }
+
+
 .. index:: limits
    pair: validation; limits
    single: abstract syntax; limits
@@ -40,7 +173,7 @@ Limits
      \qquad
      (n \leq m)^?
    }{
-     \vdashlimits \{ \LMIN~n, \LMAX~m^? \} : k
+     C \vdashlimits \{ \LMIN~n, \LMAX~m^? \} : k
    }
 
 
@@ -72,10 +205,13 @@ Block Types
 :math:`[\valtype^?]`
 ....................
 
-* The block type is valid as :ref:`function type <syntax-functype>` :math:`[] \to [\valtype^?]`.
+* The value type :math:`\valtype` must either be absent, or :ref:`valid <valid-valtype>`.
+
+* Then the block type is valid as :ref:`function type <syntax-functype>` :math:`[] \to [\valtype^?]`.
 
 .. math::
    \frac{
+     (C \vdashvaltype \valtype \ok)^?
    }{
      C \vdashblocktype [\valtype^?] : [] \to [\valtype^?]
    }
@@ -89,17 +225,22 @@ Block Types
 Function Types
 ~~~~~~~~~~~~~~
 
-:ref:`Function types <syntax-functype>` are always valid.
+:math:`[t_1^\ast] \to [t_2^\ast]`
+.................................
 
-:math:`[t_1^n] \to [t_2^m]`
-...........................
+* The :ref:`result type <syntax-resulttype>` :math:`[t_1^\ast]` must be :ref:`valid <valid-resulttype>`.
 
-* The function type is valid.
+* The :ref:`result type <syntax-resulttype>` :math:`[t_2^\ast]` must be :ref:`valid <valid-resulttype>`.
+
+* Then the function type is valid.
 
 .. math::
    \frac{
+     C \vdashvaltype [t_1^\ast] \ok
+     \qquad
+     C \vdashvaltype [t_2^\ast] \ok
    }{
-     \vdashfunctype [t_1^\ast] \to [t_2^\ast] \ok
+     C \vdashfunctype [t_1^\ast] \to [t_2^\ast] \ok
    }
 
 
@@ -116,13 +257,17 @@ Table Types
 
 * The limits :math:`\limits` must be :ref:`valid <valid-limits>` within range :math:`2^{32}-1`.
 
+* The reference type :math:`\reftype` must be :ref:`valid <valid-reftype>`.
+
 * Then the table type is valid.
 
 .. math::
    \frac{
-     \vdashlimits \limits : 2^{32} - 1
+     C \vdashlimits \limits : 2^{32} - 1
+     \qquad
+     C \vdashreftype \reftype \ok
    }{
-     \vdashtabletype \limits~\reftype \ok
+     C \vdashtabletype \limits~\reftype \ok
    }
 
 
@@ -143,9 +288,9 @@ Memory Types
 
 .. math::
    \frac{
-     \vdashlimits \limits : 2^{16}
+     C \vdashlimits \limits : 2^{16}
    }{
-     \vdashmemtype \limits \ok
+     C \vdashmemtype \limits \ok
    }
 
 
@@ -160,12 +305,15 @@ Global Types
 :math:`\mut~\valtype`
 .....................
 
-* The global type is valid.
+* The value type :math:`\valtype` must be :ref:`valid <valid-valtype>`.
+
+* Then the global type is valid.
 
 .. math::
    \frac{
+     C \vdashreftype \valtype \ok
    }{
-     \vdashglobaltype \mut~\valtype \ok
+     C \vdashglobaltype \mut~\valtype \ok
    }
 
 
@@ -186,9 +334,9 @@ External Types
 
 .. math::
    \frac{
-     \vdashfunctype \functype \ok
+     C \vdashfunctype \functype \ok
    }{
-     \vdashexterntype \ETFUNC~\functype \ok
+     C \vdashexterntype \ETFUNC~\functype \ok
    }
 
 :math:`\ETTABLE~\tabletype`
@@ -200,9 +348,9 @@ External Types
 
 .. math::
    \frac{
-     \vdashtabletype \tabletype \ok
+     C \vdashtabletype \tabletype \ok
    }{
-     \vdashexterntype \ETTABLE~\tabletype \ok
+     C \vdashexterntype \ETTABLE~\tabletype \ok
    }
 
 :math:`\ETMEM~\memtype`
@@ -214,9 +362,9 @@ External Types
 
 .. math::
    \frac{
-     \vdashmemtype \memtype \ok
+     C \vdashmemtype \memtype \ok
    }{
-     \vdashexterntype \ETMEM~\memtype \ok
+     C \vdashexterntype \ETMEM~\memtype \ok
    }
 
 :math:`\ETGLOBAL~\globaltype`
@@ -228,226 +376,7 @@ External Types
 
 .. math::
    \frac{
-     \vdashglobaltype \globaltype \ok
-   }{
-     \vdashexterntype \ETGLOBAL~\globaltype \ok
-   }
- 
- 
-.. index:: subtyping
-
-Value Subtyping
-~~~~~~~~~~~~~~~
-
-.. index:: number type
-
-.. _match-numtype:
-
-Number Types
-............
-
-A :ref:`number type <syntax-numtype>` :math:`\numtype_1` matches a :ref:`number type <syntax-numtype>` :math:`\numtype_2` if and only if:
-
-* Both :math:`\numtype_1` and :math:`\numtype_2` are the same.
-
-.. math::
-   ~\\[-1ex]
-   \frac{
-   }{
-     \vdashnumtypematch \numtype \matchesvaltype \numtype
-   }
-
-
-
-.. index:: reference type
-
-.. _match-reftype:
-
-Reference Types
-...............
-
-A :ref:`reference type <syntax-reftype>` :math:`\reftype_1` matches a :ref:`reference type <syntax-reftype>` :math:`\reftype_2` if and only if:
-
-* Either both :math:`\reftype_1` and :math:`\reftype_2` are the same.
-
-.. math::
-   ~\\[-1ex]
-   \frac{
-   }{
-     \vdashreftypematch \reftype \matchesvaltype \reftype
-   }
-
-
-.. index:: value type, number type, reference type
-
-.. _match-valtype:
-
-Value Types
-...........
-
-A :ref:`value type <syntax-valtype>` :math:`\valtype_1` matches a :ref:`value type <syntax-valtype>` :math:`\valtype_2` if and only if:
-
-* Either both :math:`\valtype_1` and :math:`\valtype_2` are :ref:`number types <syntax-numtype>` and :math:`\valtype_1` :ref:`matches <match-numtype>` :math:`\valtype_2`.
-
-* Or both :math:`\valtype_1` and :math:`\valtype_2` are :ref:`reference types <syntax-reftype>` and :math:`\valtype_1` :ref:`matches <match-reftype>` :math:`\valtype_2`.
-
-* Or :math:`\valtype_1` is :math:`\BOT`.
-
-.. math::
-   ~\\[-1ex]
-   \frac{
-   }{
-     \vdashvaltypematch \BOT \matchesvaltype \valtype
-   }
-
-
-.. _match-resulttype:
-
-Result Types
-............
-
-Subtyping is lifted to :ref:`result types <syntax-resulttype>` in a pointwise manner.
-That is, a :ref:`result type <syntax-resulttype>` :math:`[t_1^\ast]` matches a :ref:`result type <syntax-resulttype>` :math:`[t_2^\ast]` if and only if:
-
-* Every :ref:`value type <syntax-valtype>` :math:`t_1` in :math:`[t_1^\ast]` :ref:`matches <match-valtype>` the corresponding :ref:`value type <syntax-valtype>` :math:`t_2` in :math:`[t_2^\ast]`.
-
-.. math::
-   ~\\[-1ex]
-   \frac{
-     (\vdashvaltypematch t_1 \matchesvaltype t_2)^\ast
-   }{
-     \vdashresulttypematch [t_1^\ast] \matchesresulttype [t_2^ast]
-   }
-
-
-.. index:: ! matching, external type
-.. _exec-import:
-.. _match:
-
-Import Subtyping
-~~~~~~~~~~~~~~~~
-
-When :ref:`instantiating <exec-module>` a module,
-:ref:`external values <syntax-externval>` must be provided whose :ref:`types <valid-externval>` are *matched* against the respective :ref:`external types <syntax-externtype>` classifying each import.
-In some cases, this allows for a simple form of subtyping, as defined here.
-
-
-.. index:: limits
-.. _match-limits:
-
-Limits
-......
-
-:ref:`Limits <syntax-limits>` :math:`\{ \LMIN~n_1, \LMAX~m_1^? \}` match limits :math:`\{ \LMIN~n_2, \LMAX~m_2^? \}` if and only if:
-
-* :math:`n_1` is larger than or equal to :math:`n_2`.
-
-* Either:
-
-  * :math:`m_2^?` is empty.
-
-* Or:
-
-  * Both :math:`m_1^?` and :math:`m_2^?` are non-empty.
-
-  * :math:`m_1` is smaller than or equal to :math:`m_2`.
-
-.. math::
-   ~\\[-1ex]
-   \frac{
-     n_1 \geq n_2
-   }{
-     \vdashlimitsmatch \{ \LMIN~n_1, \LMAX~m_1^? \} \matcheslimits \{ \LMIN~n_2, \LMAX~\epsilon \}
-   }
-   \quad
-   \frac{
-     n_1 \geq n_2
-     \qquad
-     m_1 \leq m_2
-   }{
-     \vdashlimitsmatch \{ \LMIN~n_1, \LMAX~m_1 \} \matcheslimits \{ \LMIN~n_2, \LMAX~m_2 \}
-   }
-
-
-.. _match-externtype:
-
-.. index:: function type
-.. _match-functype:
-
-Functions
-.........
-
-An :ref:`external type <syntax-externtype>` :math:`\ETFUNC~\functype_1` matches :math:`\ETFUNC~\functype_2` if and only if:
-
-* Both :math:`\functype_1` and :math:`\functype_2` are the same.
-
-.. math::
-   ~\\[-1ex]
-   \frac{
-   }{
-     \vdashexterntypematch \ETFUNC~\functype \matchesexterntype \ETFUNC~\functype
-   }
-
-
-.. index:: table type, limits, element type
-.. _match-tabletype:
-
-Tables
-......
-
-An :ref:`external type <syntax-externtype>` :math:`\ETTABLE~(\limits_1~\reftype_1)` matches :math:`\ETTABLE~(\limits_2~\reftype_2)` if and only if:
-
-* Limits :math:`\limits_1` :ref:`match <match-limits>` :math:`\limits_2`.
-
-* Both :math:`\reftype_1` and :math:`\reftype_2` are the same.
-
-.. math::
-   \frac{
-     \vdashlimitsmatch \limits_1 \matcheslimits \limits_2
-   }{
-     \vdashexterntypematch \ETTABLE~(\limits_1~\reftype) \matchesexterntype \ETTABLE~(\limits_2~\reftype)
-   }
-
-
-.. index:: memory type, limits
-.. _match-memtype:
-
-Memories
-........
-
-An :ref:`external type <syntax-externtype>` :math:`\ETMEM~\limits_1` matches :math:`\ETMEM~\limits_2` if and only if:
-
-* Limits :math:`\limits_1` :ref:`match <match-limits>` :math:`\limits_2`.
-
-.. math::
-   \frac{
-     \vdashlimitsmatch \limits_1 \matcheslimits \limits_2
-   }{
-     \vdashexterntypematch \ETMEM~\limits_1 \matchesexterntype \ETMEM~\limits_2
-   }
-
-
-.. index:: global type, value type, mutability
-.. _match-globaltype:
-
-Globals
-.......
-
-An :ref:`external type <syntax-externtype>` :math:`\ETGLOBAL~(\mut_1~t_1)` matches :math:`\ETGLOBAL~(\mut_2~t_2)` if and only if:
-
-* Either both :math:`\mut_1` and :math:`\mut_2` are |MVAR| and :math:`t_1` and :math:`t_2` are the same.
- 
-* Or both :math:`\mut_1` and :math:`\mut_2` are |MCONST| and :math:`t_1` :ref:`matches <match-valtype>` :math:`t_2`.
-
-.. math::
-   ~\\[-1ex]
-   \frac{
-   }{
-     \vdashexterntypematch \ETGLOBAL~(\MVAR~t) \matchesexterntype \ETGLOBAL~(\MVAR~t)
-   }
-   \qquad
-   \frac{
-     \vdashvaltypematch t_1 \matchesvaltype t_2
+     C \vdashglobaltype \globaltype \ok
    }{
-     \vdashexterntypematch \ETGLOBAL~(\MCONST~t_1) \matchesexterntype \ETGLOBAL~(\MCONST~t_2)
+     C \vdashexterntype \ETGLOBAL~\globaltype \ok
    }
diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 646d8a437..471e11d76 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -148,19 +148,25 @@ let num_type s =
 
 let heap_type s =
   let pos = pos s in
-  match vs33 s with
-  | -0x10l -> FuncHeapType
-  | -0x11l -> ExternHeapType
-  | i when i >= 0l -> DefHeapType (SynVar i)
-  | _ -> error s pos "malformed heap type"
+  match peek s with
+  | Some i when i land 0xc0 = 0x40 ->
+    (match vs7 s with
+    | -0x10 -> FuncHeapType
+    | -0x11 -> ExternHeapType
+    | _ -> error s pos "malformed heap type"
+    )
+  | _ ->
+    match vs33 s with
+    | i when i >= 0l -> DefHeapType (SynVar i)
+    | _ -> error s pos "malformed heap type"
 
 let ref_type s =
   let pos = pos s in
-  match vs33 s with
-  | -0x10l -> (Nullable, FuncHeapType)
-  | -0x11l -> (Nullable, ExternHeapType)
-  | -0x14l -> (Nullable, heap_type s)
-  | -0x15l -> (NonNullable, heap_type s)
+  match vs7 s with
+  | -0x10 -> (Nullable, FuncHeapType)
+  | -0x11 -> (Nullable, ExternHeapType)
+  | -0x14 -> (Nullable, heap_type s)
+  | -0x15 -> (NonNullable, heap_type s)
   | _ -> error s pos "malformed reference type"
 
 let value_type s =
diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index 567dcc331..051606d9c 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -108,10 +108,10 @@ struct
     | BotHeapType -> assert false
 
   let ref_type = function
-    | (Nullable, FuncHeapType) -> vs32 (-0x10l)
-    | (Nullable, ExternHeapType) -> vs32 (-0x11l)
-    | (Nullable, t) -> vs33 (-0x14l); heap_type t
-    | (NonNullable, t) -> vs33 (-0x15l); heap_type t
+    | (Nullable, FuncHeapType) -> vs7 (-0x10)
+    | (Nullable, ExternHeapType) -> vs7 (-0x11)
+    | (Nullable, t) -> vs7 (-0x14); heap_type t
+    | (NonNullable, t) -> vs7 (-0x15); heap_type t
 
   let value_type = function
     | NumType t -> num_type t

From acf5d26ca5fa218453195f49aa5181c68ade13d6 Mon Sep 17 00:00:00 2001
From: Ivan Panchenko <39594356+ivan-pan@users.noreply.github.com>
Date: Sat, 14 Aug 2021 15:34:04 +0200
Subject: [PATCH 031/285] [spec] Fix typos (#1351)

---
 document/core/exec/modules.rst     | 16 ++++++++--------
 document/core/syntax/values.rst    |  2 +-
 document/core/text/conventions.rst |  2 +-
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index cf0cf0874..34f1298ad 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -468,17 +468,17 @@ and list of :ref:`reference <syntax-ref>` vectors for the module's :ref:`element
 
    a. Let :math:`\dataaddr_i` be the :ref:`data address <syntax-dataaddr>` resulting from :ref:`allocating <alloc-data>` a :ref:`data instance <syntax-datainst>` with contents :math:`\data_i.\DINIT`.
 
-8. Let :math:`\funcaddr^\ast` be the the concatenation of the :ref:`function addresses <syntax-funcaddr>` :math:`\funcaddr_i` in index order.
+8. Let :math:`\funcaddr^\ast` be the concatenation of the :ref:`function addresses <syntax-funcaddr>` :math:`\funcaddr_i` in index order.
 
-9. Let :math:`\tableaddr^\ast` be the the concatenation of the :ref:`table addresses <syntax-tableaddr>` :math:`\tableaddr_i` in index order.
+9. Let :math:`\tableaddr^\ast` be the concatenation of the :ref:`table addresses <syntax-tableaddr>` :math:`\tableaddr_i` in index order.
 
-10. Let :math:`\memaddr^\ast` be the the concatenation of the :ref:`memory addresses <syntax-memaddr>` :math:`\memaddr_i` in index order.
+10. Let :math:`\memaddr^\ast` be the concatenation of the :ref:`memory addresses <syntax-memaddr>` :math:`\memaddr_i` in index order.
 
-11. Let :math:`\globaladdr^\ast` be the the concatenation of the :ref:`global addresses <syntax-globaladdr>` :math:`\globaladdr_i` in index order.
+11. Let :math:`\globaladdr^\ast` be the concatenation of the :ref:`global addresses <syntax-globaladdr>` :math:`\globaladdr_i` in index order.
 
-12. Let :math:`\elemaddr^\ast` be the the concatenation of the :ref:`element addresses <syntax-elemaddr>` :math:`\elemaddr_i` in index order.
+12. Let :math:`\elemaddr^\ast` be the concatenation of the :ref:`element addresses <syntax-elemaddr>` :math:`\elemaddr_i` in index order.
 
-13. Let :math:`\dataaddr^\ast` be the the concatenation of the :ref:`data addresses <syntax-dataaddr>` :math:`\dataaddr_i` in index order.
+13. Let :math:`\dataaddr^\ast` be the concatenation of the :ref:`data addresses <syntax-dataaddr>` :math:`\dataaddr_i` in index order.
 
 14. Let :math:`\funcaddr_{\F{mod}}^\ast` be the list of :ref:`function addresses <syntax-funcaddr>` extracted from :math:`\externval_{\F{im}}^\ast`, concatenated with :math:`\funcaddr^\ast`.
 
@@ -500,7 +500,7 @@ and list of :ref:`reference <syntax-ref>` vectors for the module's :ref:`element
 
     e. Let :math:`\exportinst_i` be the :ref:`export instance <syntax-exportinst>` :math:`\{\EINAME~(\export_i.\ENAME), \EIVALUE~\externval_i\}`.
 
-19. Let :math:`\exportinst^\ast` be the the concatenation of the :ref:`export instances <syntax-exportinst>` :math:`\exportinst_i` in index order.
+19. Let :math:`\exportinst^\ast` be the concatenation of the :ref:`export instances <syntax-exportinst>` :math:`\exportinst_i` in index order.
 
 20. Let :math:`\moduleinst` be the :ref:`module instance <syntax-moduleinst>` :math:`\{\MITYPES~(\module.\MTYPES),` :math:`\MIFUNCS~\funcaddr_{\F{mod}}^\ast,` :math:`\MITABLES~\tableaddr_{\F{mod}}^\ast,` :math:`\MIMEMS~\memaddr_{\F{mod}}^\ast,` :math:`\MIGLOBALS~\globaladdr_{\F{mod}}^\ast,` :math:`\MIEXPORTS~\exportinst^\ast\}`.
 
@@ -635,7 +635,7 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
    b. Assert: due to :ref:`validation <valid-module>`, the frame :math:`F_{\F{init}}` is now on the top of the stack.
 
-   c. Let :math:`\val^\ast` be the conatenation of :math:`\val_i` in index order.
+   c. Let :math:`\val^\ast` be the concatenation of :math:`\val_i` in index order.
 
 9. Let :math:`(\reff^\ast)^\ast` be the list of :ref:`reference <syntax-ref>` vectors determined by the :ref:`element segments <syntax-elem>` in :math:`\module`. These may be calculated as follows.
 
diff --git a/document/core/syntax/values.rst b/document/core/syntax/values.rst
index 744384274..98acc7a69 100644
--- a/document/core/syntax/values.rst
+++ b/document/core/syntax/values.rst
@@ -94,7 +94,7 @@ Floating-Point
 *Floating-point* data represents 32 or 64 bit values that correspond to the respective binary formats of the |IEEE754|_ standard (Section 3.3).
 
 Every value has a *sign* and a *magnitude*.
-Magnitudes can either be expressed as *normal* numbers of the form :math:`m_0.m_1m_2\dots m_M \cdot2^e`, where :math:`e` is the exponent and :math:`m` is the *significand* whose most signifcant bit :math:`m_0` is :math:`1`,
+Magnitudes can either be expressed as *normal* numbers of the form :math:`m_0.m_1m_2\dots m_M \cdot2^e`, where :math:`e` is the exponent and :math:`m` is the *significand* whose most significant bit :math:`m_0` is :math:`1`,
 or as a *subnormal* number where the exponent is fixed to the smallest possible value and :math:`m_0` is :math:`0`; among the subnormals are positive and negative zero values.
 Since the significands are binary values, normals are represented in the form :math:`(1 + m\cdot 2^{-M}) \cdot 2^e`, where :math:`M` is the bit width of :math:`m`; similarly for subnormals.
 
diff --git a/document/core/text/conventions.rst b/document/core/text/conventions.rst
index ea62cc4b7..7d77c76aa 100644
--- a/document/core/text/conventions.rst
+++ b/document/core/text/conventions.rst
@@ -10,7 +10,7 @@ A text string is a well-formed description of a module if and only if it is gene
 Each production of this grammar has at most one synthesized attribute: the abstract syntax that the respective character sequence expresses.
 Thus, the attribute grammar implicitly defines a *parsing* function.
 Some productions also take a :ref:`context <text-context>` as an inherited attribute
-that records bound :ref:`identifers <text-id>`.
+that records bound :ref:`identifiers <text-id>`.
 
 Except for a few exceptions, the core of the text grammar closely mirrors the grammar of the abstract syntax.
 However, it also defines a number of *abbreviations* that are "syntactic sugar" over the core syntax.

From ed0f0194b50bafd79bafa6156de7dfaa9572d3f6 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@igalia.com>
Date: Thu, 19 Aug 2021 09:25:45 +0200
Subject: [PATCH 032/285] [js-api] Update CreateBuiltinFunction call for ES
 changes. (#1337)

See <https://github.com/tc39/ecma262/pull/2116>.
---
 document/js-api/index.bs | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index ff36c930c..e3184c2d8 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -52,7 +52,6 @@ urlPrefix: https://tc39.github.io/ecma262/; spec: ECMASCRIPT
         url: sec-well-known-intrinsic-objects
             text: %ErrorPrototype%
         text: %ObjectPrototype%; url: sec-properties-of-the-object-prototype-object
-        text: %FunctionPrototype%; url: sec-properties-of-the-function-prototype-object
         text: %Promise%; url: sec-promise-constructor
         text: Property Descriptor; url: sec-property-descriptor-specification-type
         text: array index; url: sec-array-exotic-objects
@@ -978,15 +977,13 @@ This slot holds a [=function address=] relative to the [=surrounding agent=]'s [
         1. Return |map|[|funcaddr|].
     1. Let |steps| be "[=call an Exported Function|call the Exported Function=] |funcaddr| with arguments."
     1. Let |realm| be the [=current Realm=].
-    1. Let |function| be [=CreateBuiltinFunction=](|realm|, |steps|, [=%FunctionPrototype%=], &laquo; \[[FunctionAddress]] &raquo;).
-    1. Set |function|.\[[FunctionAddress]] to |funcaddr|.
     1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let |functype| be [=func_type=](|store|, |funcaddr|).
     1. Let [|paramTypes|] → [<var ignore>resultTypes</var>] be |functype|.
     1. Let |arity| be |paramTypes|'s [=list/size=].
-    1. Perform ! [=SetFunctionLength=](|function|, |arity|).
     1. Let |name| be the [=name of the WebAssembly function=] |funcaddr|.
-    1. Perform ! [=SetFunctionName=](|function|, |name|).
+    1. Let |function| be [=!=] [=CreateBuiltinFunction=](|steps|, |arity|, |name|, « \[[FunctionAddress]] », |realm|).
+    1. Set |function|.\[[FunctionAddress]] to |funcaddr|.
     1. [=map/Set=] |map|[|funcaddr|] to |function|.
     1. Return |function|.
 </div>

From 22f7fa47f8c8344a453fabd6b71d1aef7756e16e Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Wed, 8 Sep 2021 13:39:05 +0200
Subject: [PATCH 033/285] [interpreter] Minor grammar fix

---
 interpreter/text/parser.mly | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index d423ee74e..4e328b69e 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -260,17 +260,19 @@ def_type :
   | LPAR FUNC func_type RPAR { $3 }
 
 func_type :
-  | /* empty */
-    { FuncType ([], []) }
-  | LPAR RESULT value_type_list RPAR func_type
-    { let FuncType (ins, out) = $5 in
-      if ins <> [] then error (at ()) "result before parameter";
-      FuncType (ins, $3 @ out) }
+  | func_type_result
+    { FuncType ([], $1) }
   | LPAR PARAM value_type_list RPAR func_type
     { let FuncType (ins, out) = $5 in FuncType ($3 @ ins, out) }
   | LPAR PARAM bind_var value_type RPAR func_type  /* Sugar */
     { let FuncType (ins, out) = $6 in FuncType ($4 :: ins, out) }
 
+func_type_result :
+  | /* empty */
+    { [] }
+  | LPAR RESULT value_type_list RPAR func_type_result
+    { $3 @ $5 }
+
 table_type :
   | limits ref_type { TableType ($1, $2) }
 

From d404d096bcdbe7f663bd6b2384dd65c8023b8312 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Wed, 8 Sep 2021 14:44:22 +0200
Subject: [PATCH 034/285] [interpreter] Unbreak

---
 test/core/type.wast | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/core/type.wast b/test/core/type.wast
index b94063e6a..aad40dd16 100644
--- a/test/core/type.wast
+++ b/test/core/type.wast
@@ -42,7 +42,7 @@
 
 (assert_malformed
   (module quote "(type (func (result i32) (param i32)))")
-  "result before parameter"
+  "unexpected token"
 )
 (assert_malformed
   (module quote "(type (func (result $x i32)))")

From 4353b29ef0a0851f7ac665fe4405c939f6db61cc Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@dfinity.org>
Date: Wed, 8 Sep 2021 15:05:10 +0200
Subject: [PATCH 035/285] [spec] Fix variable name typos (#1358)

---
 document/core/exec/instructions.rst | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 78c43da79..907703b49 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -1412,15 +1412,15 @@ Memory Instructions
 
 10. Assert: due to :ref:`validation <valid-memory.init>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
 
-11. Pop the value :math:`\I32.\CONST~cnt` from the stack.
+11. Pop the value :math:`\I32.\CONST~n` from the stack.
 
 12. Assert: due to :ref:`validation <valid-memory.init>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
 
-13. Pop the value :math:`\I32.\CONST~src` from the stack.
+13. Pop the value :math:`\I32.\CONST~s` from the stack.
 
 14. Assert: due to :ref:`validation <valid-memory.init>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
 
-15. Pop the value :math:`\I32.\CONST~dst` from the stack.
+15. Pop the value :math:`\I32.\CONST~d` from the stack.
 
 16. If :math:`s + n` is larger than the length of :math:`\X{data}.\DIDATA` or :math:`d + n` is larger than the length of :math:`\X{mem}.\MIDATA`, then:
 

From 02ef8da4b3efd339497517af81f2171c39891167 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 8 Sep 2021 18:30:50 +0200
Subject: [PATCH 036/285] Remove outdated statement

---
 proposals/function-references/Overview.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/proposals/function-references/Overview.md b/proposals/function-references/Overview.md
index 7d08ed54d..d5a3eaee4 100644
--- a/proposals/function-references/Overview.md
+++ b/proposals/function-references/Overview.md
@@ -152,8 +152,6 @@ A *reference type* denotes the type of a reference to some data. It may either i
 
 #### Subtyping
 
-Greatest fixpoint (co-inductive interpretation) of the given rules (implying reflexivity and transitivity).
-
 The following rules, now defined in terms of heap types, replace and extend the rules for [basic reference types](https://github.com/WebAssembly/reference-types/proposals/reference-types/Overview.md#subtyping).
 
 ##### Reference Types

From 1a421a0249310ec10403a7e9b86f4309940e8c66 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 15 Sep 2021 15:22:14 +0200
Subject: [PATCH 037/285] Minor tweaks to overview

---
 proposals/function-references/Overview.md | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/proposals/function-references/Overview.md b/proposals/function-references/Overview.md
index d5a3eaee4..801553ab5 100644
--- a/proposals/function-references/Overview.md
+++ b/proposals/function-references/Overview.md
@@ -166,13 +166,18 @@ The following rules, now defined in terms of heap types, replace and extend the
   - `(ref <heaptype1>) <: (ref null <heaptype2>)`
     - iff `<heaptype1> <: <heaptype2>`
 
-##### Constructed Types
+##### Heap Types
 
 * Any function type is a subtype of `func`
   - `$t <: func`
      - iff `$t = <functype>`
 
-* Note: Function types themselves are invariant for now. This may be relaxed in future extensions.
+##### Type Indices
+
+* Type indices are subtypes only if they define equivalent types
+  - `$t <: $t'`
+    - iff `$t = <functype>` and `$t' = <functype'>` and `<functype> == <functype'>`
+  - Note: Function types are invariant for now. This may be relaxed in future extensions.
 
 
 #### Defaultability

From 994ee7c17407ab436beea39a5eadb2fefa04f748 Mon Sep 17 00:00:00 2001
From: Andreas Haas <ahaas@google.com>
Date: Wed, 15 Sep 2021 15:59:07 +0200
Subject: [PATCH 038/285] Remove outdated table test

---
 test/js-api/table/get-set.any.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/js-api/table/get-set.any.js b/test/js-api/table/get-set.any.js
index 2e16346c6..a1586ef83 100644
--- a/test/js-api/table/get-set.any.js
+++ b/test/js-api/table/get-set.any.js
@@ -56,7 +56,6 @@ test(() => {
   const argument = { "element": "anyfunc", "initial": 5 };
   const table = new WebAssembly.Table(argument);
   assert_throws_js(TypeError, () => table.set());
-  assert_throws_js(TypeError, () => table.set(0));
 }, "Missing arguments: set");
 
 test(t => {

From e6bee704620d2265cf147c5601b60bdfd9985899 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@igalia.com>
Date: Wed, 15 Sep 2021 17:52:34 +0200
Subject: [PATCH 039/285] [test] Sync with wpt.

---
 test/js-api/assertions.js                  |   9 +-
 test/js-api/constructor/toStringTag.any.js |  42 +++++++
 test/js-api/functions/helper.js            |  12 ++
 test/js-api/instanceTestFactory.js         | 128 +++++++++++++++++++++
 test/js-api/memory/constructor.any.js      |  11 +-
 test/js-api/module/exports.any.js          |  54 +++++++++
 test/js-api/module/imports.any.js          |  60 ++++++++++
 test/js-api/table/assertions.js            |  11 ++
 test/js-api/table/constructor.any.js       |  50 ++++++--
 test/js-api/table/get-set.any.js           |  39 +++++++
 test/js-api/table/grow.any.js              |  29 +++++
 test/js-api/wasm-module-builder.js         |  16 +--
 12 files changed, 434 insertions(+), 27 deletions(-)
 create mode 100644 test/js-api/constructor/toStringTag.any.js
 create mode 100644 test/js-api/functions/helper.js

diff --git a/test/js-api/assertions.js b/test/js-api/assertions.js
index f00303f6a..162f5a9a6 100644
--- a/test/js-api/assertions.js
+++ b/test/js-api/assertions.js
@@ -17,8 +17,13 @@ function assert_function_length(fn, length, description) {
 }
 
 function assert_exported_function(fn, { name, length }, description) {
-  assert_equals(Object.getPrototypeOf(fn), Function.prototype,
-                `${description}: prototype`);
+  if (WebAssembly.Function === undefined) {
+    assert_equals(Object.getPrototypeOf(fn), Function.prototype,
+                  `${description}: prototype`);
+  } else {
+    assert_equals(Object.getPrototypeOf(fn), WebAssembly.Function.prototype,
+                  `${description}: prototype`);
+  }
 
   assert_function_name(fn, name, description);
   assert_function_length(fn, length, description);
diff --git a/test/js-api/constructor/toStringTag.any.js b/test/js-api/constructor/toStringTag.any.js
new file mode 100644
index 000000000..9c0d346bc
--- /dev/null
+++ b/test/js-api/constructor/toStringTag.any.js
@@ -0,0 +1,42 @@
+// META: global=window,dedicatedworker,jsshell
+
+"use strict";
+// https://heycam.github.io/webidl/#es-namespaces
+// https://webassembly.github.io/spec/js-api/#namespacedef-webassembly
+
+test(() => {
+  assert_own_property(WebAssembly, Symbol.toStringTag);
+
+  const propDesc = Object.getOwnPropertyDescriptor(WebAssembly, Symbol.toStringTag);
+  assert_equals(propDesc.value, "WebAssembly", "value");
+  assert_equals(propDesc.writable, false, "writable");
+  assert_equals(propDesc.enumerable, false, "enumerable");
+  assert_equals(propDesc.configurable, true, "configurable");
+}, "@@toStringTag exists on the namespace object with the appropriate descriptor");
+
+test(() => {
+  assert_equals(WebAssembly.toString(), "[object WebAssembly]");
+  assert_equals(Object.prototype.toString.call(WebAssembly), "[object WebAssembly]");
+}, "Object.prototype.toString applied to the namespace object");
+
+test(t => {
+  assert_own_property(WebAssembly, Symbol.toStringTag, "Precondition: @@toStringTag on the namespace object");
+  t.add_cleanup(() => {
+    Object.defineProperty(WebAssembly, Symbol.toStringTag, { value: "WebAssembly" });
+  });
+
+  Object.defineProperty(WebAssembly, Symbol.toStringTag, { value: "Test" });
+  assert_equals(WebAssembly.toString(), "[object Test]");
+  assert_equals(Object.prototype.toString.call(WebAssembly), "[object Test]");
+}, "Object.prototype.toString applied after modifying the namespace object's @@toStringTag");
+
+test(t => {
+  assert_own_property(WebAssembly, Symbol.toStringTag, "Precondition: @@toStringTag on the namespace object");
+  t.add_cleanup(() => {
+    Object.defineProperty(WebAssembly, Symbol.toStringTag, { value: "WebAssembly" });
+  });
+
+  assert_true(delete WebAssembly[Symbol.toStringTag]);
+  assert_equals(WebAssembly.toString(), "[object Object]");
+  assert_equals(Object.prototype.toString.call(WebAssembly), "[object Object]");
+}, "Object.prototype.toString applied after deleting @@toStringTag");
diff --git a/test/js-api/functions/helper.js b/test/js-api/functions/helper.js
new file mode 100644
index 000000000..487791c69
--- /dev/null
+++ b/test/js-api/functions/helper.js
@@ -0,0 +1,12 @@
+function call_later(f) {
+  const builder = new WasmModuleBuilder();
+  const functionIndex = builder.addImport("module", "imported", kSig_v_v);
+  builder.addStart(functionIndex);
+  const buffer = builder.toBuffer();
+
+  WebAssembly.instantiate(buffer, {
+    "module": {
+      "imported": f,
+    }
+  });
+}
diff --git a/test/js-api/instanceTestFactory.js b/test/js-api/instanceTestFactory.js
index 86f593f46..ac468947e 100644
--- a/test/js-api/instanceTestFactory.js
+++ b/test/js-api/instanceTestFactory.js
@@ -126,6 +126,134 @@ const instanceTestFactory = [
     }
   ],
 
+  [
+    "imports with empty module names",
+    function() {
+      const builder = new WasmModuleBuilder();
+
+      builder.addImport("", "fn", kSig_v_v);
+      builder.addImportedGlobal("", "global", kWasmI32);
+      builder.addImportedMemory("", "memory", 0, 128);
+      builder.addImportedTable("", "table", 0, 128);
+
+      const buffer = builder.toBuffer();
+      const imports = {
+        "": {
+          "fn": function() {},
+          "global": 0,
+          "memory": new WebAssembly.Memory({ "initial": 64, maximum: 128 }),
+          "table": new WebAssembly.Table({ "element": "anyfunc", "initial": 64, maximum: 128 }),
+        },
+      };
+
+      return {
+        buffer,
+        args: [imports],
+        exports: {},
+        verify: () => {},
+      };
+    }
+  ],
+
+  [
+    "imports with empty names",
+    function() {
+      const builder = new WasmModuleBuilder();
+
+      builder.addImport("a", "", kSig_v_v);
+      builder.addImportedGlobal("b", "", kWasmI32);
+      builder.addImportedMemory("c", "", 0, 128);
+      builder.addImportedTable("d", "", 0, 128);
+
+      const buffer = builder.toBuffer();
+      const imports = {
+        "a": { "": function() {} },
+        "b": { "": 0 },
+        "c": { "": new WebAssembly.Memory({ "initial": 64, maximum: 128 }) },
+        "d": { "": new WebAssembly.Table({ "element": "anyfunc", "initial": 64, maximum: 128 }) },
+      };
+
+      return {
+        buffer,
+        args: [imports],
+        exports: {},
+        verify: () => {},
+      };
+    }
+  ],
+
+  [
+    "exports with empty name: function",
+    function() {
+      const builder = new WasmModuleBuilder();
+
+      builder
+        .addFunction("", kSig_v_d)
+        .addBody([])
+        .exportFunc();
+
+      const buffer = builder.toBuffer();
+
+      const exports = {
+        "": { "kind": "function", "name": "0", "length": 1 },
+      };
+
+      return {
+        buffer,
+        args: [],
+        exports,
+        verify: () => {},
+      };
+    }
+  ],
+
+  [
+    "exports with empty name: table",
+    function() {
+      const builder = new WasmModuleBuilder();
+
+      builder.setTableBounds(1);
+      builder.addExportOfKind("", kExternalTable, 0);
+
+      const buffer = builder.toBuffer();
+
+      const exports = {
+        "": { "kind": "table", "length": 1 },
+      };
+
+      return {
+        buffer,
+        args: [],
+        exports,
+        verify: () => {},
+      };
+    }
+  ],
+
+  [
+    "exports with empty name: global",
+    function() {
+      const builder = new WasmModuleBuilder();
+
+      builder.addGlobal(kWasmI32, true)
+        .exportAs("")
+        .init = 7;
+
+      const buffer = builder.toBuffer();
+
+      const exports = {
+        "": { "kind": "global", "value": 7 },
+      };
+
+      return {
+        buffer,
+        args: [],
+        exports,
+        verify: () => {},
+      };
+    }
+  ],
+
   [
     "No imports",
     function() {
diff --git a/test/js-api/memory/constructor.any.js b/test/js-api/memory/constructor.any.js
index 6524c8acc..0a0be11e3 100644
--- a/test/js-api/memory/constructor.any.js
+++ b/test/js-api/memory/constructor.any.js
@@ -72,7 +72,16 @@ test(() => {
       assert_unreached(`Should not call [[HasProperty]] with ${x}`);
     },
     get(o, x) {
-      return 0;
+      // Due to the requirement not to supply both minimum and initial, we need to ignore one of them.
+      switch (x) {
+        case "shared":
+          return false;
+        case "initial":
+        case "maximum":
+          return 0;
+        default:
+          return undefined;
+      }
     },
   });
   new WebAssembly.Memory(proxy);
diff --git a/test/js-api/module/exports.any.js b/test/js-api/module/exports.any.js
index 60b2c04f4..40a3935a4 100644
--- a/test/js-api/module/exports.any.js
+++ b/test/js-api/module/exports.any.js
@@ -75,6 +75,12 @@ test(() => {
   }
 }, "Branding");
 
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  const exports = WebAssembly.Module.exports(module);
+  assert_true(Array.isArray(exports));
+}, "Return type");
+
 test(() => {
   const module = new WebAssembly.Module(emptyModuleBinary);
   const exports = WebAssembly.Module.exports(module);
@@ -124,6 +130,54 @@ test(() => {
   assert_exports(exports, expected);
 }, "exports");
 
+test(() => {
+  const builder = new WasmModuleBuilder();
+
+  builder
+    .addFunction("", kSig_v_v)
+    .addBody([])
+    .exportFunc();
+
+  const buffer = builder.toBuffer()
+  const module = new WebAssembly.Module(buffer);
+  const exports = WebAssembly.Module.exports(module);
+  const expected = [
+    { "kind": "function", "name": "" },
+  ];
+  assert_exports(exports, expected);
+}, "exports with empty name: function");
+
+test(() => {
+  const builder = new WasmModuleBuilder();
+
+  builder.setTableBounds(1);
+  builder.addExportOfKind("", kExternalTable, 0);
+
+  const buffer = builder.toBuffer()
+  const module = new WebAssembly.Module(buffer);
+  const exports = WebAssembly.Module.exports(module);
+  const expected = [
+    { "kind": "table", "name": "" },
+  ];
+  assert_exports(exports, expected);
+}, "exports with empty name: table");
+
+test(() => {
+  const builder = new WasmModuleBuilder();
+
+  builder.addGlobal(kWasmI32, true)
+    .exportAs("")
+    .init = 7;
+
+  const buffer = builder.toBuffer()
+  const module = new WebAssembly.Module(buffer);
+  const exports = WebAssembly.Module.exports(module);
+  const expected = [
+    { "kind": "global", "name": "" },
+  ];
+  assert_exports(exports, expected);
+}, "exports with empty name: global");
+
 test(() => {
   const module = new WebAssembly.Module(emptyModuleBinary);
   const exports = WebAssembly.Module.exports(module, {});
diff --git a/test/js-api/module/imports.any.js b/test/js-api/module/imports.any.js
index d6754c9ef..ec550ce6c 100644
--- a/test/js-api/module/imports.any.js
+++ b/test/js-api/module/imports.any.js
@@ -118,6 +118,66 @@ test(() => {
   assert_imports(imports, expected);
 }, "imports");
 
+test(() => {
+  const builder = new WasmModuleBuilder();
+
+  builder.addImport("", "fn", kSig_v_v);
+  builder.addImportedGlobal("", "global", kWasmI32);
+  builder.addImportedMemory("", "memory", 0, 128);
+  builder.addImportedTable("", "table", 0, 128);
+
+  const buffer = builder.toBuffer()
+  const module = new WebAssembly.Module(buffer);
+  const imports = WebAssembly.Module.imports(module);
+  const expected = [
+    { "module": "", "kind": "function", "name": "fn" },
+    { "module": "", "kind": "global", "name": "global" },
+    { "module": "", "kind": "memory", "name": "memory" },
+    { "module": "", "kind": "table", "name": "table" },
+  ];
+  assert_imports(imports, expected);
+}, "imports with empty module name");
+
+test(() => {
+  const builder = new WasmModuleBuilder();
+
+  builder.addImport("a", "", kSig_v_v);
+  builder.addImportedGlobal("b", "", kWasmI32);
+  builder.addImportedMemory("c", "", 0, 128);
+  builder.addImportedTable("d", "", 0, 128);
+
+  const buffer = builder.toBuffer()
+  const module = new WebAssembly.Module(buffer);
+  const imports = WebAssembly.Module.imports(module);
+  const expected = [
+    { "module": "a", "kind": "function", "name": "" },
+    { "module": "b", "kind": "global", "name": "" },
+    { "module": "c", "kind": "memory", "name": "" },
+    { "module": "d", "kind": "table", "name": "" },
+  ];
+  assert_imports(imports, expected);
+}, "imports with empty names");
+
+test(() => {
+  const builder = new WasmModuleBuilder();
+
+  builder.addImport("", "", kSig_v_v);
+  builder.addImportedGlobal("", "", kWasmI32);
+  builder.addImportedMemory("", "", 0, 128);
+  builder.addImportedTable("", "", 0, 128);
+
+  const buffer = builder.toBuffer()
+  const module = new WebAssembly.Module(buffer);
+  const imports = WebAssembly.Module.imports(module);
+  const expected = [
+    { "module": "", "kind": "function", "name": "" },
+    { "module": "", "kind": "global", "name": "" },
+    { "module": "", "kind": "memory", "name": "" },
+    { "module": "", "kind": "table", "name": "" },
+  ];
+  assert_imports(imports, expected);
+}, "imports with empty module names and names");
+
 test(() => {
   const module = new WebAssembly.Module(emptyModuleBinary);
   const imports = WebAssembly.Module.imports(module, {});
diff --git a/test/js-api/table/assertions.js b/test/js-api/table/assertions.js
index b1aeaf1a6..19cc5c3b9 100644
--- a/test/js-api/table/assertions.js
+++ b/test/js-api/table/assertions.js
@@ -11,3 +11,14 @@ function assert_equal_to_array(table, expected, message) {
   assert_throws_js(RangeError, () => table.get(expected.length + 1),
                    `${message}: table.get(${expected.length + 1} of ${expected.length})`);
 }
+
+function assert_Table(actual, expected) {
+  assert_equals(Object.getPrototypeOf(actual), WebAssembly.Table.prototype,
+                "prototype");
+  assert_true(Object.isExtensible(actual), "extensible");
+
+  assert_equals(actual.length, expected.length, "length");
+  for (let i = 0; i < expected.length; ++i) {
+    assert_equals(actual.get(i), null, `actual.get(${i})`);
+  }
+}
diff --git a/test/js-api/table/constructor.any.js b/test/js-api/table/constructor.any.js
index e9e77a132..6acb4fc9d 100644
--- a/test/js-api/table/constructor.any.js
+++ b/test/js-api/table/constructor.any.js
@@ -1,16 +1,6 @@
 // META: global=window,dedicatedworker,jsshell
 // META: script=/wasm/jsapi/assertions.js
-
-function assert_Table(actual, expected) {
-  assert_equals(Object.getPrototypeOf(actual), WebAssembly.Table.prototype,
-                "prototype");
-  assert_true(Object.isExtensible(actual), "extensible");
-
-  assert_equals(actual.length, expected.length, "length");
-  for (let i = 0; i < expected.length; ++i) {
-    assert_equals(actual.get(i), null, `actual.get(${i})`);
-  }
-}
+// META: script=/wasm/jsapi/table/assertions.js
 
 test(() => {
   assert_function_name(WebAssembly.Table, "Table", "WebAssembly.Table");
@@ -177,3 +167,41 @@ test(() => {
     "maximum valueOf",
   ]);
 }, "Order of evaluation for descriptor");
+
+test(() => {
+  const testObject = {};
+  const argument = { "element": "externref", "initial": 3 };
+  const table = new WebAssembly.Table(argument, testObject);
+  assert_equals(table.length, 3);
+  assert_equals(table.get(0), testObject);
+  assert_equals(table.get(1), testObject);
+  assert_equals(table.get(2), testObject);
+}, "initialize externref table with default value");
+
+test(() => {
+  const argument = { "element": "i32", "initial": 3 };
+  assert_throws_js(TypeError, () => new WebAssembly.Table(argument));
+}, "initialize table with a wrong element value");
+
+test(() => {
+  const builder = new WasmModuleBuilder();
+  builder
+    .addFunction("fn", kSig_v_v)
+    .addBody([])
+    .exportFunc();
+  const bin = builder.toBuffer();
+  const fn = new WebAssembly.Instance(new WebAssembly.Module(bin)).exports.fn;
+  const argument = { "element": "anyfunc", "initial": 3 };
+  const table = new WebAssembly.Table(argument, fn);
+  assert_equals(table.length, 3);
+  assert_equals(table.get(0), fn);
+  assert_equals(table.get(1), fn);
+  assert_equals(table.get(2), fn);
+}, "initialize anyfunc table with default value");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 3 };
+  assert_throws_js(TypeError, () => new WebAssembly.Table(argument, {}));
+  assert_throws_js(TypeError, () => new WebAssembly.Table(argument, "cannot be used as a wasm function"));
+  assert_throws_js(TypeError, () => new WebAssembly.Table(argument, 37));
+}, "initialize anyfunc table with a bad default value");
diff --git a/test/js-api/table/get-set.any.js b/test/js-api/table/get-set.any.js
index a1586ef83..9301057a5 100644
--- a/test/js-api/table/get-set.any.js
+++ b/test/js-api/table/get-set.any.js
@@ -222,3 +222,42 @@ test(() => {
   assert_equals(table.get(0, {}), null);
   assert_equals(table.set(0, fn, {}), undefined);
 }, "Stray argument");
+
+test(() => {
+  const builder = new WasmModuleBuilder();
+  builder
+    .addFunction("fn", kSig_v_v)
+    .addBody([])
+    .exportFunc();
+  const bin = builder.toBuffer();
+  const fn = new WebAssembly.Instance(new WebAssembly.Module(bin)).exports.fn;
+
+  const argument = { "element": "anyfunc", "initial": 1 };
+  const table = new WebAssembly.Table(argument, fn);
+
+  assert_equals(table.get(0), fn);
+  table.set(0);
+  assert_equals(table.get(0), null);
+
+  table.set(0, fn);
+  assert_equals(table.get(0), fn);
+
+  assert_throws_js(TypeError, () => table.set(0, {}));
+  assert_throws_js(TypeError, () => table.set(0, 37));
+}, "Arguments for anyfunc table set");
+
+test(() => {
+  const testObject = {};
+  const argument = { "element": "externref", "initial": 1 };
+  const table = new WebAssembly.Table(argument, testObject);
+
+  assert_equals(table.get(0), testObject);
+  table.set(0);
+  assert_equals(table.get(0), undefined);
+
+  table.set(0, testObject);
+  assert_equals(table.get(0), testObject);
+
+  table.set(0, 37);
+  assert_equals(table.get(0), 37);
+}, "Arguments for externref table set");
diff --git a/test/js-api/table/grow.any.js b/test/js-api/table/grow.any.js
index 3b2ee5fa8..a1b193873 100644
--- a/test/js-api/table/grow.any.js
+++ b/test/js-api/table/grow.any.js
@@ -94,3 +94,32 @@ test(() => {
   assert_equals(result, 5);
   assert_equal_to_array(table, nulls(8), "after");
 }, "Stray argument");
+
+test(() => {
+  const builder = new WasmModuleBuilder();
+  builder
+    .addFunction("fn", kSig_v_v)
+    .addBody([])
+    .exportFunc();
+  const bin = builder.toBuffer()
+  const argument = { "element": "anyfunc", "initial": 1 };
+  const table = new WebAssembly.Table(argument);
+  const fn = new WebAssembly.Instance(new WebAssembly.Module(bin)).exports.fn;
+  const result = table.grow(2, fn);
+  assert_equals(result, 1);
+  assert_equals(table.get(0), null);
+  assert_equals(table.get(1), fn);
+  assert_equals(table.get(2), fn);
+}, "Grow with exported-function argument");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 1 };
+  const table = new WebAssembly.Table(argument);
+  assert_throws_js(TypeError, () => table.grow(2, {}));
+}, "Grow with non-function argument");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 1 };
+  const table = new WebAssembly.Table(argument);
+  assert_throws_js(TypeError, () => table.grow(2, () => true));
+}, "Grow with JS-function argument");
diff --git a/test/js-api/wasm-module-builder.js b/test/js-api/wasm-module-builder.js
index 25fb1c836..7be72f86d 100644
--- a/test/js-api/wasm-module-builder.js
+++ b/test/js-api/wasm-module-builder.js
@@ -99,7 +99,6 @@ let kWasmF64 = 0x7c;
 let kWasmS128 = 0x7b;
 let kWasmAnyRef = 0x6f;
 let kWasmAnyFunc = 0x70;
-let kWasmExnRef = 0x68;
 
 let kExternalFunction = 0;
 let kExternalTable = 1;
@@ -149,17 +148,14 @@ let kSig_f_d = makeSig([kWasmF64], [kWasmF32]);
 let kSig_d_d = makeSig([kWasmF64], [kWasmF64]);
 let kSig_r_r = makeSig([kWasmAnyRef], [kWasmAnyRef]);
 let kSig_a_a = makeSig([kWasmAnyFunc], [kWasmAnyFunc]);
-let kSig_e_e = makeSig([kWasmExnRef], [kWasmExnRef]);
 let kSig_i_r = makeSig([kWasmAnyRef], [kWasmI32]);
 let kSig_v_r = makeSig([kWasmAnyRef], []);
 let kSig_v_a = makeSig([kWasmAnyFunc], []);
-let kSig_v_e = makeSig([kWasmExnRef], []);
 let kSig_v_rr = makeSig([kWasmAnyRef, kWasmAnyRef], []);
 let kSig_v_aa = makeSig([kWasmAnyFunc, kWasmAnyFunc], []);
 let kSig_r_v = makeSig([], [kWasmAnyRef]);
 let kSig_a_v = makeSig([], [kWasmAnyFunc]);
 let kSig_a_i = makeSig([kWasmI32], [kWasmAnyFunc]);
-let kSig_e_v = makeSig([], [kWasmExnRef]);
 
 function makeSig(params, results) {
   return {params: params, results: results};
@@ -194,6 +190,7 @@ let kExprIf = 0x04;
 let kExprElse = 0x05;
 let kExprTry = 0x06;
 let kExprCatch = 0x07;
+let kExprCatchAll = 0x19;
 let kExprThrow = 0x08;
 let kExprRethrow = 0x09;
 let kExprBrOnExn = 0x0a;
@@ -746,9 +743,8 @@ class WasmModuleBuilder {
   }
 
   addTable(type, initial_size, max_size = undefined) {
-    if (type != kWasmAnyRef && type != kWasmAnyFunc && type != kWasmExnRef) {
-      throw new Error(
-          'Tables must be of type kWasmAnyRef, kWasmAnyFunc, or kWasmExnRef');
+    if (type != kWasmAnyRef && type != kWasmAnyFunc) {
+      throw new Error('Tables must be of type kWasmAnyRef or kWasmAnyFunc');
     }
     let table = new WasmTableBuilder(this, type, initial_size, max_size);
     table.index = this.tables.length + this.num_imported_tables;
@@ -1029,9 +1025,6 @@ class WasmModuleBuilder {
                 section.emit_u8(kExprRefNull);
               }
               break;
-            case kWasmExnRef:
-              section.emit_u8(kExprRefNull);
-              break;
             }
           } else {
             // Emit a global-index initializer.
@@ -1173,9 +1166,6 @@ class WasmModuleBuilder {
             if (l.anyfunc_count > 0) {
               local_decls.push({count: l.anyfunc_count, type: kWasmAnyFunc});
             }
-            if (l.except_count > 0) {
-              local_decls.push({count: l.except_count, type: kWasmExnRef});
-            }
           }
 
           header.emit_u32v(local_decls.length);

From 6a2b3b2f55db725cd863853944aeb63cb9d4b9da Mon Sep 17 00:00:00 2001
From: gahaas <ahaas@google.com>
Date: Thu, 16 Sep 2021 15:37:41 +0200
Subject: [PATCH 040/285] Add missing import to test

---
 test/js-api/table/constructor.any.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/js-api/table/constructor.any.js b/test/js-api/table/constructor.any.js
index 6acb4fc9d..cf501fbc2 100644
--- a/test/js-api/table/constructor.any.js
+++ b/test/js-api/table/constructor.any.js
@@ -1,4 +1,5 @@
 // META: global=window,dedicatedworker,jsshell
+// META: script=/wasm/jsapi/wasm-module-builder.js
 // META: script=/wasm/jsapi/assertions.js
 // META: script=/wasm/jsapi/table/assertions.js
 

From f528da2ef9dc70e4e26e86bf9f5fded929856ed1 Mon Sep 17 00:00:00 2001
From: gahaas <ahaas@google.com>
Date: Thu, 16 Sep 2021 15:39:50 +0200
Subject: [PATCH 041/285] Add missing import to test [2]

---
 test/js-api/table/grow.any.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/js-api/table/grow.any.js b/test/js-api/table/grow.any.js
index a1b193873..520d24bf4 100644
--- a/test/js-api/table/grow.any.js
+++ b/test/js-api/table/grow.any.js
@@ -1,4 +1,5 @@
 // META: global=window,dedicatedworker,jsshell
+// META: script=/wasm/jsapi/wasm-module-builder.js
 // META: script=assertions.js
 
 function nulls(n) {

From b7065d8f6a37f1f93adf18ce08531a050088beca Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@dfinity.org>
Date: Fri, 17 Sep 2021 16:36:37 +0200
Subject: [PATCH 042/285] [spec] New instructions (#52)

---
 .../core/appendix/gen-index-instructions.py   |  12 +-
 document/core/appendix/index-instructions.rst | 548 +++++++++---------
 document/core/binary/instructions.rst         |  12 +-
 document/core/exec/instructions.rst           | 125 +++-
 document/core/syntax/instructions.rst         |  14 +-
 document/core/text/instructions.rst           |  12 +-
 document/core/util/macros.def                 |  14 +-
 document/core/valid/instructions.rst          | 120 +++-
 document/core/valid/types.rst                 |  80 +--
 9 files changed, 569 insertions(+), 368 deletions(-)

diff --git a/document/core/appendix/gen-index-instructions.py b/document/core/appendix/gen-index-instructions.py
index 6191a07b8..f366ae480 100755
--- a/document/core/appendix/gen-index-instructions.py
+++ b/document/core/appendix/gen-index-instructions.py
@@ -81,7 +81,7 @@ def Instruction(name, opcode, type=None, validation=None, execution=None, operat
     Instruction(r'\CALLINDIRECT~x~y', r'\hex{11}', r'[t_1^\ast~\I32] \to [t_2^\ast]', r'valid-call_indirect', r'exec-call_indirect'),
     Instruction(None, r'\hex{12}'),
     Instruction(None, r'\hex{13}'),
-    Instruction(None, r'\hex{14}'),
+    Instruction(r'\CALLREF', r'\hex{14}', r'[t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]', r'valid-call_ref', r'exec-call_ref'),
     Instruction(None, r'\hex{15}'),
     Instruction(None, r'\hex{16}'),
     Instruction(None, r'\hex{17}'),
@@ -269,13 +269,13 @@ def Instruction(name, opcode, type=None, validation=None, execution=None, operat
     Instruction(None, r'\hex{CD}'),
     Instruction(None, r'\hex{CE}'),
     Instruction(None, r'\hex{CF}'),
-    Instruction(r'\REFNULL~t', r'\hex{D0}', r'[] \to [t]', r'valid-ref.null', r'exec-ref.null'),
-    Instruction(r'\REFISNULL', r'\hex{D1}', r'[t] \to [\I32]', r'valid-ref.is_null', r'exec-ref.is_null'),
+    Instruction(r'\REFNULL~\X{ht}', r'\hex{D0}', r'[] \to [(\REF~\NULL~\X{ht})]', r'valid-ref.null', r'exec-ref.null'),
+    Instruction(r'\REFISNULL', r'\hex{D1}', r'[(\REF~\NULL~\X{ht})] \to [\I32]', r'valid-ref.is_null', r'exec-ref.is_null'),
     Instruction(r'\REFFUNC~x', r'\hex{D2}', r'[] \to [\FUNCREF]', r'valid-ref.func', r'exec-ref.func'),
-    Instruction(None, r'\hex{D3}'),
-    Instruction(None, r'\hex{D4}'),
+    Instruction(r'\REFASNONNULL', r'\hex{D3}', r'[(\REF~\NULL~\X{ht})] \to [(\REF~\X{ht})]', r'valid-ref.as_non_null', r'exec-ref.as_non_null'),
+    Instruction(r'\BRONNULL~l', r'\hex{D4}', r'[t^\ast~(\REF~\NULL~\X{ht})] \to [t^\ast~(\REF~\X{ht})]', r'valid-br_on_null', r'exec-br_on_null'),
     Instruction(None, r'\hex{D5}'),
-    Instruction(None, r'\hex{D6}'),
+    Instruction(r'\BRONNONNULL~l', r'\hex{D6}', r'[t^\ast~(\REF~\NULL~\X{ht})] \to [t^\ast]', r'valid-br_on_non_null', r'exec-br_on_non_null'),
     Instruction(None, r'\hex{D7}'),
     Instruction(None, r'\hex{D8}'),
     Instruction(None, r'\hex{D9}'),
diff --git a/document/core/appendix/index-instructions.rst b/document/core/appendix/index-instructions.rst
index 55bf8fb98..545638b6b 100644
--- a/document/core/appendix/index-instructions.rst
+++ b/document/core/appendix/index-instructions.rst
@@ -6,277 +6,277 @@
 Index of Instructions
 ---------------------
 
-=========================================  =========================  =============================================  =======================================  ===============================================================
-Instruction                                Binary Opcode              Type                                           Validation                               Execution                                                      
-=========================================  =========================  =============================================  =======================================  ===============================================================
-:math:`\UNREACHABLE`                       :math:`\hex{00}`           :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-unreachable>`    :ref:`execution <exec-unreachable>`                            
-:math:`\NOP`                               :math:`\hex{01}`           :math:`[] \to []`                              :ref:`validation <valid-nop>`            :ref:`execution <exec-nop>`                                    
-:math:`\BLOCK~\X{bt}`                      :math:`\hex{02}`           :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-block>`          :ref:`execution <exec-block>`                                  
-:math:`\LOOP~\X{bt}`                       :math:`\hex{03}`           :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-loop>`           :ref:`execution <exec-loop>`                                   
-:math:`\IF~\X{bt}`                         :math:`\hex{04}`           :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-if>`             :ref:`execution <exec-if>`                                     
-:math:`\ELSE`                              :math:`\hex{05}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{06}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{07}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{08}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{09}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{0A}`                                                                                                                                                                  
-:math:`\END`                               :math:`\hex{0B}`                                                                                                                                                                  
-:math:`\BR~l`                              :math:`\hex{0C}`           :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`       :ref:`validation <valid-br>`             :ref:`execution <exec-br>`                                     
-:math:`\BRIF~l`                            :math:`\hex{0D}`           :math:`[t^\ast~\I32] \to [t^\ast]`             :ref:`validation <valid-br_if>`          :ref:`execution <exec-br_if>`                                  
-:math:`\BRTABLE~l^\ast~l`                  :math:`\hex{0E}`           :math:`[t_1^\ast~t^\ast~\I32] \to [t_2^\ast]`  :ref:`validation <valid-br_table>`       :ref:`execution <exec-br_table>`                               
-:math:`\RETURN`                            :math:`\hex{0F}`           :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`       :ref:`validation <valid-return>`         :ref:`execution <exec-return>`                                 
-:math:`\CALL~x`                            :math:`\hex{10}`           :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-call>`           :ref:`execution <exec-call>`                                   
-:math:`\CALLINDIRECT~x~y`                  :math:`\hex{11}`           :math:`[t_1^\ast~\I32] \to [t_2^\ast]`         :ref:`validation <valid-call_indirect>`  :ref:`execution <exec-call_indirect>`                          
-(reserved)                                 :math:`\hex{12}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{13}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{14}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{15}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{16}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{17}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{18}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{19}`                                                                                                                                                                  
-:math:`\DROP`                              :math:`\hex{1A}`           :math:`[t] \to []`                             :ref:`validation <valid-drop>`           :ref:`execution <exec-drop>`                                   
-:math:`\SELECT`                            :math:`\hex{1B}`           :math:`[t~t~\I32] \to [t]`                     :ref:`validation <valid-select>`         :ref:`execution <exec-select>`                                 
-:math:`\SELECT~t`                          :math:`\hex{1C}`           :math:`[t~t~\I32] \to [t]`                     :ref:`validation <valid-select>`         :ref:`execution <exec-select>`                                 
-(reserved)                                 :math:`\hex{1D}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{1E}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{1F}`                                                                                                                                                                  
-:math:`\LOCALGET~x`                        :math:`\hex{20}`           :math:`[] \to [t]`                             :ref:`validation <valid-local.get>`      :ref:`execution <exec-local.get>`                              
-:math:`\LOCALSET~x`                        :math:`\hex{21}`           :math:`[t] \to []`                             :ref:`validation <valid-local.set>`      :ref:`execution <exec-local.set>`                              
-:math:`\LOCALTEE~x`                        :math:`\hex{22}`           :math:`[t] \to [t]`                            :ref:`validation <valid-local.tee>`      :ref:`execution <exec-local.tee>`                              
-:math:`\GLOBALGET~x`                       :math:`\hex{23}`           :math:`[] \to [t]`                             :ref:`validation <valid-global.get>`     :ref:`execution <exec-global.get>`                             
-:math:`\GLOBALSET~x`                       :math:`\hex{24}`           :math:`[t] \to []`                             :ref:`validation <valid-global.set>`     :ref:`execution <exec-global.set>`                             
-:math:`\TABLEGET~x`                        :math:`\hex{25}`           :math:`[\I32] \to [t]`                         :ref:`validation <valid-table.get>`      :ref:`execution <exec-table.get>`                              
-:math:`\TABLESET~x`                        :math:`\hex{26}`           :math:`[\I32~t] \to []`                        :ref:`validation <valid-table.set>`      :ref:`execution <exec-table.set>`                              
-(reserved)                                 :math:`\hex{27}`                                                                                                                                                                  
-:math:`\I32.\LOAD~\memarg`                 :math:`\hex{28}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-load>`           :ref:`execution <exec-load>`                                   
-:math:`\I64.\LOAD~\memarg`                 :math:`\hex{29}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-load>`           :ref:`execution <exec-load>`                                   
-:math:`\F32.\LOAD~\memarg`                 :math:`\hex{2A}`           :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-load>`           :ref:`execution <exec-load>`                                   
-:math:`\F64.\LOAD~\memarg`                 :math:`\hex{2B}`           :math:`[\I32] \to [\F64]`                      :ref:`validation <valid-load>`           :ref:`execution <exec-load>`                                   
-:math:`\I32.\LOAD\K{8\_s}~\memarg`         :math:`\hex{2C}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I32.\LOAD\K{8\_u}~\memarg`         :math:`\hex{2D}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I32.\LOAD\K{16\_s}~\memarg`        :math:`\hex{2E}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I32.\LOAD\K{16\_u}~\memarg`        :math:`\hex{2F}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{8\_s}~\memarg`         :math:`\hex{30}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{8\_u}~\memarg`         :math:`\hex{31}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{16\_s}~\memarg`        :math:`\hex{32}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{16\_u}~\memarg`        :math:`\hex{33}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{32\_s}~\memarg`        :math:`\hex{34}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{32\_u}~\memarg`        :math:`\hex{35}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I32.\STORE~\memarg`                :math:`\hex{36}`           :math:`[\I32~\I32] \to []`                     :ref:`validation <valid-store>`          :ref:`execution <exec-store>`                                  
-:math:`\I64.\STORE~\memarg`                :math:`\hex{37}`           :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-store>`          :ref:`execution <exec-store>`                                  
-:math:`\F32.\STORE~\memarg`                :math:`\hex{38}`           :math:`[\I32~\F32] \to []`                     :ref:`validation <valid-store>`          :ref:`execution <exec-store>`                                  
-:math:`\F64.\STORE~\memarg`                :math:`\hex{39}`           :math:`[\I32~\F64] \to []`                     :ref:`validation <valid-store>`          :ref:`execution <exec-store>`                                  
-:math:`\I32.\STORE\K{8}~\memarg`           :math:`\hex{3A}`           :math:`[\I32~\I32] \to []`                     :ref:`validation <valid-storen>`         :ref:`execution <exec-storen>`                                 
-:math:`\I32.\STORE\K{16}~\memarg`          :math:`\hex{3B}`           :math:`[\I32~\I32] \to []`                     :ref:`validation <valid-storen>`         :ref:`execution <exec-storen>`                                 
-:math:`\I64.\STORE\K{8}~\memarg`           :math:`\hex{3C}`           :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-storen>`         :ref:`execution <exec-storen>`                                 
-:math:`\I64.\STORE\K{16}~\memarg`          :math:`\hex{3D}`           :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-storen>`         :ref:`execution <exec-storen>`                                 
-:math:`\I64.\STORE\K{32}~\memarg`          :math:`\hex{3E}`           :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-storen>`         :ref:`execution <exec-storen>`                                 
-:math:`\MEMORYSIZE`                        :math:`\hex{3F}`           :math:`[] \to [\I32]`                          :ref:`validation <valid-memory.size>`    :ref:`execution <exec-memory.size>`                            
-:math:`\MEMORYGROW`                        :math:`\hex{40}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-memory.grow>`    :ref:`execution <exec-memory.grow>`                            
-:math:`\I32.\CONST~\i32`                   :math:`\hex{41}`           :math:`[] \to [\I32]`                          :ref:`validation <valid-const>`          :ref:`execution <exec-const>`                                  
-:math:`\I64.\CONST~\i64`                   :math:`\hex{42}`           :math:`[] \to [\I64]`                          :ref:`validation <valid-const>`          :ref:`execution <exec-const>`                                  
-:math:`\F32.\CONST~\f32`                   :math:`\hex{43}`           :math:`[] \to [\F32]`                          :ref:`validation <valid-const>`          :ref:`execution <exec-const>`                                  
-:math:`\F64.\CONST~\f64`                   :math:`\hex{44}`           :math:`[] \to [\F64]`                          :ref:`validation <valid-const>`          :ref:`execution <exec-const>`                                  
-:math:`\I32.\EQZ`                          :math:`\hex{45}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-testop>`         :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`      
-:math:`\I32.\EQ`                           :math:`\hex{46}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`        
-:math:`\I32.\NE`                           :math:`\hex{47}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`        
-:math:`\I32.\LT\K{\_s}`                    :math:`\hex{48}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`      
-:math:`\I32.\LT\K{\_u}`                    :math:`\hex{49}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`      
-:math:`\I32.\GT\K{\_s}`                    :math:`\hex{4A}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`      
-:math:`\I32.\GT\K{\_u}`                    :math:`\hex{4B}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`      
-:math:`\I32.\LE\K{\_s}`                    :math:`\hex{4C}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`      
-:math:`\I32.\LE\K{\_u}`                    :math:`\hex{4D}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`      
-:math:`\I32.\GE\K{\_s}`                    :math:`\hex{4E}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`      
-:math:`\I32.\GE\K{\_u}`                    :math:`\hex{4F}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`      
-:math:`\I64.\EQZ`                          :math:`\hex{50}`           :math:`[\I64] \to [\I32]`                      :ref:`validation <valid-testop>`         :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`      
-:math:`\I64.\EQ`                           :math:`\hex{51}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`        
-:math:`\I64.\NE`                           :math:`\hex{52}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`        
-:math:`\I64.\LT\K{\_s}`                    :math:`\hex{53}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`      
-:math:`\I64.\LT\K{\_u}`                    :math:`\hex{54}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`      
-:math:`\I64.\GT\K{\_s}`                    :math:`\hex{55}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`      
-:math:`\I64.\GT\K{\_u}`                    :math:`\hex{56}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`      
-:math:`\I64.\LE\K{\_s}`                    :math:`\hex{57}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`      
-:math:`\I64.\LE\K{\_u}`                    :math:`\hex{58}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`      
-:math:`\I64.\GE\K{\_s}`                    :math:`\hex{59}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`      
-:math:`\I64.\GE\K{\_u}`                    :math:`\hex{5A}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`      
-:math:`\F32.\EQ`                           :math:`\hex{5B}`           :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`        
-:math:`\F32.\NE`                           :math:`\hex{5C}`           :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`        
-:math:`\F32.\LT`                           :math:`\hex{5D}`           :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`        
-:math:`\F32.\GT`                           :math:`\hex{5E}`           :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`        
-:math:`\F32.\LE`                           :math:`\hex{5F}`           :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`        
-:math:`\F32.\GE`                           :math:`\hex{60}`           :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`        
-:math:`\F64.\EQ`                           :math:`\hex{61}`           :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`        
-:math:`\F64.\NE`                           :math:`\hex{62}`           :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`        
-:math:`\F64.\LT`                           :math:`\hex{63}`           :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`        
-:math:`\F64.\GT`                           :math:`\hex{64}`           :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`        
-:math:`\F64.\LE`                           :math:`\hex{65}`           :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`        
-:math:`\F64.\GE`                           :math:`\hex{66}`           :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`        
-:math:`\I32.\CLZ`                          :math:`\hex{67}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`        
-:math:`\I32.\CTZ`                          :math:`\hex{68}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`        
-:math:`\I32.\POPCNT`                       :math:`\hex{69}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`     
-:math:`\I32.\ADD`                          :math:`\hex{6A}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`       
-:math:`\I32.\SUB`                          :math:`\hex{6B}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`       
-:math:`\I32.\MUL`                          :math:`\hex{6C}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`       
-:math:`\I32.\DIV\K{\_s}`                   :math:`\hex{6D}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`     
-:math:`\I32.\DIV\K{\_u}`                   :math:`\hex{6E}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`     
-:math:`\I32.\REM\K{\_s}`                   :math:`\hex{6F}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`     
-:math:`\I32.\REM\K{\_u}`                   :math:`\hex{70}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`     
-:math:`\I32.\AND`                          :math:`\hex{71}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`       
-:math:`\I32.\OR`                           :math:`\hex{72}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`        
-:math:`\I32.\XOR`                          :math:`\hex{73}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`       
-:math:`\I32.\SHL`                          :math:`\hex{74}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`       
-:math:`\I32.\SHR\K{\_s}`                   :math:`\hex{75}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`     
-:math:`\I32.\SHR\K{\_u}`                   :math:`\hex{76}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`     
-:math:`\I32.\ROTL`                         :math:`\hex{77}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`      
-:math:`\I32.\ROTR`                         :math:`\hex{78}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`      
-:math:`\I64.\CLZ`                          :math:`\hex{79}`           :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`        
-:math:`\I64.\CTZ`                          :math:`\hex{7A}`           :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`        
-:math:`\I64.\POPCNT`                       :math:`\hex{7B}`           :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`     
-:math:`\I64.\ADD`                          :math:`\hex{7C}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`       
-:math:`\I64.\SUB`                          :math:`\hex{7D}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`       
-:math:`\I64.\MUL`                          :math:`\hex{7E}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`       
-:math:`\I64.\DIV\K{\_s}`                   :math:`\hex{7F}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`     
-:math:`\I64.\DIV\K{\_u}`                   :math:`\hex{80}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`     
-:math:`\I64.\REM\K{\_s}`                   :math:`\hex{81}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`     
-:math:`\I64.\REM\K{\_u}`                   :math:`\hex{82}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`     
-:math:`\I64.\AND`                          :math:`\hex{83}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`       
-:math:`\I64.\OR`                           :math:`\hex{84}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`        
-:math:`\I64.\XOR`                          :math:`\hex{85}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`       
-:math:`\I64.\SHL`                          :math:`\hex{86}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`       
-:math:`\I64.\SHR\K{\_s}`                   :math:`\hex{87}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`     
-:math:`\I64.\SHR\K{\_u}`                   :math:`\hex{88}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`     
-:math:`\I64.\ROTL`                         :math:`\hex{89}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`      
-:math:`\I64.\ROTR`                         :math:`\hex{8A}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`      
-:math:`\F32.\ABS`                          :math:`\hex{8B}`           :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`        
-:math:`\F32.\NEG`                          :math:`\hex{8C}`           :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`        
-:math:`\F32.\CEIL`                         :math:`\hex{8D}`           :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`       
-:math:`\F32.\FLOOR`                        :math:`\hex{8E}`           :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`      
-:math:`\F32.\TRUNC`                        :math:`\hex{8F}`           :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`      
-:math:`\F32.\NEAREST`                      :math:`\hex{90}`           :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`    
-:math:`\F32.\SQRT`                         :math:`\hex{91}`           :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`       
-:math:`\F32.\ADD`                          :math:`\hex{92}`           :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`       
-:math:`\F32.\SUB`                          :math:`\hex{93}`           :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`       
-:math:`\F32.\MUL`                          :math:`\hex{94}`           :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`       
-:math:`\F32.\DIV`                          :math:`\hex{95}`           :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`       
-:math:`\F32.\FMIN`                         :math:`\hex{96}`           :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`       
-:math:`\F32.\FMAX`                         :math:`\hex{97}`           :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`       
-:math:`\F32.\COPYSIGN`                     :math:`\hex{98}`           :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`  
-:math:`\F64.\ABS`                          :math:`\hex{99}`           :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`        
-:math:`\F64.\NEG`                          :math:`\hex{9A}`           :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`        
-:math:`\F64.\CEIL`                         :math:`\hex{9B}`           :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`       
-:math:`\F64.\FLOOR`                        :math:`\hex{9C}`           :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`      
-:math:`\F64.\TRUNC`                        :math:`\hex{9D}`           :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`      
-:math:`\F64.\NEAREST`                      :math:`\hex{9E}`           :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`    
-:math:`\F64.\SQRT`                         :math:`\hex{9F}`           :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`       
-:math:`\F64.\ADD`                          :math:`\hex{A0}`           :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`       
-:math:`\F64.\SUB`                          :math:`\hex{A1}`           :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`       
-:math:`\F64.\MUL`                          :math:`\hex{A2}`           :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`       
-:math:`\F64.\DIV`                          :math:`\hex{A3}`           :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`       
-:math:`\F64.\FMIN`                         :math:`\hex{A4}`           :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`       
-:math:`\F64.\FMAX`                         :math:`\hex{A5}`           :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`       
-:math:`\F64.\COPYSIGN`                     :math:`\hex{A6}`           :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`  
-:math:`\I32.\WRAP\K{\_}\I64`               :math:`\hex{A7}`           :math:`[\I64] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-wrap>`       
-:math:`\I32.\TRUNC\K{\_}\F32\K{\_s}`       :math:`\hex{A8}`           :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
-:math:`\I32.\TRUNC\K{\_}\F32\K{\_u}`       :math:`\hex{A9}`           :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
-:math:`\I32.\TRUNC\K{\_}\F64\K{\_s}`       :math:`\hex{AA}`           :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
-:math:`\I32.\TRUNC\K{\_}\F64\K{\_u}`       :math:`\hex{AB}`           :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
-:math:`\I64.\EXTEND\K{\_}\I32\K{\_s}`      :math:`\hex{AC}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_s>`   
-:math:`\I64.\EXTEND\K{\_}\I32\K{\_u}`      :math:`\hex{AD}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_u>`   
-:math:`\I64.\TRUNC\K{\_}\F32\K{\_s}`       :math:`\hex{AE}`           :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
-:math:`\I64.\TRUNC\K{\_}\F32\K{\_u}`       :math:`\hex{AF}`           :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
-:math:`\I64.\TRUNC\K{\_}\F64\K{\_s}`       :math:`\hex{B0}`           :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
-:math:`\I64.\TRUNC\K{\_}\F64\K{\_u}`       :math:`\hex{B1}`           :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
-:math:`\F32.\CONVERT\K{\_}\I32\K{\_s}`     :math:`\hex{B2}`           :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
-:math:`\F32.\CONVERT\K{\_}\I32\K{\_u}`     :math:`\hex{B3}`           :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
-:math:`\F32.\CONVERT\K{\_}\I64\K{\_s}`     :math:`\hex{B4}`           :math:`[\I64] \to [\F32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
-:math:`\F32.\CONVERT\K{\_}\I64\K{\_u}`     :math:`\hex{B5}`           :math:`[\I64] \to [\F32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
-:math:`\F32.\DEMOTE\K{\_}\F64`             :math:`\hex{B6}`           :math:`[\F64] \to [\F32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-demote>`     
-:math:`\F64.\CONVERT\K{\_}\I32\K{\_s}`     :math:`\hex{B7}`           :math:`[\I32] \to [\F64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
-:math:`\F64.\CONVERT\K{\_}\I32\K{\_u}`     :math:`\hex{B8}`           :math:`[\I32] \to [\F64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
-:math:`\F64.\CONVERT\K{\_}\I64\K{\_s}`     :math:`\hex{B9}`           :math:`[\I64] \to [\F64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
-:math:`\F64.\CONVERT\K{\_}\I64\K{\_u}`     :math:`\hex{BA}`           :math:`[\I64] \to [\F64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
-:math:`\F64.\PROMOTE\K{\_}\F32`            :math:`\hex{BB}`           :math:`[\F32] \to [\F64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-promote>`    
-:math:`\I32.\REINTERPRET\K{\_}\F32`        :math:`\hex{BC}`           :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
-:math:`\I64.\REINTERPRET\K{\_}\F64`        :math:`\hex{BD}`           :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
-:math:`\F32.\REINTERPRET\K{\_}\I32`        :math:`\hex{BE}`           :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
-:math:`\F64.\REINTERPRET\K{\_}\I64`        :math:`\hex{BF}`           :math:`[\I64] \to [\F64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
-:math:`\I32.\EXTEND\K{8\_s}`               :math:`\hex{C0}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
-:math:`\I32.\EXTEND\K{16\_s}`              :math:`\hex{C1}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
-:math:`\I64.\EXTEND\K{8\_s}`               :math:`\hex{C2}`           :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
-:math:`\I64.\EXTEND\K{16\_s}`              :math:`\hex{C3}`           :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
-:math:`\I64.\EXTEND\K{32\_s}`              :math:`\hex{C4}`           :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
-(reserved)                                 :math:`\hex{C5}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{C6}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{C7}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{C8}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{C9}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{CA}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{CB}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{CC}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{CD}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{CE}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{CF}`                                                                                                                                                                  
-:math:`\REFNULL~t`                         :math:`\hex{D0}`           :math:`[] \to [t]`                             :ref:`validation <valid-ref.null>`       :ref:`execution <exec-ref.null>`                               
-:math:`\REFISNULL`                         :math:`\hex{D1}`           :math:`[t] \to [\I32]`                         :ref:`validation <valid-ref.is_null>`    :ref:`execution <exec-ref.is_null>`                            
-:math:`\REFFUNC~x`                         :math:`\hex{D2}`           :math:`[] \to [\FUNCREF]`                      :ref:`validation <valid-ref.func>`       :ref:`execution <exec-ref.func>`                               
-(reserved)                                 :math:`\hex{D3}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{D4}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{D5}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{D6}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{D7}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{D8}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{D9}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{DA}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{DB}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{DC}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{DD}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{DE}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{DF}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E0}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E1}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E2}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E3}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E4}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E5}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E6}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E7}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E8}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E9}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{EA}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{EB}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{EC}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{ED}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{EE}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{EF}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F0}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F1}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F2}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F3}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F4}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F5}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F6}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F7}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F8}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F9}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{FA}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{FB}`                                                                                                                                                                  
-:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_s}`  :math:`\hex{FC}~\hex{00}`  :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
-:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_u}`  :math:`\hex{FC}~\hex{01}`  :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
-:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_s}`  :math:`\hex{FC}~\hex{02}`  :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
-:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_u}`  :math:`\hex{FC}~\hex{03}`  :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
-:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_s}`  :math:`\hex{FC}~\hex{04}`  :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
-:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_u}`  :math:`\hex{FC}~\hex{05}`  :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
-:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_s}`  :math:`\hex{FC}~\hex{06}`  :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
-:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_u}`  :math:`\hex{FC}~\hex{07}`  :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
-:math:`\MEMORYINIT~x`                      :math:`\hex{FC}~\hex{08}`  :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-memory.init>`    :ref:`execution <exec-memory.init>`                            
-:math:`\DATADROP~x`                        :math:`\hex{FC}~\hex{09}`  :math:`[] \to []`                              :ref:`validation <valid-data.drop>`      :ref:`execution <exec-data.drop>`                              
-:math:`\MEMORYCOPY`                        :math:`\hex{FC}~\hex{0A}`  :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-memory.copy>`    :ref:`execution <exec-memory.copy>`                            
-:math:`\MEMORYFILL`                        :math:`\hex{FC}~\hex{0B}`  :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-memory.fill>`    :ref:`execution <exec-memory.fill>`                            
-:math:`\TABLEINIT~x~y`                     :math:`\hex{FC}~\hex{0C}`  :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-table.init>`     :ref:`execution <exec-table.init>`                             
-:math:`\ELEMDROP~x`                        :math:`\hex{FC}~\hex{0D}`  :math:`[] \to []`                              :ref:`validation <valid-elem.drop>`      :ref:`execution <exec-elem.drop>`                              
-:math:`\TABLECOPY~x~y`                     :math:`\hex{FC}~\hex{0E}`  :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-table.copy>`     :ref:`execution <exec-table.copy>`                             
-:math:`\TABLEGROW~x`                       :math:`\hex{FC}~\hex{0F}`  :math:`[t~\I32] \to []`                        :ref:`validation <valid-table.grow>`     :ref:`execution <exec-table.grow>`                             
-:math:`\TABLESIZE~x`                       :math:`\hex{FC}~\hex{10}`  :math:`[] \to [\I32]`                          :ref:`validation <valid-table.size>`     :ref:`execution <exec-table.size>`                             
-:math:`\TABLEFILL~x`                       :math:`\hex{FC}~\hex{11}`  :math:`[\I32~t~\I32] \to []`                   :ref:`validation <valid-table.fill>`     :ref:`execution <exec-table.fill>`                             
-=========================================  =========================  =============================================  =======================================  ===============================================================
+=========================================  =========================  ===============================================================  =========================================  ===============================================================
+Instruction                                Binary Opcode              Type                                                             Validation                                 Execution                                                      
+=========================================  =========================  ===============================================================  =========================================  ===============================================================
+:math:`\UNREACHABLE`                       :math:`\hex{00}`           :math:`[t_1^\ast] \to [t_2^\ast]`                                :ref:`validation <valid-unreachable>`      :ref:`execution <exec-unreachable>`                            
+:math:`\NOP`                               :math:`\hex{01}`           :math:`[] \to []`                                                :ref:`validation <valid-nop>`              :ref:`execution <exec-nop>`                                    
+:math:`\BLOCK~\X{bt}`                      :math:`\hex{02}`           :math:`[t_1^\ast] \to [t_2^\ast]`                                :ref:`validation <valid-block>`            :ref:`execution <exec-block>`                                  
+:math:`\LOOP~\X{bt}`                       :math:`\hex{03}`           :math:`[t_1^\ast] \to [t_2^\ast]`                                :ref:`validation <valid-loop>`             :ref:`execution <exec-loop>`                                   
+:math:`\IF~\X{bt}`                         :math:`\hex{04}`           :math:`[t_1^\ast] \to [t_2^\ast]`                                :ref:`validation <valid-if>`               :ref:`execution <exec-if>`                                     
+:math:`\ELSE`                              :math:`\hex{05}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{06}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{07}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{08}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{09}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{0A}`                                                                                                                                                                                      
+:math:`\END`                               :math:`\hex{0B}`                                                                                                                                                                                      
+:math:`\BR~l`                              :math:`\hex{0C}`           :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`                         :ref:`validation <valid-br>`               :ref:`execution <exec-br>`                                     
+:math:`\BRIF~l`                            :math:`\hex{0D}`           :math:`[t^\ast~\I32] \to [t^\ast]`                               :ref:`validation <valid-br_if>`            :ref:`execution <exec-br_if>`                                  
+:math:`\BRTABLE~l^\ast~l`                  :math:`\hex{0E}`           :math:`[t_1^\ast~t^\ast~\I32] \to [t_2^\ast]`                    :ref:`validation <valid-br_table>`         :ref:`execution <exec-br_table>`                               
+:math:`\RETURN`                            :math:`\hex{0F}`           :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`                         :ref:`validation <valid-return>`           :ref:`execution <exec-return>`                                 
+:math:`\CALL~x`                            :math:`\hex{10}`           :math:`[t_1^\ast] \to [t_2^\ast]`                                :ref:`validation <valid-call>`             :ref:`execution <exec-call>`                                   
+:math:`\CALLINDIRECT~x~y`                  :math:`\hex{11}`           :math:`[t_1^\ast~\I32] \to [t_2^\ast]`                           :ref:`validation <valid-call_indirect>`    :ref:`execution <exec-call_indirect>`                          
+(reserved)                                 :math:`\hex{12}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{13}`                                                                                                                                                                                      
+:math:`\CALLREF`                           :math:`\hex{14}`           :math:`[t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]`                 :ref:`validation <valid-call_ref>`         :ref:`execution <exec-call_ref>`                               
+(reserved)                                 :math:`\hex{15}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{16}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{17}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{18}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{19}`                                                                                                                                                                                      
+:math:`\DROP`                              :math:`\hex{1A}`           :math:`[t] \to []`                                               :ref:`validation <valid-drop>`             :ref:`execution <exec-drop>`                                   
+:math:`\SELECT`                            :math:`\hex{1B}`           :math:`[t~t~\I32] \to [t]`                                       :ref:`validation <valid-select>`           :ref:`execution <exec-select>`                                 
+:math:`\SELECT~t`                          :math:`\hex{1C}`           :math:`[t~t~\I32] \to [t]`                                       :ref:`validation <valid-select>`           :ref:`execution <exec-select>`                                 
+(reserved)                                 :math:`\hex{1D}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{1E}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{1F}`                                                                                                                                                                                      
+:math:`\LOCALGET~x`                        :math:`\hex{20}`           :math:`[] \to [t]`                                               :ref:`validation <valid-local.get>`        :ref:`execution <exec-local.get>`                              
+:math:`\LOCALSET~x`                        :math:`\hex{21}`           :math:`[t] \to []`                                               :ref:`validation <valid-local.set>`        :ref:`execution <exec-local.set>`                              
+:math:`\LOCALTEE~x`                        :math:`\hex{22}`           :math:`[t] \to [t]`                                              :ref:`validation <valid-local.tee>`        :ref:`execution <exec-local.tee>`                              
+:math:`\GLOBALGET~x`                       :math:`\hex{23}`           :math:`[] \to [t]`                                               :ref:`validation <valid-global.get>`       :ref:`execution <exec-global.get>`                             
+:math:`\GLOBALSET~x`                       :math:`\hex{24}`           :math:`[t] \to []`                                               :ref:`validation <valid-global.set>`       :ref:`execution <exec-global.set>`                             
+:math:`\TABLEGET~x`                        :math:`\hex{25}`           :math:`[\I32] \to [t]`                                           :ref:`validation <valid-table.get>`        :ref:`execution <exec-table.get>`                              
+:math:`\TABLESET~x`                        :math:`\hex{26}`           :math:`[\I32~t] \to []`                                          :ref:`validation <valid-table.set>`        :ref:`execution <exec-table.set>`                              
+(reserved)                                 :math:`\hex{27}`                                                                                                                                                                                      
+:math:`\I32.\LOAD~\memarg`                 :math:`\hex{28}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-load>`             :ref:`execution <exec-load>`                                   
+:math:`\I64.\LOAD~\memarg`                 :math:`\hex{29}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-load>`             :ref:`execution <exec-load>`                                   
+:math:`\F32.\LOAD~\memarg`                 :math:`\hex{2A}`           :math:`[\I32] \to [\F32]`                                        :ref:`validation <valid-load>`             :ref:`execution <exec-load>`                                   
+:math:`\F64.\LOAD~\memarg`                 :math:`\hex{2B}`           :math:`[\I32] \to [\F64]`                                        :ref:`validation <valid-load>`             :ref:`execution <exec-load>`                                   
+:math:`\I32.\LOAD\K{8\_s}~\memarg`         :math:`\hex{2C}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
+:math:`\I32.\LOAD\K{8\_u}~\memarg`         :math:`\hex{2D}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
+:math:`\I32.\LOAD\K{16\_s}~\memarg`        :math:`\hex{2E}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
+:math:`\I32.\LOAD\K{16\_u}~\memarg`        :math:`\hex{2F}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
+:math:`\I64.\LOAD\K{8\_s}~\memarg`         :math:`\hex{30}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
+:math:`\I64.\LOAD\K{8\_u}~\memarg`         :math:`\hex{31}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
+:math:`\I64.\LOAD\K{16\_s}~\memarg`        :math:`\hex{32}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
+:math:`\I64.\LOAD\K{16\_u}~\memarg`        :math:`\hex{33}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
+:math:`\I64.\LOAD\K{32\_s}~\memarg`        :math:`\hex{34}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
+:math:`\I64.\LOAD\K{32\_u}~\memarg`        :math:`\hex{35}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
+:math:`\I32.\STORE~\memarg`                :math:`\hex{36}`           :math:`[\I32~\I32] \to []`                                       :ref:`validation <valid-store>`            :ref:`execution <exec-store>`                                  
+:math:`\I64.\STORE~\memarg`                :math:`\hex{37}`           :math:`[\I32~\I64] \to []`                                       :ref:`validation <valid-store>`            :ref:`execution <exec-store>`                                  
+:math:`\F32.\STORE~\memarg`                :math:`\hex{38}`           :math:`[\I32~\F32] \to []`                                       :ref:`validation <valid-store>`            :ref:`execution <exec-store>`                                  
+:math:`\F64.\STORE~\memarg`                :math:`\hex{39}`           :math:`[\I32~\F64] \to []`                                       :ref:`validation <valid-store>`            :ref:`execution <exec-store>`                                  
+:math:`\I32.\STORE\K{8}~\memarg`           :math:`\hex{3A}`           :math:`[\I32~\I32] \to []`                                       :ref:`validation <valid-storen>`           :ref:`execution <exec-storen>`                                 
+:math:`\I32.\STORE\K{16}~\memarg`          :math:`\hex{3B}`           :math:`[\I32~\I32] \to []`                                       :ref:`validation <valid-storen>`           :ref:`execution <exec-storen>`                                 
+:math:`\I64.\STORE\K{8}~\memarg`           :math:`\hex{3C}`           :math:`[\I32~\I64] \to []`                                       :ref:`validation <valid-storen>`           :ref:`execution <exec-storen>`                                 
+:math:`\I64.\STORE\K{16}~\memarg`          :math:`\hex{3D}`           :math:`[\I32~\I64] \to []`                                       :ref:`validation <valid-storen>`           :ref:`execution <exec-storen>`                                 
+:math:`\I64.\STORE\K{32}~\memarg`          :math:`\hex{3E}`           :math:`[\I32~\I64] \to []`                                       :ref:`validation <valid-storen>`           :ref:`execution <exec-storen>`                                 
+:math:`\MEMORYSIZE`                        :math:`\hex{3F}`           :math:`[] \to [\I32]`                                            :ref:`validation <valid-memory.size>`      :ref:`execution <exec-memory.size>`                            
+:math:`\MEMORYGROW`                        :math:`\hex{40}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-memory.grow>`      :ref:`execution <exec-memory.grow>`                            
+:math:`\I32.\CONST~\i32`                   :math:`\hex{41}`           :math:`[] \to [\I32]`                                            :ref:`validation <valid-const>`            :ref:`execution <exec-const>`                                  
+:math:`\I64.\CONST~\i64`                   :math:`\hex{42}`           :math:`[] \to [\I64]`                                            :ref:`validation <valid-const>`            :ref:`execution <exec-const>`                                  
+:math:`\F32.\CONST~\f32`                   :math:`\hex{43}`           :math:`[] \to [\F32]`                                            :ref:`validation <valid-const>`            :ref:`execution <exec-const>`                                  
+:math:`\F64.\CONST~\f64`                   :math:`\hex{44}`           :math:`[] \to [\F64]`                                            :ref:`validation <valid-const>`            :ref:`execution <exec-const>`                                  
+:math:`\I32.\EQZ`                          :math:`\hex{45}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-testop>`           :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`      
+:math:`\I32.\EQ`                           :math:`\hex{46}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`        
+:math:`\I32.\NE`                           :math:`\hex{47}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`        
+:math:`\I32.\LT\K{\_s}`                    :math:`\hex{48}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`      
+:math:`\I32.\LT\K{\_u}`                    :math:`\hex{49}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`      
+:math:`\I32.\GT\K{\_s}`                    :math:`\hex{4A}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`      
+:math:`\I32.\GT\K{\_u}`                    :math:`\hex{4B}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`      
+:math:`\I32.\LE\K{\_s}`                    :math:`\hex{4C}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`      
+:math:`\I32.\LE\K{\_u}`                    :math:`\hex{4D}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`      
+:math:`\I32.\GE\K{\_s}`                    :math:`\hex{4E}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`      
+:math:`\I32.\GE\K{\_u}`                    :math:`\hex{4F}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`      
+:math:`\I64.\EQZ`                          :math:`\hex{50}`           :math:`[\I64] \to [\I32]`                                        :ref:`validation <valid-testop>`           :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`      
+:math:`\I64.\EQ`                           :math:`\hex{51}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`        
+:math:`\I64.\NE`                           :math:`\hex{52}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`        
+:math:`\I64.\LT\K{\_s}`                    :math:`\hex{53}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`      
+:math:`\I64.\LT\K{\_u}`                    :math:`\hex{54}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`      
+:math:`\I64.\GT\K{\_s}`                    :math:`\hex{55}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`      
+:math:`\I64.\GT\K{\_u}`                    :math:`\hex{56}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`      
+:math:`\I64.\LE\K{\_s}`                    :math:`\hex{57}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`      
+:math:`\I64.\LE\K{\_u}`                    :math:`\hex{58}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`      
+:math:`\I64.\GE\K{\_s}`                    :math:`\hex{59}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`      
+:math:`\I64.\GE\K{\_u}`                    :math:`\hex{5A}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`      
+:math:`\F32.\EQ`                           :math:`\hex{5B}`           :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`        
+:math:`\F32.\NE`                           :math:`\hex{5C}`           :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`        
+:math:`\F32.\LT`                           :math:`\hex{5D}`           :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`        
+:math:`\F32.\GT`                           :math:`\hex{5E}`           :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`        
+:math:`\F32.\LE`                           :math:`\hex{5F}`           :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`        
+:math:`\F32.\GE`                           :math:`\hex{60}`           :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`        
+:math:`\F64.\EQ`                           :math:`\hex{61}`           :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`        
+:math:`\F64.\NE`                           :math:`\hex{62}`           :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`        
+:math:`\F64.\LT`                           :math:`\hex{63}`           :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`        
+:math:`\F64.\GT`                           :math:`\hex{64}`           :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`        
+:math:`\F64.\LE`                           :math:`\hex{65}`           :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`        
+:math:`\F64.\GE`                           :math:`\hex{66}`           :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`        
+:math:`\I32.\CLZ`                          :math:`\hex{67}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`        
+:math:`\I32.\CTZ`                          :math:`\hex{68}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`        
+:math:`\I32.\POPCNT`                       :math:`\hex{69}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`     
+:math:`\I32.\ADD`                          :math:`\hex{6A}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`       
+:math:`\I32.\SUB`                          :math:`\hex{6B}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`       
+:math:`\I32.\MUL`                          :math:`\hex{6C}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`       
+:math:`\I32.\DIV\K{\_s}`                   :math:`\hex{6D}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`     
+:math:`\I32.\DIV\K{\_u}`                   :math:`\hex{6E}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`     
+:math:`\I32.\REM\K{\_s}`                   :math:`\hex{6F}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`     
+:math:`\I32.\REM\K{\_u}`                   :math:`\hex{70}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`     
+:math:`\I32.\AND`                          :math:`\hex{71}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`       
+:math:`\I32.\OR`                           :math:`\hex{72}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`        
+:math:`\I32.\XOR`                          :math:`\hex{73}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`       
+:math:`\I32.\SHL`                          :math:`\hex{74}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`       
+:math:`\I32.\SHR\K{\_s}`                   :math:`\hex{75}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`     
+:math:`\I32.\SHR\K{\_u}`                   :math:`\hex{76}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`     
+:math:`\I32.\ROTL`                         :math:`\hex{77}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`      
+:math:`\I32.\ROTR`                         :math:`\hex{78}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`      
+:math:`\I64.\CLZ`                          :math:`\hex{79}`           :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`        
+:math:`\I64.\CTZ`                          :math:`\hex{7A}`           :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`        
+:math:`\I64.\POPCNT`                       :math:`\hex{7B}`           :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`     
+:math:`\I64.\ADD`                          :math:`\hex{7C}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`       
+:math:`\I64.\SUB`                          :math:`\hex{7D}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`       
+:math:`\I64.\MUL`                          :math:`\hex{7E}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`       
+:math:`\I64.\DIV\K{\_s}`                   :math:`\hex{7F}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`     
+:math:`\I64.\DIV\K{\_u}`                   :math:`\hex{80}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`     
+:math:`\I64.\REM\K{\_s}`                   :math:`\hex{81}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`     
+:math:`\I64.\REM\K{\_u}`                   :math:`\hex{82}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`     
+:math:`\I64.\AND`                          :math:`\hex{83}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`       
+:math:`\I64.\OR`                           :math:`\hex{84}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`        
+:math:`\I64.\XOR`                          :math:`\hex{85}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`       
+:math:`\I64.\SHL`                          :math:`\hex{86}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`       
+:math:`\I64.\SHR\K{\_s}`                   :math:`\hex{87}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`     
+:math:`\I64.\SHR\K{\_u}`                   :math:`\hex{88}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`     
+:math:`\I64.\ROTL`                         :math:`\hex{89}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`      
+:math:`\I64.\ROTR`                         :math:`\hex{8A}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`      
+:math:`\F32.\ABS`                          :math:`\hex{8B}`           :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`        
+:math:`\F32.\NEG`                          :math:`\hex{8C}`           :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`        
+:math:`\F32.\CEIL`                         :math:`\hex{8D}`           :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`       
+:math:`\F32.\FLOOR`                        :math:`\hex{8E}`           :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`      
+:math:`\F32.\TRUNC`                        :math:`\hex{8F}`           :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`      
+:math:`\F32.\NEAREST`                      :math:`\hex{90}`           :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`    
+:math:`\F32.\SQRT`                         :math:`\hex{91}`           :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`       
+:math:`\F32.\ADD`                          :math:`\hex{92}`           :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`       
+:math:`\F32.\SUB`                          :math:`\hex{93}`           :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`       
+:math:`\F32.\MUL`                          :math:`\hex{94}`           :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`       
+:math:`\F32.\DIV`                          :math:`\hex{95}`           :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`       
+:math:`\F32.\FMIN`                         :math:`\hex{96}`           :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`       
+:math:`\F32.\FMAX`                         :math:`\hex{97}`           :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`       
+:math:`\F32.\COPYSIGN`                     :math:`\hex{98}`           :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`  
+:math:`\F64.\ABS`                          :math:`\hex{99}`           :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`        
+:math:`\F64.\NEG`                          :math:`\hex{9A}`           :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`        
+:math:`\F64.\CEIL`                         :math:`\hex{9B}`           :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`       
+:math:`\F64.\FLOOR`                        :math:`\hex{9C}`           :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`      
+:math:`\F64.\TRUNC`                        :math:`\hex{9D}`           :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`      
+:math:`\F64.\NEAREST`                      :math:`\hex{9E}`           :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`    
+:math:`\F64.\SQRT`                         :math:`\hex{9F}`           :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`       
+:math:`\F64.\ADD`                          :math:`\hex{A0}`           :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`       
+:math:`\F64.\SUB`                          :math:`\hex{A1}`           :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`       
+:math:`\F64.\MUL`                          :math:`\hex{A2}`           :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`       
+:math:`\F64.\DIV`                          :math:`\hex{A3}`           :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`       
+:math:`\F64.\FMIN`                         :math:`\hex{A4}`           :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`       
+:math:`\F64.\FMAX`                         :math:`\hex{A5}`           :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`       
+:math:`\F64.\COPYSIGN`                     :math:`\hex{A6}`           :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`  
+:math:`\I32.\WRAP\K{\_}\I64`               :math:`\hex{A7}`           :math:`[\I64] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-wrap>`       
+:math:`\I32.\TRUNC\K{\_}\F32\K{\_s}`       :math:`\hex{A8}`           :math:`[\F32] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
+:math:`\I32.\TRUNC\K{\_}\F32\K{\_u}`       :math:`\hex{A9}`           :math:`[\F32] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
+:math:`\I32.\TRUNC\K{\_}\F64\K{\_s}`       :math:`\hex{AA}`           :math:`[\F64] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
+:math:`\I32.\TRUNC\K{\_}\F64\K{\_u}`       :math:`\hex{AB}`           :math:`[\F64] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
+:math:`\I64.\EXTEND\K{\_}\I32\K{\_s}`      :math:`\hex{AC}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_s>`   
+:math:`\I64.\EXTEND\K{\_}\I32\K{\_u}`      :math:`\hex{AD}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_u>`   
+:math:`\I64.\TRUNC\K{\_}\F32\K{\_s}`       :math:`\hex{AE}`           :math:`[\F32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
+:math:`\I64.\TRUNC\K{\_}\F32\K{\_u}`       :math:`\hex{AF}`           :math:`[\F32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
+:math:`\I64.\TRUNC\K{\_}\F64\K{\_s}`       :math:`\hex{B0}`           :math:`[\F64] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
+:math:`\I64.\TRUNC\K{\_}\F64\K{\_u}`       :math:`\hex{B1}`           :math:`[\F64] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
+:math:`\F32.\CONVERT\K{\_}\I32\K{\_s}`     :math:`\hex{B2}`           :math:`[\I32] \to [\F32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
+:math:`\F32.\CONVERT\K{\_}\I32\K{\_u}`     :math:`\hex{B3}`           :math:`[\I32] \to [\F32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
+:math:`\F32.\CONVERT\K{\_}\I64\K{\_s}`     :math:`\hex{B4}`           :math:`[\I64] \to [\F32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
+:math:`\F32.\CONVERT\K{\_}\I64\K{\_u}`     :math:`\hex{B5}`           :math:`[\I64] \to [\F32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
+:math:`\F32.\DEMOTE\K{\_}\F64`             :math:`\hex{B6}`           :math:`[\F64] \to [\F32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-demote>`     
+:math:`\F64.\CONVERT\K{\_}\I32\K{\_s}`     :math:`\hex{B7}`           :math:`[\I32] \to [\F64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
+:math:`\F64.\CONVERT\K{\_}\I32\K{\_u}`     :math:`\hex{B8}`           :math:`[\I32] \to [\F64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
+:math:`\F64.\CONVERT\K{\_}\I64\K{\_s}`     :math:`\hex{B9}`           :math:`[\I64] \to [\F64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
+:math:`\F64.\CONVERT\K{\_}\I64\K{\_u}`     :math:`\hex{BA}`           :math:`[\I64] \to [\F64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
+:math:`\F64.\PROMOTE\K{\_}\F32`            :math:`\hex{BB}`           :math:`[\F32] \to [\F64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-promote>`    
+:math:`\I32.\REINTERPRET\K{\_}\F32`        :math:`\hex{BC}`           :math:`[\F32] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
+:math:`\I64.\REINTERPRET\K{\_}\F64`        :math:`\hex{BD}`           :math:`[\F64] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
+:math:`\F32.\REINTERPRET\K{\_}\I32`        :math:`\hex{BE}`           :math:`[\I32] \to [\F32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
+:math:`\F64.\REINTERPRET\K{\_}\I64`        :math:`\hex{BF}`           :math:`[\I64] \to [\F64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
+:math:`\I32.\EXTEND\K{8\_s}`               :math:`\hex{C0}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
+:math:`\I32.\EXTEND\K{16\_s}`              :math:`\hex{C1}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
+:math:`\I64.\EXTEND\K{8\_s}`               :math:`\hex{C2}`           :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
+:math:`\I64.\EXTEND\K{16\_s}`              :math:`\hex{C3}`           :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
+:math:`\I64.\EXTEND\K{32\_s}`              :math:`\hex{C4}`           :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
+(reserved)                                 :math:`\hex{C5}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{C6}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{C7}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{C8}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{C9}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{CA}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{CB}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{CC}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{CD}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{CE}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{CF}`                                                                                                                                                                                      
+:math:`\REFNULL~\X{ht}`                    :math:`\hex{D0}`           :math:`[] \to [(\REF~\NULL~\X{ht})]`                             :ref:`validation <valid-ref.null>`         :ref:`execution <exec-ref.null>`                               
+:math:`\REFISNULL`                         :math:`\hex{D1}`           :math:`[(\REF~\NULL~\X{ht})] \to [\I32]`                         :ref:`validation <valid-ref.is_null>`      :ref:`execution <exec-ref.is_null>`                            
+:math:`\REFFUNC~x`                         :math:`\hex{D2}`           :math:`[] \to [\FUNCREF]`                                        :ref:`validation <valid-ref.func>`         :ref:`execution <exec-ref.func>`                               
+:math:`\REFASNONNULL`                      :math:`\hex{D3}`           :math:`[(\REF~\NULL~\X{ht})] \to [(\REF~\X{ht})]`                :ref:`validation <valid-ref.as_non_null>`  :ref:`execution <exec-ref.as_non_null>`                        
+:math:`\BRONNULL~l`                        :math:`\hex{D4}`           :math:`[t^\ast~(\REF~\NULL~\X{ht})] \to [t^\ast~(\REF~\X{ht})]`  :ref:`validation <valid-br_on_null>`       :ref:`execution <exec-br_on_null>`                             
+(reserved)                                 :math:`\hex{D5}`                                                                                                                                                                                      
+:math:`\BRONNONNULL~l`                     :math:`\hex{D6}`           :math:`[t^\ast~(\REF~\NULL~\X{ht})] \to [t^\ast]`                :ref:`validation <valid-br_on_non_null>`   :ref:`execution <exec-br_on_non_null>`                         
+(reserved)                                 :math:`\hex{D7}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{D8}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{D9}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{DA}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{DB}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{DC}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{DD}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{DE}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{DF}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{E0}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{E1}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{E2}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{E3}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{E4}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{E5}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{E6}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{E7}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{E8}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{E9}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{EA}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{EB}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{EC}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{ED}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{EE}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{EF}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{F0}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{F1}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{F2}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{F3}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{F4}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{F5}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{F6}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{F7}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{F8}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{F9}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{FA}`                                                                                                                                                                                      
+(reserved)                                 :math:`\hex{FB}`                                                                                                                                                                                      
+:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_s}`  :math:`\hex{FC}~\hex{00}`  :math:`[\F32] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
+:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_u}`  :math:`\hex{FC}~\hex{01}`  :math:`[\F32] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
+:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_s}`  :math:`\hex{FC}~\hex{02}`  :math:`[\F64] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
+:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_u}`  :math:`\hex{FC}~\hex{03}`  :math:`[\F64] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
+:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_s}`  :math:`\hex{FC}~\hex{04}`  :math:`[\F32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
+:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_u}`  :math:`\hex{FC}~\hex{05}`  :math:`[\F32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
+:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_s}`  :math:`\hex{FC}~\hex{06}`  :math:`[\F64] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
+:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_u}`  :math:`\hex{FC}~\hex{07}`  :math:`[\F64] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
+:math:`\MEMORYINIT~x`                      :math:`\hex{FC}~\hex{08}`  :math:`[\I32~\I32~\I32] \to []`                                  :ref:`validation <valid-memory.init>`      :ref:`execution <exec-memory.init>`                            
+:math:`\DATADROP~x`                        :math:`\hex{FC}~\hex{09}`  :math:`[] \to []`                                                :ref:`validation <valid-data.drop>`        :ref:`execution <exec-data.drop>`                              
+:math:`\MEMORYCOPY`                        :math:`\hex{FC}~\hex{0A}`  :math:`[\I32~\I32~\I32] \to []`                                  :ref:`validation <valid-memory.copy>`      :ref:`execution <exec-memory.copy>`                            
+:math:`\MEMORYFILL`                        :math:`\hex{FC}~\hex{0B}`  :math:`[\I32~\I32~\I32] \to []`                                  :ref:`validation <valid-memory.fill>`      :ref:`execution <exec-memory.fill>`                            
+:math:`\TABLEINIT~x~y`                     :math:`\hex{FC}~\hex{0C}`  :math:`[\I32~\I32~\I32] \to []`                                  :ref:`validation <valid-table.init>`       :ref:`execution <exec-table.init>`                             
+:math:`\ELEMDROP~x`                        :math:`\hex{FC}~\hex{0D}`  :math:`[] \to []`                                                :ref:`validation <valid-elem.drop>`        :ref:`execution <exec-elem.drop>`                              
+:math:`\TABLECOPY~x~y`                     :math:`\hex{FC}~\hex{0E}`  :math:`[\I32~\I32~\I32] \to []`                                  :ref:`validation <valid-table.copy>`       :ref:`execution <exec-table.copy>`                             
+:math:`\TABLEGROW~x`                       :math:`\hex{FC}~\hex{0F}`  :math:`[t~\I32] \to []`                                          :ref:`validation <valid-table.grow>`       :ref:`execution <exec-table.grow>`                             
+:math:`\TABLESIZE~x`                       :math:`\hex{FC}~\hex{10}`  :math:`[] \to [\I32]`                                            :ref:`validation <valid-table.size>`       :ref:`execution <exec-table.size>`                             
+:math:`\TABLEFILL~x`                       :math:`\hex{FC}~\hex{11}`  :math:`[\I32~t~\I32] \to []`                                     :ref:`validation <valid-table.fill>`       :ref:`execution <exec-table.fill>`                             
+=========================================  =========================  ===============================================================  =========================================  ===============================================================
diff --git a/document/core/binary/instructions.rst b/document/core/binary/instructions.rst
index 897246972..f6e8051fe 100644
--- a/document/core/binary/instructions.rst
+++ b/document/core/binary/instructions.rst
@@ -34,8 +34,11 @@ Control Instructions
 .. _binary-br:
 .. _binary-br_if:
 .. _binary-br_table:
+.. _binary-br_on_null:
+.. _binary-br_on_non_null:
 .. _binary-return:
 .. _binary-call:
+.. _binary-call_ref:
 .. _binary-call_indirect:
 
 .. math::
@@ -62,7 +65,10 @@ Control Instructions
        &\Rightarrow& \BRTABLE~l^\ast~l_N \\ &&|&
      \hex{0F} &\Rightarrow& \RETURN \\ &&|&
      \hex{10}~~x{:}\Bfuncidx &\Rightarrow& \CALL~x \\ &&|&
-     \hex{11}~~y{:}\Btypeidx~~x{:}\Btableidx &\Rightarrow& \CALLINDIRECT~x~y \\
+     \hex{11}~~y{:}\Btypeidx~~x{:}\Btableidx &\Rightarrow& \CALLINDIRECT~x~y \\ &&|&
+     \hex{14}~~x{:}\Bfuncidx &\Rightarrow& \CALLREF \\ &&|&
+     \hex{D4}~~x{:}\Bfuncidx &\Rightarrow& \BRONNULL \\ &&|&
+     \hex{D6}~~x{:}\Bfuncidx &\Rightarrow& \BRONNONNULL \\
    \end{array}
 
 .. note::
@@ -84,13 +90,15 @@ Reference Instructions
 .. _binary-ref.null:
 .. _binary-ref.func:
 .. _binary-ref.is_null:
+.. _binary-ref.as_non_null:
 
 .. math::
    \begin{array}{llclll}
    \production{instruction} & \Binstr &::=& \dots \\ &&|&
      \hex{D0}~~t{:}\Bheaptype &\Rightarrow& \REFNULL~t \\ &&|&
      \hex{D1} &\Rightarrow& \REFISNULL \\ &&|&
-     \hex{D2}~~x{:}\Bfuncidx &\Rightarrow& \REFFUNC~x \\
+     \hex{D2}~~x{:}\Bfuncidx &\Rightarrow& \REFFUNC~x \\ &&|&
+     \hex{D3} &\Rightarrow& \REFASNONNULL \\
    \end{array}
 
 
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 78c43da79..572c6d9cc 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -192,15 +192,35 @@ Reference Instructions
 
 .. _exec-ref.null:
 
-:math:`\REFNULL~t`
-..................
+:math:`\REFNULL~\X{ht}`
+.......................
 
-1. Push the value :math:`\REFNULL~t` to the stack.
+1. Push the value :math:`\REFNULL~\X{ht}` to the stack.
 
 .. note::
    No formal reduction rule is required for this instruction, since the |REFNULL| instruction is already a :ref:`value <syntax-val>`.
 
 
+.. _exec-ref.func:
+
+:math:`\REFFUNC~x`
+..................
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-ref.func>`, :math:`F.\AMODULE.\MIFUNCS[x]` exists.
+
+3. Let :math:`a` be the :ref:`function address <syntax-funcaddr>` :math:`F.\AMODULE.\MIFUNCS[x]`.
+
+4. Push the value :math:`\REFFUNCADDR~a` to the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   F; \REFFUNC~x &\stepto& F; \REFFUNCADDR~a
+     & (\iff a = F.\AMODULE.\MIFUNCS[x]) \\
+   \end{array}
+
+
 .. _exec-ref.is_null:
 
 :math:`\REFISNULL`
@@ -210,7 +230,7 @@ Reference Instructions
 
 2. Pop the value :math:`\val` from the stack.
 
-3. If :math:`\val` is :math:`\REFNULL~t`, then:
+3. If :math:`\val` is :math:`\REFNULL~\X{ht}`, then:
 
    a. Push the value :math:`\I32.\CONST~1` to the stack.
 
@@ -221,29 +241,33 @@ Reference Instructions
 .. math::
    \begin{array}{lcl@{\qquad}l}
    \val~\REFISNULL &\stepto& \I32.\CONST~1
-     & (\iff \val = \REFNULL~t) \\
+     & (\iff \val = \REFNULL~\X{ht}) \\
    \val~\REFISNULL &\stepto& \I32.\CONST~0
      & (\otherwise) \\
    \end{array}
 
 
-.. _exec-ref.func:
+.. _exec-ref.as_non_null:
 
-:math:`\REFFUNC~x`
-..................
+:math:`\REFASNONNULL`
+.....................
 
-1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+1. Assert: due to :ref:`validation <valid-ref.is_null>`, a :ref:`reference value <syntax-ref>` is on the top of the stack.
 
-2. Assert: due to :ref:`validation <valid-ref.func>`, :math:`F.\AMODULE.\MIFUNCS[x]` exists.
+2. Pop the value :math:`\val` from the stack.
 
-3. Let :math:`a` be the :ref:`function address <syntax-funcaddr>` :math:`F.\AMODULE.\MIFUNCS[x]`.
+3. If :math:`\val` is :math:`\REFNULL~\X{ht}`, then:
 
-4. Push the value :math:`\REFFUNCADDR~a` to the stack.
+   a. Trap.
+
+4. Push the value :math:`\val` back to the stack.
 
 .. math::
    \begin{array}{lcl@{\qquad}l}
-   F; \REFFUNC~x &\stepto& F; \REFFUNCADDR~a
-     & (\iff a = F.\AMODULE.\MIFUNCS[x]) \\
+   \val~\REFASNONNULL &\stepto& \TRAP
+     & (\iff \val = \REFNULL~\X{ht}) \\
+   \val~\REFASNONNULL &\stepto& \val
+     & (\otherwise) \\
    \end{array}
 
 
@@ -1722,6 +1746,60 @@ Control Instructions
    \end{array}
 
 
+.. _exec-br_on_null:
+
+:math:`\BRONNULL~l`
+...................
+
+1. Assert: due to :ref:`validation <valid-ref.is_null>`, a :ref:`reference value <syntax-ref>` is on the top of the stack.
+
+2. Pop the value :math:`\val` from the stack.
+
+3. If :math:`\val` is :math:`\REFNULL~\X{ht}`, then:
+
+   a. :ref:`Execute <exec-br>` the instruction :math:`(\BR~l)`.
+
+4. Else:
+
+   a. Push the value :math:`\val` back to the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   \val~(\BRONNULL~l) &\stepto& (\BR~l)
+     & (\iff \val = \REFNULL~\X{ht}) \\
+   \val~(\BRONNULL~l) &\stepto& \val
+     & (\otherwise) \\
+   \end{array}
+
+
+.. _exec-br_on_non_null:
+
+:math:`\BRONNONNULL~l`
+......................
+
+1. Assert: due to :ref:`validation <valid-ref.is_null>`, a :ref:`reference value <syntax-ref>` is on the top of the stack.
+
+2. Pop the value :math:`\val` from the stack.
+
+3. If :math:`\val` is :math:`\REFNULL~\X{ht}`, then:
+
+   a. Do nothing.
+
+4. Else:
+
+   a. Push the value :math:`\val` back to the stack.
+
+   b. :ref:`Execute <exec-br>` the instruction :math:`(\BR~l)`.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   \val~(\BRONNONNULL~l) &\stepto& \epsilon
+     & (\iff \val = \REFNULL~\X{ht}) \\
+   \val~(\BRONNONNULL~l) &\stepto& \val~(\BR~l)
+     & (\otherwise) \\
+   \end{array}
+
+
 .. _exec-return:
 
 :math:`\RETURN`
@@ -1776,6 +1854,23 @@ Control Instructions
    \end{array}
 
 
+.. _exec-call_ref:
+
+:math:`\CALLREF`
+................
+
+1. Assert: due to :ref:`validation <valid-call_ref>`, a :ref:`function reference <syntax-ref>` is on the top of the stack.
+
+2. Pop the value :math:`\REFFUNCADDR~a` from the stack.
+
+3. :ref:`Invoke <exec-invoke>` the function instance at address :math:`a`.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   F; (\REFFUNCADDR~a)~\CALLREF &\stepto& F; (\INVOKE~a)
+   \end{array}
+
+
 .. _exec-call_indirect:
 
 :math:`\CALLINDIRECT~x~y`
@@ -1805,7 +1900,7 @@ Control Instructions
 
 11. Let :math:`r` be the :ref:`reference <syntax-ref>` :math:`\X{tab}.\TIELEM[i]`.
 
-12. If :math:`r` is :math:`\REFNULL~t`, then:
+12. If :math:`r` is :math:`\REFNULL~\X{ht}`, then:
 
     a. Trap.
 
diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index ed3aff9c4..23f0ef5b9 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -174,8 +174,9 @@ Occasionally, it is convenient to group operators together according to the foll
 .. index:: ! reference instruction, reference, null
    pair: abstract syntax; instruction
 .. _syntax-ref.null:
-.. _syntax-ref.is_null:
 .. _syntax-ref.func:
+.. _syntax-ref.is_null:
+.. _syntax-ref.as_non_null:
 .. _syntax-instr-ref:
 
 Reference Instructions
@@ -188,11 +189,13 @@ Instructions in this group are concerned with accessing :ref:`references <syntax
    \production{instruction} & \instr &::=&
      \dots \\&&|&
      \REFNULL~\reftype \\&&|&
+     \REFFUNC~\funcidx \\&&|&
      \REFISNULL \\&&|&
-     \REFFUNC~\funcidx \\
+     \REFASNONNULL \\
    \end{array}
 
-These instruction produce a null value, check for a null value, or produce a reference to a given function, respectively.
+The first three of these instruction produce a :ref:`null <syntax-null>` value, produce a reference to a given function, or check for a null value, respectively.
+The |REFASNONNULL| casts a :ref:`nullable <syntax-reftype>` to a non-null one, and :ref:`traps <trap>` if it encounters null.
 
 
 .. index:: ! parametric instruction, value type
@@ -389,8 +392,11 @@ Instructions in this group affect the flow of control.
      \BR~\labelidx \\&&|&
      \BRIF~\labelidx \\&&|&
      \BRTABLE~\vec(\labelidx)~\labelidx \\&&|&
+     \BRONNULL~\labelidx \\&&|&
+     \BRONNONNULL~\labelidx \\&&|&
      \RETURN \\&&|&
      \CALL~\funcidx \\&&|&
+     \CALLREF \\&&|&
      \CALLINDIRECT~\tableidx~\typeidx \\
    \end{array}
 
@@ -427,6 +433,7 @@ Branch instructions come in several flavors:
 |BR| performs an unconditional branch,
 |BRIF| performs a conditional branch,
 and |BRTABLE| performs an indirect branch through an operand indexing into the label vector that is an immediate to the instruction, or to a default target if the operand is out of bounds.
+The |BRONNULL| and |BRONNONNULL| instructions check whether a reference operand is :ref:`null <syntax-null>` and branch if that is the case or not the case, respectively.
 The |RETURN| instruction is a shortcut for an unconditional branch to the outermost block, which implicitly is the body of the current function.
 Taking a branch *unwinds* the operand stack up to the height where the targeted structured control instruction was entered.
 However, branches may additionally consume operands themselves, which they push back on the operand stack after unwinding.
@@ -434,6 +441,7 @@ Forward branches require operands according to the output of the targeted block'
 Backward branches require operands according to the input of the targeted block's type, i.e., represent the values consumed by the restarted block.
 
 The |CALL| instruction invokes another :ref:`function <syntax-func>`, consuming the necessary arguments from the stack and returning the result values of the call.
+The |CALLREF| instruction invokes a function indirectly through a :ref:`function reference <syntax-reftype>` operand.
 The |CALLINDIRECT| instruction calls a function indirectly through an operand indexing into a :ref:`table <syntax-table>` that is denoted by a :ref:`table index <syntax-tableidx>` and must contain :ref:`function references <syntax-reftype>`.
 Since it may contain functions of heterogeneous type,
 the callee is dynamically checked against the :ref:`function type <syntax-functype>` indexed by the instruction's second immediate, and the call is aborted with a :ref:`trap <trap>` if it does not match.
diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index 0c350d000..d116523d8 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -95,8 +95,11 @@ However, the special case of a type use that is syntactically empty or consists
 .. _text-br:
 .. _text-br_if:
 .. _text-br_table:
+.. _text-br_on_null:
+.. _text-br_on_non_null:
 .. _text-return:
 .. _text-call:
+.. _text-call_ref:
 .. _text-call_indirect:
 
 All other control instruction are represented verbatim.
@@ -110,8 +113,11 @@ All other control instruction are represented verbatim.
      \text{br\_if}~~l{:}\Tlabelidx_I &\Rightarrow& \BRIF~l \\ &&|&
      \text{br\_table}~~l^\ast{:}\Tvec(\Tlabelidx_I)~~l_N{:}\Tlabelidx_I
        &\Rightarrow& \BRTABLE~l^\ast~l_N \\ &&|&
+     \text{br\_on\_null}~~l{:}\Tlabelidx_I &\Rightarrow& \BRONNULL~l \\ &&|&
+     \text{br\_on\_non\_null}~~l{:}\Tlabelidx_I &\Rightarrow& \BRONNONNULL~l \\ &&|&
      \text{return} &\Rightarrow& \RETURN \\ &&|&
      \text{call}~~x{:}\Tfuncidx_I &\Rightarrow& \CALL~x \\ &&|&
+     \text{call\_ref} &\Rightarrow& \CALLREF \\ &&|&
      \text{call\_indirect}~~x{:}\Ttableidx~~y,I'{:}\Ttypeuse_I &\Rightarrow& \CALLINDIRECT~x~y
        & (\iff I' = \{\ILOCALS~(\epsilon)^\ast\}) \\
    \end{array}
@@ -152,15 +158,17 @@ Reference Instructions
 ~~~~~~~~~~~~~~~~~~~~~~
 
 .. _text-ref.null:
-.. _text-ref.is_null:
 .. _text-ref.func:
+.. _text-ref.is_null:
+.. _text-ref.as_non_null:
 
 .. math::
    \begin{array}{llclll}
    \production{instruction} & \Tplaininstr_I &::=& \dots \\ &&|&
      \text{ref.null}~~t{:}\Theaptype &\Rightarrow& \REFNULL~t \\ &&|&
-     \text{ref.is\_null} &\Rightarrow& \REFISNULL \\ &&|&
      \text{ref.func}~~x{:}\Tfuncidx &\Rightarrow& \REFFUNC~x \\ &&|&
+     \text{ref.is\_null} &\Rightarrow& \REFISNULL \\ &&|&
+     \text{ref.as\_non\_null} &\Rightarrow& \REFASNONNULL \\
    \end{array}
 
 
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index a4d950e9e..6d49a2395 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -351,8 +351,11 @@
 .. |BR| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{br}}
 .. |BRIF| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{br\_if}}
 .. |BRTABLE| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{br\_table}}
+.. |BRONNULL| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{br\_on\_null}}
+.. |BRONNONNULL| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{br\_on\_non\_null}}
 .. |RETURN| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{return}}
 .. |CALL| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{call}}
+.. |CALLREF| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{call\_ref}}
 .. |CALLINDIRECT| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{call\_indirect}}
 
 .. |DROP| mathdef:: \xref{syntax/instructions}{syntax-instr-parametric}{\K{drop}}
@@ -383,8 +386,9 @@
 .. |DATADROP| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{data.drop}}
 
 .. |REFNULL| mathdef:: \xref{syntax/instructions}{syntax-instr-ref}{\K{ref{.}null}}
-.. |REFISNULL| mathdef:: \xref{syntax/instructions}{syntax-instr-ref}{\K{ref{.}is\_null}}
 .. |REFFUNC| mathdef:: \xref{syntax/instructions}{syntax-instr-ref}{\K{ref{.}func}}
+.. |REFISNULL| mathdef:: \xref{syntax/instructions}{syntax-instr-ref}{\K{ref{.}is\_null}}
+.. |REFASNONNULL| mathdef:: \xref{syntax/instructions}{syntax-instr-ref}{\K{ref{.}as\_non\_null}}
 
 .. |CONST| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{const}}
 .. |EQZ| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{eqz}}
@@ -789,8 +793,8 @@
 .. |matchestabletype| mathdef:: \xref{valid/matching}{match-tabletype}{\leq}
 .. |matchesmemtype| mathdef:: \xref{valid/matching}{match-memtype}{\leq}
 .. |matchesglobaltype| mathdef:: \xref{valid/matching}{match-globaltype}{\leq}
-.. |matchesexterntype| mathdef:: \xref{exec/matching}{match-externtype}{\leq}
-.. |matcheslimits| mathdef:: \xref{exec/matching}{match-limits}{\leq}
+.. |matchesexterntype| mathdef:: \xref{valid/matching}{match-externtype}{\leq}
+.. |matcheslimits| mathdef:: \xref{valid/matching}{match-limits}{\leq}
 
 
 .. Contexts
@@ -832,8 +836,8 @@
 .. |vdashtabletypematch| mathdef:: \xref{valid/matching}{match-tabletype}{\vdash}
 .. |vdashmemtypematch| mathdef:: \xref{valid/matching}{match-memtype}{\vdash}
 .. |vdashglobaltypematch| mathdef:: \xref{valid/matching}{match-globaltype}{\vdash}
-.. |vdashexterntypematch| mathdef:: \xref{exec/matching}{match-externtype}{\vdash}
-.. |vdashlimitsmatch| mathdef:: \xref{exec/matching}{match-limits}{\vdash}
+.. |vdashexterntypematch| mathdef:: \xref{valid/matching}{match-externtype}{\vdash}
+.. |vdashlimitsmatch| mathdef:: \xref{valid/matching}{match-limits}{\vdash}
 
 .. |vdashinstr| mathdef:: \xref{valid/instructions}{valid-instr}{\vdash}
 .. |vdashinstrseq| mathdef:: \xref{valid/instructions}{valid-instr-seq}{\vdash}
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 9478e96c4..2626650d2 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -166,32 +166,18 @@ Reference Instructions
 
 .. _valid-ref.null:
 
-:math:`\REFNULL~t`
-..................
-
-* The instruction is valid with type :math:`[] \to [t]`.
-
-.. math::
-   \frac{
-   }{
-     C \vdashinstr \REFNULL~t : [] \to [t]
-   }
+:math:`\REFNULL~\X{ht}`
+.......................
 
-.. note::
-   In future versions of WebAssembly, there may be reference types for which no null reference is allowed.
+* The :ref:`heap type <syntax-heaptype>` :math:`\X{ht}` must be :ref:`valid <valid-heaptype>`.
 
-.. _valid-ref.is_null:
-
-:math:`\REFISNULL`
-..................
-
-* The instruction is valid with type :math:`[t] \to [\I32]`, for any :ref:`reference type <syntax-reftype>` :math:`t`.
+* Then the instruction is valid with type :math:`[] \to [(\REF~\NULL~\X{ht})]`.
 
 .. math::
    \frac{
-     t = \reftype
+     C \vdashheaptype \X{ht} \ok
    }{
-     C \vdashinstr \REFISNULL : [t] \to [\I32]
+     C \vdashinstr \REFNULL~\X{ht} : [] \to [(\REF~\NULL~\X{ht})]
    }
 
 .. _valid-ref.func:
@@ -216,6 +202,34 @@ Reference Instructions
      C \vdashinstr \REFFUNC~x : [] \to [(\REF~y)]
    }
 
+.. _valid-ref.is_null:
+
+:math:`\REFISNULL`
+..................
+
+* The instruction is valid with type :math:`[(\REF~\NULL~\X{ht})] \to [\I32]`, for any :ref:`valid <valid-heaptype>` :ref:`heap type <syntax-heaptype>` :math:`\X{ht}`.
+
+.. math::
+   \frac{
+     C \vdashheaptype \X{ht} \ok
+   }{
+     C \vdashinstr \REFISNULL : [(\REF~\NULL~\X{ht})] \to [\I32]
+   }
+
+.. _valid-ref.as_non_null:
+
+:math:`\REFASNONNULL`
+.....................
+
+* The instruction is valid with type :math:`[(\REF~\NULL~\X{ht})] \to [(\REF~\X{ht})]`, for any :ref:`valid <valid-heaptype>` :ref:`heap type <syntax-heaptype>` :math:`\X{ht}`.
+
+.. math::
+   \frac{
+     C \vdashheaptype \X{ht} \ok
+   }{
+     C \vdashinstr \REFASNONNULL : [(\REF~\NULL~\X{ht})] \to [(\REF~\X{ht})]
+   }
+
 
 .. index:: parametric instructions, value type, polymorphism
    pair: validation; instruction
@@ -230,10 +244,11 @@ Parametric Instructions
 :math:`\DROP`
 .............
 
-* The instruction is valid with type :math:`[t] \to []`, for any :ref:`value type <syntax-valtype>` :math:`t`.
+* The instruction is valid with type :math:`[t] \to []`, for any :ref:`valid <valid-valtype>` :ref:`value type <syntax-valtype>` :math:`t`.
 
 .. math::
    \frac{
+     C \vdashvaltype t \ok
    }{
      C \vdashinstr \DROP : [t] \to []
    }
@@ -975,6 +990,52 @@ Control Instructions
    a simple :ref:`linear algorithm <algo-valid>` does not require this.
 
 
+.. _valid-br_on_null:
+
+:math:`\BRONNULL~l`
+...................
+
+* The label :math:`C.\CLABELS[l]` must be defined in the context.
+
+* Let :math:`[t^\ast]` be the :ref:`result type <syntax-resulttype>` :math:`C.\CLABELS[l]`.
+
+* Then the instruction is valid with type :math:`[t^\ast~(\REF~\NULL~\X{ht})] \to [t^\ast~(\REF~\X{ht})]` for any :ref:`valid <valid-heaptype>` :ref:`heap type <syntax-heaptype>` :math:`\X{ht}`.
+
+.. math::
+   \frac{
+     C.\CLABELS[l] = [t^\ast]
+     \qquad
+     C \vdashheaptype \X{ht} \ok
+   }{
+     C \vdashinstr \BRONNULL~l : [t^\ast~(\REF~\NULL~\X{ht})] \to [t^\ast~(\REF~\X{ht})]
+   }
+
+
+.. _valid-br_on_non_null:
+
+:math:`\BRONNONNULL~l`
+......................
+
+* The label :math:`C.\CLABELS[l]` must be defined in the context.
+
+* Let :math:`[{t'}^\ast]` be the :ref:`result type <syntax-resulttype>` :math:`C.\CLABELS[l]`.
+
+* The result type :math:`[{t'}^\ast]` must contain at least one type.
+
+* Let the :ref:`value type <syntax-valtype>` :math:`t_l` be the last element in the sequence :math:`{t'}^\ast`, and :math:`[t^\ast]` the remainder of the sequence preceding it.
+
+* The value type :math:`t_l` must be a reference type of the form :math:`\REF~\NULL^?~\X{ht}`.
+
+* Then the instruction is valid with type :math:`[t^\ast~(\REF~\NULL~\X{ht})] \to [t^\ast]`.
+
+.. math::
+   \frac{
+     C.\CLABELS[l] = [t^\ast~(\REF~\X{ht})]
+   }{
+     C \vdashinstr \BRONNONNULL~l : [t^\ast~(\REF~\NULL~\X{ht})] \to [t^\ast]
+   }
+
+
 .. _valid-return:
 
 :math:`\RETURN`
@@ -1020,6 +1081,23 @@ Control Instructions
    }
 
 
+.. _valid-call_ref:
+
+:math:`\CALLREF`
+................
+
+* Let :math:`x` be some :ref:`type index <syntax-typeidx>` for which :math:`C.\CTYPES[x]` is a :ref:`function type <syntax-functype>` of the form :math:`[t_1^\ast] \to [t_2^\ast]`.
+
+* Then the instruction is valid with type :math:`[t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]`.
+
+.. math::
+   \frac{
+     C.\CTYPES[x] = [t_1^\ast] \to [t_2^\ast]
+   }{
+     C \vdashinstr \CALLREF : [t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]
+   }
+
+
 .. _valid-call_indirect:
 
 :math:`\CALLINDIRECT~x~y`
diff --git a/document/core/valid/types.rst b/document/core/valid/types.rst
index 1fd575b1a..7db800d17 100644
--- a/document/core/valid/types.rst
+++ b/document/core/valid/types.rst
@@ -119,6 +119,46 @@ Valid :ref:`value types <syntax-valtype>` are either valid :ref:`number type <va
    }
 
 
+.. index:: block type
+   pair: validation; block type
+   single: abstract syntax; block type
+.. _valid-blocktype:
+
+Block Types
+~~~~~~~~~~~
+
+:ref:`Block types <syntax-blocktype>` may be expressed in one of two forms, both of which are converted to plain :ref:`function types <syntax-functype>` by the following rules.
+
+:math:`\typeidx`
+................
+
+* The type :math:`C.\CTYPES[\typeidx]` must be defined in the context.
+
+* Then the block type is valid as :ref:`function type <syntax-functype>` :math:`C.\CTYPES[\typeidx]`.
+
+.. math::
+   \frac{
+     C.\CTYPES[\typeidx] = \functype
+   }{
+     C \vdashblocktype \typeidx : \functype
+   }
+
+
+:math:`[\valtype^?]`
+....................
+
+* The value type :math:`\valtype` must either be absent, or :ref:`valid <valid-valtype>`.
+
+* Then the block type is valid as :ref:`function type <syntax-functype>` :math:`[] \to [\valtype^?]`.
+
+.. math::
+   \frac{
+     (C \vdashvaltype \valtype \ok)^?
+   }{
+     C \vdashblocktype [\valtype^?] : [] \to [\valtype^?]
+   }
+
+
 .. index:: result type, value type
    pair: validation; result type
    single: abstract syntax; result type
@@ -177,46 +217,6 @@ Limits
    }
 
 
-.. index:: block type
-   pair: validation; block type
-   single: abstract syntax; block type
-.. _valid-blocktype:
-
-Block Types
-~~~~~~~~~~~
-
-:ref:`Block types <syntax-blocktype>` may be expressed in one of two forms, both of which are converted to plain :ref:`function types <syntax-functype>` by the following rules.
-
-:math:`\typeidx`
-................
-
-* The type :math:`C.\CTYPES[\typeidx]` must be defined in the context.
-
-* Then the block type is valid as :ref:`function type <syntax-functype>` :math:`C.\CTYPES[\typeidx]`.
-
-.. math::
-   \frac{
-     C.\CTYPES[\typeidx] = \functype
-   }{
-     C \vdashblocktype \typeidx : \functype
-   }
-
-
-:math:`[\valtype^?]`
-....................
-
-* The value type :math:`\valtype` must either be absent, or :ref:`valid <valid-valtype>`.
-
-* Then the block type is valid as :ref:`function type <syntax-functype>` :math:`[] \to [\valtype^?]`.
-
-.. math::
-   \frac{
-     (C \vdashvaltype \valtype \ok)^?
-   }{
-     C \vdashblocktype [\valtype^?] : [] \to [\valtype^?]
-   }
-
-
 .. index:: function type
    pair: validation; function type
    single: abstract syntax; function type

From ac1bb59a0915523b86b3b950dfcf14987ede4495 Mon Sep 17 00:00:00 2001
From: Ng Zhi An <zhin@chromium.org>
Date: Tue, 28 Sep 2021 09:01:19 -0700
Subject: [PATCH 043/285] Add action to mirror main to master (#1364)

---
 .github/workflows/mirror.yml | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 .github/workflows/mirror.yml

diff --git a/.github/workflows/mirror.yml b/.github/workflows/mirror.yml
new file mode 100644
index 000000000..5c4707573
--- /dev/null
+++ b/.github/workflows/mirror.yml
@@ -0,0 +1,17 @@
+on:
+  push:
+    branches:
+      - 'main'
+
+jobs:
+  mirror_job:
+    runs-on: ubuntu-latest
+    name: Mirror main branch to master branch
+    steps:
+    - name: Mirror action step
+      id: mirror
+      uses: google/mirror-branch-action@v1.0
+      with:
+        github-token: ${{ secrets.GITHUB_TOKEN }}
+        source: 'main'
+        dest: 'master'

From 397399a70565609bf142d211891724e21bffd01f Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@dfinity.org>
Date: Fri, 1 Oct 2021 10:13:43 +0200
Subject: [PATCH 044/285] [test] Fix binary test (#1367)

---
 test/core/binary.wast | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/core/binary.wast b/test/core/binary.wast
index c6f975570..ca25e542c 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -1406,7 +1406,7 @@
 (assert_malformed
   (module binary
       "\00asm" "\01\00\00\00"
-      "\05\03\01"                           ;; table section with one entry
+      "\04\03\01"                           ;; table section with one entry
       "\70"                                 ;; anyfunc
       "\02"                                 ;; malformed table limits flag
   )
@@ -1415,7 +1415,7 @@
 (assert_malformed
   (module binary
       "\00asm" "\01\00\00\00"
-      "\05\04\01"                           ;; table section with one entry
+      "\04\04\01"                           ;; table section with one entry
       "\70"                                 ;; anyfunc
       "\02"                                 ;; malformed table limits flag
       "\00"                                 ;; dummy byte
@@ -1425,12 +1425,12 @@
 (assert_malformed
   (module binary
       "\00asm" "\01\00\00\00"
-      "\05\06\01"                           ;; table section with one entry
+      "\04\06\01"                           ;; table section with one entry
       "\70"                                 ;; anyfunc
       "\81\00"                              ;; malformed table limits flag as LEB128
       "\00\00"                              ;; dummy bytes
   )
-  "integer too large"
+  "integer representation too long"
 )
 
 ;; Memory count can be zero

From e28a8e4b6200a0c06836383845d721a6072078be Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 13 Oct 2021 10:37:10 +0200
Subject: [PATCH 045/285] Eps

---
 document/core/binary/types.rst        | 2 +-
 document/core/syntax/instructions.rst | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/binary/types.rst b/document/core/binary/types.rst
index 67e378aec..e9adc4df9 100644
--- a/document/core/binary/types.rst
+++ b/document/core/binary/types.rst
@@ -7,7 +7,7 @@ Types
 
 .. note::
    In some places, possible types include both type constructors or types denoted by :ref:`type indices <syntax-typeidx>`.
-   Thus, the binary format for most type constructors corresponds to the encodings of small negative :math:`\xref{binary/values}{binary-sint}{\sN}` values, such that they can unambiguously occur in the same place as (positive) type indices.
+   Thus, the binary format for type constructors corresponds to the encodings of small negative :math:`\xref{binary/values}{binary-sint}{\sN}` values, such that they can unambiguously occur in the same place as (positive) type indices.
 
 
 .. index:: number type
diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index 3bebe174f..29d6ed377 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -188,7 +188,7 @@ Instructions in this group are concerned with accessing :ref:`references <syntax
    \begin{array}{llcl}
    \production{instruction} & \instr &::=&
      \dots \\&&|&
-     \REFNULL~\reftype \\&&|&
+     \REFNULL~\heaptype \\&&|&
      \REFFUNC~\funcidx \\&&|&
      \REFISNULL \\&&|&
      \REFASNONNULL \\

From bc936b8b304352f3352a6cd0c2ad99dbe7daeda4 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 13 Oct 2021 11:42:50 +0200
Subject: [PATCH 046/285] Merge fallout

---
 document/core/appendix/properties.rst |  2 +
 document/core/exec/modules.rst        |  8 ++--
 document/core/syntax/types.rst        |  4 +-
 document/core/util/macros.def         |  1 +
 document/core/valid/matching.rst      | 59 ++++++++++++++-------------
 5 files changed, 39 insertions(+), 35 deletions(-)

diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index a8d5cc7fe..7f26eefe1 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -7,6 +7,8 @@ Soundness
 .. todo:: need to operate wrt semantic types
 .. todo:: define "S \vdash t ok"
 .. todo:: ensure wf of guessed valtypes
+.. _valid-typeinst:
+.. todo:: define valid-typeinst as well
 
 The :ref:`type system <type-system>` of WebAssembly is *sound*, implying both *type safety* and *memory safety* with respect to the WebAssembly semantics. For example:
 
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index 44255368f..125ed75ae 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -201,8 +201,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 
 4. Let :math:`\functype` be the :ref:`function type <syntax-functype>` :math:`S.\STYPES[\typeaddr]`.
 
-5. Let :math:`\functype'` be the :ref:`function type <syntax-functype>`
- obtained from :math:`\functype` by substituting each :ref:`type index <syntax-typeidx>` :math:`x` occurring in it with the :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.MITYPES[x]`.
+5. Let :math:`\functype'` be the :ref:`function type <syntax-functype>` obtained from :math:`\functype` by substituting each :ref:`type index <syntax-typeidx>` :math:`x` occurring in it with the :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.MITYPES[x]`.
 
 6. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`\{ \FITYPE~\functype', \FIMODULE~\moduleinst, \FICODE~\func \}`.
 
@@ -213,7 +212,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 .. math::
    ~\\[-1ex]
    \begin{array}{rlll}
-   \allocfunc(S, \func, \modulinst) &=& S', \funcaddr \\[1ex]
+   \allocfunc(S, \func, \moduleinst) &=& S', \funcaddr \\[1ex]
    \mbox{where:} \hfill \\
    \funcaddr &=& |S.\SFUNCS| \\
    \functype &=& S.\STYPES[\moduleinst.\MITYPES[\func.\FTYPE]] \\
@@ -263,8 +262,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 
 2. Let :math:`(\{\LMIN~n, \LMAX~m^?\}~\reftype)` be the structure of :ref:`table type <syntax-tabletype>` :math:`\tabletype`.
 
-3. Let :math:`\tabletype'` be the :ref:`table type <syntax-tabletype>`
- obtained from :math:`\tabletype` by substituting each :ref:`type index <syntax-typeidx>` :math:`x` occurring in it with the :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.MITYPES[x]`.
+3. Let :math:`\tabletype'` be the :ref:`table type <syntax-tabletype>` obtained from :math:`\tabletype` by substituting each :ref:`type index <syntax-typeidx>` :math:`x` occurring in it with the :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.MITYPES[x]`.
 
 4. Let :math:`a` be the first free :ref:`table address <syntax-tableaddr>` in :math:`S`.
 
diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index e7675b4f7..6ea68fa2e 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -17,7 +17,7 @@ Types are checked during :ref:`validation <valid>`, :ref:`instantiation <exec-in
 Type Identifiers
 ~~~~~~~~~~~~~~~~
 
-Types such as :ref:`function types <syntax-functypes>` are not embedded directly into other types, such as :ref:`reference types <syntax-reftype>`.
+Types such as :ref:`function types <syntax-functype>` are not embedded directly into other types, such as :ref:`reference types <syntax-reftype>`.
 Instead, they are referred to indirectly.
 
 In a :ref:`module <syntax-module>` and during validation, this indirection is expressed through a :ref:`type index <syntax-typeidx>`, whose meaning is confined to one module.
@@ -42,7 +42,7 @@ Syntactic types are transformed into semantic types during module :ref:`instanti
 Convention
 ..........
 
-If :math:`t` is some syntactic type, then :math:`t[x^\ast \subst a^\ast]` denotes the semantic type obtained by parallel substitution of :ref:`type indices <syntax-typeidx>` :math:`x^\ast` with :ref:`type addresses <typeaddr>` :math:`a^\ast`, provided :math:`|x^\ast| = |a^\ast|`.
+If :math:`t` is some syntactic type, then :math:`t[x^\ast \subst a^\ast]` denotes the semantic type obtained by parallel substitution of :ref:`type indices <syntax-typeidx>` :math:`x^\ast` with :ref:`type addresses <syntax-typeaddr>` :math:`a^\ast`, provided :math:`|x^\ast| = |a^\ast|`.
 
 Furthermore, :math:`t[\subst a^\ast]` is shorthand for the substitution :math:`t[x^\ast \subst a^\ast]` where :math:`x^\ast = 0 \cdots (|a^\ast| - 1)`.
 
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index 9ed225d91..5d6722df6 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -968,6 +968,7 @@
 
 .. Store, terminals
 
+.. |STYPES| mathdef:: \xref{exec/runtime}{syntax-store}{\K{types}}
 .. |SFUNCS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{funcs}}
 .. |STABLES| mathdef:: \xref{exec/runtime}{syntax-store}{\K{tables}}
 .. |SMEMS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{mems}}
diff --git a/document/core/valid/matching.rst b/document/core/valid/matching.rst
index 5f502507d..a658bea8c 100644
--- a/document/core/valid/matching.rst
+++ b/document/core/valid/matching.rst
@@ -8,24 +8,6 @@ On most types, a simple notion of subtyping is defined that is applicable in val
 .. todo:: externtype matching is used on semantic types; need to define how to reinterpret C for semantic types
 
 
-.. index:: number type
-.. _match-numtype:
-
-Number Types
-~~~~~~~~~~~~
-
-A :ref:`number type <syntax-numtype>` :math:`\numtype_1` matches a :ref:`number type <syntax-numtype>` :math:`\numtype_2` if and only if:
-
-* Both :math:`\numtype_1` and :math:`\numtype_2` are the same.
-
-.. math::
-   ~\\[-1ex]
-   \frac{
-   }{
-     C \vdashnumtypematch \numtype \matchesvaltype \numtype
-   }
-
-
 .. index:: heap type
 .. _match-heaptype:
 
@@ -36,9 +18,9 @@ A :ref:`heap type <syntax-heaptype>` :math:`\heaptype_1` matches a :ref:`heap ty
 
 * Either both :math:`\heaptype_1` and :math:`\heaptype_2` are the same.
 
-* Or :math:`\heaptype_1` is a :ref:`type index <syntax-typeidx>` that defines a function type and :math:`\heaptype_2` is :math:`FUNC`.
+* Or :math:`\heaptype_1` is a :ref:`type identifier <syntax-typeid>` that defines a function type and :math:`\heaptype_2` is :math:`FUNC`.
 
-* Or :math:`\heaptype_1` is a :ref:`type index <syntax-typeidx>` that defines a function type :math:`\functype_1`, and :math:`\heaptype_2` is a :ref:`type index <syntax-typeidx>` that defines a function type :math:`\functype_2`, and :math:`\functype_1` :ref:`matches <match-functype>` :math:`\functype_2`.
+* Or :math:`\heaptype_1` is a :ref:`type identifier <syntax-typeid>` that defines a function type :math:`\functype_1`, and :math:`\heaptype_2` is a :ref:`type identifier <syntax-typeid>` that defines a function type :math:`\functype_2`, and :math:`\functype_1` :ref:`matches <match-functype>` :math:`\functype_2`.
 
 .. math::
    ~\\[-1ex]
@@ -48,21 +30,21 @@ A :ref:`heap type <syntax-heaptype>` :math:`\heaptype_1` matches a :ref:`heap ty
    }
    \qquad
    \frac{
-     C.\CTYPES[\typeidx] = \functype
+     C \vdashtypeid \typeid : \functype
    }{
-     C \vdashheaptypematch \typeidx \matchesheaptype \FUNC
+     C \vdashheaptypematch \typeid \matchesheaptype \FUNC
    }
 
 .. math::
    ~\\[-1ex]
    \frac{
-     C.\CTYPES[\typeidx_1] = \functype_1
+     C \vdashtypeid \typeid_1 : \functype_1
      \qquad
-     C.\CTYPES[\typeidx_2] = \functype_2
+     C \vdashtypeid \typeid_2 : \functype_2
      \qquad
      C \vdashfunctypematch \functype_1 \matchesfunctype \functype_2
    }{
-     C \vdashheaptypematch \typeidx_1 \matchesheaptype \typeidx_2
+     C \vdashheaptypematch \typeid_1 \matchesheaptype \typeid_2
    }
 
 
@@ -93,6 +75,24 @@ A :ref:`reference type <syntax-reftype>` :math:`\REF~\NULL_1^?~heaptype_1` match
    }
 
 
+.. index:: number type
+.. _match-numtype:
+
+Number Types
+~~~~~~~~~~~~
+
+A :ref:`number type <syntax-numtype>` :math:`\numtype_1` matches a :ref:`number type <syntax-numtype>` :math:`\numtype_2` if and only if:
+
+* Both :math:`\numtype_1` and :math:`\numtype_2` are the same.
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+   }{
+     C \vdashnumtypematch \numtype \matchesvaltype \numtype
+   }
+
+
 .. index:: value type, number type, reference type
 .. _match-valtype:
 
@@ -259,15 +259,18 @@ Global Types
 
 A :ref:`global type <syntax-globaltype>` :math:`(\mut_1~t_1)` matches :math:`(\mut_2~t_2)` if and only if:
 
-* Either both :math:`\mut_1` and :math:`\mut_2` are |MVAR| and :math:`t_1` and :math:`t_2` are the same.
- 
+* Either both :math:`\mut_1` and :math:`\mut_2` are |MVAR| and :math:`t_1` :ref:`matches <match-valtype>` :math:`t_2` and vice versa.
+
 * Or both :math:`\mut_1` and :math:`\mut_2` are |MCONST| and :math:`t_1` :ref:`matches <match-valtype>` :math:`t_2`.
 
 .. math::
    ~\\[-1ex]
    \frac{
+     C \vdashvaltypematch t_1 \matchesvaltype t_2
+     \qquad
+     C \vdashvaltypematch t_2 \matchesvaltype t_1
    }{
-     C \vdashglobaltypematch \MVAR~t \matchesglobaltype \MVAR~t
+     C \vdashglobaltypematch \MVAR~t_1 \matchesglobaltype \MVAR~t_2
    }
    \qquad
    \frac{

From 7856f9c1c6feaba2038699be7b77220fb936d9f1 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 13 Oct 2021 12:35:34 +0200
Subject: [PATCH 047/285] Define semantic matching

---
 document/core/appendix/properties.rst |  2 +-
 document/core/exec/modules.rst        |  2 +-
 document/core/exec/runtime.rst        | 30 +++++++++++++++++++++++++++
 document/core/syntax/types.rst        |  7 +++++--
 document/core/util/macros.def         |  1 +
 document/core/valid/matching.rst      |  1 +
 6 files changed, 39 insertions(+), 4 deletions(-)

diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index 7f26eefe1..80ca1d341 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -6,9 +6,9 @@ Soundness
 
 .. todo:: need to operate wrt semantic types
 .. todo:: define "S \vdash t ok"
-.. todo:: ensure wf of guessed valtypes
 .. _valid-typeinst:
 .. todo:: define valid-typeinst as well
+.. todo:: ensure wf of guessed valtypes
 
 The :ref:`type system <type-system>` of WebAssembly is *sound*, implying both *type safety* and *memory safety* with respect to the WebAssembly semantics. For example:
 
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index 125ed75ae..0892a0348 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -3,7 +3,7 @@ Modules
 
 For modules, the execution semantics primarily defines :ref:`instantiation <exec-instantiation>`, which :ref:`allocates <alloc>` instances for a module and its contained definitions, initializes :ref:`tables <syntax-table>` and :ref:`memories <syntax-mem>` from contained :ref:`element <syntax-elem>` and :ref:`data <syntax-data>` segments, and invokes the :ref:`start function <syntax-start>` if present. It also includes :ref:`invocation <exec-invocation>` of exported functions.
 
-Instantiation depends on a number of auxiliary notions for :ref:`type-checking imports <match-externtype>` and :ref:`allocating <alloc>` instances.
+Instantiation depends on a number of auxiliary notions for :ref:`allocating <alloc>` instances.
 
 
 .. index:: external value, external type, validation, import, store
diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index 24f275649..6c28f9c78 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -704,3 +704,33 @@ that is, either a sequence of :ref:`values <syntax-val>` or to a |TRAP|.
       E = (\F64.\CONST~x_1)~[\_]~(\F64.\CONST~x_3)~\F64.\ADD~\F64.\MUL
 
    Moreover, this is the *only* possible choice of evaluation context where the contents of the hole matches the left-hand side of a reduction rule.
+
+
+
+.. index:: type, matching, store, semantic types
+.. _exec-match:
+
+Matching
+~~~~~~~~
+
+Execution has to compares types and :ref:`type instances <syntax-typeinst>` in a few places, such as :ref:`executing <exec-call_indirect>` |CALLINDIRECT| or :ref:`instantiating <exec-instantiation>` :ref:`modules <syntax-modules>`.
+To that end, corresponding judgements for :ref:`matching <match>` types are invoked.
+However, types are represented as :ref:`semantic <syntax-semantic>` types during execution, while the matching judgements operate on syntactic types.
+
+Therefor, for any *static* judgement
+
+.. math:: C \vdash T_1 \matches T_2
+
+on syntactic types :math:`T_1` and :math:`T_2`, the *dynamic* judgement
+
+.. math:: S \vdash T'_1 \matches T'_2
+
+on corresponding semantic types :math:`T'_1` and :math:`T'_2` is defined by constructing a :ref:`context <syntax-context>`
+
+.. math:: C = \{\CTYPES~S.\STYPES\}
+
+and reinterpreting all :ref:`type addresses <syntax-typeaddr>` (in :math:`T'_1`, :math:`T'_2`, and :math:`S.\STYPES`) that are relative to the :ref:`store <syntax-store>` :math:`S` as :ref:`type indices <syntax-typeidx>` relative to the :ref:`context <syntax-context>` :math:`C`.
+
+.. note::
+   This works because both type indices and type addresses are ultimately zero-based indices into a sequence of types.
+   The reinterpretation could also be viewed as a reverse :ref:`substitution <notation-subst>` from addresses back to indices relative to a virtual module accumulating all types that have been allocated so far.
diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index 6ea68fa2e..19db14c85 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -13,6 +13,7 @@ Types are checked during :ref:`validation <valid>`, :ref:`instantiation <exec-in
 .. index:: ! type identifier, type index, type address
    pair: abstract syntax; type identifier
 .. _syntax-typeid:
+.. _syntax-semantic:
 
 Type Identifiers
 ~~~~~~~~~~~~~~~~
@@ -42,9 +43,11 @@ Syntactic types are transformed into semantic types during module :ref:`instanti
 Convention
 ..........
 
-If :math:`t` is some syntactic type, then :math:`t[x^\ast \subst a^\ast]` denotes the semantic type obtained by parallel substitution of :ref:`type indices <syntax-typeidx>` :math:`x^\ast` with :ref:`type addresses <syntax-typeaddr>` :math:`a^\ast`, provided :math:`|x^\ast| = |a^\ast|`.
+The following notation expresses conversion between syntactic and semantic types:
 
-Furthermore, :math:`t[\subst a^\ast]` is shorthand for the substitution :math:`t[x^\ast \subst a^\ast]` where :math:`x^\ast = 0 \cdots (|a^\ast| - 1)`.
+* :math:`t[x^\ast \subst a^\ast]` denotes the parallel substitution of :ref:`type indices <syntax-typeidx>` :math:`x^\ast` with :ref:`type addresses <syntax-typeaddr>` :math:`a^\ast`, provided :math:`|x^\ast| = |a^\ast|`.
+
+* :math:`t[\subst a^\ast]` is shorthand for the substitution :math:`t[x^\ast \subst a^\ast]` where :math:`x^\ast = 0 \cdots (|a^\ast| - 1)`.
 
 
 .. index:: ! heap type, store, type identifier
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index 5d6722df6..8cdec85aa 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -786,6 +786,7 @@
 .. |ok| mathdef:: \mathrel{\mbox{ok}}
 .. |const| mathdef:: \xref{valid/instructions}{valid-constant}{\mathrel{\mbox{const}}}
 
+.. |matches| mathdef:: \leq
 .. |matchesnumtype| mathdef:: \xref{valid/matching}{match-numtype}{\leq}
 .. |matchesheaptype| mathdef:: \xref{valid/matching}{match-heaptype}{\leq}
 .. |matchesreftype| mathdef:: \xref{valid/matching}{match-reftype}{\leq}
diff --git a/document/core/valid/matching.rst b/document/core/valid/matching.rst
index a658bea8c..a04fa8680 100644
--- a/document/core/valid/matching.rst
+++ b/document/core/valid/matching.rst
@@ -1,4 +1,5 @@
 .. index:: ! matching, subtyping
+.. _match:
 
 Matching
 --------

From 26b45a7b999aaf82da7800913ad1c70b532e16dd Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 13 Oct 2021 13:21:02 +0200
Subject: [PATCH 048/285] Proper semantic rules

---
 document/core/exec/runtime.rst | 24 +++++++++++++++++++-----
 1 file changed, 19 insertions(+), 5 deletions(-)

diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index 6c28f9c78..9de43ac8c 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -725,12 +725,26 @@ on syntactic types :math:`T_1` and :math:`T_2`, the *dynamic* judgement
 
 .. math:: S \vdash T'_1 \matches T'_2
 
-on corresponding semantic types :math:`T'_1` and :math:`T'_2` is defined by constructing a :ref:`context <syntax-context>`
+on corresponding semantic types :math:`T'_1` and :math:`T'_2` is defined analogously, by replacing all occurrences of a :ref:`context <syntax-context>` :math:`C` in the rules with a :ref:`store <syntax-store>` :math:`S`.
 
-.. math:: C = \{\CTYPES~S.\STYPES\}
+Furthermore, the following base rule looking up :ref:`type addresses <syntax-typeaddr>` in the store is added.
 
-and reinterpreting all :ref:`type addresses <syntax-typeaddr>` (in :math:`T'_1`, :math:`T'_2`, and :math:`S.\STYPES`) that are relative to the :ref:`store <syntax-store>` :math:`S` as :ref:`type indices <syntax-typeidx>` relative to the :ref:`context <syntax-context>` :math:`C`.
+.. index:: type, type instance, type address
+. _valid-typeinst:
+
+Type Addresses
+..............
+
+* The type :math:`S.\STYPES[\typeaddr]` must be defined in the store.
+
+* Then the type address is valid as :ref:`function type <syntax-functype>` :math:`S.\STYPES[\typeaddr]`.
+
+.. math::
+   \frac{
+     S.\STYPES[\typeaddr] = \functype
+   }{
+     S \vdashtypeid \typeaddr : \functype
+   }
 
 .. note::
-   This works because both type indices and type addresses are ultimately zero-based indices into a sequence of types.
-   The reinterpretation could also be viewed as a reverse :ref:`substitution <notation-subst>` from addresses back to indices relative to a virtual module accumulating all types that have been allocated so far.
+   Unlike :ref:`type indices <syntax-typeidx>` recorded in a context, the number of type addresses in a store is not bounded by :math:`2^{32}`.

From 2e13027ffaf08794ea4c6b5bf1dae287a02ffae8 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 13 Oct 2021 13:28:24 +0200
Subject: [PATCH 049/285] Wording

---
 document/core/exec/runtime.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index 9de43ac8c..a4798af80 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -727,7 +727,7 @@ on syntactic types :math:`T_1` and :math:`T_2`, the *dynamic* judgement
 
 on corresponding semantic types :math:`T'_1` and :math:`T'_2` is defined analogously, by replacing all occurrences of a :ref:`context <syntax-context>` :math:`C` in the rules with a :ref:`store <syntax-store>` :math:`S`.
 
-Furthermore, the following base rule looking up :ref:`type addresses <syntax-typeaddr>` in the store is added.
+Furthermore, the base rule looking up :ref:`type indices <syntax-typeidx>` in the context is replaced by a corresponding rule for looking up :ref:`type addresses <syntax-typeaddr>` in the store.
 
 .. index:: type, type instance, type address
 . _valid-typeinst:

From 9086f716fc870c14cf25a942d9336b094c67d87f Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 13 Oct 2021 13:29:17 +0200
Subject: [PATCH 050/285] Typo

---
 document/core/exec/runtime.rst | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index a4798af80..c16ff87ec 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -730,7 +730,8 @@ on corresponding semantic types :math:`T'_1` and :math:`T'_2` is defined analogo
 Furthermore, the base rule looking up :ref:`type indices <syntax-typeidx>` in the context is replaced by a corresponding rule for looking up :ref:`type addresses <syntax-typeaddr>` in the store.
 
 .. index:: type, type instance, type address
-. _valid-typeinst:
+.. _valid-typeaddr:
+.. _valid-typeinst:
 
 Type Addresses
 ..............

From d296a3d10045e5c40426838b58ae9f74e9ee58a9 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 13 Oct 2021 14:52:13 +0200
Subject: [PATCH 051/285] Move runtime typing to separate section

---
 document/core/exec/index.rst   |  1 +
 document/core/exec/runtime.rst | 45 -------------------------
 document/core/exec/types.rst   | 60 ++++++++++++++++++++++++++++++++++
 document/core/valid/types.rst  | 11 ++++---
 4 files changed, 67 insertions(+), 50 deletions(-)
 create mode 100644 document/core/exec/types.rst

diff --git a/document/core/exec/index.rst b/document/core/exec/index.rst
index d81812669..b74d87139 100644
--- a/document/core/exec/index.rst
+++ b/document/core/exec/index.rst
@@ -9,5 +9,6 @@ Execution
    conventions
    runtime
    numerics
+   types
    instructions
    modules
diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index c16ff87ec..24f275649 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -704,48 +704,3 @@ that is, either a sequence of :ref:`values <syntax-val>` or to a |TRAP|.
       E = (\F64.\CONST~x_1)~[\_]~(\F64.\CONST~x_3)~\F64.\ADD~\F64.\MUL
 
    Moreover, this is the *only* possible choice of evaluation context where the contents of the hole matches the left-hand side of a reduction rule.
-
-
-
-.. index:: type, matching, store, semantic types
-.. _exec-match:
-
-Matching
-~~~~~~~~
-
-Execution has to compares types and :ref:`type instances <syntax-typeinst>` in a few places, such as :ref:`executing <exec-call_indirect>` |CALLINDIRECT| or :ref:`instantiating <exec-instantiation>` :ref:`modules <syntax-modules>`.
-To that end, corresponding judgements for :ref:`matching <match>` types are invoked.
-However, types are represented as :ref:`semantic <syntax-semantic>` types during execution, while the matching judgements operate on syntactic types.
-
-Therefor, for any *static* judgement
-
-.. math:: C \vdash T_1 \matches T_2
-
-on syntactic types :math:`T_1` and :math:`T_2`, the *dynamic* judgement
-
-.. math:: S \vdash T'_1 \matches T'_2
-
-on corresponding semantic types :math:`T'_1` and :math:`T'_2` is defined analogously, by replacing all occurrences of a :ref:`context <syntax-context>` :math:`C` in the rules with a :ref:`store <syntax-store>` :math:`S`.
-
-Furthermore, the base rule looking up :ref:`type indices <syntax-typeidx>` in the context is replaced by a corresponding rule for looking up :ref:`type addresses <syntax-typeaddr>` in the store.
-
-.. index:: type, type instance, type address
-.. _valid-typeaddr:
-.. _valid-typeinst:
-
-Type Addresses
-..............
-
-* The type :math:`S.\STYPES[\typeaddr]` must be defined in the store.
-
-* Then the type address is valid as :ref:`function type <syntax-functype>` :math:`S.\STYPES[\typeaddr]`.
-
-.. math::
-   \frac{
-     S.\STYPES[\typeaddr] = \functype
-   }{
-     S \vdashtypeid \typeaddr : \functype
-   }
-
-.. note::
-   Unlike :ref:`type indices <syntax-typeidx>` recorded in a context, the number of type addresses in a store is not bounded by :math:`2^{32}`.
diff --git a/document/core/exec/types.rst b/document/core/exec/types.rst
new file mode 100644
index 000000000..a23055c2b
--- /dev/null
+++ b/document/core/exec/types.rst
@@ -0,0 +1,60 @@
+.. index:: type, semantic type
+.. _exec-type:
+
+Types
+-----
+
+Execution has to check and compare types and :ref:`type instances <syntax-typeinst>` in a few places, such as :ref:`executing <exec-call_indirect>` |CALLINDIRECT| or :ref:`instantiating <exec-instantiation>` :ref:`modules <syntax-module>`.
+However, types are represented as :ref:`semantic <syntax-semantic>` types during execution.
+Therefore, relevant type relations on syntactic types need to be redefined for execution.
+
+
+.. index:: type identifier, type address, store
+   pair: validation; type identifier
+   single: abstract syntax; type identifier
+.. _valid-typeaddr:
+.. _valid-typeinst:
+
+Type Identifiers
+~~~~~~~~~~~~~~~~
+
+During execution, :ref:`type identifiers <syntax-typeid>` are represented as :ref:`type addresses <syntax-typeaddr>`, which are looked up as :ref:`function types <syntax-functype>` in the :ref:`store <syntax-store>` by the following rule.
+
+:math:`\typeaddr`
+.................
+
+* The type :math:`S.\STYPES[\typeaddr]` must be defined in the store.
+
+* Then the type address is valid as :ref:`function type <syntax-functype>` :math:`S.\STYPES[\typeaddr]`.
+
+.. math::
+   \frac{
+     S.\STYPES[\typeaddr] = \functype
+   }{
+     S \vdashtypeid \typeaddr : \functype
+   }
+
+.. note::
+   Unlike :ref:`type indices <syntax-typeidx>` recorded in a context, the number of type addresses in a store is not bounded by :math:`2^{32}`.
+
+
+.. index:: type, matching, store, semantic types
+.. _exec-match:
+
+Matching
+~~~~~~~~
+
+For each *static* :ref:`matching relation <match>` on syntactic types, operating relative to a :ref:`context <context>`, an analogous *dynamic* matching relation is defined, operating relative to a :ref:`store <syntax-store>`.
+
+Formally, for each judgement
+
+.. math:: C \vdash T_1 \matches T_2
+
+on syntactic types :math:`T_1` and :math:`T_2`, an analogous judgement
+
+.. math:: S \vdash T'_1 \matches T'_2
+
+on corresponding semantic types :math:`T'_1` and :math:`T'_2` is introduced. It is defined analogously, by replacing all occurrences of a :ref:`context <context>` :math:`C` in the associated rules with a :ref:`store <syntax-store>` :math:`S`.
+
+.. note::
+   Where the static matching rules invoke :ref:`static lookup <valid-typeidx>` for :ref:`type indices <syntax-typeidx>` in the context, the dynamic matching rules thereby invoke :ref:`dynamic lookup <valid-typeaddr>` for :ref:`type addresses <syntax-typeaddr>` in the store.
diff --git a/document/core/valid/types.rst b/document/core/valid/types.rst
index bc70b0919..7e12c9598 100644
--- a/document/core/valid/types.rst
+++ b/document/core/valid/types.rst
@@ -11,14 +11,15 @@ Moreover, :ref:`block types <syntax-blocktype>` are converted to plain :ref:`fun
    pair: validation; type identifier
    single: abstract syntax; type identifier
 .. _valid-typeid:
+.. _valid-typeidx:
 
 Type Identifiers
 ~~~~~~~~~~~~~~~~
 
-During validation, :ref:`type identifiers <syntax-typeid>` are represented as :ref:`type indices <syntax-typeidx>`, which are converted to plain :ref:`function types <syntax-functype>` by the following rule.
+During validation, :ref:`type identifiers <syntax-typeid>` are represented as :ref:`type indices <syntax-typeidx>`, which are lookued up as :ref:`function types <syntax-functype>` by the following rule.
 
-:math:`\typeid`
-...............
+:math:`\typeidx`
+................
 
 * The type :math:`C.\CTYPES[\typeidx]` must be defined in the context.
 
@@ -32,8 +33,8 @@ During validation, :ref:`type identifiers <syntax-typeid>` are represented as :r
    }
 
 .. note::
-   Validity of :ref:`semantic types <syntax-typeid>` never needs to be checked during validation.
-   It only needs to be :ref:`defined <valid-typeinst>` as part of :ref:`store validity <valid-store>`, an auxiliary notion for proving :ref:`soundness <soundness>` of the type system.
+   :ref:`Semantic types <syntax-typeid>` do not arise during validation.
+   They only need to be :ref:`looked up <valid-typeaddr>` during :ref:`execution <exec-type>`.
 
 
 .. index:: heap type, type identifier

From 530d3091b546a75a503a69c3eea0d6bd29a502c1 Mon Sep 17 00:00:00 2001
From: Ng Zhi An <zhin@chromium.org>
Date: Wed, 13 Oct 2021 06:58:58 -0700
Subject: [PATCH 052/285] Improve parse error message and add null-byte in
 comments test (#1372)

---
 interpreter/binary/decode.ml |   2 +-
 test/core/binary.wast        |   2 +-
 test/core/comments.wast      | Bin 701 -> 772 bytes
 3 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index ce864f056..37b5aabca 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -808,7 +808,7 @@ let module_ s =
   iterate custom_section s;
   let datas = data_section s in
   iterate custom_section s;
-  require (pos s = len s) s (len s) "junk after last section";
+  require (pos s = len s) s (len s) "unexpected content after last section";
   require (List.length func_types = List.length func_bodies)
     s (len s) "function and code section have inconsistent lengths";
   require (data_count = None || data_count = Some (Lib.List32.length datas))
diff --git a/test/core/binary.wast b/test/core/binary.wast
index ca25e542c..ebebd2ead 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -1760,5 +1760,5 @@
     "\02\00"
     "\0b"                      ;; end
   )
-  "junk after last section"
+  "unexpected content after last section"
 )
diff --git a/test/core/comments.wast b/test/core/comments.wast
index 90a64b42d9ec854f6522e940c0466eb6c1ca6de9..c291370fa72141c02e627c6edf0442bd409129cf 100644
GIT binary patch
delta 83
zcmdnX+QPQMgVDv>S|P7ACr3A_vLsa@Ek7qGzdSWXAu~5OH6=5#BsHf}A*oU!H7`Xs
lKTS6|A1ItxqL7lBlbM@Yl3K*2Va;Hz$+g*yv7C{S3joUf8<zk8

delta 12
TcmZo++snGagK={oV<{s5954g^


From 5893af5bce241fbb074d482a65706126c031b8ed Mon Sep 17 00:00:00 2001
From: Ng Zhi An <zhin@chromium.org>
Date: Wed, 13 Oct 2021 08:49:10 -0700
Subject: [PATCH 053/285] Add tests for using nan patterns outside of script
 (#1373)

---
 test/core/f32.wast | 10 ++++++++++
 test/core/f64.wast | 10 ++++++++++
 2 files changed, 20 insertions(+)

diff --git a/test/core/f32.wast b/test/core/f32.wast
index 36d81a05b..0f8ae0aa4 100644
--- a/test/core/f32.wast
+++ b/test/core/f32.wast
@@ -2531,3 +2531,13 @@
 (assert_invalid (module (func (result f32) (f32.nearest (i64.const 0)))) "type mismatch")
 (assert_invalid (module (func (result f32) (f32.sqrt (i64.const 0)))) "type mismatch")
 (assert_invalid (module (func (result f32) (f32.trunc (i64.const 0)))) "type mismatch")
+
+;; These float literal patterns are only allowed in scripts, not in text format.
+(assert_malformed
+  (module quote "(func (result f32) (f32.const nan:arithmetic))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (result f32) (f32.const nan:canonical))")
+  "unexpected token"
+)
diff --git a/test/core/f64.wast b/test/core/f64.wast
index 70bb477c7..afd2b2f73 100644
--- a/test/core/f64.wast
+++ b/test/core/f64.wast
@@ -2531,3 +2531,13 @@
 (assert_invalid (module (func (result f64) (f64.nearest (i64.const 0)))) "type mismatch")
 (assert_invalid (module (func (result f64) (f64.sqrt (i64.const 0)))) "type mismatch")
 (assert_invalid (module (func (result f64) (f64.trunc (i64.const 0)))) "type mismatch")
+
+;; These float literal patterns are only allowed in scripts, not in text format.
+(assert_malformed
+  (module quote "(func (result f64) (f64.const nan:arithmetic))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (result f64) (f64.const nan:canonical))")
+  "unexpected token"
+)

From efb35b2163daf393cad8315fbc6b297ee4fecd23 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@dfinity.org>
Date: Wed, 13 Oct 2021 18:04:32 +0200
Subject: [PATCH 054/285] [spec] Fix algorithm (#1375)

---
 document/core/appendix/algorithm.rst | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/document/core/appendix/algorithm.rst b/document/core/appendix/algorithm.rst
index bd86ee4f1..858a416f4 100644
--- a/document/core/appendix/algorithm.rst
+++ b/document/core/appendix/algorithm.rst
@@ -75,15 +75,13 @@ However, these variables are not manipulated directly by the main checking funct
 
    func pop_val(expect : val_type | Unknown) : val_type | Unknown =
      let actual = pop_val()
-     if (actual = Unknown) return expect
-     if (expect = Unknown) return actual
-     error_if(actual =/= expect)
+     error_if(actual =/= expect && actual =/= Unknown && expect =/= Unknown)
      return actual
 
    func push_vals(types : list(val_type)) = foreach (t in types) push_val(t)
    func pop_vals(types : list(val_type)) : list(val_type) =
      var popped := []
-     foreach (t in reverse(types)) popped.append(pop_val(t))
+     foreach (t in reverse(types)) popped.prepend(pop_val(t))
      return popped
 
 Pushing an operand value simply pushes the respective type to the value stack.

From 9b4d86fbcd3309c3365c8430a4ac5ef2126c43a8 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Wed, 13 Oct 2021 18:12:03 +0200
Subject: [PATCH 055/285] [spec] Replace some odd whitespace

---
 document/core/appendix/algorithm.rst | 46 ++++++++++++++--------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/document/core/appendix/algorithm.rst b/document/core/appendix/algorithm.rst
index 858a416f4..537105959 100644
--- a/document/core/appendix/algorithm.rst
+++ b/document/core/appendix/algorithm.rst
@@ -107,24 +107,24 @@ The control stack is likewise manipulated through auxiliary functions:
 .. code-block:: pseudo
 
    func push_ctrl(opcode : opcode, in : list(val_type), out : list(val_type)) =
-     let frame = ctrl_frame(opcode, in, out, vals.size(), false)
-     ctrls.push(frame)
+     let frame = ctrl_frame(opcode, in, out, vals.size(), false)
+     ctrls.push(frame)
      push_vals(in)
 
    func pop_ctrl() : ctrl_frame =
-     error_if(ctrls.is_empty())
-     let frame = ctrls[0]
-     pop_vals(frame.end_types)
-     error_if(vals.size() =/= frame.height)
+     error_if(ctrls.is_empty())
+     let frame = ctrls[0]
+     pop_vals(frame.end_types)
+     error_if(vals.size() =/= frame.height)
      ctrls.pop()
-     return frame
+     return frame
 
    func label_types(frame : ctrl_frame) : list(val_types) =
      return (if frame.opcode == loop then frame.start_types else frame.end_types)
 
    func unreachable() =
-     vals.resize(ctrls[0].height)
-     ctrls[0].unreachable := true
+     vals.resize(ctrls[0].height)
+     ctrls[0].unreachable := true
 
 Pushing a control frame takes the types of the label and result values.
 It allocates a new frame record recording them along with the current height of the operand stack and marks the block as reachable.
@@ -182,8 +182,8 @@ Other instructions are checked in a similar manner.
          pop_val(t)
          push_val(t)
 
-       case (unreachable)
-         unreachable()
+       case (unreachable)
+         unreachable()
 
        case (block t1*->t2*)
          pop_vals([t1*])
@@ -208,26 +208,26 @@ Other instructions are checked in a similar manner.
          push_ctrl(else, frame.start_types, frame.end_types)
 
        case (br n)
-         error_if(ctrls.size() < n)
-         pop_vals(label_types(ctrls[n]))
-         unreachable()
+         error_if(ctrls.size() < n)
+         pop_vals(label_types(ctrls[n]))
+         unreachable()
 
        case (br_if n)
-         error_if(ctrls.size() < n)
+         error_if(ctrls.size() < n)
          pop_val(I32)
-         pop_vals(label_types(ctrls[n]))
-         push_vals(label_types(ctrls[n]))
+         pop_vals(label_types(ctrls[n]))
+         push_vals(label_types(ctrls[n]))
 
-       case (br_table n* m)
+       case (br_table n* m)
          pop_val(I32)
-         error_if(ctrls.size() < m)
+         error_if(ctrls.size() < m)
          let arity = label_types(ctrls[m]).size()
-         foreach (n in n*)
-           error_if(ctrls.size() < n)
-           error_if(label_types(ctrls[n]).size() =/= arity)
+         foreach (n in n*)
+           error_if(ctrls.size() < n)
+           error_if(label_types(ctrls[n]).size() =/= arity)
            push_vals(pop_vals(label_types(ctrls[n])))
          pop_vals(label_types(ctrls[m]))
-         unreachable()
+         unreachable()
 
 
 .. note::

From 7f2dc80bf4e8fba90098989fd833ee7b67253bc7 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@dfinity.org>
Date: Thu, 14 Oct 2021 10:14:05 +0200
Subject: [PATCH 056/285] [spec] Fix outdated item from br_table validation
 prose (#1378)

---
 document/core/valid/instructions.rst | 2 --
 1 file changed, 2 deletions(-)

diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 07e4921b6..1e041d33c 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -960,8 +960,6 @@ Control Instructions
 
 * The label :math:`C.\CLABELS[l_N]` must be defined in the context.
 
-* Let :math:`[t^\ast]` be the :ref:`result type <syntax-resulttype>` :math:`C.\CLABELS[l_N]`.
-
 * For all :math:`l_i` in :math:`l^\ast`,
   the label :math:`C.\CLABELS[l_i]` must be defined in the context.
 

From 6d15d3efdc27f0d34ca3e561c455c7de8d3c7aeb Mon Sep 17 00:00:00 2001
From: Ng Zhi An <zhin@chromium.org>
Date: Thu, 14 Oct 2021 11:18:27 -0700
Subject: [PATCH 057/285] Use main in github workflow (#1380)

Default branch is now main, so all the PRs are based on main, which
means the actions aren't currently triggered, since they only run on
push to master. Update it to main.

Since we have the main->master mirror, we should still be testing, but
it is a bit delayed (only after the mirror I think, and not on the PR).
---
 .github/workflows/main.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 7952079e5..a7b1f1df9 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -2,9 +2,9 @@ name: CI
 
 on:
   push:
-    branches: [ master ]
+    branches: [ main ]
   pull_request:
-    branches: [ master ]
+    branches: [ main ]
 
   # Allows you to run this workflow manually from the Actions tab
   workflow_dispatch:
@@ -78,7 +78,7 @@ jobs:
           name: core-api-rendered
           path: _output/core
       - name: Publish HTML to GitHub Pages
-        if: github.ref == 'refs/heads/master'
+        if: github.ref == 'refs/heads/main'
         uses: peaceiris/actions-gh-pages@v3
         with:
           publish_dir: ./_output

From 5d850a2ad5fc72e7b04d3fceafeba042843deef8 Mon Sep 17 00:00:00 2001
From: Dan Gohman <dev@sunfishcode.online>
Date: Wed, 13 Oct 2021 15:56:32 -0700
Subject: [PATCH 058/285] Rename "master" to "main" in repository URLs that
 have switched to "main".

Several WebAssembly organization repositories have changed their default
branch from "master" to "main": see WebAssembly/design#1417 for details.
This PR updates URLs in the spec repository to point to "main" instead of
"master", for repositories which have done so.
---
 Contributing.md                                        |  2 +-
 document/core/appendix/changes.rst                     | 10 +++++-----
 document/deploy.sh                                     |  2 +-
 interpreter/README.md                                  |  4 ++--
 proposals/multi-value/Overview.md                      |  2 +-
 .../nontrapping-float-to-int-conversion/Overview.md    |  4 ++--
 proposals/reference-types/Overview.md                  |  4 ++--
 proposals/sign-extension-ops/Overview.md               |  2 +-
 test/Todo.md                                           |  2 +-
 test/core/README.md                                    |  4 ++--
 10 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/Contributing.md b/Contributing.md
index 1cc607fa4..2c299890b 100644
--- a/Contributing.md
+++ b/Contributing.md
@@ -3,6 +3,6 @@
 Interested in participating? Please follow
 [the same contributing guidelines as the design repository][].
 
-  [the same contributing guidelines as the design repository]: https://github.com/WebAssembly/design/blob/master/Contributing.md
+  [the same contributing guidelines as the design repository]: https://github.com/WebAssembly/design/blob/main/Contributing.md
 
 Also, please be sure to read [the README.md](README.md) for this repository.
diff --git a/document/core/appendix/changes.rst b/document/core/appendix/changes.rst
index 9488c1882..04330a914 100644
--- a/document/core/appendix/changes.rst
+++ b/document/core/appendix/changes.rst
@@ -105,16 +105,16 @@ Added instructions that modify ranges of memory or table entries [#proposal-reft
 
 
 .. [#proposal-signext]
-   https://github.com/WebAssembly/spec/tree/master/proposals/sign-extension-ops/
+   https://github.com/WebAssembly/spec/tree/main/proposals/sign-extension-ops/
 
 .. [#proposal-cvtsat]
-   https://github.com/WebAssembly/spec/tree/master/proposals/nontrapping-float-to-int-conversion/
+   https://github.com/WebAssembly/spec/tree/main/proposals/nontrapping-float-to-int-conversion/
 
 .. [#proposal-multivalue]
-   https://github.com/WebAssembly/spec/tree/master/proposals/multi-value/
+   https://github.com/WebAssembly/spec/tree/main/proposals/multi-value/
 
 .. [#proposal-reftype]
-   https://github.com/WebAssembly/spec/tree/master/proposals/reference-types/
+   https://github.com/WebAssembly/spec/tree/main/proposals/reference-types/
 
 .. [#proposal-bulk]
-   https://github.com/WebAssembly/spec/tree/master/proposals/bulk-memory-operations/
+   https://github.com/WebAssembly/spec/tree/main/proposals/bulk-memory-operations/
diff --git a/document/deploy.sh b/document/deploy.sh
index 66bba483e..9c86b2600 100755
--- a/document/deploy.sh
+++ b/document/deploy.sh
@@ -177,7 +177,7 @@ incremental_deploy() {
 		0) echo No changes to files in $deploy_directory. Skipping commit.;;
 		1) commit_and_push;;
 		*)
-			echo git diff exited with code $diff. Aborting. Staying on branch $deploy_branch so you can debug. To switch back to master, use: git symbolic-ref HEAD refs/heads/master && git reset --mixed >&2
+			echo git diff exited with code $diff. Aborting. Staying on branch $deploy_branch so you can debug. To switch back to main, use: git symbolic-ref HEAD refs/heads/main && git reset --mixed >&2
 			return $diff
 			;;
 	esac
diff --git a/interpreter/README.md b/interpreter/README.md
index ed300410e..f2ebad9aa 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -163,7 +163,7 @@ WebAssemblyText.decode(binary)
 
 ## S-Expression Syntax
 
-The implementation consumes a WebAssembly AST given in S-expression syntax. Here is an overview of the grammar of types, expressions, functions, and modules, mirroring what's described in the [design doc](https://github.com/WebAssembly/design/blob/master/Semantics.md).
+The implementation consumes a WebAssembly AST given in S-expression syntax. Here is an overview of the grammar of types, expressions, functions, and modules, mirroring what's described in the [design doc](https://github.com/WebAssembly/design/blob/main/Semantics.md).
 
 Note: The grammar is shown here for convenience, the definite source is the [specification of the text format](https://webassembly.github.io/spec/core/text/).
 ```
@@ -479,7 +479,7 @@ Moreover, float values are required to be precise, that is, they may not contain
 
 ## Abstract Syntax
 
-The abstract WebAssembly syntax, as described above and in the [design doc](https://github.com/WebAssembly/design/blob/master/Semantics.md), is defined in [ast.ml](syntax/ast.ml).
+The abstract WebAssembly syntax, as described above and in the [design doc](https://github.com/WebAssembly/design/blob/main/Semantics.md), is defined in [ast.ml](syntax/ast.ml).
 
 However, to simplify the implementation, this AST representation represents some of the inner structure of the operators more explicitly. The mapping from the operators as given in the design doc to their structured form is defined in [operators.ml](syntax/operators.ml).
 
diff --git a/proposals/multi-value/Overview.md b/proposals/multi-value/Overview.md
index a6aeb61b6..b3c0277fe 100644
--- a/proposals/multi-value/Overview.md
+++ b/proposals/multi-value/Overview.md
@@ -14,7 +14,7 @@
   - can easily be lifted by generalising to value* -> value*
 
 * Generalised semantics is well-understood
-  - https://github.com/WebAssembly/spec/tree/master/papers/pldi2017.pdf
+  - https://github.com/WebAssembly/spec/tree/main/papers/pldi2017.pdf
 
 * Semi-complete implementation of multiple results in V8
 
diff --git a/proposals/nontrapping-float-to-int-conversion/Overview.md b/proposals/nontrapping-float-to-int-conversion/Overview.md
index 574fcde70..6a80ca817 100644
--- a/proposals/nontrapping-float-to-int-conversion/Overview.md
+++ b/proposals/nontrapping-float-to-int-conversion/Overview.md
@@ -32,7 +32,7 @@ https://github.com/WebAssembly/meetings/pull/3
 
 and
 
-https://github.com/WebAssembly/meetings/blob/master/2017/CG-05.md#non-trapping-float-to-int
+https://github.com/WebAssembly/meetings/blob/main/2017/CG-05.md#non-trapping-float-to-int
 
 which made decisions about which semantics to choose, and which encoding strategy.
 
@@ -43,7 +43,7 @@ https://github.com/WebAssembly/design/pull/1089
 At the CG-07-06 meeting it was decided that a full spec repo fork should be
 created to follow the new process for new features:
 
-https://github.com/WebAssembly/meetings/blob/master/2017/CG-07-06.md#float-to-int-conversion
+https://github.com/WebAssembly/meetings/blob/main/2017/CG-07-06.md#float-to-int-conversion
 
 This led to the creation of the present repo:
 
diff --git a/proposals/reference-types/Overview.md b/proposals/reference-types/Overview.md
index 43a36d351..670658f2b 100644
--- a/proposals/reference-types/Overview.md
+++ b/proposals/reference-types/Overview.md
@@ -6,7 +6,7 @@ TODO: more text, motivation, explanation
 
 Motivation:
 
-* Easier and more efficient interop with host environment (see e.g. the [Interface Types proposal](https://github.com/WebAssembly/interface-types/blob/master/proposals/interface-types/Explainer.md))
+* Easier and more efficient interop with host environment (see e.g. the [Interface Types proposal](https://github.com/WebAssembly/interface-types/blob/main/proposals/interface-types/Explainer.md))
   - allow host references to be represented directly by type `externref` (see [here](https://github.com/WebAssembly/interface-types/issues/9))
   - without having to go through tables, allocating slots, and maintaining index bijections at the boundaries
 
@@ -19,7 +19,7 @@ by repurposing tables as a general memory for opaque data types
 * Set the stage for later additions:
 
   - Typed function references (see [below](#typed-function-references))
-  - Exception references (see the [exception handling proposal](https://github.com/WebAssembly/exception-handling/blob/master/proposals/Exceptions.md) and [here](https://github.com/WebAssembly/interface-types/issues/10))
+  - Exception references (see the [exception handling proposal](https://github.com/WebAssembly/exception-handling/blob/main/proposals/Exceptions.md) and [here](https://github.com/WebAssembly/interface-types/issues/10))
   - A smoother transition path to GC (see the [GC proposal](https://github.com/WebAssembly/gc/blob/master/proposals/gc/Overview.md))
 
 Get the most important parts soon!
diff --git a/proposals/sign-extension-ops/Overview.md b/proposals/sign-extension-ops/Overview.md
index 55df64b4c..4b1650e7d 100644
--- a/proposals/sign-extension-ops/Overview.md
+++ b/proposals/sign-extension-ops/Overview.md
@@ -45,7 +45,7 @@ instr ::= ...
         | 0xC4                  =>  i64.extend32_s
 ```
 
-[future sext]: https://github.com/WebAssembly/design/blob/master/FutureFeatures.md#additional-integer-operators
+[future sext]: https://github.com/WebAssembly/design/blob/main/FutureFeatures.md#additional-integer-operators
 [instruction syntax]: https://webassembly.github.io/spec/syntax/instructions.html
 [instruction binary format]: https://webassembly.github.io/spec/binary/instructions.html
 [spec]: https://webassembly.github.io/sign-extension-ops/
diff --git a/test/Todo.md b/test/Todo.md
index 99e246435..9e06a9e45 100644
--- a/test/Todo.md
+++ b/test/Todo.md
@@ -1,5 +1,5 @@
 This is a rough list of "tests to write". Everything here should either be
-specified in [Semantics.md](https://github.com/WebAssembly/design/blob/master/Semantics.md),
+specified in [Semantics.md](https://github.com/WebAssembly/design/blob/main/Semantics.md),
 have a link to an open issue/PR, or be obvious. Comments/corrections/additions
 welcome.
 
diff --git a/test/core/README.md b/test/core/README.md
index 319151461..6b923e4fb 100644
--- a/test/core/README.md
+++ b/test/core/README.md
@@ -1,6 +1,6 @@
-This directory contains tests for the core WebAssembly semantics, as described in [Semantics.md](https://github.com/WebAssembly/design/blob/master/Semantics.md) and specified by the [spec interpreter](https://github.com/WebAssembly/spec/blob/master/interpreter).
+This directory contains tests for the core WebAssembly semantics, as described in [Semantics.md](https://github.com/WebAssembly/design/blob/main/Semantics.md) and specified by the [spec interpreter](https://github.com/WebAssembly/spec/blob/main/interpreter).
 
-Tests are written in the [S-Expression script format](https://github.com/WebAssembly/spec/blob/master/interpreter/README.md#s-expression-syntax) defined by the interpreter.
+Tests are written in the [S-Expression script format](https://github.com/WebAssembly/spec/blob/main/interpreter/README.md#s-expression-syntax) defined by the interpreter.
 
 The test suite can be run with the spec interpreter as follows:
 ```

From c204c78e9553af8eab9e6d47e57f827784717b45 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 20 Oct 2021 13:28:00 +0200
Subject: [PATCH 059/285] Fix free

---
 interpreter/syntax/free.ml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/interpreter/syntax/free.ml b/interpreter/syntax/free.ml
index a8e765976..4a0a2581a 100644
--- a/interpreter/syntax/free.ml
+++ b/interpreter/syntax/free.ml
@@ -59,6 +59,7 @@ let zero = Set.singleton 0l
 let shift s = Set.map (Int32.add (-1l)) (Set.remove 0l s)
 
 let (++) = union
+let opt free xo = Lib.Option.get (Option.map free xo) empty
 let list free xs = List.fold_left union empty (List.map free xs)
 
 let var_type = function
@@ -91,7 +92,7 @@ let def_type = function
 
 let block_type = function
   | VarBlockType x -> var_type x
-  | ValBlockType _ -> empty
+  | ValBlockType t -> opt value_type t
 
 let rec instr (e : instr) =
   match e.it with

From 9b0e2401799d23f837e89667b53d7a082f3e8e9b Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 20 Oct 2021 16:02:45 +0200
Subject: [PATCH 060/285] Tweak

---
 interpreter/syntax/free.ml  | 5 ++---
 interpreter/syntax/free.mli | 3 ++-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/interpreter/syntax/free.ml b/interpreter/syntax/free.ml
index 4a0a2581a..43a56792a 100644
--- a/interpreter/syntax/free.ml
+++ b/interpreter/syntax/free.ml
@@ -166,8 +166,7 @@ let import_desc (d : import_desc) =
 let export (e : export) = export_desc e.it.edesc
 let import (i : import) = import_desc i.it.idesc
 
-let start (s : idx option) =
-  funcs (Lib.Option.get (Lib.Option.map idx s) Set.empty)
+let start (s : idx) = funcs (idx s)
 
 let module_ (m : module_) =
   list type_ m.it.types ++
@@ -175,7 +174,7 @@ let module_ (m : module_) =
   list table m.it.tables ++
   list memory m.it.memories ++
   list func m.it.funcs ++
-  start m.it.start ++
+  opt start m.it.start ++
   list elem m.it.elems ++
   list data m.it.datas ++
   list import m.it.imports ++
diff --git a/interpreter/syntax/free.mli b/interpreter/syntax/free.mli
index 71456c8d4..c5afe6233 100644
--- a/interpreter/syntax/free.mli
+++ b/interpreter/syntax/free.mli
@@ -29,8 +29,9 @@ val elem : Ast.elem_segment -> t
 val data : Ast.data_segment -> t
 val export : Ast.export -> t
 val import : Ast.import -> t
-val start : Ast.idx option -> t
+val start : Ast.idx -> t
 
 val module_ : Ast.module_ -> t
 
+val opt : ('a -> t) -> 'a option -> t
 val list : ('a -> t) -> 'a list -> t

From ee4a6c40afa22e3e4c58610ce75186aafc22344e Mon Sep 17 00:00:00 2001
From: Ng Zhi An <zhin@chromium.org>
Date: Thu, 21 Oct 2021 09:10:40 -0700
Subject: [PATCH 061/285] Add integer tests for using nan patterns outside of
 script (#1379)

Similar to 5893af5bce241fbb074d482a65706126c031b8ed but for integers,
this is also a type mismatch, but should first be caught at parse time.
---
 test/core/i32.wast | 9 +++++++++
 test/core/i64.wast | 9 +++++++++
 2 files changed, 18 insertions(+)

diff --git a/test/core/i32.wast b/test/core/i32.wast
index 32862c347..2e8ab7005 100644
--- a/test/core/i32.wast
+++ b/test/core/i32.wast
@@ -974,3 +974,12 @@
 (assert_invalid (module (func (result i32) (i32.lt_s (i64.const 0) (f32.const 0)))) "type mismatch")
 (assert_invalid (module (func (result i32) (i32.lt_u (i64.const 0) (f32.const 0)))) "type mismatch")
 (assert_invalid (module (func (result i32) (i32.ne (i64.const 0) (f32.const 0)))) "type mismatch")
+
+(assert_malformed
+  (module quote "(func (result i32) (i32.const nan:arithmetic))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (result i32) (i32.const nan:canonical))")
+  "unexpected token"
+)
diff --git a/test/core/i64.wast b/test/core/i64.wast
index baeed0ce1..b662f3d92 100644
--- a/test/core/i64.wast
+++ b/test/core/i64.wast
@@ -483,3 +483,12 @@
 (assert_invalid (module (func (result i64) (i64.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
 (assert_invalid (module (func (result i64) (i64.lt_u (i32.const 0) (f32.const 0)))) "type mismatch")
 (assert_invalid (module (func (result i64) (i64.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+
+(assert_malformed
+  (module quote "(func (result i64) (i64.const nan:arithmetic))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (result i64) (i64.const nan:canonical))")
+  "unexpected token"
+)

From 09a9540f6ddb943890a5305cbf0aefa26b9e4fc0 Mon Sep 17 00:00:00 2001
From: Ng Zhi An <zhin@chromium.org>
Date: Wed, 27 Oct 2021 10:17:18 -0700
Subject: [PATCH 062/285] Update sphinx to 3.5.4 (#1382)

Our current version of sphinx doesn't limit the supported docutils
versions, and 0.18.0 breaks something
(https://docutils.sourceforge.io/RELEASE-NOTES.html#release-0-18-2021-10-26
likely the new meta node)

3.5.4 restricts the docutils versions:
https://www.sphinx-doc.org/en/master/changes.html#release-3-5-4-released-apr-11-2021
---
 .github/workflows/main.yml | 2 +-
 document/README.md         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index a7b1f1df9..cc1a9c333 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -52,7 +52,7 @@ jobs:
       - run: pip install bikeshed && bikeshed update
       - run: pip install six
       - run: sudo apt-get update -y && sudo apt-get install -y latexmk texlive-latex-recommended texlive-latex-extra texlive-fonts-recommended
-      - run: pip install sphinx==3.5.2
+      - run: pip install sphinx==3.5.4
       - run: cd document/core && make all
       - uses: actions/upload-artifact@v2
         with:
diff --git a/document/README.md b/document/README.md
index a11196f66..6ee838af0 100644
--- a/document/README.md
+++ b/document/README.md
@@ -42,7 +42,7 @@ pipenv shell
 Install Python dependencies:
 
 ```
-pipenv install Sphinx==3.5.2
+pipenv install Sphinx==3.5.4
 ```
 
 ### Checking out the repository

From 0fd42aefa3639c47a5c2c145e94ab0f1f391cdd0 Mon Sep 17 00:00:00 2001
From: Ng Zhi An <zhin@chromium.org>
Date: Wed, 27 Oct 2021 10:32:46 -0700
Subject: [PATCH 063/285] Import main conf.py in bikeshed/conf.py (#1381)

This syncs the changes made in conf.py to bikeshed/conf.py.
---
 document/core/conf.py               |   7 +-
 document/core/util/bikeshed/conf.py | 475 ++--------------------------
 2 files changed, 27 insertions(+), 455 deletions(-)

diff --git a/document/core/conf.py b/document/core/conf.py
index c32644b2c..2bae57195 100644
--- a/document/core/conf.py
+++ b/document/core/conf.py
@@ -18,8 +18,9 @@
 import os
 import sys
 from datetime import date
+
 pwd = os.path.abspath('.')
-sys.path.insert(0, pwd + '/util')
+sys.path.insert(0, pwd)
 
 # -- General configuration ------------------------------------------------
 
@@ -36,8 +37,8 @@
   'sphinx.ext.mathjax',
   'sphinx.ext.ifconfig',
   'sphinx.ext.githubpages',
-  'mathdef',
-  'pseudo-lexer'
+  'util.mathdef',
+  'util.pseudo-lexer'
 ]
 
 # Add any paths that contain templates here, relative to this directory.
diff --git a/document/core/util/bikeshed/conf.py b/document/core/util/bikeshed/conf.py
index 930d47191..31273d2a3 100644
--- a/document/core/util/bikeshed/conf.py
+++ b/document/core/util/bikeshed/conf.py
@@ -1,470 +1,41 @@
 # -*- coding: utf-8 -*-
 #
-# WebAssembly documentation build configuration file, created by
-# sphinx-quickstart on Mon Nov 21 11:32:49 2016.
-#
-# This file is execfile()d with the current directory set to its
-# containing dir.
-#
-# Note that not all possible configuration values are present in this
-# autogenerated file.
-#
-# All configuration values have a default; values that are commented out
-# serve to show the default.
+# Sphinx configuration for bikeshed builds (make bikeshed).
+# This imports the main document/core/conf.py, then overwrites certain config
+# values for the bikeshed build.
 
-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
 import os
 import sys
-pwd = os.path.abspath('../..')
-sys.path.insert(0, pwd + '/util')
-
-# -- General configuration ------------------------------------------------
-
-# If your documentation needs a minimal Sphinx version, state it here.
-#
-needs_sphinx = '1.4'
-
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
-# ones.
-extensions = [
-  'sphinx.ext.todo',
-  'sphinx.ext.coverage',
-  'sphinx.ext.mathjax',
-  'sphinx.ext.ifconfig',
-  'sphinx.ext.githubpages',
-  'mathdefbs',
-  'pseudo-lexer'
-]
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
-
-# The suffix(es) of source filenames.
-# You can specify multiple suffix as a list of string:
-#
-source_suffix = ['.rst']
-
-# The encoding of source files.
-#
-# source_encoding = 'utf-8-sig'
-
-# The master toctree document.
-master_doc = 'index'
-
-# General information about the project.
-name = 'WebAssembly'
-project = u'WebAssembly'
-title = u'WebAssembly Specification'
-copyright = u'2017, WebAssembly Community Group'
-author = u'WebAssembly Community Group'
-logo = 'static/webassembly.png'
-
-# The version info for the project you're documenting, acts as replacement for
-# |version| and |release|, also used in various other places throughout the
-# built documents.
-#
-# The short X.Y version.
-version = u'1.1'
-# The full version, including alpha/beta/rc tags.
-release = version + ''
-
-# The language for content autogenerated by Sphinx. Refer to documentation
-# for a list of supported languages.
-#
-# This is also used if you do content translation via gettext catalogs.
-# Usually you set "language" from the command line for these cases.
-language = None
-
-# There are two options for replacing |today|: either, you set today to some
-# non-false value, then it is used:
-#
-# today = ''
-#
-# Else, today_fmt is used as the format for a strftime call.
-#
-# today_fmt = '%B %d, %Y'
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-# This patterns also effect to html_static_path and html_extra_path
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
-
-# The reST default role (used for this markup: `text`) to use for all
-# documents.
-#
-# default_role = None
-
-# If true, '()' will be appended to :func: etc. cross-reference text.
-#
-# add_function_parentheses = True
-
-# If true, the current module name will be prepended to all description
-# unit titles (such as .. function::).
-#
-# add_module_names = True
-
-# If true, sectionauthor and moduleauthor directives will be shown in the
-# output. They are ignored by default.
-#
-# show_authors = False
-
-# The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
-
-# A list of ignored prefixes for module index sorting.
-# modindex_common_prefix = []
+original_pwd = os.path.abspath('../..')
+# Change sys.path so that we can find the main 'conf.py'.
+sys.path.insert(0, original_pwd)
+from conf import *
+main_conf_pwd = pwd
 
-# If true, keep warnings as "system message" paragraphs in the built documents.
-# keep_warnings = False
+# Now that we have imported all the settings, we need to overwrite some of
+# them.
 
-# If true, `todo` and `todoList` produce output, else they produce nothing.
-todo_include_todos = True
+# The first is `pwd`, we want to reset it to document/core, because rst_prolog
+# below depends on this to find macros.def.
+pwd = original_pwd
 
+# The bikeshed build requires the mathdefbs extension.
+extensions[extensions.index('util.mathdef')] = 'util.mathdefbs'
 
-# -- Options for HTML output ----------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-#
+# Overwrite html themes and configurations.
 html_theme = 'classic'
 html_permalinks = False
-
-# Theme options are theme-specific and customize the look and feel of a theme
-# further.  For a list of options available for each theme, see the
-# documentation.
-#
 html_theme_options = {
   'nosidebar': True,
 }
-
-html_sidebars = {
-  '**': [
-    # 'about.html',
-    'navigation.html',
-    # 'relations.html',
-    'searchbox.html',
-  ]
-}
-
-
-# Add any paths that contain custom themes here, relative to this directory.
-# html_theme_path = []
-
-# The name for this set of Sphinx documents.
-# "<project> v<release> documentation" by default.
-#
-html_title = project + u' ' + release
-
-# A shorter title for the navigation bar.  Default is the same as html_title.
-#
-# html_short_title = None
-
-# The name of an image file (relative to this directory) to place at the top
-# of the sidebar.
-#
-html_logo = logo
-
-# The name of an image file (relative to this directory) to use as a favicon of
-# the docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
-# pixels large.
-#
-# html_favicon = None
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-# html_static_path = ['_static', 'static/custom.css']
-
-# Add any extra paths that contain custom files (such as robots.txt or
-# .htaccess) here, relative to this directory. These files are copied
-# directly to the root of the documentation.
-#
-# html_extra_path = []
-
-# If not None, a 'Last updated on:' timestamp is inserted at every page
-# bottom, using the given strftime format.
-# The empty string is equivalent to '%b %d, %Y'.
-#
-# html_last_updated_fmt = None
-
-# If true, SmartyPants will be used to convert quotes and dashes to
-# typographically correct entities.
-#
-# html_use_smartypants = True
-
-# Additional templates that should be rendered to pages, maps page names to
-# template names.
-#
-# html_additional_pages = {}
-
-# If false, no module index is generated.
-#
-html_domain_indices = False
-
-# If false, no index is generated.
-#
-html_use_index = True
-
-# If true, the index is split into individual pages for each letter.
-#
-html_split_index = False
-
-# If true, the reST sources are included in the HTML build as _sources/name. The default is True.
-#
-html_copy_source = False
-
-# If true, links to the reST sources are added to the pages.
-#
-html_show_sourcelink = False
-
-# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
-#
-html_show_sphinx = False
-
-# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
-#
 html_show_copyright = False
 
-# If this is not None, a ‘Last updated on:’ timestamp is inserted at every
-# page bottom, using the given strftime() format.
-#
-html_last_updated_fmt = None
-
-# If true, an OpenSearch description file will be output, and all pages will
-# contain a <link> tag referring to it.  The value of this option must be the
-# base URL from which the finished HTML is served.
-#
-# html_use_opensearch = ''
-
-# This is the file name suffix for HTML files (e.g. ".xhtml").
-#
-# html_file_suffix = None
+# Overwrite the prolog to make sure the include directive has the correct path.
 
-# Language to be used for generating the HTML full-text search index.
-# Sphinx supports the following languages:
-#   'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
-#   'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr', 'zh'
-#
-# html_search_language = 'en'
-
-# A dictionary with options for the search language support, empty by default.
-# 'ja' uses this config value.
-# 'zh' user can custom change `jieba` dictionary path.
-#
-# html_search_options = {'type': 'default'}
-
-# The name of a javascript file (relative to the configuration directory) that
-# implements a search results scorer. If empty, the default will be used.
-#
-# html_search_scorer = 'scorer.js'
-
-# Output file base name for HTML help builder.
-#
-htmlhelp_basename = 'WebAssemblydoc'
-
-
-# -- Options for LaTeX output ---------------------------------------------
-
-latex_elements = {
-   # The paper size ('a4paper' or 'letterpaper').
-  'papersize': 'a4paper',
-
-   # The font size ('10pt', '11pt' or '12pt').
-  'pointsize': '10pt',
-
-   # Additional stuff for the LaTeX preamble.
-   'preamble': '',
-
-   # Latex figure (float) alignment
-  'figure_align': 'htbp',
-
-   # Fancy chapters [Bjarne, Sonny, Lenny, Glenn, Conny, Rejne]
-   'fncychap': '\\usepackage[Sonny]{fncychap}',
-}
-
-# Grouping the document tree into LaTeX files. List of tuples
-# (source start file, target name, title,
-#  author, documentclass [howto, manual, or own class]).
-latex_documents = [
-  ( master_doc,
-    name + '.tex',
-    title,
-    author,
-    'manual'
-  ),
-]
-
-# The name of an image file (relative to this directory) to place at the top of
-# the title page.
-#
-latex_logo = logo
-
-# For "manual" documents [part, chapter, or section].
-#
-latex_toplevel_sectioning = 'chapter'
-
-# If true, show page references after internal links.
-#
-latex_show_pagerefs = False
-
-# How to show URL addresses after external links [no, footnote, inline].
-#
-latex_show_urls = 'footnote'
-
-# Documents to append as an appendix to all manuals.
-#
-# latex_appendices = []
-
-# It false, will not define \strong, \code, \titleref, \crossref ... but only
-# \sphinxstrong, ..., \sphinxtitleref, ... To help avoid clash with user added
-# packages.
-#
-# latex_keep_old_macro_names = True
-
-# If false, no module index is generated.
-#
-latex_domain_indices = False
-
-
-# -- Options for manual page output ---------------------------------------
-
-# One entry per manual page. List of tuples
-# (source start file, name, description, authors, manual section).
-man_pages = [
-  ( master_doc,
-    name,
-    title,
-    [author],
-    1
-  )
-]
-
-# If true, show URL addresses after external links.
-#
-# man_show_urls = False
-
-
-# -- Options for Texinfo output -------------------------------------------
-
-# Grouping the document tree into Texinfo files. List of tuples
-# (source start file, target name, title, author,
-#  dir menu entry, description, category)
-texinfo_documents = [
-  ( master_doc,
-    name,
-    title,
-    author,
-    name,
-    'A portable low-level execution format.',
-    'Virtual Machine'
-  ),
-]
-
-# Documents to append as an appendix to all manuals.
-#
-# texinfo_appendices = []
-
-# If false, no module index is generated.
-#
-texinfo_domain_indices = False
-
-# How to display URL addresses: 'footnote', 'no', or 'inline'.
-#
-# texinfo_show_urls = 'footnote'
-
-# If true, do not generate a @detailmenu in the "Top" node's menu.
-#
-# texinfo_no_detailmenu = False
-
-
-# -- Options for Epub output ----------------------------------------------
-
-# Bibliographic Dublin Core info.
-epub_title = project
-epub_author = author
-epub_publisher = author
-epub_copyright = copyright
-
-# The basename for the epub file. It defaults to the project name.
-# epub_basename = project
-
-# The HTML theme for the epub output. Since the default themes are not
-# optimized for small screen space, using the same theme for HTML and epub
-# output is usually not wise. This defaults to 'epub', a theme designed to save
-# visual space.
-#
-# epub_theme = 'epub'
-
-# The language of the text. It defaults to the language option
-# or 'en' if the language is not set.
-#
-# epub_language = ''
-
-# The scheme of the identifier. Typical schemes are ISBN or URL.
-# epub_scheme = ''
-
-# The unique identifier of the text. This can be a ISBN number
-# or the project homepage.
-#
-# epub_identifier = ''
-
-# A unique identification for the text.
-#
-# epub_uid = ''
-
-# A tuple containing the cover image and cover page html template filenames.
-#
-# epub_cover = ()
-
-# A sequence of (type, uri, title) tuples for the guide element of content.opf.
-#
-# epub_guide = ()
-
-# HTML files that should be inserted before the pages created by sphinx.
-# The format is a list of tuples containing the path and title.
-#
-# epub_pre_files = []
-
-# HTML files that should be inserted after the pages created by sphinx.
-# The format is a list of tuples containing the path and title.
-#
-# epub_post_files = []
-
-# A list of files that should not be packed into the epub file.
-epub_exclude_files = ['search.html']
-
-# The depth of the table of contents in toc.ncx.
-#
-# epub_tocdepth = 3
-
-# Allow duplicate toc entries.
-#
-# epub_tocdup = True
-
-# Choose between 'default' and 'includehidden'.
-#
-# epub_tocscope = 'default'
-
-# Fix unsupported image types using the Pillow.
-#
-# epub_fix_images = False
-
-# Scale large images.
-#
-# epub_max_image_width = 0
-
-# How to display URL addresses: 'footnote', 'no', or 'inline'.
-#
-# epub_show_urls = 'inline'
-
-# If false, no index is generated.
-#
-# epub_use_index = True
+main_macros_def = "/" + main_conf_pwd + "/util/macros.def"
+# If we hit this assertion, the configuration files probably moved, or files
+# are renamed, and we have to update rst_prolog accordingly.
+assert(main_macros_def in rst_prolog)
+rst_prolog  = rst_prolog.replace(main_macros_def, "/" + pwd + "/util/macros.def")
 
-# Macros
-rst_prolog = """
-.. include:: /""" + pwd + """/util/macros.def
-"""
+del mathjax_config

From b506bdae4c71da655ae171b9f889493dd18aa16e Mon Sep 17 00:00:00 2001
From: Ng Zhi An <zhin@chromium.org>
Date: Wed, 27 Oct 2021 10:33:13 -0700
Subject: [PATCH 064/285] Check that partially-oob stores do not store partial
 data (#1384)

For #1250. More tests for different data types in a follow-up.
---
 test/core/memory_trap.wast | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/test/core/memory_trap.wast b/test/core/memory_trap.wast
index a4156fe2c..91990c6fa 100644
--- a/test/core/memory_trap.wast
+++ b/test/core/memory_trap.wast
@@ -20,7 +20,9 @@
 
 (assert_return (invoke "store" (i32.const -4) (i32.const 42)))
 (assert_return (invoke "load" (i32.const -4)) (i32.const 42))
-(assert_trap (invoke "store" (i32.const -3) (i32.const 13)) "out of bounds memory access")
+(assert_trap (invoke "store" (i32.const -3) (i32.const 0x12345678)) "out of bounds memory access")
+;; check that the oob store above does not store partial data.
+(assert_return (invoke "load" (i32.const -4)) (i32.const 42))
 (assert_trap (invoke "load" (i32.const -3)) "out of bounds memory access")
 (assert_trap (invoke "store" (i32.const -2) (i32.const 13)) "out of bounds memory access")
 (assert_trap (invoke "load" (i32.const -2)) "out of bounds memory access")

From 941c6f37cb13de20f54b89b73145f802b87b8155 Mon Sep 17 00:00:00 2001
From: Ng Zhi An <zhin@chromium.org>
Date: Wed, 27 Oct 2021 10:54:40 -0700
Subject: [PATCH 065/285] Upgrade katex to v0.13.19 (#1383)

v0.11.0 added trust setting that indicates if input text is trusted,
this breaks \href.
Update to v0.13.19 which accepts a command line flag --trust to trust
all inputs.

I diffed the singlehtml output, it looks like the only changes are in
certain text that were:

<span class="mord mathsf">i</span><span class="mord
mathsf">3</span><span class="mord mathsf">2</span>

became

<span class="mord mathsf">i32</span>

which is a nice simplification.
---
 document/core/util/katex            | 2 +-
 document/core/util/mathjax2katex.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/util/katex b/document/core/util/katex
index b9deec098..e751278cf 160000
--- a/document/core/util/katex
+++ b/document/core/util/katex
@@ -1 +1 @@
-Subproject commit b9deec098f35919b9ad77baa6b11b7593473d488
+Subproject commit e751278cff42fada16dba6df331fda52aaa90f73
diff --git a/document/core/util/mathjax2katex.py b/document/core/util/mathjax2katex.py
index f9e709f80..39e7b9d4e 100755
--- a/document/core/util/mathjax2katex.py
+++ b/document/core/util/mathjax2katex.py
@@ -106,7 +106,7 @@ def ReplaceMath(cache, data):
         break
       data = data[:start] + v.replace('#1', data[start+len(k):end]) + data[end:]
   p = subprocess.Popen(
-      ['node', os.path.join(SCRIPT_DIR, 'katex/cli.js'), '--display-mode'],
+      ['node', os.path.join(SCRIPT_DIR, 'katex/cli.js'), '--display-mode', '--trust'],
       stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
   ret = p.communicate(input=data)[0]
   if p.returncode != 0:

From 93054e700f6180fe0a49023a2e5b0309be3cf2fa Mon Sep 17 00:00:00 2001
From: Ng Zhi An <zhin@chromium.org>
Date: Thu, 28 Oct 2021 09:47:13 -0700
Subject: [PATCH 066/285] Check all types of partially-oob stores (#1385)

Follow-up to #1384 to add checks for all numeric type.

Fixes #1250.
---
 test/core/memory_trap.wast | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/test/core/memory_trap.wast b/test/core/memory_trap.wast
index 91990c6fa..5ce8f5c31 100644
--- a/test/core/memory_trap.wast
+++ b/test/core/memory_trap.wast
@@ -21,8 +21,6 @@
 (assert_return (invoke "store" (i32.const -4) (i32.const 42)))
 (assert_return (invoke "load" (i32.const -4)) (i32.const 42))
 (assert_trap (invoke "store" (i32.const -3) (i32.const 0x12345678)) "out of bounds memory access")
-;; check that the oob store above does not store partial data.
-(assert_return (invoke "load" (i32.const -4)) (i32.const 42))
 (assert_trap (invoke "load" (i32.const -3)) "out of bounds memory access")
 (assert_trap (invoke "store" (i32.const -2) (i32.const 13)) "out of bounds memory access")
 (assert_trap (invoke "load" (i32.const -2)) "out of bounds memory access")
@@ -270,3 +268,15 @@
 ;; No memory was changed
 (assert_return (invoke "i64.load" (i32.const 0xfff8)) (i64.const 0x6867666564636261))
 (assert_return (invoke "i64.load" (i32.const 0)) (i64.const 0x6867666564636261))
+
+;; Check that out of bounds store do not store partial data.
+;; Zero last 8 bytes.
+(assert_return (invoke "i64.store" (i32.const 0xfff8) (i64.const 0)))
+(assert_trap (invoke "i32.store" (i32.const 0xfffd) (i32.const 0x12345678)) "out of bounds memory access")
+(assert_return (invoke "i32.load" (i32.const 0xfffc)) (i32.const 0))
+(assert_trap (invoke "i64.store" (i32.const 0xfff9) (i64.const 0x1234567890abcdef)) "out of bounds memory access")
+(assert_return (invoke "i64.load" (i32.const 0xfff8)) (i64.const 0))
+(assert_trap (invoke "f32.store" (i32.const 0xfffd) (f32.const 0x12345678)) "out of bounds memory access")
+(assert_return (invoke "f32.load" (i32.const 0xfffc)) (f32.const 0))
+(assert_trap (invoke "f64.store" (i32.const 0xfff9) (f64.const 0x1234567890abcdef)) "out of bounds memory access")
+(assert_return (invoke "f64.load" (i32.const 0xfff8)) (f64.const 0))

From b6307dc21b01e4cc6b4612e3dd28603626a14f57 Mon Sep 17 00:00:00 2001
From: Ng Zhi An <zhin@chromium.org>
Date: Fri, 29 Oct 2021 11:09:05 -0700
Subject: [PATCH 067/285] Upgrade to Sphinx 4.0.0 (#1387)

Changes:
https://www.sphinx-doc.org/en/master/changes.html#release-4-0-0-released-may-09-2021

Things to note:

- docutils updated to 0.17
https://docutils.sourceforge.io/RELEASE-NOTES.html#release-0-17-2021-04-03
the big change here is to use semantic elements, <div class="section">
is now <section>, I see this a whole bunch when I diff the output HTML.
- supposedly some html themes break due to the docutils change, probably
due to divs not matching, I don't see any visible breakage, so it should
be fine
- mathjax 3
https://docs.mathjax.org/en/latest/upgrading/whats-new-3.0.html it's
faster to render, we need to tweak our configuration a bit, to
camelCase, so updated it in conf.py

I diffed the output html, some differences I noted:

- div -> section as noted above
- a new meta tag for Docutils
- link tag for css, the type and href attributs swapped places
- script tag for documetation_options, id and data-url_root swapped
places
- some css changes in sphinx css files

Co-authored-by: Ms2ger <Ms2ger@gmail.com>
---
 .github/workflows/main.yml          | 2 +-
 document/README.md                  | 2 +-
 document/core/conf.py               | 9 +++++----
 document/core/util/bikeshed/conf.py | 2 +-
 4 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index cc1a9c333..4a5527ca2 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -52,7 +52,7 @@ jobs:
       - run: pip install bikeshed && bikeshed update
       - run: pip install six
       - run: sudo apt-get update -y && sudo apt-get install -y latexmk texlive-latex-recommended texlive-latex-extra texlive-fonts-recommended
-      - run: pip install sphinx==3.5.4
+      - run: pip install sphinx==4.0.0
       - run: cd document/core && make all
       - uses: actions/upload-artifact@v2
         with:
diff --git a/document/README.md b/document/README.md
index 6ee838af0..caf75430d 100644
--- a/document/README.md
+++ b/document/README.md
@@ -42,7 +42,7 @@ pipenv shell
 Install Python dependencies:
 
 ```
-pipenv install Sphinx==3.5.4
+pipenv install Sphinx==4.0.0
 ```
 
 ### Checking out the repository
diff --git a/document/core/conf.py b/document/core/conf.py
index 2bae57195..a012f33bc 100644
--- a/document/core/conf.py
+++ b/document/core/conf.py
@@ -492,8 +492,9 @@
 .. include:: /""" + pwd + """/util/macros.def
 """
 
-# https://www.sphinx-doc.org/en/master/usage/extensions/math.html#confval-mathjax_config
-# http://docs.mathjax.org/en/v2.7-latest/options/input-processors/TeX.html
-mathjax_config = {
-    'TeX': { 'MAXBUFFER': 30*1024 },
+# https://www.sphinx-doc.org/en/master/usage/extensions/math.html#confval-mathjax3_config
+# https://docs.mathjax.org/en/latest/web/configuration.html#configuration
+# https://docs.mathjax.org/en/latest/options/input/tex.html#tex-maxbuffer
+mathjax3_config = {
+    'tex': { 'maxBuffer': 30*1024 },
 }
diff --git a/document/core/util/bikeshed/conf.py b/document/core/util/bikeshed/conf.py
index 31273d2a3..af725bd7e 100644
--- a/document/core/util/bikeshed/conf.py
+++ b/document/core/util/bikeshed/conf.py
@@ -38,4 +38,4 @@
 assert(main_macros_def in rst_prolog)
 rst_prolog  = rst_prolog.replace(main_macros_def, "/" + pwd + "/util/macros.def")
 
-del mathjax_config
+del mathjax3_config

From 932fbf8ce19c10812bd1df9903b483dece96a67f Mon Sep 17 00:00:00 2001
From: devsnek <me@gus.host>
Date: Tue, 2 Nov 2021 04:45:06 -0500
Subject: [PATCH 068/285] [spec] Remove outdated footnote (#1389)

---
 document/core/intro/overview.rst | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/document/core/intro/overview.rst b/document/core/intro/overview.rst
index 6973396c0..351f1ed2d 100644
--- a/document/core/intro/overview.rst
+++ b/document/core/intro/overview.rst
@@ -50,7 +50,7 @@ This language is structured around the following concepts.
 **Functions**
   Code is organized into separate *functions*.
   Each function takes a sequence of values as parameters
-  and returns a sequence of values as results. [#arity]_
+  and returns a sequence of values as results.
   Functions can call each other, including recursively,
   resulting in an implicit call stack that cannot be accessed directly.
   Functions may also declare mutable *local variables* that are usable as virtual registers.
@@ -96,8 +96,6 @@ This language is structured around the following concepts.
 
 .. [#stackmachine] In practice, implementations need not maintain an actual operand stack. Instead, the stack can be viewed as a set of anonymous registers that are implicitly referenced by instructions. The :ref:`type system <validation>` ensures that the stack height, and thus any referenced register, is always known statically.
 
-.. [#arity] In the current version of WebAssembly, there may be at most one result value.
-
 
 .. index:: phases, decoding, validation, execution, instantiation, invocation
 

From 3ae76b1ca33ef5cc56b6ca2dde6ec6c132fa683c Mon Sep 17 00:00:00 2001
From: Ng Zhi An <zhin@chromium.org>
Date: Tue, 2 Nov 2021 10:19:51 -0700
Subject: [PATCH 069/285] Only include ref links to index in multi-page html
 (#1388)

This allows us to drop some manual links removal in mathjax2katex.py.
---
 document/core/index.rst             |  6 +++++-
 document/core/util/mathjax2katex.py | 13 -------------
 2 files changed, 5 insertions(+), 14 deletions(-)

diff --git a/document/core/index.rst b/document/core/index.rst
index 94bd4b218..0179df7be 100644
--- a/document/core/index.rst
+++ b/document/core/index.rst
@@ -29,7 +29,11 @@ WebAssembly Specification
       appendix/index-instructions
       appendix/index-rules
 
-.. only:: html
+..
+   Only include these links when using (multi-page) html builder.
+   (The singlepage html builder is called builder_singlehtml.)
+
+.. only:: builder_html
 
    * :ref:`index-type`
    * :ref:`index-instr`
diff --git a/document/core/util/mathjax2katex.py b/document/core/util/mathjax2katex.py
index 39e7b9d4e..fabd08283 100755
--- a/document/core/util/mathjax2katex.py
+++ b/document/core/util/mathjax2katex.py
@@ -160,19 +160,6 @@ def ExtractMath(match):
   data = data.replace(
       '<li class="nav-item nav-item-0"><a href="index.html#document-index">'
       'WebAssembly 1.0</a> »', '')
-  # Drop Index links.
-  data = data.replace(
-      '<li><a class="reference internal" href="index.html#index-type">'
-      '<span class="std std-ref">Index of Types</span></a>', '')
-  data = data.replace(
-      '<li><a class="reference internal" href="index.html#index-instr">'
-      '<span class="std std-ref">Index of Instructions</span></a>', '')
-  data = data.replace(
-      '<li><a class="reference internal" href="index.html#index-rules">'
-      '<span class="std std-ref">Index of Semantic Rules</span></a>', '')
-  data = data.replace(
-      '<li><a class="reference internal" href="genindex.html">'
-      '<span class="std std-ref">Index</span></a>', '')
   # Drop sphinx css.
   data = data.replace(
       '<link href="_static/classic.css" rel="stylesheet" type="text/css">', '')

From e87021b46a7519ff5264e62fa4773e4c92ded57a Mon Sep 17 00:00:00 2001
From: Ng Zhi An <zhin@google.com>
Date: Tue, 2 Nov 2021 14:54:57 -0700
Subject: [PATCH 070/285] Fix html_last_updated_fmt

'%F' is not a supported format, see
https://github.com/sphinx-doc/sphinx/blob/4.x/sphinx/util/i18n.py#L133,
it is also not supported in Python's strftime/strptime
https://docs.python.org/3/library/datetime.html#strftime-strptime-behavior.

It is however supported in strftime
(https://man7.org/linux/man-pages/man3/strftime.3.html) and defined to
be "%Y-%m-%d", which is supported by sphinx.
---
 document/core/conf.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/conf.py b/document/core/conf.py
index a012f33bc..1cde497d7 100644
--- a/document/core/conf.py
+++ b/document/core/conf.py
@@ -252,7 +252,7 @@
 # If this is not None, a ‘Last updated on:’ timestamp is inserted at every
 # page bottom, using the given strftime() format.
 #
-html_last_updated_fmt = '%F'
+html_last_updated_fmt = '%Y-%m-%d'
 
 # If true, an OpenSearch description file will be output, and all pages will
 # contain a <link> tag referring to it.  The value of this option must be the

From 25ffaea16814c37dd4ab5df688255da9f65888e9 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@dfinity.org>
Date: Thu, 11 Nov 2021 08:34:40 +0100
Subject: [PATCH 071/285] [spec] Add reference types to overview (#1394)

---
 document/core/intro/overview.rst | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/document/core/intro/overview.rst b/document/core/intro/overview.rst
index 351f1ed2d..4b7ec0652 100644
--- a/document/core/intro/overview.rst
+++ b/document/core/intro/overview.rst
@@ -23,6 +23,9 @@ This language is structured around the following concepts.
   Instead, integers are interpreted by respective operations
   as either unsigned or signed in two’s complement representation.
 
+  Finally, values can consist of opaque *references* that represent pointers towards different sorts of entities.
+  Unlike with other types, their size or representation is not observable.
+
 .. _instruction:
 
 **Instructions**

From eae4abc2cc1f54850cc3f6b61bec7da935ae4333 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hans=20H=C3=B6glund?= <hanshoglund@users.noreply.github.com>
Date: Tue, 16 Nov 2021 21:51:28 +0000
Subject: [PATCH 072/285] [interpreter] Remove use of physical equality on
 characters (#1396)

---
 interpreter/exec/int.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interpreter/exec/int.ml b/interpreter/exec/int.ml
index ec23208d8..375475dfb 100644
--- a/interpreter/exec/int.ml
+++ b/interpreter/exec/int.ml
@@ -284,7 +284,7 @@ struct
 
   let of_string_u s =
     let n = of_string s in
-    require (s.[0] != '+' && s.[0] != '-');
+    require (s.[0] <> '+' && s.[0] <> '-');
     n
 
   (* String conversion that groups digits for readability *)

From f5a260a2025ba4d7d398654581c7c532e3a2c319 Mon Sep 17 00:00:00 2001
From: Ng Zhi An <zhin@chromium.org>
Date: Thu, 18 Nov 2021 10:42:28 -0800
Subject: [PATCH 073/285] Merge SIMD proposal (#1391)

SIMD is [phase 5](https://github.com/WebAssembly/simd/issues/507), merge all the changes back into main spec.
---
 document/core/appendix/algorithm.rst          |     4 +-
 document/core/appendix/changes.rst            |    37 +
 .../core/appendix/gen-index-instructions.py   |   244 +
 document/core/appendix/index-instructions.rst |   792 +-
 document/core/appendix/index-types.rst        |     3 +-
 document/core/binary/conventions.rst          |     6 +-
 document/core/binary/instructions.rst         |   379 +-
 document/core/binary/types.rst                |    16 +
 document/core/exec/instructions.rst           |   991 ++
 document/core/exec/numerics.rst               |   379 +-
 document/core/exec/runtime.rst                |     9 +-
 document/core/intro/overview.rst              |     9 +-
 document/core/syntax/instructions.rst         |   256 +-
 document/core/syntax/types.rst                |    37 +-
 document/core/syntax/values.rst               |    11 +
 document/core/text/conventions.rst            |     4 +-
 document/core/text/instructions.rst           |   357 +
 document/core/text/types.rst                  |    17 +-
 document/core/util/macros.def                 |   124 +
 document/core/valid/instructions.rst          |   456 +-
 document/js-api/index.bs                      |    18 +
 interpreter/Makefile                          |    32 +-
 interpreter/README.md                         |    56 +-
 interpreter/binary/decode.ml                  |   274 +-
 interpreter/binary/encode.ml                  |   360 +-
 interpreter/exec/eval.ml                      |   160 +-
 .../exec/{eval_numeric.ml => eval_num.ml}     |    46 +-
 .../exec/{eval_numeric.mli => eval_num.mli}   |     2 -
 interpreter/exec/eval_vec.ml                  |   314 +
 interpreter/exec/eval_vec.mli                 |    16 +
 interpreter/exec/f32.ml                       |     2 +-
 interpreter/exec/f64.ml                       |     2 +-
 interpreter/exec/{float.ml => fxx.ml}         |     0
 interpreter/exec/i16.ml                       |    12 +
 interpreter/exec/i32.ml                       |     5 +-
 interpreter/exec/i32_convert.ml               |    16 +-
 interpreter/exec/i64.ml                       |     5 +-
 interpreter/exec/i64_convert.ml               |    16 +-
 interpreter/exec/i8.ml                        |    12 +
 interpreter/exec/{int.ml => ixx.ml}           |   156 +-
 interpreter/exec/numeric_error.ml             |     3 -
 interpreter/exec/v128.ml                      |   506 +
 interpreter/exec/v128.mli                     |   211 +
 interpreter/host/spectest.ml                  |     1 +
 interpreter/runtime/instance.ml               |     7 +
 interpreter/runtime/memory.ml                 |    56 +-
 interpreter/runtime/memory.mli                |    13 +-
 interpreter/script/js.ml                      |   148 +-
 interpreter/script/run.ml                     |   111 +-
 interpreter/script/script.ml                  |    26 +-
 interpreter/syntax/ast.ml                     |    94 +-
 interpreter/syntax/free.ml                    |     9 +-
 interpreter/syntax/operators.ml               |   315 +-
 interpreter/syntax/types.ml                   |    32 +-
 interpreter/syntax/values.ml                  |   119 +-
 interpreter/tests/smallint.ml                 |   108 +
 interpreter/text/arrange.ml                   |   323 +-
 interpreter/text/lexer.mll                    |   297 +-
 interpreter/text/parser.mly                   |   122 +-
 interpreter/util/lib.ml                       |     7 +-
 interpreter/util/lib.mli                      |     3 +-
 interpreter/valid/valid.ml                    |   161 +-
 proposals/simd/BinarySIMD.md                  |   270 +
 proposals/simd/ImplementationStatus.md        |   248 +
 proposals/simd/NewOpcodes.md                  |   157 +
 proposals/simd/SIMD.md                        |  1178 ++
 proposals/simd/TextSIMD.md                    |    27 +
 proposals/simd/W3CTAG-SIMDExplainer.md        |    72 +
 proposals/simd/WebAssembly-SIMD-May-2017.pdf  |   Bin 0 -> 128301 bytes
 test/core/run.py                              |     7 +-
 test/core/simd/meta/README.md                 |    55 +
 test/core/simd/meta/gen_tests.py              |    77 +
 test/core/simd/meta/simd.py                   |    84 +
 test/core/simd/meta/simd_arithmetic.py        |   328 +
 test/core/simd/meta/simd_bitwise.py           |   502 +
 test/core/simd/meta/simd_compare.py           |   412 +
 test/core/simd/meta/simd_ext_mul.py           |    75 +
 test/core/simd/meta/simd_extadd_pairwise.py   |    62 +
 test/core/simd/meta/simd_f32x4.py             |   376 +
 test/core/simd/meta/simd_f32x4_arith.py       |   229 +
 test/core/simd/meta/simd_f32x4_cmp.py         |   507 +
 test/core/simd/meta/simd_f32x4_pmin_pmax.py   |    83 +
 test/core/simd/meta/simd_f32x4_rounding.py    |    85 +
 test/core/simd/meta/simd_f64x2.py             |   395 +
 test/core/simd/meta/simd_f64x2_arith.py       |   165 +
 test/core/simd/meta/simd_f64x2_cmp.py         |   220 +
 test/core/simd/meta/simd_f64x2_pmin_pmax.py   |    27 +
 test/core/simd/meta/simd_f64x2_rounding.py    |    29 +
 test/core/simd/meta/simd_float_op.py          |   303 +
 test/core/simd/meta/simd_i16x8_arith.py       |   176 +
 test/core/simd/meta/simd_i16x8_cmp.py         |   825 ++
 .../simd/meta/simd_i16x8_q15mulr_sat_s.py     |    36 +
 test/core/simd/meta/simd_i32x4_arith.py       |   176 +
 test/core/simd/meta/simd_i32x4_cmp.py         |   837 ++
 test/core/simd/meta/simd_i32x4_dot_i16x8.py   |    56 +
 test/core/simd/meta/simd_i64x2_arith.py       |   201 +
 test/core/simd/meta/simd_i64x2_cmp.py         |   252 +
 test/core/simd/meta/simd_i8x16_arith.py       |   148 +
 test/core/simd/meta/simd_i8x16_cmp.py         |   825 ++
 test/core/simd/meta/simd_int_arith2.py        |   575 +
 test/core/simd/meta/simd_int_to_int_extend.py |   113 +
 .../simd/meta/simd_int_trunc_sat_float.py     |   178 +
 test/core/simd/meta/simd_integer_op.py        |   209 +
 test/core/simd/meta/simd_lane_value.py        |    38 +
 test/core/simd/meta/simd_load_lane.py         |   227 +
 test/core/simd/meta/simd_sat_arith.py         |   456 +
 test/core/simd/meta/simd_store_lane.py        |   237 +
 test/core/simd/meta/test_assert.py            |    91 +
 test/core/simd/simd_address.wast              |   157 +
 test/core/simd/simd_align.wast                |   355 +
 test/core/simd/simd_bit_shift.wast            |  1104 ++
 test/core/simd/simd_bitwise.wast              |   812 ++
 test/core/simd/simd_boolean.wast              |  1058 ++
 test/core/simd/simd_const.wast                |  1664 +++
 test/core/simd/simd_conversions.wast          |   899 ++
 test/core/simd/simd_f32x4.wast                |  2407 ++++
 test/core/simd/simd_f32x4_arith.wast          |  5476 ++++++++
 test/core/simd/simd_f32x4_cmp.wast            |  8167 +++++++++++
 test/core/simd/simd_f32x4_pmin_pmax.wast      | 11676 ++++++++++++++++
 test/core/simd/simd_f32x4_rounding.wast       |   424 +
 test/core/simd/simd_f64x2.wast                |  2459 ++++
 test/core/simd/simd_f64x2_arith.wast          |  5483 ++++++++
 test/core/simd/simd_f64x2_cmp.wast            |  8337 +++++++++++
 test/core/simd/simd_f64x2_pmin_pmax.wast      | 11676 ++++++++++++++++
 test/core/simd/simd_f64x2_rounding.wast       |   424 +
 test/core/simd/simd_i16x8_arith.wast          |   634 +
 test/core/simd/simd_i16x8_arith2.wast         |   610 +
 test/core/simd/simd_i16x8_cmp.wast            |  1901 +++
 .../simd_i16x8_extadd_pairwise_i8x16.wast     |    68 +
 test/core/simd/simd_i16x8_extmul_i8x16.wast   |   404 +
 test/core/simd/simd_i16x8_q15mulr_sat_s.wast  |   110 +
 test/core/simd/simd_i16x8_sat_arith.wast      |   742 +
 test/core/simd/simd_i32x4_arith.wast          |   634 +
 test/core/simd/simd_i32x4_arith2.wast         |   494 +
 test/core/simd/simd_i32x4_cmp.wast            |  1920 +++
 test/core/simd/simd_i32x4_dot_i16x8.wast      |   110 +
 .../simd_i32x4_extadd_pairwise_i16x8.wast     |    68 +
 test/core/simd/simd_i32x4_extmul_i16x8.wast   |   404 +
 .../core/simd/simd_i32x4_trunc_sat_f32x4.wast |   239 +
 .../core/simd/simd_i32x4_trunc_sat_f64x2.wast |   239 +
 test/core/simd/simd_i64x2_arith.wast          |   652 +
 test/core/simd/simd_i64x2_arith2.wast         |    78 +
 test/core/simd/simd_i64x2_cmp.wast            |   420 +
 test/core/simd/simd_i64x2_extmul_i32x4.wast   |   404 +
 test/core/simd/simd_i8x16_arith.wast          |   426 +
 test/core/simd/simd_i8x16_arith2.wast         |   713 +
 test/core/simd/simd_i8x16_cmp.wast            |  1847 +++
 test/core/simd/simd_i8x16_sat_arith.wast      |   718 +
 test/core/simd/simd_int_to_int_extend.wast    |   599 +
 test/core/simd/simd_lane.wast                 |  1265 ++
 test/core/simd/simd_load.wast                 |   188 +
 test/core/simd/simd_load16_lane.wast          |   211 +
 test/core/simd/simd_load32_lane.wast          |   143 +
 test/core/simd/simd_load64_lane.wast          |    97 +
 test/core/simd/simd_load8_lane.wast           |   299 +
 test/core/simd/simd_load_extend.wast          |   384 +
 test/core/simd/simd_load_splat.wast           |   261 +
 test/core/simd/simd_load_zero.wast            |   154 +
 test/core/simd/simd_splat.wast                |   430 +
 test/core/simd/simd_store.wast                |   166 +
 test/core/simd/simd_store16_lane.wast         |   299 +
 test/core/simd/simd_store32_lane.wast         |   199 +
 test/core/simd/simd_store64_lane.wast         |   131 +
 test/core/simd/simd_store8_lane.wast          |   427 +
 test/js-api/global/constructor.any.js         |     5 +
 165 files changed, 100917 insertions(+), 690 deletions(-)
 rename interpreter/exec/{eval_numeric.ml => eval_num.ml} (86%)
 rename interpreter/exec/{eval_numeric.mli => eval_num.mli} (82%)
 create mode 100644 interpreter/exec/eval_vec.ml
 create mode 100644 interpreter/exec/eval_vec.mli
 rename interpreter/exec/{float.ml => fxx.ml} (100%)
 create mode 100644 interpreter/exec/i16.ml
 create mode 100644 interpreter/exec/i8.ml
 rename interpreter/exec/{int.ml => ixx.ml} (60%)
 delete mode 100644 interpreter/exec/numeric_error.ml
 create mode 100644 interpreter/exec/v128.ml
 create mode 100644 interpreter/exec/v128.mli
 create mode 100644 interpreter/tests/smallint.ml
 create mode 100644 proposals/simd/BinarySIMD.md
 create mode 100644 proposals/simd/ImplementationStatus.md
 create mode 100644 proposals/simd/NewOpcodes.md
 create mode 100644 proposals/simd/SIMD.md
 create mode 100644 proposals/simd/TextSIMD.md
 create mode 100644 proposals/simd/W3CTAG-SIMDExplainer.md
 create mode 100644 proposals/simd/WebAssembly-SIMD-May-2017.pdf
 create mode 100644 test/core/simd/meta/README.md
 create mode 100644 test/core/simd/meta/gen_tests.py
 create mode 100644 test/core/simd/meta/simd.py
 create mode 100644 test/core/simd/meta/simd_arithmetic.py
 create mode 100644 test/core/simd/meta/simd_bitwise.py
 create mode 100644 test/core/simd/meta/simd_compare.py
 create mode 100644 test/core/simd/meta/simd_ext_mul.py
 create mode 100644 test/core/simd/meta/simd_extadd_pairwise.py
 create mode 100644 test/core/simd/meta/simd_f32x4.py
 create mode 100644 test/core/simd/meta/simd_f32x4_arith.py
 create mode 100644 test/core/simd/meta/simd_f32x4_cmp.py
 create mode 100644 test/core/simd/meta/simd_f32x4_pmin_pmax.py
 create mode 100644 test/core/simd/meta/simd_f32x4_rounding.py
 create mode 100644 test/core/simd/meta/simd_f64x2.py
 create mode 100644 test/core/simd/meta/simd_f64x2_arith.py
 create mode 100644 test/core/simd/meta/simd_f64x2_cmp.py
 create mode 100644 test/core/simd/meta/simd_f64x2_pmin_pmax.py
 create mode 100644 test/core/simd/meta/simd_f64x2_rounding.py
 create mode 100644 test/core/simd/meta/simd_float_op.py
 create mode 100644 test/core/simd/meta/simd_i16x8_arith.py
 create mode 100644 test/core/simd/meta/simd_i16x8_cmp.py
 create mode 100644 test/core/simd/meta/simd_i16x8_q15mulr_sat_s.py
 create mode 100644 test/core/simd/meta/simd_i32x4_arith.py
 create mode 100644 test/core/simd/meta/simd_i32x4_cmp.py
 create mode 100644 test/core/simd/meta/simd_i32x4_dot_i16x8.py
 create mode 100644 test/core/simd/meta/simd_i64x2_arith.py
 create mode 100644 test/core/simd/meta/simd_i64x2_cmp.py
 create mode 100644 test/core/simd/meta/simd_i8x16_arith.py
 create mode 100644 test/core/simd/meta/simd_i8x16_cmp.py
 create mode 100644 test/core/simd/meta/simd_int_arith2.py
 create mode 100644 test/core/simd/meta/simd_int_to_int_extend.py
 create mode 100644 test/core/simd/meta/simd_int_trunc_sat_float.py
 create mode 100644 test/core/simd/meta/simd_integer_op.py
 create mode 100644 test/core/simd/meta/simd_lane_value.py
 create mode 100644 test/core/simd/meta/simd_load_lane.py
 create mode 100644 test/core/simd/meta/simd_sat_arith.py
 create mode 100644 test/core/simd/meta/simd_store_lane.py
 create mode 100644 test/core/simd/meta/test_assert.py
 create mode 100644 test/core/simd/simd_address.wast
 create mode 100644 test/core/simd/simd_align.wast
 create mode 100644 test/core/simd/simd_bit_shift.wast
 create mode 100644 test/core/simd/simd_bitwise.wast
 create mode 100644 test/core/simd/simd_boolean.wast
 create mode 100644 test/core/simd/simd_const.wast
 create mode 100644 test/core/simd/simd_conversions.wast
 create mode 100644 test/core/simd/simd_f32x4.wast
 create mode 100644 test/core/simd/simd_f32x4_arith.wast
 create mode 100644 test/core/simd/simd_f32x4_cmp.wast
 create mode 100644 test/core/simd/simd_f32x4_pmin_pmax.wast
 create mode 100644 test/core/simd/simd_f32x4_rounding.wast
 create mode 100644 test/core/simd/simd_f64x2.wast
 create mode 100644 test/core/simd/simd_f64x2_arith.wast
 create mode 100644 test/core/simd/simd_f64x2_cmp.wast
 create mode 100644 test/core/simd/simd_f64x2_pmin_pmax.wast
 create mode 100644 test/core/simd/simd_f64x2_rounding.wast
 create mode 100644 test/core/simd/simd_i16x8_arith.wast
 create mode 100644 test/core/simd/simd_i16x8_arith2.wast
 create mode 100644 test/core/simd/simd_i16x8_cmp.wast
 create mode 100644 test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast
 create mode 100644 test/core/simd/simd_i16x8_extmul_i8x16.wast
 create mode 100644 test/core/simd/simd_i16x8_q15mulr_sat_s.wast
 create mode 100644 test/core/simd/simd_i16x8_sat_arith.wast
 create mode 100644 test/core/simd/simd_i32x4_arith.wast
 create mode 100644 test/core/simd/simd_i32x4_arith2.wast
 create mode 100644 test/core/simd/simd_i32x4_cmp.wast
 create mode 100644 test/core/simd/simd_i32x4_dot_i16x8.wast
 create mode 100644 test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast
 create mode 100644 test/core/simd/simd_i32x4_extmul_i16x8.wast
 create mode 100644 test/core/simd/simd_i32x4_trunc_sat_f32x4.wast
 create mode 100644 test/core/simd/simd_i32x4_trunc_sat_f64x2.wast
 create mode 100644 test/core/simd/simd_i64x2_arith.wast
 create mode 100644 test/core/simd/simd_i64x2_arith2.wast
 create mode 100644 test/core/simd/simd_i64x2_cmp.wast
 create mode 100644 test/core/simd/simd_i64x2_extmul_i32x4.wast
 create mode 100644 test/core/simd/simd_i8x16_arith.wast
 create mode 100644 test/core/simd/simd_i8x16_arith2.wast
 create mode 100644 test/core/simd/simd_i8x16_cmp.wast
 create mode 100644 test/core/simd/simd_i8x16_sat_arith.wast
 create mode 100644 test/core/simd/simd_int_to_int_extend.wast
 create mode 100644 test/core/simd/simd_lane.wast
 create mode 100644 test/core/simd/simd_load.wast
 create mode 100644 test/core/simd/simd_load16_lane.wast
 create mode 100644 test/core/simd/simd_load32_lane.wast
 create mode 100644 test/core/simd/simd_load64_lane.wast
 create mode 100644 test/core/simd/simd_load8_lane.wast
 create mode 100644 test/core/simd/simd_load_extend.wast
 create mode 100644 test/core/simd/simd_load_splat.wast
 create mode 100644 test/core/simd/simd_load_zero.wast
 create mode 100644 test/core/simd/simd_splat.wast
 create mode 100644 test/core/simd/simd_store.wast
 create mode 100644 test/core/simd/simd_store16_lane.wast
 create mode 100644 test/core/simd/simd_store32_lane.wast
 create mode 100644 test/core/simd/simd_store64_lane.wast
 create mode 100644 test/core/simd/simd_store8_lane.wast

diff --git a/document/core/appendix/algorithm.rst b/document/core/appendix/algorithm.rst
index 537105959..fa6fa1110 100644
--- a/document/core/appendix/algorithm.rst
+++ b/document/core/appendix/algorithm.rst
@@ -25,10 +25,10 @@ Types are representable as an enumeration.
 
 .. code-block:: pseudo
 
-   type val_type = I32 | I64 | F32 | F64 | Funcref | Externref
+   type val_type = I32 | I64 | F32 | F64 | V128 | Funcref | Externref
 
    func is_num(t : val_type | Unknown) : bool =
-     return t = I32 || t = I64 || t = F32 || t = F64 || t = Unknown
+     return t = I32 || t = I64 || t = F32 || t = F64 || t = V128 || t = Unknown
 
    func is_ref(t : val_type | Unknown) : bool =
      return t = Funcref || t = Externref || t = Unknown
diff --git a/document/core/appendix/changes.rst b/document/core/appendix/changes.rst
index 04330a914..66303ba21 100644
--- a/document/core/appendix/changes.rst
+++ b/document/core/appendix/changes.rst
@@ -104,6 +104,40 @@ Added instructions that modify ranges of memory or table entries [#proposal-reft
 * Active data and element segments boundaries are no longer checked at compile time but may trap instead
 
 
+.. index:: instructions, SIMD, value type, vector type
+
+Vector instructions
+...................
+
+Added vector type and instructions that manipulate multiple numeric values in parallel (also known as *SIMD*, single instruction multiple data) [#proposal-vectype]_
+
+* New :ref:`value type <syntax-valtype>`: |V128|
+
+* New :ref:`memory instructions <syntax-instr-memory>`: :math:`\K{v128.}\LOAD`, :math:`\K{v128.}\LOAD{}\!N\!\K{x}\!M\!\K{\_}\sx`, :math:`\K{v128.}\LOAD{}N\K{\_zero}`, :math:`\K{v128.}\LOAD{}N\K{\_splat}`, :math:`\K{v128.}\LOAD{}N\K{\_lane}`, :math:`\K{v128.}\STORE`, :math:`\K{v128.}\STORE{}N\K{\_lane}`
+
+* New constant :ref:`vector instruction <syntax-instr-vec>`: :math:`\K{v128.}\VCONST`
+
+* New unary :ref:`vector instructions <syntax-instr-vec>`: :math:`\K{v128.not}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.abs}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.neg}`, :math:`\K{i8x16.popcnt}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.abs}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.neg}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.sqrt}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.ceil}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.floor}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.trunc}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.nearest}`
+
+* New binary :ref:`vector instructions <syntax-instr-vec>`: :math:`\K{v128.and}`, :math:`\K{v128.andnot}`, :math:`\K{v128.or}`, :math:`\K{v128.xor}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.add}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.sub}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.mul}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.add\_sat\_}\sx`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.sub\_sat\_}\sx`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.min\_}\sx`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.max\_}\sx`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.shl}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.shr\_}\sx`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.add}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.extmul\_}\half\K{\_i}\!N'\!\K{x}\!M'\!\K{\_}\sx`, :math:`\K{i16x8.q15mulr\_sat\_s}`, :math:`\K{i32x4.dot\_i16x8\_s}`, :math:`\K{i16x8.extadd\_pairwise\_i8x16\_}\sx`, :math:`\K{i32x4.extadd\_pairwise\_i16x8\_}\sx`, :math:`\K{i8x16.avgr\_u}`, :math:`\K{i16x8.avgr\_u}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.sub}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.mul}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.div}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.min}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.max}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.pmin}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.pmax}`
+
+* New ternary :ref:`vector instruction <syntax-instr-vec>`: :math:`\K{v128.bitselect}`
+
+* New test :ref:`vector instructions <syntax-instr-vec>`: :math:`\K{v128.any\_true}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.all\_true}`
+
+* New relational :ref:`vector instructions <syntax-instr-vec>`: :math:`\K{i}\!N\!\K{x}\!M\!\K{.eq}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.ne}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.lt\_}\sx`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.gt\_}\sx`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.le\_}\sx`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.ge\_}\sx`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.eq}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.ne}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.lt}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.gt}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.le}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.ge}`
+
+* New conversion :ref:`vector instructions <syntax-instr-vec>`::math:`\K{i32x4.trunc\_sat\_f32x4\_}\sx`, :math:`\K{i32x4.trunc\_sat\_f64x2\_}\sx\K{\_zero}`, :math:`\K{f32x4.convert\_i32x4\_}\sx`, :math:`\K{f32x4.demote\_f64x2\_zero}`, :math:`\K{f64x2.convert\_low\_i32x4\_}\sx`, :math:`\K{f64x2.promote\_low\_f32x4}`
+
+* New lane access :ref:`vector instructions <syntax-instr-vec>`: :math:`\K{i}\!N\!\K{x}\!M\!\K{.extract\_lane\_}\sx^?`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.replace\_lane}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.extract\_lane}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.replace\_lane}`
+
+* New lane splitting/combining :ref:`vector instructions <syntax-instr-vec>`: :math:`\K{i}\!N\!\K{x}\!M\!\K{.extend\_}\half\K{\_i}\!N'\!\K{x}\!M'\!\K{\_}\sx`, :math:`\K{i8x16.narrow\_i16x8\_}\sx`, :math:`\K{i16x8.narrow\_i32x4\_}\sx`
+
+* New byte reordering :ref:`vector instructions <syntax-instr-vec>`: :math:`\K{i8x16.shuffle}`, :math:`\K{i8x16.swizzle}`
+
+* New injection/projection :ref:`vector instructions <syntax-instr-vec>`: :math:`\K{i}\!N\!\K{x}\!M\!\K{.splat}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.splat}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.bitmask}`
+
+
 .. [#proposal-signext]
    https://github.com/WebAssembly/spec/tree/main/proposals/sign-extension-ops/
 
@@ -118,3 +152,6 @@ Added instructions that modify ranges of memory or table entries [#proposal-reft
 
 .. [#proposal-bulk]
    https://github.com/WebAssembly/spec/tree/main/proposals/bulk-memory-operations/
+
+.. [#proposal-vectype]
+   https://github.com/WebAssembly/spec/tree/main/proposals/simd/
diff --git a/document/core/appendix/gen-index-instructions.py b/document/core/appendix/gen-index-instructions.py
index 713da71d2..9e8dbb8c3 100755
--- a/document/core/appendix/gen-index-instructions.py
+++ b/document/core/appendix/gen-index-instructions.py
@@ -331,6 +331,250 @@ def Instruction(name, opcode, type=None, validation=None, execution=None, operat
     Instruction(r'\TABLEGROW~x', r'\hex{FC}~\hex{0F}', r'[t~\I32] \to [\I32]', r'valid-table.grow', r'exec-table.grow'),
     Instruction(r'\TABLESIZE~x', r'\hex{FC}~\hex{10}', r'[] \to [\I32]', r'valid-table.size', r'exec-table.size'),
     Instruction(r'\TABLEFILL~x', r'\hex{FC}~\hex{11}', r'[\I32~t~\I32] \to []', r'valid-table.fill', r'exec-table.fill'),
+    Instruction(r'\I32.\TRUNC\K{\_sat\_}\F32\K{\_s}', r'\hex{FC}~~0', r'[\F32] \to [\I32]', r'valid-cvtop', r'exec-cvtop', r'op-trunc_sat_s'),
+    Instruction(r'\I32.\TRUNC\K{\_sat\_}\F32\K{\_u}', r'\hex{FC}~~1', r'[\F32] \to [\I32]', r'valid-cvtop', r'exec-cvtop', r'op-trunc_sat_u'),
+    Instruction(r'\I32.\TRUNC\K{\_sat\_}\F64\K{\_s}', r'\hex{FC}~~2', r'[\F64] \to [\I32]', r'valid-cvtop', r'exec-cvtop', r'op-trunc_sat_s'),
+    Instruction(r'\I32.\TRUNC\K{\_sat\_}\F64\K{\_u}', r'\hex{FC}~~3', r'[\F64] \to [\I32]', r'valid-cvtop', r'exec-cvtop', r'op-trunc_sat_u'),
+    Instruction(r'\I64.\TRUNC\K{\_sat\_}\F32\K{\_s}', r'\hex{FC}~~4', r'[\F32] \to [\I64]', r'valid-cvtop', r'exec-cvtop', r'op-trunc_sat_s'),
+    Instruction(r'\I64.\TRUNC\K{\_sat\_}\F32\K{\_u}', r'\hex{FC}~~5', r'[\F32] \to [\I64]', r'valid-cvtop', r'exec-cvtop', r'op-trunc_sat_u'),
+    Instruction(r'\I64.\TRUNC\K{\_sat}\_\F64\K{\_s}', r'\hex{FC}~~6', r'[\F64] \to [\I64]', r'valid-cvtop', r'exec-cvtop', r'op-trunc_sat_s'),
+    Instruction(r'\I64.\TRUNC\K{\_sat\_}\F64\K{\_u}', r'\hex{FC}~~7', r'[\F64] \to [\I64]', r'valid-cvtop', r'exec-cvtop', r'op-trunc_sat_u'),
+    Instruction(r'\V128.\LOAD~\memarg', r'\hex{FD}~~\hex{00}', r'[\I32] \to [\V128]', r'valid-load', r'exec-load'),
+    Instruction(r'\I16X8.\LOAD\K{8x8\_s}~\memarg', r'\hex{FD}~~\hex{01}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
+    Instruction(r'\I16X8.\LOAD\K{8x8\_u}~\memarg', r'\hex{FD}~~\hex{02}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
+    Instruction(r'\I32X4.\LOAD\K{16x4\_s}~\memarg', r'\hex{FD}~~\hex{03}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
+    Instruction(r'\I32X4.\LOAD\K{16x4\_u}~\memarg', r'\hex{FD}~~\hex{04}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
+    Instruction(r'\I64X2.\LOAD\K{32x2\_s}~\memarg', r'\hex{FD}~~\hex{05}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
+    Instruction(r'\I64X2.\LOAD\K{32x2\_u}~\memarg', r'\hex{FD}~~\hex{06}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
+    Instruction(r'\I8X16.\LOAD\K{\_splat}~\memarg', r'\hex{FD}~~\hex{07}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
+    Instruction(r'\I16X8.\LOAD\K{\_splat}~\memarg', r'\hex{FD}~~\hex{08}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
+    Instruction(r'\I32X4.\LOAD\K{\_splat}~\memarg', r'\hex{FD}~~\hex{09}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
+    Instruction(r'\I64X2.\LOAD\K{\_splat}~\memarg', r'\hex{FD}~~\hex{0A}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
+    Instruction(r'\V128.\STORE~\memarg', r'\hex{FD}~~\hex{0B}', r'[\I32~\V128] \to []', r'valid-store', r'exec-store'),
+    Instruction(r'\V128.\VCONST~\i128', r'\hex{FD}~~\hex{0C}', r'[] \to [\V128]', r'valid-vconst', r'exec-vconst'),
+    Instruction(r'\I8X16.\SHUFFLE~\laneidx^{16}', r'\hex{FD}~~\hex{0D}', r'[\V128~\V128] \to [\V128]', r'valid-vec-shuffle', r'exec-vec-shuffle'),
+    Instruction(r'\I8X16.\SWIZZLE', r'\hex{FD}~~\hex{0E}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vec-swizzle'),
+    Instruction(r'\I8X16.\SPLAT', r'\hex{FD}~~\hex{0F}', r'[\I32] \to [\V128]', r'valid-vec-splat', r'exec-vec-splat'),
+    Instruction(r'\I16X8.\SPLAT', r'\hex{FD}~~\hex{10}', r'[\I32] \to [\V128]', r'valid-vec-splat', r'exec-vec-splat'),
+    Instruction(r'\I32X4.\SPLAT', r'\hex{FD}~~\hex{11}', r'[\I32] \to [\V128]', r'valid-vec-splat', r'exec-vec-splat'),
+    Instruction(r'\I64X2.\SPLAT', r'\hex{FD}~~\hex{12}', r'[\I64] \to [\V128]', r'valid-vec-splat', r'exec-vec-splat'),
+    Instruction(r'\F32X4.\SPLAT', r'\hex{FD}~~\hex{13}', r'[\F32] \to [\V128]', r'valid-vec-splat', r'exec-vec-splat'),
+    Instruction(r'\F64X2.\SPLAT', r'\hex{FD}~~\hex{14}', r'[\F64] \to [\V128]', r'valid-vec-splat', r'exec-vec-splat'),
+    Instruction(r'\I8X16.\EXTRACTLANE\K{\_s}~\laneidx', r'\hex{FD}~~\hex{15}', r'[\V128] \to [\I32]', r'valid-vec-extract_lane', r'exec-vec-extract_lane'),
+    Instruction(r'\I8X16.\EXTRACTLANE\K{\_u}~\laneidx', r'\hex{FD}~~\hex{16}', r'[\V128] \to [\I32]', r'valid-vec-extract_lane', r'exec-vec-extract_lane'),
+    Instruction(r'\I8X16.\REPLACELANE~\laneidx', r'\hex{FD}~~\hex{17}', r'[\V128~\I32] \to [\V128]', r'valid-vec-replace_lane', r'exec-vec-replace_lane'),
+    Instruction(r'\I16X8.\EXTRACTLANE\K{\_s}~\laneidx', r'\hex{FD}~~\hex{18}', r'[\V128] \to [\I32]', r'valid-vec-extract_lane', r'exec-vec-extract_lane'),
+    Instruction(r'\I16X8.\EXTRACTLANE\K{\_u}~\laneidx', r'\hex{FD}~~\hex{19}', r'[\V128] \to [\I32]', r'valid-vec-extract_lane', r'exec-vec-extract_lane'),
+    Instruction(r'\I16X8.\REPLACELANE~\laneidx', r'\hex{FD}~~\hex{1A}', r'[\V128~\I32] \to [\V128]', r'valid-vec-replace_lane', r'exec-vec-replace_lane'),
+    Instruction(r'\I32X4.\EXTRACTLANE~\laneidx', r'\hex{FD}~~\hex{1B}', r'[\V128] \to [\I32]', r'valid-vec-extract_lane', r'exec-vec-extract_lane'),
+    Instruction(r'\I32X4.\REPLACELANE~\laneidx', r'\hex{FD}~~\hex{1C}', r'[\V128~\I32] \to [\V128]', r'valid-vec-replace_lane', r'exec-vec-replace_lane'),
+    Instruction(r'\I64X2.\EXTRACTLANE~\laneidx', r'\hex{FD}~~\hex{1D}', r'[\V128] \to [\I64]', r'valid-vec-extract_lane', r'exec-vec-extract_lane'),
+    Instruction(r'\I64X2.\REPLACELANE~\laneidx', r'\hex{FD}~~\hex{1E}', r'[\V128~\I64] \to [\V128]', r'valid-vec-replace_lane', r'exec-vec-replace_lane'),
+    Instruction(r'\F32X4.\EXTRACTLANE~\laneidx', r'\hex{FD}~~\hex{1F}', r'[\V128] \to [\F32]', r'valid-vec-extract_lane', r'exec-vec-extract_lane'),
+    Instruction(r'\F32X4.\REPLACELANE~\laneidx', r'\hex{FD}~~\hex{20}', r'[\V128~\F32] \to [\V128]', r'valid-vec-replace_lane', r'exec-vec-replace_lane'),
+    Instruction(r'\F64X2.\EXTRACTLANE~\laneidx', r'\hex{FD}~~\hex{21}', r'[\V128] \to [\F64]', r'valid-vec-extract_lane', r'exec-vec-extract_lane'),
+    Instruction(r'\F64X2.\REPLACELANE~\laneidx', r'\hex{FD}~~\hex{22}', r'[\V128~\F64] \to [\V128]', r'valid-vec-replace_lane', r'exec-vec-replace_lane'),
+    Instruction(r'\I8X16.\VEQ', r'\hex{FD}~~\hex{23}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ieq'),
+    Instruction(r'\I8X16.\VNE', r'\hex{FD}~~\hex{24}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ine'),
+    Instruction(r'\I8X16.\VLT\K{\_s}', r'\hex{FD}~~\hex{25}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ilt_s'),
+    Instruction(r'\I8X16.\VLT\K{\_u}', r'\hex{FD}~~\hex{26}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ilt_u'),
+    Instruction(r'\I8X16.\VGT\K{\_s}', r'\hex{FD}~~\hex{27}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-igt_s'),
+    Instruction(r'\I8X16.\VGT\K{\_u}', r'\hex{FD}~~\hex{28}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-igt_u'),
+    Instruction(r'\I8X16.\VLE\K{\_s}', r'\hex{FD}~~\hex{29}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ile_s'),
+    Instruction(r'\I8X16.\VLE\K{\_u}', r'\hex{FD}~~\hex{2A}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ile_u'),
+    Instruction(r'\I8X16.\VGE\K{\_s}', r'\hex{FD}~~\hex{2B}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ige_s'),
+    Instruction(r'\I8X16.\VGE\K{\_u}', r'\hex{FD}~~\hex{2C}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ige_u'),
+    Instruction(r'\I16X8.\VEQ', r'\hex{FD}~~\hex{2D}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ieq'),
+    Instruction(r'\I16X8.\VNE', r'\hex{FD}~~\hex{2E}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ine'),
+    Instruction(r'\I16X8.\VLT\K{\_s}', r'\hex{FD}~~\hex{2F}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ilt_s'),
+    Instruction(r'\I16X8.\VLT\K{\_u}', r'\hex{FD}~~\hex{30}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ilt_u'),
+    Instruction(r'\I16X8.\VGT\K{\_s}', r'\hex{FD}~~\hex{31}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-igt_s'),
+    Instruction(r'\I16X8.\VGT\K{\_u}', r'\hex{FD}~~\hex{32}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-igt_u'),
+    Instruction(r'\I16X8.\VLE\K{\_s}', r'\hex{FD}~~\hex{33}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ile_s'),
+    Instruction(r'\I16X8.\VLE\K{\_u}', r'\hex{FD}~~\hex{34}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ile_u'),
+    Instruction(r'\I16X8.\VGE\K{\_s}', r'\hex{FD}~~\hex{35}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ige_s'),
+    Instruction(r'\I16X8.\VGE\K{\_u}', r'\hex{FD}~~\hex{36}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ige_u'),
+    Instruction(r'\I32X4.\VEQ', r'\hex{FD}~~\hex{37}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ieq'),
+    Instruction(r'\I32X4.\VNE', r'\hex{FD}~~\hex{38}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ine'),
+    Instruction(r'\I32X4.\VLT\K{\_s}', r'\hex{FD}~~\hex{39}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ilt_s'),
+    Instruction(r'\I32X4.\VLT\K{\_u}', r'\hex{FD}~~\hex{3A}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ilt_u'),
+    Instruction(r'\I32X4.\VGT\K{\_s}', r'\hex{FD}~~\hex{3B}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-igt_s'),
+    Instruction(r'\I32X4.\VGT\K{\_u}', r'\hex{FD}~~\hex{3C}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-igt_u'),
+    Instruction(r'\I32X4.\VLE\K{\_s}', r'\hex{FD}~~\hex{3D}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ile_s'),
+    Instruction(r'\I32X4.\VLE\K{\_u}', r'\hex{FD}~~\hex{3E}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ile_u'),
+    Instruction(r'\I32X4.\VGE\K{\_s}', r'\hex{FD}~~\hex{3F}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ige_s'),
+    Instruction(r'\I32X4.\VGE\K{\_u}', r'\hex{FD}~~\hex{40}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ige_u'),
+    Instruction(r'\F32X4.\VEQ', r'\hex{FD}~~\hex{41}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-feq'),
+    Instruction(r'\F32X4.\VNE', r'\hex{FD}~~\hex{42}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fne'),
+    Instruction(r'\F32X4.\VLT', r'\hex{FD}~~\hex{43}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-flt'),
+    Instruction(r'\F32X4.\VGT', r'\hex{FD}~~\hex{44}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fgt'),
+    Instruction(r'\F32X4.\VLE', r'\hex{FD}~~\hex{45}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fle'),
+    Instruction(r'\F32X4.\VGE', r'\hex{FD}~~\hex{46}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fge'),
+    Instruction(r'\F64X2.\VEQ', r'\hex{FD}~~\hex{47}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-feq'),
+    Instruction(r'\F64X2.\VNE', r'\hex{FD}~~\hex{48}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fne'),
+    Instruction(r'\F64X2.\VLT', r'\hex{FD}~~\hex{49}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-flt'),
+    Instruction(r'\F64X2.\VGT', r'\hex{FD}~~\hex{4A}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fgt'),
+    Instruction(r'\F64X2.\VLE', r'\hex{FD}~~\hex{4B}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fle'),
+    Instruction(r'\F64X2.\VGE', r'\hex{FD}~~\hex{4C}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fge'),
+    Instruction(r'\V128.\VNOT', r'\hex{FD}~~\hex{4D}', r'[\V128] \to [\V128]', r'valid-vvunop', r'exec-vvunop', r'op-inot'),
+    Instruction(r'\V128.\VAND', r'\hex{FD}~~\hex{4E}', r'[\V128~\V128] \to [\V128]', r'valid-vvbinop', r'exec-vvbinop', r'op-iand'),
+    Instruction(r'\V128.\VANDNOT', r'\hex{FD}~~\hex{4F}', r'[\V128~\V128] \to [\V128]', r'valid-vvbinop', r'exec-vvbinop', r'op-iandnot'),
+    Instruction(r'\V128.\VOR', r'\hex{FD}~~\hex{50}', r'[\V128~\V128] \to [\V128]', r'valid-vvbinop', r'exec-vvbinop', r'op-ior'),
+    Instruction(r'\V128.\VXOR', r'\hex{FD}~~\hex{51}', r'[\V128~\V128] \to [\V128]', r'valid-vvbinop', r'exec-vvbinop', r'op-ixor'),
+    Instruction(r'\V128.\BITSELECT', r'\hex{FD}~~\hex{52}', r'[\V128~\V128~\V128] \to [\V128]', r'valid-vvternop', r'exec-vvternop', r'op-ibitselect'),
+    Instruction(r'\V128.\ANYTRUE', r'\hex{FD}~~\hex{53}', r'[\V128] \to [\I32]', r'valid-vvtestop', r'exec-vvtestop'),
+    Instruction(r'\V128.\LOAD\K{8\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{54}', r'[\I32~\V128] \to [\V128]', r'valid-load-lane', r'exec-load-lane'),
+    Instruction(r'\V128.\LOAD\K{16\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{55}', r'[\I32~\V128] \to [\V128]', r'valid-load-lane', r'exec-load-lane'),
+    Instruction(r'\V128.\LOAD\K{32\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{56}', r'[\I32~\V128] \to [\V128]', r'valid-load-lane', r'exec-load-lane'),
+    Instruction(r'\V128.\LOAD\K{64\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{57}', r'[\I32~\V128] \to [\V128]', r'valid-load-lane', r'exec-load-lane'),
+    Instruction(r'\V128.\STORE\K{8\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{58}', r'[\I32~\V128] \to [\V128]', r'valid-store-lane', r'exec-store-lane'),
+    Instruction(r'\V128.\STORE\K{16\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{59}', r'[\I32~\V128] \to [\V128]', r'valid-store-lane', r'exec-store-lane'),
+    Instruction(r'\V128.\STORE\K{32\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{5A}', r'[\I32~\V128] \to [\V128]', r'valid-store-lane', r'exec-store-lane'),
+    Instruction(r'\V128.\STORE\K{64\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{5B}', r'[\I32~\V128] \to [\V128]', r'valid-store-lane', r'exec-store-lane'),
+    Instruction(r'\V128.\LOAD\K{32\_zero}~\memarg~\laneidx', r'\hex{FD}~~\hex{5C}', r'[\I32] \to [\V128]', r'valid-load-zero', r'exec-load-zero'),
+    Instruction(r'\V128.\LOAD\K{64\_zero}~\memarg~\laneidx', r'\hex{FD}~~\hex{5D}', r'[\I32] \to [\V128]', r'valid-load-zero', r'exec-load-zero'),
+    Instruction(r'\F32X4.\VDEMOTE\K{\_f64x2\_zero}', r'\hex{FD}~~\hex{5E}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-demote'),
+    Instruction(r'\F64X2.\VPROMOTE\K{\_low\_f32x4}', r'\hex{FD}~~\hex{5F}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-promote'),
+    Instruction(r'\I8X16.\VABS', r'\hex{FD}~~\hex{60}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-iabs'),
+    Instruction(r'\I8X16.\VNEG', r'\hex{FD}~~\hex{61}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ineg'),
+    Instruction(r'\I8X16.\VPOPCNT', r'\hex{FD}~~\hex{62}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ipopcnt'),
+    Instruction(r'\I8X16.\ALLTRUE', r'\hex{FD}~~\hex{63}', r'[\V128] \to [\I32]', r'valid-vtestop', r'exec-vtestop'),
+    Instruction(r'\I8X16.\BITMASK', r'\hex{FD}~~\hex{64}', r'[\V128] \to [\I32]', r'valid-vec-bitmask', r'exec-vec-bitmask'),
+    Instruction(r'\I8X16.\NARROW\K{\_i16x8\_s}', r'\hex{FD}~~\hex{65}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vec-narrow'),
+    Instruction(r'\I8X16.\NARROW\K{\_i16x8\_u}', r'\hex{FD}~~\hex{66}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vec-narrow'),
+    Instruction(r'\F32X4.\VCEIL', r'\hex{FD}~~\hex{67}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fceil'),
+    Instruction(r'\F32X4.\VFLOOR', r'\hex{FD}~~\hex{68}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ffloor'),
+    Instruction(r'\F32X4.\VTRUNC', r'\hex{FD}~~\hex{69}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ftrunc'),
+    Instruction(r'\F32X4.\VNEAREST', r'\hex{FD}~~\hex{6A}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fnearest'),
+    Instruction(r'\I8X16.\VSHL', r'\hex{FD}~~\hex{6B}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishl'),
+    Instruction(r'\I8X16.\VSHR\K{\_s}', r'\hex{FD}~~\hex{6C}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_s'),
+    Instruction(r'\I8X16.\VSHR\K{\_u}', r'\hex{FD}~~\hex{6D}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_u'),
+    Instruction(r'\I8X16.\VADD', r'\hex{FD}~~\hex{6E}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd'),
+    Instruction(r'\I8X16.\VADD\K{\_sat\_s}', r'\hex{FD}~~\hex{6F}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd_sat_s'),
+    Instruction(r'\I8X16.\VADD\K{\_sat\_u}', r'\hex{FD}~~\hex{70}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd_sat_u'),
+    Instruction(r'\I8X16.\VSUB', r'\hex{FD}~~\hex{71}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub'),
+    Instruction(r'\I8X16.\VSUB\K{\_sat\_s}', r'\hex{FD}~~\hex{72}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub_sat_s'),
+    Instruction(r'\I8X16.\VSUB\K{\_sat\_u}', r'\hex{FD}~~\hex{73}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub_sat_u'),
+    Instruction(r'\F64X2.\VCEIL', r'\hex{FD}~~\hex{74}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fceil'),
+    Instruction(r'\F64X2.\VFLOOR', r'\hex{FD}~~\hex{75}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ffloor'),
+    Instruction(r'\I8X16.\VMIN\K{\_s}', r'\hex{FD}~~\hex{76}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imin_s'),
+    Instruction(r'\I8X16.\VMIN\K{\_u}', r'\hex{FD}~~\hex{77}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imin_u'),
+    Instruction(r'\I8X16.\VMAX\K{\_s}', r'\hex{FD}~~\hex{78}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imax_s'),
+    Instruction(r'\I8X16.\VMAX\K{\_u}', r'\hex{FD}~~\hex{79}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imax_u'),
+    Instruction(r'\F64X2.\VTRUNC', r'\hex{FD}~~\hex{7A}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ftrunc'),
+    Instruction(r'\I8X16.\AVGR\K{\_u}', r'\hex{FD}~~\hex{7B}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iavgr_u'),
+    Instruction(r'\I16X8.\EXTADDPAIRWISE\K{\_i8x16\_s}', r'\hex{FD}~~\hex{7C}', r'[\V128] \to [\V128]', r'valid-vec-extadd_pairwise', r'exec-vec-extadd_pairwise'),
+    Instruction(r'\I16X8.\EXTADDPAIRWISE\K{\_i8x16\_u}', r'\hex{FD}~~\hex{7D}', r'[\V128] \to [\V128]', r'valid-vec-extadd_pairwise', r'exec-vec-extadd_pairwise'),
+    Instruction(r'\I32X4.\EXTADDPAIRWISE\K{\_i16x8\_s}', r'\hex{FD}~~\hex{7E}', r'[\V128] \to [\V128]', r'valid-vec-extadd_pairwise', r'exec-vec-extadd_pairwise'),
+    Instruction(r'\I32X4.\EXTADDPAIRWISE\K{\_i16x8\_u}', r'\hex{FD}~~\hex{7F}', r'[\V128] \to [\V128]', r'valid-vec-extadd_pairwise', r'exec-vec-extadd_pairwise'),
+    Instruction(r'\I16X8.\VABS', r'\hex{FD}~~\hex{80}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-iabs'),
+    Instruction(r'\I16X8.\VNEG', r'\hex{FD}~~\hex{81}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ineg'),
+    Instruction(r'\I16X8.\Q15MULRSAT\K{\_s}', r'\hex{FD}~~\hex{82}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iq15mulrsat_s'),
+    Instruction(r'\I16X8.\ALLTRUE', r'\hex{FD}~~\hex{83}', r'[\V128] \to [\I32]', r'valid-vtestop', r'exec-vtestop'),
+    Instruction(r'\I16X8.\BITMASK', r'\hex{FD}~~\hex{84}', r'[\V128] \to [\I32]', r'valid-vec-bitmask', r'exec-vec-bitmask'),
+    Instruction(r'\I16X8.\NARROW\K{\_i32x4\_s}', r'\hex{FD}~~\hex{85}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vec-narrow'),
+    Instruction(r'\I16X8.\NARROW\K{\_i32x4\_u}', r'\hex{FD}~~\hex{86}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vec-narrow'),
+    Instruction(r'\I16X8.\VEXTEND\K{\_low\_i8x16\_s}', r'\hex{FD}~~\hex{87}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I16X8.\VEXTEND\K{\_high\_i8x16\_s}', r'\hex{FD}~~\hex{88}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I16X8.\VEXTEND\K{\_low\_i8x16\_u}', r'\hex{FD}~~\hex{89}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I16X8.\VEXTEND\K{\_high\_i8x16\_u}', r'\hex{FD}~~\hex{8A}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I16X8.\VSHL', r'\hex{FD}~~\hex{8B}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishl'),
+    Instruction(r'\I16X8.\VSHR\K{\_s}', r'\hex{FD}~~\hex{8C}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_s'),
+    Instruction(r'\I16X8.\VSHR\K{\_u}', r'\hex{FD}~~\hex{8D}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_u'),
+    Instruction(r'\I16X8.\VADD', r'\hex{FD}~~\hex{8E}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd'),
+    Instruction(r'\I16X8.\VADD\K{\_sat\_s}', r'\hex{FD}~~\hex{8F}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd_sat_s'),
+    Instruction(r'\I16X8.\VADD\K{\_sat\_u}', r'\hex{FD}~~\hex{90}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd_sat_u'),
+    Instruction(r'\I16X8.\VSUB', r'\hex{FD}~~\hex{91}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub'),
+    Instruction(r'\I16X8.\VSUB\K{\_sat\_s}', r'\hex{FD}~~\hex{92}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub_sat_s'),
+    Instruction(r'\I16X8.\VSUB\K{\_sat\_u}', r'\hex{FD}~~\hex{93}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub_sat_u'),
+    Instruction(r'\F64X2.\VNEAREST', r'\hex{FD}~~\hex{94}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fnearest'),
+    Instruction(r'\I16X8.\VMUL', r'\hex{FD}~~\hex{95}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imul'),
+    Instruction(r'\I16X8.\VMIN\K{\_s}', r'\hex{FD}~~\hex{96}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imin_s'),
+    Instruction(r'\I16X8.\VMIN\K{\_u}', r'\hex{FD}~~\hex{97}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imin_u'),
+    Instruction(r'\I16X8.\VMAX\K{\_s}', r'\hex{FD}~~\hex{98}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imax_s'),
+    Instruction(r'\I16X8.\VMAX\K{\_u}', r'\hex{FD}~~\hex{99}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imax_u'),
+    Instruction(r'\I16X8.\AVGR\K{\_u}', r'\hex{FD}~~\hex{9B}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iavgr_u'),
+    Instruction(r'\I16X8.\EXTMUL\K{\_low\_i8x16\_s}', r'\hex{FD}~~\hex{9C}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I16X8.\EXTMUL\K{\_high\_i8x16\_s}', r'\hex{FD}~~\hex{9D}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I16X8.\EXTMUL\K{\_low\_i8x16\_u}', r'\hex{FD}~~\hex{9E}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I16X8.\EXTMUL\K{\_high\_i8x16\_u}', r'\hex{FD}~~\hex{9F}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I32X4.\VABS', r'\hex{FD}~~\hex{A0}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-iabs'),
+    Instruction(r'\I32X4.\VNEG', r'\hex{FD}~~\hex{A1}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ineg'),
+    Instruction(r'\I32X4.\ALLTRUE', r'\hex{FD}~~\hex{A3}', r'[\V128] \to [\I32]', r'valid-vtestop', r'exec-vtestop'),
+    Instruction(r'\I32X4.\BITMASK', r'\hex{FD}~~\hex{A4}', r'[\V128] \to [\I32]', r'valid-vec-bitmask', r'exec-vec-bitmask'),
+    Instruction(r'\I32X4.\VEXTEND\K{\_low\_i16x8\_s}', r'\hex{FD}~~\hex{A7}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I32X4.\VEXTEND\K{\_high\_i16x8\_s}', r'\hex{FD}~~\hex{A8}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I32X4.\VEXTEND\K{\_low\_i16x8\_u}', r'\hex{FD}~~\hex{A9}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I32X4.\VEXTEND\K{\_high\_i16x8\_u}', r'\hex{FD}~~\hex{AA}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I32X4.\VSHL', r'\hex{FD}~~\hex{AB}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishl'),
+    Instruction(r'\I32X4.\VSHR\K{\_s}', r'\hex{FD}~~\hex{AC}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_s'),
+    Instruction(r'\I32X4.\VSHR\K{\_u}', r'\hex{FD}~~\hex{AD}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_u'),
+    Instruction(r'\I32X4.\VADD', r'\hex{FD}~~\hex{AE}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd'),
+    Instruction(r'\I32X4.\VSUB', r'\hex{FD}~~\hex{B1}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub'),
+    Instruction(r'\I32X4.\VMUL', r'\hex{FD}~~\hex{B5}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imul'),
+    Instruction(r'\I32X4.\VMIN\K{\_s}', r'\hex{FD}~~\hex{B6}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imin_s'),
+    Instruction(r'\I32X4.\VMIN\K{\_u}', r'\hex{FD}~~\hex{B7}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imin_u'),
+    Instruction(r'\I32X4.\VMAX\K{\_s}', r'\hex{FD}~~\hex{B8}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imax_s'),
+    Instruction(r'\I32X4.\VMAX\K{\_u}', r'\hex{FD}~~\hex{B9}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imax_u'),
+    Instruction(r'\I32X4.\DOT\K{\_i16x8\_s}', r'\hex{FD}~~\hex{BA}', r'[\V128~\V128] \to [\V128]', r'valid-vec-dot', r'exec-vec-dot'),
+    Instruction(r'\I32X4.\EXTMUL\K{\_low\_i16x8\_s}', r'\hex{FD}~~\hex{BC}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I32X4.\EXTMUL\K{\_high\_i16x8\_s}', r'\hex{FD}~~\hex{BD}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I32X4.\EXTMUL\K{\_low\_i16x8\_u}', r'\hex{FD}~~\hex{BE}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I32X4.\EXTMUL\K{\_high\_i16x8\_u}', r'\hex{FD}~~\hex{BF}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I64X2.\VABS', r'\hex{FD}~~\hex{C0}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-iabs'),
+    Instruction(r'\I64X2.\VNEG', r'\hex{FD}~~\hex{C1}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ineg'),
+    Instruction(r'\I64X2.\ALLTRUE', r'\hex{FD}~~\hex{C3}', r'[\V128] \to [\I32]', r'valid-vtestop', r'exec-vtestop'),
+    Instruction(r'\I64X2.\BITMASK', r'\hex{FD}~~\hex{C4}', r'[\V128] \to [\I32]', r'valid-vec-bitmask', r'exec-vec-bitmask'),
+    Instruction(r'\I64X2.\VEXTEND\K{\_low\_i32x4\_s}', r'\hex{FD}~~\hex{C7}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I64X2.\VEXTEND\K{\_high\_i32x4\_s}', r'\hex{FD}~~\hex{C8}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I64X2.\VEXTEND\K{\_low\_i32x4\_u}', r'\hex{FD}~~\hex{C9}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I64X2.\VEXTEND\K{\_high\_i32x4\_u}', r'\hex{FD}~~\hex{CA}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I64X2.\VSHL', r'\hex{FD}~~\hex{CB}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishl'),
+    Instruction(r'\I64X2.\VSHR\K{\_s}', r'\hex{FD}~~\hex{CC}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_s'),
+    Instruction(r'\I64X2.\VSHR\K{\_u}', r'\hex{FD}~~\hex{CD}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_u'),
+    Instruction(r'\I64X2.\VADD', r'\hex{FD}~~\hex{CE}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd'),
+    Instruction(r'\I64X2.\VSUB', r'\hex{FD}~~\hex{D1}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub'),
+    Instruction(r'\I64X2.\VMUL', r'\hex{FD}~~\hex{D5}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imul'),
+    Instruction(r'\I64X2.\VEQ', r'\hex{FD}~~\hex{D6}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ieq'),
+    Instruction(r'\I64X2.\VNE', r'\hex{FD}~~\hex{D7}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ine'),
+    Instruction(r'\I64X2.\VLT\K{\_s}', r'\hex{FD}~~\hex{D8}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ilt_s'),
+    Instruction(r'\I64X2.\VGT\K{\_s}', r'\hex{FD}~~\hex{D9}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-igt_s'),
+    Instruction(r'\I64X2.\VLE\K{\_s}', r'\hex{FD}~~\hex{DA}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ile_s'),
+    Instruction(r'\I64X2.\VGE\K{\_s}', r'\hex{FD}~~\hex{DB}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ige_s'),
+    Instruction(r'\I64X2.\EXTMUL\K{\_low\_i32x4\_s}', r'\hex{FD}~~\hex{DC}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I64X2.\EXTMUL\K{\_high\_i32x4\_s}', r'\hex{FD}~~\hex{DD}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I64X2.\EXTMUL\K{\_low\_i32x4\_u}', r'\hex{FD}~~\hex{DE}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I64X2.\EXTMUL\K{\_high\_i32x4\_u}', r'\hex{FD}~~\hex{DF}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\F32X4.\VABS', r'\hex{FD}~~\hex{E0}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fabs'),
+    Instruction(r'\F32X4.\VNEG', r'\hex{FD}~~\hex{E1}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fneg'),
+    Instruction(r'\F32X4.\VSQRT', r'\hex{FD}~~\hex{E3}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fsqrt'),
+    Instruction(r'\F32X4.\VADD', r'\hex{FD}~~\hex{E4}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fadd'),
+    Instruction(r'\F32X4.\VSUB', r'\hex{FD}~~\hex{E5}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fsub'),
+    Instruction(r'\F32X4.\VMUL', r'\hex{FD}~~\hex{E6}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmul'),
+    Instruction(r'\F32X4.\VDIV', r'\hex{FD}~~\hex{E7}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fdiv'),
+    Instruction(r'\F32X4.\VMIN', r'\hex{FD}~~\hex{E8}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmin'),
+    Instruction(r'\F32X4.\VMAX', r'\hex{FD}~~\hex{E9}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmax'),
+    Instruction(r'\F32X4.\VPMIN', r'\hex{FD}~~\hex{EA}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fpmin'),
+    Instruction(r'\F32X4.\VPMAX', r'\hex{FD}~~\hex{EB}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fpmax'),
+    Instruction(r'\F64X2.\VABS', r'\hex{FD}~~\hex{EC}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fabs'),
+    Instruction(r'\F64X2.\VNEG', r'\hex{FD}~~\hex{ED}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fneg'),
+    Instruction(r'\F64X2.\VSQRT', r'\hex{FD}~~\hex{EF}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fsqrt'),
+    Instruction(r'\F64X2.\VADD', r'\hex{FD}~~\hex{F0}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fadd'),
+    Instruction(r'\F64X2.\VSUB', r'\hex{FD}~~\hex{F1}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fsub'),
+    Instruction(r'\F64X2.\VMUL', r'\hex{FD}~~\hex{F2}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmul'),
+    Instruction(r'\F64X2.\VDIV', r'\hex{FD}~~\hex{F3}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fdiv'),
+    Instruction(r'\F64X2.\VMIN', r'\hex{FD}~~\hex{F4}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmin'),
+    Instruction(r'\F64X2.\VMAX', r'\hex{FD}~~\hex{F5}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmax'),
+    Instruction(r'\F64X2.\VPMIN', r'\hex{FD}~~\hex{F6}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fpmin'),
+    Instruction(r'\F64X2.\VPMAX', r'\hex{FD}~~\hex{F7}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fpmax'),
+    Instruction(r'\I32X4.\TRUNC\K{\_sat\_f32x4\_s}', r'\hex{FD}~~\hex{F8}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-trunc_sat_s'),
+    Instruction(r'\I32X4.\TRUNC\K{\_sat\_f32x4\_u}', r'\hex{FD}~~\hex{F9}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-trunc_sat_u'),
+    Instruction(r'\F32X4.\VCONVERT\K{\_i32x4\_s}', r'\hex{FD}~~\hex{FA}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-convert_s'),
+    Instruction(r'\F32X4.\VCONVERT\K{\_i32x4\_u}', r'\hex{FD}~~\hex{FB}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-convert_u'),
+    Instruction(r'\I32X4.\VTRUNC\K{\_sat\_f64x2\_s\_zero}', r'\hex{FD}~~\hex{FC}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-trunc_sat_s'),
+    Instruction(r'\I32X4.\VTRUNC\K{\_sat\_f64x2\_u\_zero}', r'\hex{FD}~~\hex{FD}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-trunc_sat_u'),
+    Instruction(r'\F64X2.\VCONVERT\K{\_low\_i32x4\_s}', r'\hex{FD}~~\hex{FE}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-convert_s'),
+    Instruction(r'\F64X2.\VCONVERT\K{\_low\_i32x4\_u}', r'\hex{FD}~~\hex{FF}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-convert_u'),
 ]
 
 
diff --git a/document/core/appendix/index-instructions.rst b/document/core/appendix/index-instructions.rst
index 6e424f659..0c43fe0f1 100644
--- a/document/core/appendix/index-instructions.rst
+++ b/document/core/appendix/index-instructions.rst
@@ -6,277 +6,521 @@
 Index of Instructions
 ---------------------
 
-=========================================  =========================  =============================================  =======================================  ===============================================================
-Instruction                                Binary Opcode              Type                                           Validation                               Execution                                                      
-=========================================  =========================  =============================================  =======================================  ===============================================================
-:math:`\UNREACHABLE`                       :math:`\hex{00}`           :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-unreachable>`    :ref:`execution <exec-unreachable>`                            
-:math:`\NOP`                               :math:`\hex{01}`           :math:`[] \to []`                              :ref:`validation <valid-nop>`            :ref:`execution <exec-nop>`                                    
-:math:`\BLOCK~\X{bt}`                      :math:`\hex{02}`           :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-block>`          :ref:`execution <exec-block>`                                  
-:math:`\LOOP~\X{bt}`                       :math:`\hex{03}`           :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-loop>`           :ref:`execution <exec-loop>`                                   
-:math:`\IF~\X{bt}`                         :math:`\hex{04}`           :math:`[t_1^\ast~\I32] \to [t_2^\ast]`         :ref:`validation <valid-if>`             :ref:`execution <exec-if>`                                     
-:math:`\ELSE`                              :math:`\hex{05}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{06}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{07}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{08}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{09}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{0A}`                                                                                                                                                                  
-:math:`\END`                               :math:`\hex{0B}`                                                                                                                                                                  
-:math:`\BR~l`                              :math:`\hex{0C}`           :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`       :ref:`validation <valid-br>`             :ref:`execution <exec-br>`                                     
-:math:`\BRIF~l`                            :math:`\hex{0D}`           :math:`[t^\ast~\I32] \to [t^\ast]`             :ref:`validation <valid-br_if>`          :ref:`execution <exec-br_if>`                                  
-:math:`\BRTABLE~l^\ast~l`                  :math:`\hex{0E}`           :math:`[t_1^\ast~t^\ast~\I32] \to [t_2^\ast]`  :ref:`validation <valid-br_table>`       :ref:`execution <exec-br_table>`                               
-:math:`\RETURN`                            :math:`\hex{0F}`           :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`       :ref:`validation <valid-return>`         :ref:`execution <exec-return>`                                 
-:math:`\CALL~x`                            :math:`\hex{10}`           :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-call>`           :ref:`execution <exec-call>`                                   
-:math:`\CALLINDIRECT~x~y`                  :math:`\hex{11}`           :math:`[t_1^\ast~\I32] \to [t_2^\ast]`         :ref:`validation <valid-call_indirect>`  :ref:`execution <exec-call_indirect>`                          
-(reserved)                                 :math:`\hex{12}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{13}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{14}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{15}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{16}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{17}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{18}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{19}`                                                                                                                                                                  
-:math:`\DROP`                              :math:`\hex{1A}`           :math:`[t] \to []`                             :ref:`validation <valid-drop>`           :ref:`execution <exec-drop>`                                   
-:math:`\SELECT`                            :math:`\hex{1B}`           :math:`[t~t~\I32] \to [t]`                     :ref:`validation <valid-select>`         :ref:`execution <exec-select>`                                 
-:math:`\SELECT~t`                          :math:`\hex{1C}`           :math:`[t~t~\I32] \to [t]`                     :ref:`validation <valid-select>`         :ref:`execution <exec-select>`                                 
-(reserved)                                 :math:`\hex{1D}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{1E}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{1F}`                                                                                                                                                                  
-:math:`\LOCALGET~x`                        :math:`\hex{20}`           :math:`[] \to [t]`                             :ref:`validation <valid-local.get>`      :ref:`execution <exec-local.get>`                              
-:math:`\LOCALSET~x`                        :math:`\hex{21}`           :math:`[t] \to []`                             :ref:`validation <valid-local.set>`      :ref:`execution <exec-local.set>`                              
-:math:`\LOCALTEE~x`                        :math:`\hex{22}`           :math:`[t] \to [t]`                            :ref:`validation <valid-local.tee>`      :ref:`execution <exec-local.tee>`                              
-:math:`\GLOBALGET~x`                       :math:`\hex{23}`           :math:`[] \to [t]`                             :ref:`validation <valid-global.get>`     :ref:`execution <exec-global.get>`                             
-:math:`\GLOBALSET~x`                       :math:`\hex{24}`           :math:`[t] \to []`                             :ref:`validation <valid-global.set>`     :ref:`execution <exec-global.set>`                             
-:math:`\TABLEGET~x`                        :math:`\hex{25}`           :math:`[\I32] \to [t]`                         :ref:`validation <valid-table.get>`      :ref:`execution <exec-table.get>`                              
-:math:`\TABLESET~x`                        :math:`\hex{26}`           :math:`[\I32~t] \to []`                        :ref:`validation <valid-table.set>`      :ref:`execution <exec-table.set>`                              
-(reserved)                                 :math:`\hex{27}`                                                                                                                                                                  
-:math:`\I32.\LOAD~\memarg`                 :math:`\hex{28}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-load>`           :ref:`execution <exec-load>`                                   
-:math:`\I64.\LOAD~\memarg`                 :math:`\hex{29}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-load>`           :ref:`execution <exec-load>`                                   
-:math:`\F32.\LOAD~\memarg`                 :math:`\hex{2A}`           :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-load>`           :ref:`execution <exec-load>`                                   
-:math:`\F64.\LOAD~\memarg`                 :math:`\hex{2B}`           :math:`[\I32] \to [\F64]`                      :ref:`validation <valid-load>`           :ref:`execution <exec-load>`                                   
-:math:`\I32.\LOAD\K{8\_s}~\memarg`         :math:`\hex{2C}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I32.\LOAD\K{8\_u}~\memarg`         :math:`\hex{2D}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I32.\LOAD\K{16\_s}~\memarg`        :math:`\hex{2E}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I32.\LOAD\K{16\_u}~\memarg`        :math:`\hex{2F}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{8\_s}~\memarg`         :math:`\hex{30}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{8\_u}~\memarg`         :math:`\hex{31}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{16\_s}~\memarg`        :math:`\hex{32}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{16\_u}~\memarg`        :math:`\hex{33}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{32\_s}~\memarg`        :math:`\hex{34}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{32\_u}~\memarg`        :math:`\hex{35}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`          :ref:`execution <exec-loadn>`                                  
-:math:`\I32.\STORE~\memarg`                :math:`\hex{36}`           :math:`[\I32~\I32] \to []`                     :ref:`validation <valid-store>`          :ref:`execution <exec-store>`                                  
-:math:`\I64.\STORE~\memarg`                :math:`\hex{37}`           :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-store>`          :ref:`execution <exec-store>`                                  
-:math:`\F32.\STORE~\memarg`                :math:`\hex{38}`           :math:`[\I32~\F32] \to []`                     :ref:`validation <valid-store>`          :ref:`execution <exec-store>`                                  
-:math:`\F64.\STORE~\memarg`                :math:`\hex{39}`           :math:`[\I32~\F64] \to []`                     :ref:`validation <valid-store>`          :ref:`execution <exec-store>`                                  
-:math:`\I32.\STORE\K{8}~\memarg`           :math:`\hex{3A}`           :math:`[\I32~\I32] \to []`                     :ref:`validation <valid-storen>`         :ref:`execution <exec-storen>`                                 
-:math:`\I32.\STORE\K{16}~\memarg`          :math:`\hex{3B}`           :math:`[\I32~\I32] \to []`                     :ref:`validation <valid-storen>`         :ref:`execution <exec-storen>`                                 
-:math:`\I64.\STORE\K{8}~\memarg`           :math:`\hex{3C}`           :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-storen>`         :ref:`execution <exec-storen>`                                 
-:math:`\I64.\STORE\K{16}~\memarg`          :math:`\hex{3D}`           :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-storen>`         :ref:`execution <exec-storen>`                                 
-:math:`\I64.\STORE\K{32}~\memarg`          :math:`\hex{3E}`           :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-storen>`         :ref:`execution <exec-storen>`                                 
-:math:`\MEMORYSIZE`                        :math:`\hex{3F}`           :math:`[] \to [\I32]`                          :ref:`validation <valid-memory.size>`    :ref:`execution <exec-memory.size>`                            
-:math:`\MEMORYGROW`                        :math:`\hex{40}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-memory.grow>`    :ref:`execution <exec-memory.grow>`                            
-:math:`\I32.\CONST~\i32`                   :math:`\hex{41}`           :math:`[] \to [\I32]`                          :ref:`validation <valid-const>`          :ref:`execution <exec-const>`                                  
-:math:`\I64.\CONST~\i64`                   :math:`\hex{42}`           :math:`[] \to [\I64]`                          :ref:`validation <valid-const>`          :ref:`execution <exec-const>`                                  
-:math:`\F32.\CONST~\f32`                   :math:`\hex{43}`           :math:`[] \to [\F32]`                          :ref:`validation <valid-const>`          :ref:`execution <exec-const>`                                  
-:math:`\F64.\CONST~\f64`                   :math:`\hex{44}`           :math:`[] \to [\F64]`                          :ref:`validation <valid-const>`          :ref:`execution <exec-const>`                                  
-:math:`\I32.\EQZ`                          :math:`\hex{45}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-testop>`         :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`      
-:math:`\I32.\EQ`                           :math:`\hex{46}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`        
-:math:`\I32.\NE`                           :math:`\hex{47}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`        
-:math:`\I32.\LT\K{\_s}`                    :math:`\hex{48}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`      
-:math:`\I32.\LT\K{\_u}`                    :math:`\hex{49}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`      
-:math:`\I32.\GT\K{\_s}`                    :math:`\hex{4A}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`      
-:math:`\I32.\GT\K{\_u}`                    :math:`\hex{4B}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`      
-:math:`\I32.\LE\K{\_s}`                    :math:`\hex{4C}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`      
-:math:`\I32.\LE\K{\_u}`                    :math:`\hex{4D}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`      
-:math:`\I32.\GE\K{\_s}`                    :math:`\hex{4E}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`      
-:math:`\I32.\GE\K{\_u}`                    :math:`\hex{4F}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`      
-:math:`\I64.\EQZ`                          :math:`\hex{50}`           :math:`[\I64] \to [\I32]`                      :ref:`validation <valid-testop>`         :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`      
-:math:`\I64.\EQ`                           :math:`\hex{51}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`        
-:math:`\I64.\NE`                           :math:`\hex{52}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`        
-:math:`\I64.\LT\K{\_s}`                    :math:`\hex{53}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`      
-:math:`\I64.\LT\K{\_u}`                    :math:`\hex{54}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`      
-:math:`\I64.\GT\K{\_s}`                    :math:`\hex{55}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`      
-:math:`\I64.\GT\K{\_u}`                    :math:`\hex{56}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`      
-:math:`\I64.\LE\K{\_s}`                    :math:`\hex{57}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`      
-:math:`\I64.\LE\K{\_u}`                    :math:`\hex{58}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`      
-:math:`\I64.\GE\K{\_s}`                    :math:`\hex{59}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`      
-:math:`\I64.\GE\K{\_u}`                    :math:`\hex{5A}`           :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`      
-:math:`\F32.\EQ`                           :math:`\hex{5B}`           :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`        
-:math:`\F32.\NE`                           :math:`\hex{5C}`           :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`        
-:math:`\F32.\LT`                           :math:`\hex{5D}`           :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`        
-:math:`\F32.\GT`                           :math:`\hex{5E}`           :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`        
-:math:`\F32.\LE`                           :math:`\hex{5F}`           :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`        
-:math:`\F32.\GE`                           :math:`\hex{60}`           :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`        
-:math:`\F64.\EQ`                           :math:`\hex{61}`           :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`        
-:math:`\F64.\NE`                           :math:`\hex{62}`           :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`        
-:math:`\F64.\LT`                           :math:`\hex{63}`           :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`        
-:math:`\F64.\GT`                           :math:`\hex{64}`           :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`        
-:math:`\F64.\LE`                           :math:`\hex{65}`           :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`        
-:math:`\F64.\GE`                           :math:`\hex{66}`           :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`          :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`        
-:math:`\I32.\CLZ`                          :math:`\hex{67}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`        
-:math:`\I32.\CTZ`                          :math:`\hex{68}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`        
-:math:`\I32.\POPCNT`                       :math:`\hex{69}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`     
-:math:`\I32.\ADD`                          :math:`\hex{6A}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`       
-:math:`\I32.\SUB`                          :math:`\hex{6B}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`       
-:math:`\I32.\MUL`                          :math:`\hex{6C}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`       
-:math:`\I32.\DIV\K{\_s}`                   :math:`\hex{6D}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`     
-:math:`\I32.\DIV\K{\_u}`                   :math:`\hex{6E}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`     
-:math:`\I32.\REM\K{\_s}`                   :math:`\hex{6F}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`     
-:math:`\I32.\REM\K{\_u}`                   :math:`\hex{70}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`     
-:math:`\I32.\AND`                          :math:`\hex{71}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`       
-:math:`\I32.\OR`                           :math:`\hex{72}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`        
-:math:`\I32.\XOR`                          :math:`\hex{73}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`       
-:math:`\I32.\SHL`                          :math:`\hex{74}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`       
-:math:`\I32.\SHR\K{\_s}`                   :math:`\hex{75}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`     
-:math:`\I32.\SHR\K{\_u}`                   :math:`\hex{76}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`     
-:math:`\I32.\ROTL`                         :math:`\hex{77}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`      
-:math:`\I32.\ROTR`                         :math:`\hex{78}`           :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`      
-:math:`\I64.\CLZ`                          :math:`\hex{79}`           :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`        
-:math:`\I64.\CTZ`                          :math:`\hex{7A}`           :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`        
-:math:`\I64.\POPCNT`                       :math:`\hex{7B}`           :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`     
-:math:`\I64.\ADD`                          :math:`\hex{7C}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`       
-:math:`\I64.\SUB`                          :math:`\hex{7D}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`       
-:math:`\I64.\MUL`                          :math:`\hex{7E}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`       
-:math:`\I64.\DIV\K{\_s}`                   :math:`\hex{7F}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`     
-:math:`\I64.\DIV\K{\_u}`                   :math:`\hex{80}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`     
-:math:`\I64.\REM\K{\_s}`                   :math:`\hex{81}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`     
-:math:`\I64.\REM\K{\_u}`                   :math:`\hex{82}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`     
-:math:`\I64.\AND`                          :math:`\hex{83}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`       
-:math:`\I64.\OR`                           :math:`\hex{84}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`        
-:math:`\I64.\XOR`                          :math:`\hex{85}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`       
-:math:`\I64.\SHL`                          :math:`\hex{86}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`       
-:math:`\I64.\SHR\K{\_s}`                   :math:`\hex{87}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`     
-:math:`\I64.\SHR\K{\_u}`                   :math:`\hex{88}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`     
-:math:`\I64.\ROTL`                         :math:`\hex{89}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`      
-:math:`\I64.\ROTR`                         :math:`\hex{8A}`           :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`      
-:math:`\F32.\ABS`                          :math:`\hex{8B}`           :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`        
-:math:`\F32.\NEG`                          :math:`\hex{8C}`           :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`        
-:math:`\F32.\CEIL`                         :math:`\hex{8D}`           :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`       
-:math:`\F32.\FLOOR`                        :math:`\hex{8E}`           :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`      
-:math:`\F32.\TRUNC`                        :math:`\hex{8F}`           :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`      
-:math:`\F32.\NEAREST`                      :math:`\hex{90}`           :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`    
-:math:`\F32.\SQRT`                         :math:`\hex{91}`           :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`       
-:math:`\F32.\ADD`                          :math:`\hex{92}`           :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`       
-:math:`\F32.\SUB`                          :math:`\hex{93}`           :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`       
-:math:`\F32.\MUL`                          :math:`\hex{94}`           :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`       
-:math:`\F32.\DIV`                          :math:`\hex{95}`           :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`       
-:math:`\F32.\FMIN`                         :math:`\hex{96}`           :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`       
-:math:`\F32.\FMAX`                         :math:`\hex{97}`           :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`       
-:math:`\F32.\COPYSIGN`                     :math:`\hex{98}`           :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`  
-:math:`\F64.\ABS`                          :math:`\hex{99}`           :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`        
-:math:`\F64.\NEG`                          :math:`\hex{9A}`           :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`        
-:math:`\F64.\CEIL`                         :math:`\hex{9B}`           :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`       
-:math:`\F64.\FLOOR`                        :math:`\hex{9C}`           :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`      
-:math:`\F64.\TRUNC`                        :math:`\hex{9D}`           :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`      
-:math:`\F64.\NEAREST`                      :math:`\hex{9E}`           :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`    
-:math:`\F64.\SQRT`                         :math:`\hex{9F}`           :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`       
-:math:`\F64.\ADD`                          :math:`\hex{A0}`           :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`       
-:math:`\F64.\SUB`                          :math:`\hex{A1}`           :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`       
-:math:`\F64.\MUL`                          :math:`\hex{A2}`           :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`       
-:math:`\F64.\DIV`                          :math:`\hex{A3}`           :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`       
-:math:`\F64.\FMIN`                         :math:`\hex{A4}`           :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`       
-:math:`\F64.\FMAX`                         :math:`\hex{A5}`           :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`       
-:math:`\F64.\COPYSIGN`                     :math:`\hex{A6}`           :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`          :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`  
-:math:`\I32.\WRAP\K{\_}\I64`               :math:`\hex{A7}`           :math:`[\I64] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-wrap>`       
-:math:`\I32.\TRUNC\K{\_}\F32\K{\_s}`       :math:`\hex{A8}`           :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
-:math:`\I32.\TRUNC\K{\_}\F32\K{\_u}`       :math:`\hex{A9}`           :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
-:math:`\I32.\TRUNC\K{\_}\F64\K{\_s}`       :math:`\hex{AA}`           :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
-:math:`\I32.\TRUNC\K{\_}\F64\K{\_u}`       :math:`\hex{AB}`           :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
-:math:`\I64.\EXTEND\K{\_}\I32\K{\_s}`      :math:`\hex{AC}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_s>`   
-:math:`\I64.\EXTEND\K{\_}\I32\K{\_u}`      :math:`\hex{AD}`           :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_u>`   
-:math:`\I64.\TRUNC\K{\_}\F32\K{\_s}`       :math:`\hex{AE}`           :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
-:math:`\I64.\TRUNC\K{\_}\F32\K{\_u}`       :math:`\hex{AF}`           :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
-:math:`\I64.\TRUNC\K{\_}\F64\K{\_s}`       :math:`\hex{B0}`           :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
-:math:`\I64.\TRUNC\K{\_}\F64\K{\_u}`       :math:`\hex{B1}`           :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
-:math:`\F32.\CONVERT\K{\_}\I32\K{\_s}`     :math:`\hex{B2}`           :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
-:math:`\F32.\CONVERT\K{\_}\I32\K{\_u}`     :math:`\hex{B3}`           :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
-:math:`\F32.\CONVERT\K{\_}\I64\K{\_s}`     :math:`\hex{B4}`           :math:`[\I64] \to [\F32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
-:math:`\F32.\CONVERT\K{\_}\I64\K{\_u}`     :math:`\hex{B5}`           :math:`[\I64] \to [\F32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
-:math:`\F32.\DEMOTE\K{\_}\F64`             :math:`\hex{B6}`           :math:`[\F64] \to [\F32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-demote>`     
-:math:`\F64.\CONVERT\K{\_}\I32\K{\_s}`     :math:`\hex{B7}`           :math:`[\I32] \to [\F64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
-:math:`\F64.\CONVERT\K{\_}\I32\K{\_u}`     :math:`\hex{B8}`           :math:`[\I32] \to [\F64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
-:math:`\F64.\CONVERT\K{\_}\I64\K{\_s}`     :math:`\hex{B9}`           :math:`[\I64] \to [\F64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
-:math:`\F64.\CONVERT\K{\_}\I64\K{\_u}`     :math:`\hex{BA}`           :math:`[\I64] \to [\F64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
-:math:`\F64.\PROMOTE\K{\_}\F32`            :math:`\hex{BB}`           :math:`[\F32] \to [\F64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-promote>`    
-:math:`\I32.\REINTERPRET\K{\_}\F32`        :math:`\hex{BC}`           :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
-:math:`\I64.\REINTERPRET\K{\_}\F64`        :math:`\hex{BD}`           :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
-:math:`\F32.\REINTERPRET\K{\_}\I32`        :math:`\hex{BE}`           :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
-:math:`\F64.\REINTERPRET\K{\_}\I64`        :math:`\hex{BF}`           :math:`[\I64] \to [\F64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
-:math:`\I32.\EXTEND\K{8\_s}`               :math:`\hex{C0}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
-:math:`\I32.\EXTEND\K{16\_s}`              :math:`\hex{C1}`           :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
-:math:`\I64.\EXTEND\K{8\_s}`               :math:`\hex{C2}`           :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
-:math:`\I64.\EXTEND\K{16\_s}`              :math:`\hex{C3}`           :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
-:math:`\I64.\EXTEND\K{32\_s}`              :math:`\hex{C4}`           :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`           :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
-(reserved)                                 :math:`\hex{C5}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{C6}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{C7}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{C8}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{C9}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{CA}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{CB}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{CC}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{CD}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{CE}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{CF}`                                                                                                                                                                  
-:math:`\REFNULL~t`                         :math:`\hex{D0}`           :math:`[] \to [t]`                             :ref:`validation <valid-ref.null>`       :ref:`execution <exec-ref.null>`                               
-:math:`\REFISNULL`                         :math:`\hex{D1}`           :math:`[t] \to [\I32]`                         :ref:`validation <valid-ref.is_null>`    :ref:`execution <exec-ref.is_null>`                            
-:math:`\REFFUNC~x`                         :math:`\hex{D2}`           :math:`[] \to [\FUNCREF]`                      :ref:`validation <valid-ref.func>`       :ref:`execution <exec-ref.func>`                               
-(reserved)                                 :math:`\hex{D3}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{D4}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{D5}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{D6}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{D7}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{D8}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{D9}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{DA}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{DB}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{DC}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{DD}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{DE}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{DF}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E0}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E1}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E2}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E3}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E4}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E5}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E6}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E7}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E8}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{E9}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{EA}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{EB}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{EC}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{ED}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{EE}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{EF}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F0}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F1}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F2}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F3}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F4}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F5}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F6}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F7}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F8}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{F9}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{FA}`                                                                                                                                                                  
-(reserved)                                 :math:`\hex{FB}`                                                                                                                                                                  
-:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_s}`  :math:`\hex{FC}~\hex{00}`  :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
-:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_u}`  :math:`\hex{FC}~\hex{01}`  :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
-:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_s}`  :math:`\hex{FC}~\hex{02}`  :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
-:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_u}`  :math:`\hex{FC}~\hex{03}`  :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
-:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_s}`  :math:`\hex{FC}~\hex{04}`  :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
-:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_u}`  :math:`\hex{FC}~\hex{05}`  :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
-:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_s}`  :math:`\hex{FC}~\hex{06}`  :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
-:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_u}`  :math:`\hex{FC}~\hex{07}`  :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`          :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
-:math:`\MEMORYINIT~x`                      :math:`\hex{FC}~\hex{08}`  :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-memory.init>`    :ref:`execution <exec-memory.init>`                            
-:math:`\DATADROP~x`                        :math:`\hex{FC}~\hex{09}`  :math:`[] \to []`                              :ref:`validation <valid-data.drop>`      :ref:`execution <exec-data.drop>`                              
-:math:`\MEMORYCOPY`                        :math:`\hex{FC}~\hex{0A}`  :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-memory.copy>`    :ref:`execution <exec-memory.copy>`                            
-:math:`\MEMORYFILL`                        :math:`\hex{FC}~\hex{0B}`  :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-memory.fill>`    :ref:`execution <exec-memory.fill>`                            
-:math:`\TABLEINIT~x~y`                     :math:`\hex{FC}~\hex{0C}`  :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-table.init>`     :ref:`execution <exec-table.init>`                             
-:math:`\ELEMDROP~x`                        :math:`\hex{FC}~\hex{0D}`  :math:`[] \to []`                              :ref:`validation <valid-elem.drop>`      :ref:`execution <exec-elem.drop>`                              
-:math:`\TABLECOPY~x~y`                     :math:`\hex{FC}~\hex{0E}`  :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-table.copy>`     :ref:`execution <exec-table.copy>`                             
-:math:`\TABLEGROW~x`                       :math:`\hex{FC}~\hex{0F}`  :math:`[t~\I32] \to [\I32]`                    :ref:`validation <valid-table.grow>`     :ref:`execution <exec-table.grow>`                             
-:math:`\TABLESIZE~x`                       :math:`\hex{FC}~\hex{10}`  :math:`[] \to [\I32]`                          :ref:`validation <valid-table.size>`     :ref:`execution <exec-table.size>`                             
-:math:`\TABLEFILL~x`                       :math:`\hex{FC}~\hex{11}`  :math:`[\I32~t~\I32] \to []`                   :ref:`validation <valid-table.fill>`     :ref:`execution <exec-table.fill>`                             
-=========================================  =========================  =============================================  =======================================  ===============================================================
+=================================================  ==========================  =============================================  =============================================  ==================================================================
+Instruction                                        Binary Opcode               Type                                           Validation                                     Execution                                                         
+=================================================  ==========================  =============================================  =============================================  ==================================================================
+:math:`\UNREACHABLE`                               :math:`\hex{00}`            :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-unreachable>`          :ref:`execution <exec-unreachable>`                               
+:math:`\NOP`                                       :math:`\hex{01}`            :math:`[] \to []`                              :ref:`validation <valid-nop>`                  :ref:`execution <exec-nop>`                                       
+:math:`\BLOCK~\X{bt}`                              :math:`\hex{02}`            :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-block>`                :ref:`execution <exec-block>`                                     
+:math:`\LOOP~\X{bt}`                               :math:`\hex{03}`            :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-loop>`                 :ref:`execution <exec-loop>`                                      
+:math:`\IF~\X{bt}`                                 :math:`\hex{04}`            :math:`[t_1^\ast~\I32] \to [t_2^\ast]`         :ref:`validation <valid-if>`                   :ref:`execution <exec-if>`                                        
+:math:`\ELSE`                                      :math:`\hex{05}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{06}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{07}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{08}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{09}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{0A}`                                                                                                                                                                            
+:math:`\END`                                       :math:`\hex{0B}`                                                                                                                                                                            
+:math:`\BR~l`                                      :math:`\hex{0C}`            :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`       :ref:`validation <valid-br>`                   :ref:`execution <exec-br>`                                        
+:math:`\BRIF~l`                                    :math:`\hex{0D}`            :math:`[t^\ast~\I32] \to [t^\ast]`             :ref:`validation <valid-br_if>`                :ref:`execution <exec-br_if>`                                     
+:math:`\BRTABLE~l^\ast~l`                          :math:`\hex{0E}`            :math:`[t_1^\ast~t^\ast~\I32] \to [t_2^\ast]`  :ref:`validation <valid-br_table>`             :ref:`execution <exec-br_table>`                                  
+:math:`\RETURN`                                    :math:`\hex{0F}`            :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`       :ref:`validation <valid-return>`               :ref:`execution <exec-return>`                                    
+:math:`\CALL~x`                                    :math:`\hex{10}`            :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-call>`                 :ref:`execution <exec-call>`                                      
+:math:`\CALLINDIRECT~x~y`                          :math:`\hex{11}`            :math:`[t_1^\ast~\I32] \to [t_2^\ast]`         :ref:`validation <valid-call_indirect>`        :ref:`execution <exec-call_indirect>`                             
+(reserved)                                         :math:`\hex{12}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{13}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{14}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{15}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{16}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{17}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{18}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{19}`                                                                                                                                                                            
+:math:`\DROP`                                      :math:`\hex{1A}`            :math:`[t] \to []`                             :ref:`validation <valid-drop>`                 :ref:`execution <exec-drop>`                                      
+:math:`\SELECT`                                    :math:`\hex{1B}`            :math:`[t~t~\I32] \to [t]`                     :ref:`validation <valid-select>`               :ref:`execution <exec-select>`                                    
+:math:`\SELECT~t`                                  :math:`\hex{1C}`            :math:`[t~t~\I32] \to [t]`                     :ref:`validation <valid-select>`               :ref:`execution <exec-select>`                                    
+(reserved)                                         :math:`\hex{1D}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{1E}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{1F}`                                                                                                                                                                            
+:math:`\LOCALGET~x`                                :math:`\hex{20}`            :math:`[] \to [t]`                             :ref:`validation <valid-local.get>`            :ref:`execution <exec-local.get>`                                 
+:math:`\LOCALSET~x`                                :math:`\hex{21}`            :math:`[t] \to []`                             :ref:`validation <valid-local.set>`            :ref:`execution <exec-local.set>`                                 
+:math:`\LOCALTEE~x`                                :math:`\hex{22}`            :math:`[t] \to [t]`                            :ref:`validation <valid-local.tee>`            :ref:`execution <exec-local.tee>`                                 
+:math:`\GLOBALGET~x`                               :math:`\hex{23}`            :math:`[] \to [t]`                             :ref:`validation <valid-global.get>`           :ref:`execution <exec-global.get>`                                
+:math:`\GLOBALSET~x`                               :math:`\hex{24}`            :math:`[t] \to []`                             :ref:`validation <valid-global.set>`           :ref:`execution <exec-global.set>`                                
+:math:`\TABLEGET~x`                                :math:`\hex{25}`            :math:`[\I32] \to [t]`                         :ref:`validation <valid-table.get>`            :ref:`execution <exec-table.get>`                                 
+:math:`\TABLESET~x`                                :math:`\hex{26}`            :math:`[\I32~t] \to []`                        :ref:`validation <valid-table.set>`            :ref:`execution <exec-table.set>`                                 
+(reserved)                                         :math:`\hex{27}`                                                                                                                                                                            
+:math:`\I32.\LOAD~\memarg`                         :math:`\hex{28}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
+:math:`\I64.\LOAD~\memarg`                         :math:`\hex{29}`            :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
+:math:`\F32.\LOAD~\memarg`                         :math:`\hex{2A}`            :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
+:math:`\F64.\LOAD~\memarg`                         :math:`\hex{2B}`            :math:`[\I32] \to [\F64]`                      :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
+:math:`\I32.\LOAD\K{8\_s}~\memarg`                 :math:`\hex{2C}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I32.\LOAD\K{8\_u}~\memarg`                 :math:`\hex{2D}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I32.\LOAD\K{16\_s}~\memarg`                :math:`\hex{2E}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I32.\LOAD\K{16\_u}~\memarg`                :math:`\hex{2F}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I64.\LOAD\K{8\_s}~\memarg`                 :math:`\hex{30}`            :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I64.\LOAD\K{8\_u}~\memarg`                 :math:`\hex{31}`            :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I64.\LOAD\K{16\_s}~\memarg`                :math:`\hex{32}`            :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I64.\LOAD\K{16\_u}~\memarg`                :math:`\hex{33}`            :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I64.\LOAD\K{32\_s}~\memarg`                :math:`\hex{34}`            :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I64.\LOAD\K{32\_u}~\memarg`                :math:`\hex{35}`            :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I32.\STORE~\memarg`                        :math:`\hex{36}`            :math:`[\I32~\I32] \to []`                     :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
+:math:`\I64.\STORE~\memarg`                        :math:`\hex{37}`            :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
+:math:`\F32.\STORE~\memarg`                        :math:`\hex{38}`            :math:`[\I32~\F32] \to []`                     :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
+:math:`\F64.\STORE~\memarg`                        :math:`\hex{39}`            :math:`[\I32~\F64] \to []`                     :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
+:math:`\I32.\STORE\K{8}~\memarg`                   :math:`\hex{3A}`            :math:`[\I32~\I32] \to []`                     :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
+:math:`\I32.\STORE\K{16}~\memarg`                  :math:`\hex{3B}`            :math:`[\I32~\I32] \to []`                     :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
+:math:`\I64.\STORE\K{8}~\memarg`                   :math:`\hex{3C}`            :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
+:math:`\I64.\STORE\K{16}~\memarg`                  :math:`\hex{3D}`            :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
+:math:`\I64.\STORE\K{32}~\memarg`                  :math:`\hex{3E}`            :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
+:math:`\MEMORYSIZE`                                :math:`\hex{3F}`            :math:`[] \to [\I32]`                          :ref:`validation <valid-memory.size>`          :ref:`execution <exec-memory.size>`                               
+:math:`\MEMORYGROW`                                :math:`\hex{40}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-memory.grow>`          :ref:`execution <exec-memory.grow>`                               
+:math:`\I32.\CONST~\i32`                           :math:`\hex{41}`            :math:`[] \to [\I32]`                          :ref:`validation <valid-const>`                :ref:`execution <exec-const>`                                     
+:math:`\I64.\CONST~\i64`                           :math:`\hex{42}`            :math:`[] \to [\I64]`                          :ref:`validation <valid-const>`                :ref:`execution <exec-const>`                                     
+:math:`\F32.\CONST~\f32`                           :math:`\hex{43}`            :math:`[] \to [\F32]`                          :ref:`validation <valid-const>`                :ref:`execution <exec-const>`                                     
+:math:`\F64.\CONST~\f64`                           :math:`\hex{44}`            :math:`[] \to [\F64]`                          :ref:`validation <valid-const>`                :ref:`execution <exec-const>`                                     
+:math:`\I32.\EQZ`                                  :math:`\hex{45}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-testop>`               :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`         
+:math:`\I32.\EQ`                                   :math:`\hex{46}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`           
+:math:`\I32.\NE`                                   :math:`\hex{47}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`           
+:math:`\I32.\LT\K{\_s}`                            :math:`\hex{48}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`         
+:math:`\I32.\LT\K{\_u}`                            :math:`\hex{49}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`         
+:math:`\I32.\GT\K{\_s}`                            :math:`\hex{4A}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`         
+:math:`\I32.\GT\K{\_u}`                            :math:`\hex{4B}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`         
+:math:`\I32.\LE\K{\_s}`                            :math:`\hex{4C}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`         
+:math:`\I32.\LE\K{\_u}`                            :math:`\hex{4D}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`         
+:math:`\I32.\GE\K{\_s}`                            :math:`\hex{4E}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`         
+:math:`\I32.\GE\K{\_u}`                            :math:`\hex{4F}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`         
+:math:`\I64.\EQZ`                                  :math:`\hex{50}`            :math:`[\I64] \to [\I32]`                      :ref:`validation <valid-testop>`               :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`         
+:math:`\I64.\EQ`                                   :math:`\hex{51}`            :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`           
+:math:`\I64.\NE`                                   :math:`\hex{52}`            :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`           
+:math:`\I64.\LT\K{\_s}`                            :math:`\hex{53}`            :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`         
+:math:`\I64.\LT\K{\_u}`                            :math:`\hex{54}`            :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`         
+:math:`\I64.\GT\K{\_s}`                            :math:`\hex{55}`            :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`         
+:math:`\I64.\GT\K{\_u}`                            :math:`\hex{56}`            :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`         
+:math:`\I64.\LE\K{\_s}`                            :math:`\hex{57}`            :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`         
+:math:`\I64.\LE\K{\_u}`                            :math:`\hex{58}`            :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`         
+:math:`\I64.\GE\K{\_s}`                            :math:`\hex{59}`            :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`         
+:math:`\I64.\GE\K{\_u}`                            :math:`\hex{5A}`            :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`         
+:math:`\F32.\EQ`                                   :math:`\hex{5B}`            :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`           
+:math:`\F32.\NE`                                   :math:`\hex{5C}`            :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`           
+:math:`\F32.\LT`                                   :math:`\hex{5D}`            :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`           
+:math:`\F32.\GT`                                   :math:`\hex{5E}`            :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`           
+:math:`\F32.\LE`                                   :math:`\hex{5F}`            :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`           
+:math:`\F32.\GE`                                   :math:`\hex{60}`            :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`           
+:math:`\F64.\EQ`                                   :math:`\hex{61}`            :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`           
+:math:`\F64.\NE`                                   :math:`\hex{62}`            :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`           
+:math:`\F64.\LT`                                   :math:`\hex{63}`            :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`           
+:math:`\F64.\GT`                                   :math:`\hex{64}`            :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`           
+:math:`\F64.\LE`                                   :math:`\hex{65}`            :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`           
+:math:`\F64.\GE`                                   :math:`\hex{66}`            :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`           
+:math:`\I32.\CLZ`                                  :math:`\hex{67}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`           
+:math:`\I32.\CTZ`                                  :math:`\hex{68}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`           
+:math:`\I32.\POPCNT`                               :math:`\hex{69}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`        
+:math:`\I32.\ADD`                                  :math:`\hex{6A}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`          
+:math:`\I32.\SUB`                                  :math:`\hex{6B}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`          
+:math:`\I32.\MUL`                                  :math:`\hex{6C}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`          
+:math:`\I32.\DIV\K{\_s}`                           :math:`\hex{6D}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`        
+:math:`\I32.\DIV\K{\_u}`                           :math:`\hex{6E}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`        
+:math:`\I32.\REM\K{\_s}`                           :math:`\hex{6F}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`        
+:math:`\I32.\REM\K{\_u}`                           :math:`\hex{70}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`        
+:math:`\I32.\AND`                                  :math:`\hex{71}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`          
+:math:`\I32.\OR`                                   :math:`\hex{72}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`           
+:math:`\I32.\XOR`                                  :math:`\hex{73}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`          
+:math:`\I32.\SHL`                                  :math:`\hex{74}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`          
+:math:`\I32.\SHR\K{\_s}`                           :math:`\hex{75}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`        
+:math:`\I32.\SHR\K{\_u}`                           :math:`\hex{76}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`        
+:math:`\I32.\ROTL`                                 :math:`\hex{77}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`         
+:math:`\I32.\ROTR`                                 :math:`\hex{78}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`         
+:math:`\I64.\CLZ`                                  :math:`\hex{79}`            :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`           
+:math:`\I64.\CTZ`                                  :math:`\hex{7A}`            :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`           
+:math:`\I64.\POPCNT`                               :math:`\hex{7B}`            :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`        
+:math:`\I64.\ADD`                                  :math:`\hex{7C}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`          
+:math:`\I64.\SUB`                                  :math:`\hex{7D}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`          
+:math:`\I64.\MUL`                                  :math:`\hex{7E}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`          
+:math:`\I64.\DIV\K{\_s}`                           :math:`\hex{7F}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`        
+:math:`\I64.\DIV\K{\_u}`                           :math:`\hex{80}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`        
+:math:`\I64.\REM\K{\_s}`                           :math:`\hex{81}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`        
+:math:`\I64.\REM\K{\_u}`                           :math:`\hex{82}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`        
+:math:`\I64.\AND`                                  :math:`\hex{83}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`          
+:math:`\I64.\OR`                                   :math:`\hex{84}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`           
+:math:`\I64.\XOR`                                  :math:`\hex{85}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`          
+:math:`\I64.\SHL`                                  :math:`\hex{86}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`          
+:math:`\I64.\SHR\K{\_s}`                           :math:`\hex{87}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`        
+:math:`\I64.\SHR\K{\_u}`                           :math:`\hex{88}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`        
+:math:`\I64.\ROTL`                                 :math:`\hex{89}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`         
+:math:`\I64.\ROTR`                                 :math:`\hex{8A}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`         
+:math:`\F32.\ABS`                                  :math:`\hex{8B}`            :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`           
+:math:`\F32.\NEG`                                  :math:`\hex{8C}`            :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`           
+:math:`\F32.\CEIL`                                 :math:`\hex{8D}`            :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`          
+:math:`\F32.\FLOOR`                                :math:`\hex{8E}`            :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`         
+:math:`\F32.\TRUNC`                                :math:`\hex{8F}`            :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`         
+:math:`\F32.\NEAREST`                              :math:`\hex{90}`            :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`       
+:math:`\F32.\SQRT`                                 :math:`\hex{91}`            :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`          
+:math:`\F32.\ADD`                                  :math:`\hex{92}`            :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`          
+:math:`\F32.\SUB`                                  :math:`\hex{93}`            :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`          
+:math:`\F32.\MUL`                                  :math:`\hex{94}`            :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`          
+:math:`\F32.\DIV`                                  :math:`\hex{95}`            :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`          
+:math:`\F32.\FMIN`                                 :math:`\hex{96}`            :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`          
+:math:`\F32.\FMAX`                                 :math:`\hex{97}`            :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`          
+:math:`\F32.\COPYSIGN`                             :math:`\hex{98}`            :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`     
+:math:`\F64.\ABS`                                  :math:`\hex{99}`            :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`           
+:math:`\F64.\NEG`                                  :math:`\hex{9A}`            :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`           
+:math:`\F64.\CEIL`                                 :math:`\hex{9B}`            :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`          
+:math:`\F64.\FLOOR`                                :math:`\hex{9C}`            :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`         
+:math:`\F64.\TRUNC`                                :math:`\hex{9D}`            :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`         
+:math:`\F64.\NEAREST`                              :math:`\hex{9E}`            :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`       
+:math:`\F64.\SQRT`                                 :math:`\hex{9F}`            :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`          
+:math:`\F64.\ADD`                                  :math:`\hex{A0}`            :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`          
+:math:`\F64.\SUB`                                  :math:`\hex{A1}`            :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`          
+:math:`\F64.\MUL`                                  :math:`\hex{A2}`            :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`          
+:math:`\F64.\DIV`                                  :math:`\hex{A3}`            :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`          
+:math:`\F64.\FMIN`                                 :math:`\hex{A4}`            :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`          
+:math:`\F64.\FMAX`                                 :math:`\hex{A5}`            :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`          
+:math:`\F64.\COPYSIGN`                             :math:`\hex{A6}`            :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`     
+:math:`\I32.\WRAP\K{\_}\I64`                       :math:`\hex{A7}`            :math:`[\I64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-wrap>`          
+:math:`\I32.\TRUNC\K{\_}\F32\K{\_s}`               :math:`\hex{A8}`            :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`       
+:math:`\I32.\TRUNC\K{\_}\F32\K{\_u}`               :math:`\hex{A9}`            :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`       
+:math:`\I32.\TRUNC\K{\_}\F64\K{\_s}`               :math:`\hex{AA}`            :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`       
+:math:`\I32.\TRUNC\K{\_}\F64\K{\_u}`               :math:`\hex{AB}`            :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`       
+:math:`\I64.\EXTEND\K{\_}\I32\K{\_s}`              :math:`\hex{AC}`            :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_s>`      
+:math:`\I64.\EXTEND\K{\_}\I32\K{\_u}`              :math:`\hex{AD}`            :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_u>`      
+:math:`\I64.\TRUNC\K{\_}\F32\K{\_s}`               :math:`\hex{AE}`            :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`       
+:math:`\I64.\TRUNC\K{\_}\F32\K{\_u}`               :math:`\hex{AF}`            :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`       
+:math:`\I64.\TRUNC\K{\_}\F64\K{\_s}`               :math:`\hex{B0}`            :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`       
+:math:`\I64.\TRUNC\K{\_}\F64\K{\_u}`               :math:`\hex{B1}`            :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`       
+:math:`\F32.\CONVERT\K{\_}\I32\K{\_s}`             :math:`\hex{B2}`            :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`     
+:math:`\F32.\CONVERT\K{\_}\I32\K{\_u}`             :math:`\hex{B3}`            :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`     
+:math:`\F32.\CONVERT\K{\_}\I64\K{\_s}`             :math:`\hex{B4}`            :math:`[\I64] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`     
+:math:`\F32.\CONVERT\K{\_}\I64\K{\_u}`             :math:`\hex{B5}`            :math:`[\I64] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`     
+:math:`\F32.\DEMOTE\K{\_}\F64`                     :math:`\hex{B6}`            :math:`[\F64] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-demote>`        
+:math:`\F64.\CONVERT\K{\_}\I32\K{\_s}`             :math:`\hex{B7}`            :math:`[\I32] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`     
+:math:`\F64.\CONVERT\K{\_}\I32\K{\_u}`             :math:`\hex{B8}`            :math:`[\I32] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`     
+:math:`\F64.\CONVERT\K{\_}\I64\K{\_s}`             :math:`\hex{B9}`            :math:`[\I64] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`     
+:math:`\F64.\CONVERT\K{\_}\I64\K{\_u}`             :math:`\hex{BA}`            :math:`[\I64] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`     
+:math:`\F64.\PROMOTE\K{\_}\F32`                    :math:`\hex{BB}`            :math:`[\F32] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-promote>`       
+:math:`\I32.\REINTERPRET\K{\_}\F32`                :math:`\hex{BC}`            :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`   
+:math:`\I64.\REINTERPRET\K{\_}\F64`                :math:`\hex{BD}`            :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`   
+:math:`\F32.\REINTERPRET\K{\_}\I32`                :math:`\hex{BE}`            :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`   
+:math:`\F64.\REINTERPRET\K{\_}\I64`                :math:`\hex{BF}`            :math:`[\I64] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`   
+:math:`\I32.\EXTEND\K{8\_s}`                       :math:`\hex{C0}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
+:math:`\I32.\EXTEND\K{16\_s}`                      :math:`\hex{C1}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
+:math:`\I64.\EXTEND\K{8\_s}`                       :math:`\hex{C2}`            :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
+:math:`\I64.\EXTEND\K{16\_s}`                      :math:`\hex{C3}`            :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
+:math:`\I64.\EXTEND\K{32\_s}`                      :math:`\hex{C4}`            :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
+(reserved)                                         :math:`\hex{C5}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{C6}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{C7}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{C8}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{C9}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{CA}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{CB}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{CC}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{CD}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{CE}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{CF}`                                                                                                                                                                            
+:math:`\REFNULL~t`                                 :math:`\hex{D0}`            :math:`[] \to [t]`                             :ref:`validation <valid-ref.null>`             :ref:`execution <exec-ref.null>`                                  
+:math:`\REFISNULL`                                 :math:`\hex{D1}`            :math:`[t] \to [\I32]`                         :ref:`validation <valid-ref.is_null>`          :ref:`execution <exec-ref.is_null>`                               
+:math:`\REFFUNC~x`                                 :math:`\hex{D2}`            :math:`[] \to [\FUNCREF]`                      :ref:`validation <valid-ref.func>`             :ref:`execution <exec-ref.func>`                                  
+(reserved)                                         :math:`\hex{D3}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{D4}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{D5}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{D6}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{D7}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{D8}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{D9}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{DA}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{DB}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{DC}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{DD}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{DE}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{DF}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{E0}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{E1}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{E2}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{E3}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{E4}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{E5}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{E6}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{E7}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{E8}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{E9}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{EA}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{EB}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{EC}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{ED}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{EE}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{EF}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{F0}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{F1}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{F2}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{F3}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{F4}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{F5}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{F6}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{F7}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{F8}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{F9}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{FA}`                                                                                                                                                                            
+(reserved)                                         :math:`\hex{FB}`                                                                                                                                                                            
+:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_s}`          :math:`\hex{FC}~\hex{00}`   :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
+:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_u}`          :math:`\hex{FC}~\hex{01}`   :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
+:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_s}`          :math:`\hex{FC}~\hex{02}`   :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
+:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_u}`          :math:`\hex{FC}~\hex{03}`   :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
+:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_s}`          :math:`\hex{FC}~\hex{04}`   :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
+:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_u}`          :math:`\hex{FC}~\hex{05}`   :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
+:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_s}`          :math:`\hex{FC}~\hex{06}`   :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
+:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_u}`          :math:`\hex{FC}~\hex{07}`   :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
+:math:`\MEMORYINIT~x`                              :math:`\hex{FC}~\hex{08}`   :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-memory.init>`          :ref:`execution <exec-memory.init>`                               
+:math:`\DATADROP~x`                                :math:`\hex{FC}~\hex{09}`   :math:`[] \to []`                              :ref:`validation <valid-data.drop>`            :ref:`execution <exec-data.drop>`                                 
+:math:`\MEMORYCOPY`                                :math:`\hex{FC}~\hex{0A}`   :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-memory.copy>`          :ref:`execution <exec-memory.copy>`                               
+:math:`\MEMORYFILL`                                :math:`\hex{FC}~\hex{0B}`   :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-memory.fill>`          :ref:`execution <exec-memory.fill>`                               
+:math:`\TABLEINIT~x~y`                             :math:`\hex{FC}~\hex{0C}`   :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-table.init>`           :ref:`execution <exec-table.init>`                                
+:math:`\ELEMDROP~x`                                :math:`\hex{FC}~\hex{0D}`   :math:`[] \to []`                              :ref:`validation <valid-elem.drop>`            :ref:`execution <exec-elem.drop>`                                 
+:math:`\TABLECOPY~x~y`                             :math:`\hex{FC}~\hex{0E}`   :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-table.copy>`           :ref:`execution <exec-table.copy>`                                
+:math:`\TABLEGROW~x`                               :math:`\hex{FC}~\hex{0F}`   :math:`[t~\I32] \to [\I32]`                    :ref:`validation <valid-table.grow>`           :ref:`execution <exec-table.grow>`                                
+:math:`\TABLESIZE~x`                               :math:`\hex{FC}~\hex{10}`   :math:`[] \to [\I32]`                          :ref:`validation <valid-table.size>`           :ref:`execution <exec-table.size>`                                
+:math:`\TABLEFILL~x`                               :math:`\hex{FC}~\hex{11}`   :math:`[\I32~t~\I32] \to []`                   :ref:`validation <valid-table.fill>`           :ref:`execution <exec-table.fill>`                                
+:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_s}`          :math:`\hex{FC}~~0`         :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
+:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_u}`          :math:`\hex{FC}~~1`         :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
+:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_s}`          :math:`\hex{FC}~~2`         :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
+:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_u}`          :math:`\hex{FC}~~3`         :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
+:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_s}`          :math:`\hex{FC}~~4`         :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
+:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_u}`          :math:`\hex{FC}~~5`         :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
+:math:`\I64.\TRUNC\K{\_sat}\_\F64\K{\_s}`          :math:`\hex{FC}~~6`         :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
+:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_u}`          :math:`\hex{FC}~~7`         :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
+:math:`\V128.\LOAD~\memarg`                        :math:`\hex{FD}~~\hex{00}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
+:math:`\I16X8.\LOAD\K{8x8\_s}~\memarg`             :math:`\hex{FD}~~\hex{01}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\I16X8.\LOAD\K{8x8\_u}~\memarg`             :math:`\hex{FD}~~\hex{02}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\I32X4.\LOAD\K{16x4\_s}~\memarg`            :math:`\hex{FD}~~\hex{03}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\I32X4.\LOAD\K{16x4\_u}~\memarg`            :math:`\hex{FD}~~\hex{04}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\I64X2.\LOAD\K{32x2\_s}~\memarg`            :math:`\hex{FD}~~\hex{05}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\I64X2.\LOAD\K{32x2\_u}~\memarg`            :math:`\hex{FD}~~\hex{06}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\I8X16.\LOAD\K{\_splat}~\memarg`            :math:`\hex{FD}~~\hex{07}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
+:math:`\I16X8.\LOAD\K{\_splat}~\memarg`            :math:`\hex{FD}~~\hex{08}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
+:math:`\I32X4.\LOAD\K{\_splat}~\memarg`            :math:`\hex{FD}~~\hex{09}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
+:math:`\I64X2.\LOAD\K{\_splat}~\memarg`            :math:`\hex{FD}~~\hex{0A}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
+:math:`\V128.\STORE~\memarg`                       :math:`\hex{FD}~~\hex{0B}`  :math:`[\I32~\V128] \to []`                    :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
+:math:`\V128.\VCONST~\i128`                        :math:`\hex{FD}~~\hex{0C}`  :math:`[] \to [\V128]`                         :ref:`validation <valid-vconst>`               :ref:`execution <exec-vconst>`                                    
+:math:`\I8X16.\SHUFFLE~\laneidx^{16}`              :math:`\hex{FD}~~\hex{0D}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-shuffle>`          :ref:`execution <exec-vec-shuffle>`                               
+:math:`\I8X16.\SWIZZLE`                            :math:`\hex{FD}~~\hex{0E}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-swizzle>`                               
+:math:`\I8X16.\SPLAT`                              :math:`\hex{FD}~~\hex{0F}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
+:math:`\I16X8.\SPLAT`                              :math:`\hex{FD}~~\hex{10}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
+:math:`\I32X4.\SPLAT`                              :math:`\hex{FD}~~\hex{11}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
+:math:`\I64X2.\SPLAT`                              :math:`\hex{FD}~~\hex{12}`  :math:`[\I64] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
+:math:`\F32X4.\SPLAT`                              :math:`\hex{FD}~~\hex{13}`  :math:`[\F32] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
+:math:`\F64X2.\SPLAT`                              :math:`\hex{FD}~~\hex{14}`  :math:`[\F64] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
+:math:`\I8X16.\EXTRACTLANE\K{\_s}~\laneidx`        :math:`\hex{FD}~~\hex{15}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\I8X16.\EXTRACTLANE\K{\_u}~\laneidx`        :math:`\hex{FD}~~\hex{16}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\I8X16.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{17}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
+:math:`\I16X8.\EXTRACTLANE\K{\_s}~\laneidx`        :math:`\hex{FD}~~\hex{18}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\I16X8.\EXTRACTLANE\K{\_u}~\laneidx`        :math:`\hex{FD}~~\hex{19}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\I16X8.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{1A}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
+:math:`\I32X4.\EXTRACTLANE~\laneidx`               :math:`\hex{FD}~~\hex{1B}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\I32X4.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{1C}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
+:math:`\I64X2.\EXTRACTLANE~\laneidx`               :math:`\hex{FD}~~\hex{1D}`  :math:`[\V128] \to [\I64]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\I64X2.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{1E}`  :math:`[\V128~\I64] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
+:math:`\F32X4.\EXTRACTLANE~\laneidx`               :math:`\hex{FD}~~\hex{1F}`  :math:`[\V128] \to [\F32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\F32X4.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{20}`  :math:`[\V128~\F32] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
+:math:`\F64X2.\EXTRACTLANE~\laneidx`               :math:`\hex{FD}~~\hex{21}`  :math:`[\V128] \to [\F64]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\F64X2.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{22}`  :math:`[\V128~\F64] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
+:math:`\I8X16.\VEQ`                                :math:`\hex{FD}~~\hex{23}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ieq>`          
+:math:`\I8X16.\VNE`                                :math:`\hex{FD}~~\hex{24}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ine>`          
+:math:`\I8X16.\VLT\K{\_s}`                         :math:`\hex{FD}~~\hex{25}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_s>`        
+:math:`\I8X16.\VLT\K{\_u}`                         :math:`\hex{FD}~~\hex{26}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_u>`        
+:math:`\I8X16.\VGT\K{\_s}`                         :math:`\hex{FD}~~\hex{27}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_s>`        
+:math:`\I8X16.\VGT\K{\_u}`                         :math:`\hex{FD}~~\hex{28}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_u>`        
+:math:`\I8X16.\VLE\K{\_s}`                         :math:`\hex{FD}~~\hex{29}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_s>`        
+:math:`\I8X16.\VLE\K{\_u}`                         :math:`\hex{FD}~~\hex{2A}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_u>`        
+:math:`\I8X16.\VGE\K{\_s}`                         :math:`\hex{FD}~~\hex{2B}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_s>`        
+:math:`\I8X16.\VGE\K{\_u}`                         :math:`\hex{FD}~~\hex{2C}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_u>`        
+:math:`\I16X8.\VEQ`                                :math:`\hex{FD}~~\hex{2D}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ieq>`          
+:math:`\I16X8.\VNE`                                :math:`\hex{FD}~~\hex{2E}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ine>`          
+:math:`\I16X8.\VLT\K{\_s}`                         :math:`\hex{FD}~~\hex{2F}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_s>`        
+:math:`\I16X8.\VLT\K{\_u}`                         :math:`\hex{FD}~~\hex{30}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_u>`        
+:math:`\I16X8.\VGT\K{\_s}`                         :math:`\hex{FD}~~\hex{31}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_s>`        
+:math:`\I16X8.\VGT\K{\_u}`                         :math:`\hex{FD}~~\hex{32}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_u>`        
+:math:`\I16X8.\VLE\K{\_s}`                         :math:`\hex{FD}~~\hex{33}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_s>`        
+:math:`\I16X8.\VLE\K{\_u}`                         :math:`\hex{FD}~~\hex{34}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_u>`        
+:math:`\I16X8.\VGE\K{\_s}`                         :math:`\hex{FD}~~\hex{35}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_s>`        
+:math:`\I16X8.\VGE\K{\_u}`                         :math:`\hex{FD}~~\hex{36}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_u>`        
+:math:`\I32X4.\VEQ`                                :math:`\hex{FD}~~\hex{37}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ieq>`          
+:math:`\I32X4.\VNE`                                :math:`\hex{FD}~~\hex{38}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ine>`          
+:math:`\I32X4.\VLT\K{\_s}`                         :math:`\hex{FD}~~\hex{39}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_s>`        
+:math:`\I32X4.\VLT\K{\_u}`                         :math:`\hex{FD}~~\hex{3A}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_u>`        
+:math:`\I32X4.\VGT\K{\_s}`                         :math:`\hex{FD}~~\hex{3B}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_s>`        
+:math:`\I32X4.\VGT\K{\_u}`                         :math:`\hex{FD}~~\hex{3C}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_u>`        
+:math:`\I32X4.\VLE\K{\_s}`                         :math:`\hex{FD}~~\hex{3D}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_s>`        
+:math:`\I32X4.\VLE\K{\_u}`                         :math:`\hex{FD}~~\hex{3E}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_u>`        
+:math:`\I32X4.\VGE\K{\_s}`                         :math:`\hex{FD}~~\hex{3F}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_s>`        
+:math:`\I32X4.\VGE\K{\_u}`                         :math:`\hex{FD}~~\hex{40}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_u>`        
+:math:`\F32X4.\VEQ`                                :math:`\hex{FD}~~\hex{41}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-feq>`          
+:math:`\F32X4.\VNE`                                :math:`\hex{FD}~~\hex{42}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fne>`          
+:math:`\F32X4.\VLT`                                :math:`\hex{FD}~~\hex{43}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-flt>`          
+:math:`\F32X4.\VGT`                                :math:`\hex{FD}~~\hex{44}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fgt>`          
+:math:`\F32X4.\VLE`                                :math:`\hex{FD}~~\hex{45}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fle>`          
+:math:`\F32X4.\VGE`                                :math:`\hex{FD}~~\hex{46}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fge>`          
+:math:`\F64X2.\VEQ`                                :math:`\hex{FD}~~\hex{47}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-feq>`          
+:math:`\F64X2.\VNE`                                :math:`\hex{FD}~~\hex{48}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fne>`          
+:math:`\F64X2.\VLT`                                :math:`\hex{FD}~~\hex{49}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-flt>`          
+:math:`\F64X2.\VGT`                                :math:`\hex{FD}~~\hex{4A}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fgt>`          
+:math:`\F64X2.\VLE`                                :math:`\hex{FD}~~\hex{4B}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fle>`          
+:math:`\F64X2.\VGE`                                :math:`\hex{FD}~~\hex{4C}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fge>`          
+:math:`\V128.\VNOT`                                :math:`\hex{FD}~~\hex{4D}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vvunop>`               :ref:`execution <exec-vvunop>`, :ref:`operator <op-inot>`         
+:math:`\V128.\VAND`                                :math:`\hex{FD}~~\hex{4E}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vvbinop>`              :ref:`execution <exec-vvbinop>`, :ref:`operator <op-iand>`        
+:math:`\V128.\VANDNOT`                             :math:`\hex{FD}~~\hex{4F}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vvbinop>`              :ref:`execution <exec-vvbinop>`, :ref:`operator <op-iandnot>`     
+:math:`\V128.\VOR`                                 :math:`\hex{FD}~~\hex{50}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vvbinop>`              :ref:`execution <exec-vvbinop>`, :ref:`operator <op-ior>`         
+:math:`\V128.\VXOR`                                :math:`\hex{FD}~~\hex{51}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vvbinop>`              :ref:`execution <exec-vvbinop>`, :ref:`operator <op-ixor>`        
+:math:`\V128.\BITSELECT`                           :math:`\hex{FD}~~\hex{52}`  :math:`[\V128~\V128~\V128] \to [\V128]`        :ref:`validation <valid-vvternop>`             :ref:`execution <exec-vvternop>`, :ref:`operator <op-ibitselect>` 
+:math:`\V128.\ANYTRUE`                             :math:`\hex{FD}~~\hex{53}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vvtestop>`             :ref:`execution <exec-vvtestop>`                                  
+:math:`\V128.\LOAD\K{8\_lane}~\memarg~\laneidx`    :math:`\hex{FD}~~\hex{54}`  :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
+:math:`\V128.\LOAD\K{16\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{55}`  :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
+:math:`\V128.\LOAD\K{32\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{56}`  :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
+:math:`\V128.\LOAD\K{64\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{57}`  :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
+:math:`\V128.\STORE\K{8\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{58}`  :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
+:math:`\V128.\STORE\K{16\_lane}~\memarg~\laneidx`  :math:`\hex{FD}~~\hex{59}`  :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
+:math:`\V128.\STORE\K{32\_lane}~\memarg~\laneidx`  :math:`\hex{FD}~~\hex{5A}`  :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
+:math:`\V128.\STORE\K{64\_lane}~\memarg~\laneidx`  :math:`\hex{FD}~~\hex{5B}`  :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
+:math:`\V128.\LOAD\K{32\_zero}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{5C}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-zero>`            :ref:`execution <exec-load-zero>`                                 
+:math:`\V128.\LOAD\K{64\_zero}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{5D}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-zero>`            :ref:`execution <exec-load-zero>`                                 
+:math:`\F32X4.\VDEMOTE\K{\_f64x2\_zero}`           :math:`\hex{FD}~~\hex{5E}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-demote>`       
+:math:`\F64X2.\VPROMOTE\K{\_low\_f32x4}`           :math:`\hex{FD}~~\hex{5F}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-promote>`      
+:math:`\I8X16.\VABS`                               :math:`\hex{FD}~~\hex{60}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-iabs>`          
+:math:`\I8X16.\VNEG`                               :math:`\hex{FD}~~\hex{61}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ineg>`          
+:math:`\I8X16.\VPOPCNT`                            :math:`\hex{FD}~~\hex{62}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ipopcnt>`       
+:math:`\I8X16.\ALLTRUE`                            :math:`\hex{FD}~~\hex{63}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vtestop>`              :ref:`execution <exec-vtestop>`                                   
+:math:`\I8X16.\BITMASK`                            :math:`\hex{FD}~~\hex{64}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-bitmask>`          :ref:`execution <exec-vec-bitmask>`                               
+:math:`\I8X16.\NARROW\K{\_i16x8\_s}`               :math:`\hex{FD}~~\hex{65}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-narrow>`                                
+:math:`\I8X16.\NARROW\K{\_i16x8\_u}`               :math:`\hex{FD}~~\hex{66}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-narrow>`                                
+:math:`\F32X4.\VCEIL`                              :math:`\hex{FD}~~\hex{67}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fceil>`         
+:math:`\F32X4.\VFLOOR`                             :math:`\hex{FD}~~\hex{68}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ffloor>`        
+:math:`\F32X4.\VTRUNC`                             :math:`\hex{FD}~~\hex{69}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ftrunc>`        
+:math:`\F32X4.\VNEAREST`                           :math:`\hex{FD}~~\hex{6A}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fnearest>`      
+:math:`\I8X16.\VSHL`                               :math:`\hex{FD}~~\hex{6B}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishl>`      
+:math:`\I8X16.\VSHR\K{\_s}`                        :math:`\hex{FD}~~\hex{6C}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_s>`    
+:math:`\I8X16.\VSHR\K{\_u}`                        :math:`\hex{FD}~~\hex{6D}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_u>`    
+:math:`\I8X16.\VADD`                               :math:`\hex{FD}~~\hex{6E}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd>`         
+:math:`\I8X16.\VADD\K{\_sat\_s}`                   :math:`\hex{FD}~~\hex{6F}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd_sat_s>`   
+:math:`\I8X16.\VADD\K{\_sat\_u}`                   :math:`\hex{FD}~~\hex{70}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd_sat_u>`   
+:math:`\I8X16.\VSUB`                               :math:`\hex{FD}~~\hex{71}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub>`         
+:math:`\I8X16.\VSUB\K{\_sat\_s}`                   :math:`\hex{FD}~~\hex{72}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub_sat_s>`   
+:math:`\I8X16.\VSUB\K{\_sat\_u}`                   :math:`\hex{FD}~~\hex{73}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub_sat_u>`   
+:math:`\F64X2.\VCEIL`                              :math:`\hex{FD}~~\hex{74}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fceil>`         
+:math:`\F64X2.\VFLOOR`                             :math:`\hex{FD}~~\hex{75}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ffloor>`        
+:math:`\I8X16.\VMIN\K{\_s}`                        :math:`\hex{FD}~~\hex{76}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_s>`       
+:math:`\I8X16.\VMIN\K{\_u}`                        :math:`\hex{FD}~~\hex{77}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_u>`       
+:math:`\I8X16.\VMAX\K{\_s}`                        :math:`\hex{FD}~~\hex{78}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_s>`       
+:math:`\I8X16.\VMAX\K{\_u}`                        :math:`\hex{FD}~~\hex{79}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_u>`       
+:math:`\F64X2.\VTRUNC`                             :math:`\hex{FD}~~\hex{7A}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ftrunc>`        
+:math:`\I8X16.\AVGR\K{\_u}`                        :math:`\hex{FD}~~\hex{7B}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iavgr_u>`      
+:math:`\I16X8.\EXTADDPAIRWISE\K{\_i8x16\_s}`       :math:`\hex{FD}~~\hex{7C}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vec-extadd_pairwise>`  :ref:`execution <exec-vec-extadd_pairwise>`                       
+:math:`\I16X8.\EXTADDPAIRWISE\K{\_i8x16\_u}`       :math:`\hex{FD}~~\hex{7D}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vec-extadd_pairwise>`  :ref:`execution <exec-vec-extadd_pairwise>`                       
+:math:`\I32X4.\EXTADDPAIRWISE\K{\_i16x8\_s}`       :math:`\hex{FD}~~\hex{7E}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vec-extadd_pairwise>`  :ref:`execution <exec-vec-extadd_pairwise>`                       
+:math:`\I32X4.\EXTADDPAIRWISE\K{\_i16x8\_u}`       :math:`\hex{FD}~~\hex{7F}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vec-extadd_pairwise>`  :ref:`execution <exec-vec-extadd_pairwise>`                       
+:math:`\I16X8.\VABS`                               :math:`\hex{FD}~~\hex{80}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-iabs>`          
+:math:`\I16X8.\VNEG`                               :math:`\hex{FD}~~\hex{81}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ineg>`          
+:math:`\I16X8.\Q15MULRSAT\K{\_s}`                  :math:`\hex{FD}~~\hex{82}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iq15mulrsat_s>`
+:math:`\I16X8.\ALLTRUE`                            :math:`\hex{FD}~~\hex{83}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vtestop>`              :ref:`execution <exec-vtestop>`                                   
+:math:`\I16X8.\BITMASK`                            :math:`\hex{FD}~~\hex{84}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-bitmask>`          :ref:`execution <exec-vec-bitmask>`                               
+:math:`\I16X8.\NARROW\K{\_i32x4\_s}`               :math:`\hex{FD}~~\hex{85}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-narrow>`                                
+:math:`\I16X8.\NARROW\K{\_i32x4\_u}`               :math:`\hex{FD}~~\hex{86}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-narrow>`                                
+:math:`\I16X8.\VEXTEND\K{\_low\_i8x16\_s}`         :math:`\hex{FD}~~\hex{87}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I16X8.\VEXTEND\K{\_high\_i8x16\_s}`        :math:`\hex{FD}~~\hex{88}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I16X8.\VEXTEND\K{\_low\_i8x16\_u}`         :math:`\hex{FD}~~\hex{89}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I16X8.\VEXTEND\K{\_high\_i8x16\_u}`        :math:`\hex{FD}~~\hex{8A}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I16X8.\VSHL`                               :math:`\hex{FD}~~\hex{8B}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishl>`      
+:math:`\I16X8.\VSHR\K{\_s}`                        :math:`\hex{FD}~~\hex{8C}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_s>`    
+:math:`\I16X8.\VSHR\K{\_u}`                        :math:`\hex{FD}~~\hex{8D}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_u>`    
+:math:`\I16X8.\VADD`                               :math:`\hex{FD}~~\hex{8E}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd>`         
+:math:`\I16X8.\VADD\K{\_sat\_s}`                   :math:`\hex{FD}~~\hex{8F}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd_sat_s>`   
+:math:`\I16X8.\VADD\K{\_sat\_u}`                   :math:`\hex{FD}~~\hex{90}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd_sat_u>`   
+:math:`\I16X8.\VSUB`                               :math:`\hex{FD}~~\hex{91}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub>`         
+:math:`\I16X8.\VSUB\K{\_sat\_s}`                   :math:`\hex{FD}~~\hex{92}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub_sat_s>`   
+:math:`\I16X8.\VSUB\K{\_sat\_u}`                   :math:`\hex{FD}~~\hex{93}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub_sat_u>`   
+:math:`\F64X2.\VNEAREST`                           :math:`\hex{FD}~~\hex{94}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fnearest>`      
+:math:`\I16X8.\VMUL`                               :math:`\hex{FD}~~\hex{95}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imul>`         
+:math:`\I16X8.\VMIN\K{\_s}`                        :math:`\hex{FD}~~\hex{96}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_s>`       
+:math:`\I16X8.\VMIN\K{\_u}`                        :math:`\hex{FD}~~\hex{97}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_u>`       
+:math:`\I16X8.\VMAX\K{\_s}`                        :math:`\hex{FD}~~\hex{98}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_s>`       
+:math:`\I16X8.\VMAX\K{\_u}`                        :math:`\hex{FD}~~\hex{99}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_u>`       
+:math:`\I16X8.\AVGR\K{\_u}`                        :math:`\hex{FD}~~\hex{9B}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iavgr_u>`      
+:math:`\I16X8.\EXTMUL\K{\_low\_i8x16\_s}`          :math:`\hex{FD}~~\hex{9C}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I16X8.\EXTMUL\K{\_high\_i8x16\_s}`         :math:`\hex{FD}~~\hex{9D}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I16X8.\EXTMUL\K{\_low\_i8x16\_u}`          :math:`\hex{FD}~~\hex{9E}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I16X8.\EXTMUL\K{\_high\_i8x16\_u}`         :math:`\hex{FD}~~\hex{9F}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I32X4.\VABS`                               :math:`\hex{FD}~~\hex{A0}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-iabs>`          
+:math:`\I32X4.\VNEG`                               :math:`\hex{FD}~~\hex{A1}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ineg>`          
+:math:`\I32X4.\ALLTRUE`                            :math:`\hex{FD}~~\hex{A3}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vtestop>`              :ref:`execution <exec-vtestop>`                                   
+:math:`\I32X4.\BITMASK`                            :math:`\hex{FD}~~\hex{A4}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-bitmask>`          :ref:`execution <exec-vec-bitmask>`                               
+:math:`\I32X4.\VEXTEND\K{\_low\_i16x8\_s}`         :math:`\hex{FD}~~\hex{A7}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I32X4.\VEXTEND\K{\_high\_i16x8\_s}`        :math:`\hex{FD}~~\hex{A8}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I32X4.\VEXTEND\K{\_low\_i16x8\_u}`         :math:`\hex{FD}~~\hex{A9}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I32X4.\VEXTEND\K{\_high\_i16x8\_u}`        :math:`\hex{FD}~~\hex{AA}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I32X4.\VSHL`                               :math:`\hex{FD}~~\hex{AB}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishl>`      
+:math:`\I32X4.\VSHR\K{\_s}`                        :math:`\hex{FD}~~\hex{AC}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_s>`    
+:math:`\I32X4.\VSHR\K{\_u}`                        :math:`\hex{FD}~~\hex{AD}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_u>`    
+:math:`\I32X4.\VADD`                               :math:`\hex{FD}~~\hex{AE}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd>`         
+:math:`\I32X4.\VSUB`                               :math:`\hex{FD}~~\hex{B1}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub>`         
+:math:`\I32X4.\VMUL`                               :math:`\hex{FD}~~\hex{B5}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imul>`         
+:math:`\I32X4.\VMIN\K{\_s}`                        :math:`\hex{FD}~~\hex{B6}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_s>`       
+:math:`\I32X4.\VMIN\K{\_u}`                        :math:`\hex{FD}~~\hex{B7}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_u>`       
+:math:`\I32X4.\VMAX\K{\_s}`                        :math:`\hex{FD}~~\hex{B8}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_s>`       
+:math:`\I32X4.\VMAX\K{\_u}`                        :math:`\hex{FD}~~\hex{B9}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_u>`       
+:math:`\I32X4.\DOT\K{\_i16x8\_s}`                  :math:`\hex{FD}~~\hex{BA}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-dot>`              :ref:`execution <exec-vec-dot>`                                   
+:math:`\I32X4.\EXTMUL\K{\_low\_i16x8\_s}`          :math:`\hex{FD}~~\hex{BC}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I32X4.\EXTMUL\K{\_high\_i16x8\_s}`         :math:`\hex{FD}~~\hex{BD}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I32X4.\EXTMUL\K{\_low\_i16x8\_u}`          :math:`\hex{FD}~~\hex{BE}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I32X4.\EXTMUL\K{\_high\_i16x8\_u}`         :math:`\hex{FD}~~\hex{BF}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I64X2.\VABS`                               :math:`\hex{FD}~~\hex{C0}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-iabs>`          
+:math:`\I64X2.\VNEG`                               :math:`\hex{FD}~~\hex{C1}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ineg>`          
+:math:`\I64X2.\ALLTRUE`                            :math:`\hex{FD}~~\hex{C3}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vtestop>`              :ref:`execution <exec-vtestop>`                                   
+:math:`\I64X2.\BITMASK`                            :math:`\hex{FD}~~\hex{C4}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-bitmask>`          :ref:`execution <exec-vec-bitmask>`                               
+:math:`\I64X2.\VEXTEND\K{\_low\_i32x4\_s}`         :math:`\hex{FD}~~\hex{C7}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I64X2.\VEXTEND\K{\_high\_i32x4\_s}`        :math:`\hex{FD}~~\hex{C8}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I64X2.\VEXTEND\K{\_low\_i32x4\_u}`         :math:`\hex{FD}~~\hex{C9}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I64X2.\VEXTEND\K{\_high\_i32x4\_u}`        :math:`\hex{FD}~~\hex{CA}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I64X2.\VSHL`                               :math:`\hex{FD}~~\hex{CB}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishl>`      
+:math:`\I64X2.\VSHR\K{\_s}`                        :math:`\hex{FD}~~\hex{CC}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_s>`    
+:math:`\I64X2.\VSHR\K{\_u}`                        :math:`\hex{FD}~~\hex{CD}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_u>`    
+:math:`\I64X2.\VADD`                               :math:`\hex{FD}~~\hex{CE}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd>`         
+:math:`\I64X2.\VSUB`                               :math:`\hex{FD}~~\hex{D1}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub>`         
+:math:`\I64X2.\VMUL`                               :math:`\hex{FD}~~\hex{D5}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imul>`         
+:math:`\I64X2.\VEQ`                                :math:`\hex{FD}~~\hex{D6}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ieq>`          
+:math:`\I64X2.\VNE`                                :math:`\hex{FD}~~\hex{D7}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ine>`          
+:math:`\I64X2.\VLT\K{\_s}`                         :math:`\hex{FD}~~\hex{D8}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_s>`        
+:math:`\I64X2.\VGT\K{\_s}`                         :math:`\hex{FD}~~\hex{D9}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_s>`        
+:math:`\I64X2.\VLE\K{\_s}`                         :math:`\hex{FD}~~\hex{DA}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_s>`        
+:math:`\I64X2.\VGE\K{\_s}`                         :math:`\hex{FD}~~\hex{DB}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_s>`        
+:math:`\I64X2.\EXTMUL\K{\_low\_i32x4\_s}`          :math:`\hex{FD}~~\hex{DC}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I64X2.\EXTMUL\K{\_high\_i32x4\_s}`         :math:`\hex{FD}~~\hex{DD}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I64X2.\EXTMUL\K{\_low\_i32x4\_u}`          :math:`\hex{FD}~~\hex{DE}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I64X2.\EXTMUL\K{\_high\_i32x4\_u}`         :math:`\hex{FD}~~\hex{DF}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\F32X4.\VABS`                               :math:`\hex{FD}~~\hex{E0}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fabs>`          
+:math:`\F32X4.\VNEG`                               :math:`\hex{FD}~~\hex{E1}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fneg>`          
+:math:`\F32X4.\VSQRT`                              :math:`\hex{FD}~~\hex{E3}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fsqrt>`         
+:math:`\F32X4.\VADD`                               :math:`\hex{FD}~~\hex{E4}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fadd>`         
+:math:`\F32X4.\VSUB`                               :math:`\hex{FD}~~\hex{E5}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fsub>`         
+:math:`\F32X4.\VMUL`                               :math:`\hex{FD}~~\hex{E6}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmul>`         
+:math:`\F32X4.\VDIV`                               :math:`\hex{FD}~~\hex{E7}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fdiv>`         
+:math:`\F32X4.\VMIN`                               :math:`\hex{FD}~~\hex{E8}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmin>`         
+:math:`\F32X4.\VMAX`                               :math:`\hex{FD}~~\hex{E9}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmax>`         
+:math:`\F32X4.\VPMIN`                              :math:`\hex{FD}~~\hex{EA}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fpmin>`        
+:math:`\F32X4.\VPMAX`                              :math:`\hex{FD}~~\hex{EB}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fpmax>`        
+:math:`\F64X2.\VABS`                               :math:`\hex{FD}~~\hex{EC}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fabs>`          
+:math:`\F64X2.\VNEG`                               :math:`\hex{FD}~~\hex{ED}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fneg>`          
+:math:`\F64X2.\VSQRT`                              :math:`\hex{FD}~~\hex{EF}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fsqrt>`         
+:math:`\F64X2.\VADD`                               :math:`\hex{FD}~~\hex{F0}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fadd>`         
+:math:`\F64X2.\VSUB`                               :math:`\hex{FD}~~\hex{F1}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fsub>`         
+:math:`\F64X2.\VMUL`                               :math:`\hex{FD}~~\hex{F2}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmul>`         
+:math:`\F64X2.\VDIV`                               :math:`\hex{FD}~~\hex{F3}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fdiv>`         
+:math:`\F64X2.\VMIN`                               :math:`\hex{FD}~~\hex{F4}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmin>`         
+:math:`\F64X2.\VMAX`                               :math:`\hex{FD}~~\hex{F5}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmax>`         
+:math:`\F64X2.\VPMIN`                              :math:`\hex{FD}~~\hex{F6}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fpmin>`        
+:math:`\F64X2.\VPMAX`                              :math:`\hex{FD}~~\hex{F7}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fpmax>`        
+:math:`\I32X4.\TRUNC\K{\_sat\_f32x4\_s}`           :math:`\hex{FD}~~\hex{F8}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-trunc_sat_s>`  
+:math:`\I32X4.\TRUNC\K{\_sat\_f32x4\_u}`           :math:`\hex{FD}~~\hex{F9}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-trunc_sat_u>`  
+:math:`\F32X4.\VCONVERT\K{\_i32x4\_s}`             :math:`\hex{FD}~~\hex{FA}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_s>`    
+:math:`\F32X4.\VCONVERT\K{\_i32x4\_u}`             :math:`\hex{FD}~~\hex{FB}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_u>`    
+:math:`\I32X4.\VTRUNC\K{\_sat\_f64x2\_s\_zero}`    :math:`\hex{FD}~~\hex{FC}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-trunc_sat_s>`  
+:math:`\I32X4.\VTRUNC\K{\_sat\_f64x2\_u\_zero}`    :math:`\hex{FD}~~\hex{FD}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-trunc_sat_u>`  
+:math:`\F64X2.\VCONVERT\K{\_low\_i32x4\_s}`        :math:`\hex{FD}~~\hex{FE}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_s>`    
+:math:`\F64X2.\VCONVERT\K{\_low\_i32x4\_u}`        :math:`\hex{FD}~~\hex{FF}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_u>`    
+=================================================  ==========================  =============================================  =============================================  ==================================================================
diff --git a/document/core/appendix/index-types.rst b/document/core/appendix/index-types.rst
index fd38fe205..715233cea 100644
--- a/document/core/appendix/index-types.rst
+++ b/document/core/appendix/index-types.rst
@@ -12,7 +12,8 @@ Category                                  Constructor
 :ref:`Number type <syntax-numtype>`       |I64|                                        :math:`\hex{7E}` (-2 as |Bs7|)
 :ref:`Number type <syntax-numtype>`       |F32|                                        :math:`\hex{7D}` (-3 as |Bs7|)
 :ref:`Number type <syntax-numtype>`       |F64|                                        :math:`\hex{7C}` (-4 as |Bs7|)
-(reserved)                                                                             :math:`\hex{7B}` .. :math:`\hex{71}`
+:ref:`Vector type <syntax-vectype>`       |V128|                                       :math:`\hex{7B}` (-5 as |Bs7|)
+(reserved)                                                                             :math:`\hex{7A}` .. :math:`\hex{71}`
 :ref:`Reference type <syntax-reftype>`    |FUNCREF|                                    :math:`\hex{70}` (-16 as |Bs7|)
 :ref:`Reference type <syntax-reftype>`    |EXTERNREF|                                  :math:`\hex{6F}` (-17 as |Bs7|)
 (reserved)                                                                             :math:`\hex{6E}` .. :math:`\hex{61}`
diff --git a/document/core/binary/conventions.rst b/document/core/binary/conventions.rst
index cacd25134..83c80399f 100644
--- a/document/core/binary/conventions.rst
+++ b/document/core/binary/conventions.rst
@@ -63,11 +63,11 @@ In order to distinguish symbols of the binary syntax from symbols of the abstrac
   (This is a shorthand for a side condition requiring multiple different variables to be equal.)
 
 .. note::
-   For example, the :ref:`binary grammar <binary-valtype>` for :ref:`value types <syntax-valtype>` is given as follows:
+   For example, the :ref:`binary grammar <binary-numtype>` for :ref:`number types <syntax-numtype>` is given as follows:
 
    .. math::
      \begin{array}{llcll@{\qquad\qquad}l}
-     \production{value types} & \Bvaltype &::=&
+     \production{number types} & \Bnumtype &::=&
        \hex{7F} &\Rightarrow& \I32 \\ &&|&
        \hex{7E} &\Rightarrow& \I64 \\ &&|&
        \hex{7D} &\Rightarrow& \F32 \\ &&|&
@@ -76,7 +76,7 @@ In order to distinguish symbols of the binary syntax from symbols of the abstrac
 
    Consequently, the byte :math:`\hex{7F}` encodes the type |I32|,
    :math:`\hex{7E}` encodes the type |I64|, and so forth.
-   No other byte value is allowed as the encoding of a value type.
+   No other byte value is allowed as the encoding of a number type.
 
    The :ref:`binary grammar <binary-limits>` for :ref:`limits <syntax-limits>` is defined as follows:   
 
diff --git a/document/core/binary/instructions.rst b/document/core/binary/instructions.rst
index 26e0b8fc7..f295b5e76 100644
--- a/document/core/binary/instructions.rst
+++ b/document/core/binary/instructions.rst
@@ -69,7 +69,7 @@ Control Instructions
    The |ELSE| opcode :math:`\hex{05}` in the encoding of an |IF| instruction can be omitted if the following instruction sequence is empty.
 
    Unlike any :ref:`other occurrence <binary-typeidx>`, the :ref:`type index <syntax-typeidx>` in a :ref:`block type <syntax-blocktype>` is encoded as a positive :ref:`signed integer <syntax-sint>`, so that its |SignedLEB128| bit pattern cannot collide with the encoding of :ref:`value types <binary-valtype>` or the special code :math:`\hex{40}`, which correspond to the LEB128 encoding of negative integers.
-   To avoid any loss in the range of allowed indices, it is treated as a 33 bit signed integer. 
+   To avoid any loss in the range of allowed indices, it is treated as a 33 bit signed integer.
 
 
 .. index:: reference instruction
@@ -462,6 +462,383 @@ whereas the actual opcode is encoded by a variable-length :ref:`unsigned integer
    \end{array}
 
 
+.. index:: vector instruction
+   pair: binary format; instruction
+.. _binary-instr-vec:
+
+Vector Instructions
+~~~~~~~~~~~~~~~~~~~
+
+All variants of :ref:`vector instructions <syntax-instr-vec>` are represented by separate byte codes.
+They all have a one byte prefix, whereas the actual opcode is encoded by a variable-length :ref:`unsigned integer <binary-uint>`.
+
+Vector loads and stores are followed by the encoding of their |memarg| immediate.
+
+.. _binary-laneidx:
+
+.. math::
+   \begin{array}{llclll}
+   \production{lane index} & \Blaneidx &::=&
+     l{:}\Bbyte &\Rightarrow& l \\
+   \production{instruction} & \Binstr &::=& \dots \\&&|&
+     \hex{FD}~~0{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD~m \\ &&|&
+     \hex{FD}~~1{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{8x8\_s}~m \\ &&|&
+     \hex{FD}~~2{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{8x8\_u}~m \\ &&|&
+     \hex{FD}~~3{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{16x4\_s}~m \\ &&|&
+     \hex{FD}~~4{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{16x4\_u}~m \\ &&|&
+     \hex{FD}~~5{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{32x2\_s}~m \\ &&|&
+     \hex{FD}~~6{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{32x2\_u}~m \\ &&|&
+     \hex{FD}~~7{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{8\_splat}~m \\ &&|&
+     \hex{FD}~~8{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{16\_splat}~m \\ &&|&
+     \hex{FD}~~9{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{32\_splat}~m \\ &&|&
+     \hex{FD}~~10{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{64\_splat}~m \\ &&|&
+     \hex{FD}~~92{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{32\_zero}~m \\ &&|&
+     \hex{FD}~~93{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{64\_zero}~m \\ &&|&
+     \hex{FD}~~11{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\STORE~m \\ &&|&
+     \hex{FD}~~84{:}\Bu32~~m{:}\Bmemarg~l{:}\Blaneidx &\Rightarrow& \V128.\LOAD\K{8\_lane}~m~l \\ &&|&
+     \hex{FD}~~85{:}\Bu32~~m{:}\Bmemarg~l{:}\Blaneidx &\Rightarrow& \V128.\LOAD\K{16\_lane}~m~l \\ &&|&
+     \hex{FD}~~86{:}\Bu32~~m{:}\Bmemarg~l{:}\Blaneidx &\Rightarrow& \V128.\LOAD\K{32\_lane}~m~l \\ &&|&
+     \hex{FD}~~87{:}\Bu32~~m{:}\Bmemarg~l{:}\Blaneidx &\Rightarrow& \V128.\LOAD\K{64\_lane}~m~l \\ &&|&
+     \hex{FD}~~88{:}\Bu32~~m{:}\Bmemarg~l{:}\Blaneidx &\Rightarrow& \V128.\STORE\K{8\_lane}~m~l \\ &&|&
+     \hex{FD}~~89{:}\Bu32~~m{:}\Bmemarg~l{:}\Blaneidx &\Rightarrow& \V128.\STORE\K{16\_lane}~m~l \\ &&|&
+     \hex{FD}~~90{:}\Bu32~~m{:}\Bmemarg~l{:}\Blaneidx &\Rightarrow& \V128.\STORE\K{32\_lane}~m~l \\ &&|&
+     \hex{FD}~~91{:}\Bu32~~m{:}\Bmemarg~l{:}\Blaneidx &\Rightarrow& \V128.\STORE\K{64\_lane}~m~l \\
+   \end{array}
+
+The |VCONST| instruction is followed by 16 immediate bytes, which are converted into a |i128| in |littleendian| byte order:
+
+.. math::
+   \begin{array}{llclll}
+   \production{instruction} & \Binstr &::=& \dots \\&&|&
+     \hex{FD}~~12{:}\Bu32~~(b{:}\Bbyte)^{16} &\Rightarrow& \V128.\VCONST~
+     bytes_{\K{i128}}^{-1}(b_{0}~\dots~b_{15}) \\
+   \end{array}
+
+.. _binary-vternop:
+
+The |SHUFFLE| instruction is also followed by the encoding of 16 |laneidx| immediates.
+
+.. math::
+   \begin{array}{llclll}
+   \production{instruction} & \Binstr &::=& \dots \\&&|&
+     \hex{FD}~~13{:}\Bu32~~(l{:}\Blaneidx)^{16} &\Rightarrow& \I8X16.\SHUFFLE~l^{16} \\
+   \end{array}
+
+|EXTRACTLANE| and |REPLACELANE| instructions are followed by the encoding of a |laneidx| immediate.
+
+.. math::
+   \begin{array}{llclll}
+   \production{instruction} & \Binstr &::=& \dots \\&&|&
+     \hex{FD}~~21{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \I8X16.\EXTRACTLANE\K{\_s}~l \\ &&|&
+     \hex{FD}~~22{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \I8X16.\EXTRACTLANE\K{\_u}~l \\ &&|&
+     \hex{FD}~~23{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \I8X16.\REPLACELANE~l \\ &&|&
+     \hex{FD}~~24{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \I16X8.\EXTRACTLANE\K{\_s}~l \\ &&|&
+     \hex{FD}~~25{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \I16X8.\EXTRACTLANE\K{\_u}~l \\ &&|&
+     \hex{FD}~~26{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \I16X8.\REPLACELANE~l \\ &&|&
+     \hex{FD}~~27{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \I32X4.\EXTRACTLANE~l \\ &&|&
+     \hex{FD}~~28{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \I32X4.\REPLACELANE~l \\ &&|&
+     \hex{FD}~~29{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \I64X2.\EXTRACTLANE~l \\ &&|&
+     \hex{FD}~~30{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \I64X2.\REPLACELANE~l \\ &&|&
+     \hex{FD}~~31{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \F32X4.\EXTRACTLANE~l \\ &&|&
+     \hex{FD}~~32{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \F32X4.\REPLACELANE~l \\ &&|&
+     \hex{FD}~~33{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \F64X2.\EXTRACTLANE~l \\ &&|&
+     \hex{FD}~~34{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \F64X2.\REPLACELANE~l \\
+   \end{array}
+
+All other vector instructions are plain opcodes without any immediates.
+
+.. math::
+   \begin{array}{llclll}
+   \production{instruction} & \Binstr &::=& \dots && \phantom{vechaslongerinstructionnames} \\&&|&
+     \hex{FD}~~14{:}\Bu32 &\Rightarrow& \I8X16.\SWIZZLE \\ &&|&
+     \hex{FD}~~15{:}\Bu32 &\Rightarrow& \I8X16.\SPLAT \\ &&|&
+     \hex{FD}~~16{:}\Bu32 &\Rightarrow& \I16X8.\SPLAT \\ &&|&
+     \hex{FD}~~17{:}\Bu32 &\Rightarrow& \I32X4.\SPLAT \\ &&|&
+     \hex{FD}~~18{:}\Bu32 &\Rightarrow& \I64X2.\SPLAT \\ &&|&
+     \hex{FD}~~19{:}\Bu32 &\Rightarrow& \F32X4.\SPLAT \\ &&|&
+     \hex{FD}~~20{:}\Bu32 &\Rightarrow& \F64X2.\SPLAT \\
+   \end{array}
+
+.. _binary-virelop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~35{:}\Bu32 &\Rightarrow& \I8X16.\VEQ \\ &&|&
+     \hex{FD}~~36{:}\Bu32 &\Rightarrow& \I8X16.\VNE \\ &&|&
+     \hex{FD}~~37{:}\Bu32 &\Rightarrow& \I8X16.\VLT\K{\_s} \\ &&|&
+     \hex{FD}~~38{:}\Bu32 &\Rightarrow& \I8X16.\VLT\K{\_u} \\ &&|&
+     \hex{FD}~~39{:}\Bu32 &\Rightarrow& \I8X16.\VGT\K{\_s} \\ &&|&
+     \hex{FD}~~40{:}\Bu32 &\Rightarrow& \I8X16.\VGT\K{\_u} \\ &&|&
+     \hex{FD}~~41{:}\Bu32 &\Rightarrow& \I8X16.\VLE\K{\_s} \\ &&|&
+     \hex{FD}~~42{:}\Bu32 &\Rightarrow& \I8X16.\VLE\K{\_u} \\ &&|&
+     \hex{FD}~~43{:}\Bu32 &\Rightarrow& \I8X16.\VGE\K{\_s} \\ &&|&
+     \hex{FD}~~44{:}\Bu32 &\Rightarrow& \I8X16.\VGE\K{\_u} \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~45{:}\Bu32 &\Rightarrow& \I16X8.\VEQ \\ &&|&
+     \hex{FD}~~46{:}\Bu32 &\Rightarrow& \I16X8.\VNE \\ &&|&
+     \hex{FD}~~47{:}\Bu32 &\Rightarrow& \I16X8.\VLT\K{\_s} \\ &&|&
+     \hex{FD}~~48{:}\Bu32 &\Rightarrow& \I16X8.\VLT\K{\_u} \\ &&|&
+     \hex{FD}~~49{:}\Bu32 &\Rightarrow& \I16X8.\VGT\K{\_s} \\ &&|&
+     \hex{FD}~~50{:}\Bu32 &\Rightarrow& \I16X8.\VGT\K{\_u} \\ &&|&
+     \hex{FD}~~51{:}\Bu32 &\Rightarrow& \I16X8.\VLE\K{\_s} \\ &&|&
+     \hex{FD}~~52{:}\Bu32 &\Rightarrow& \I16X8.\VLE\K{\_u} \\ &&|&
+     \hex{FD}~~53{:}\Bu32 &\Rightarrow& \I16X8.\VGE\K{\_s} \\ &&|&
+     \hex{FD}~~54{:}\Bu32 &\Rightarrow& \I16X8.\VGE\K{\_u} \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~55{:}\Bu32 &\Rightarrow& \I32X4.\VEQ \\ &&|&
+     \hex{FD}~~56{:}\Bu32 &\Rightarrow& \I32X4.\VNE \\ &&|&
+     \hex{FD}~~57{:}\Bu32 &\Rightarrow& \I32X4.\VLT\K{\_s} \\ &&|&
+     \hex{FD}~~58{:}\Bu32 &\Rightarrow& \I32X4.\VLT\K{\_u} \\ &&|&
+     \hex{FD}~~59{:}\Bu32 &\Rightarrow& \I32X4.\VGT\K{\_s} \\ &&|&
+     \hex{FD}~~60{:}\Bu32 &\Rightarrow& \I32X4.\VGT\K{\_u} \\ &&|&
+     \hex{FD}~~61{:}\Bu32 &\Rightarrow& \I32X4.\VLE\K{\_s} \\ &&|&
+     \hex{FD}~~62{:}\Bu32 &\Rightarrow& \I32X4.\VLE\K{\_u} \\ &&|&
+     \hex{FD}~~63{:}\Bu32 &\Rightarrow& \I32X4.\VGE\K{\_s} \\ &&|&
+     \hex{FD}~~64{:}\Bu32 &\Rightarrow& \I32X4.\VGE\K{\_u} \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~214{:}\Bu32 &\Rightarrow& \I64X2.\VEQ \\ &&|&
+     \hex{FD}~~215{:}\Bu32 &\Rightarrow& \I64X2.\VNE \\ &&|&
+     \hex{FD}~~216{:}\Bu32 &\Rightarrow& \I64X2.\VLT\K{\_s} \\ &&|&
+     \hex{FD}~~217{:}\Bu32 &\Rightarrow& \I64X2.\VGT\K{\_s} \\ &&|&
+     \hex{FD}~~218{:}\Bu32 &\Rightarrow& \I64X2.\VLE\K{\_s} \\ &&|&
+     \hex{FD}~~219{:}\Bu32 &\Rightarrow& \I64X2.\VGE\K{\_s} \\ &&|&
+   \end{array}
+
+.. _binary-vfrelop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~65{:}\Bu32 &\Rightarrow& \F32X4.\VEQ \\ &&|&
+     \hex{FD}~~66{:}\Bu32 &\Rightarrow& \F32X4.\VNE \\ &&|&
+     \hex{FD}~~67{:}\Bu32 &\Rightarrow& \F32X4.\VLT \\ &&|&
+     \hex{FD}~~68{:}\Bu32 &\Rightarrow& \F32X4.\VGT \\ &&|&
+     \hex{FD}~~69{:}\Bu32 &\Rightarrow& \F32X4.\VLE \\ &&|&
+     \hex{FD}~~70{:}\Bu32 &\Rightarrow& \F32X4.\VGE \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~71{:}\Bu32 &\Rightarrow& \F64X2.\VEQ \\ &&|&
+     \hex{FD}~~72{:}\Bu32 &\Rightarrow& \F64X2.\VNE \\ &&|&
+     \hex{FD}~~73{:}\Bu32 &\Rightarrow& \F64X2.\VLT \\ &&|&
+     \hex{FD}~~74{:}\Bu32 &\Rightarrow& \F64X2.\VGT \\ &&|&
+     \hex{FD}~~75{:}\Bu32 &\Rightarrow& \F64X2.\VLE \\ &&|&
+     \hex{FD}~~76{:}\Bu32 &\Rightarrow& \F64X2.\VGE \\
+   \end{array}
+
+.. _binary-vsunop:
+.. _binary-vsbinop:
+.. _binary-vsternop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~77{:}\Bu32 &\Rightarrow& \V128.\VNOT \\ &&|&
+     \hex{FD}~~78{:}\Bu32 &\Rightarrow& \V128.\VAND \\ &&|&
+     \hex{FD}~~79{:}\Bu32 &\Rightarrow& \V128.\VANDNOT \\ &&|&
+     \hex{FD}~~80{:}\Bu32 &\Rightarrow& \V128.\VOR \\ &&|&
+     \hex{FD}~~81{:}\Bu32 &\Rightarrow& \V128.\VXOR \\ &&|&
+     \hex{FD}~~82{:}\Bu32 &\Rightarrow& \V128.\BITSELECT \\ &&|&
+     \hex{FD}~~83{:}\Bu32 &\Rightarrow& \V128.\ANYTRUE \\
+   \end{array}
+
+.. _binary-vitestop:
+.. _binary-vshiftop:
+.. _binary-viunop:
+.. _binary-vibinop:
+.. _binary-viminmaxop:
+.. _binary-vsatbinop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~96{:}\Bu32 &\Rightarrow& \I8X16.\VABS \\ &&|&
+     \hex{FD}~~97{:}\Bu32 &\Rightarrow& \I8X16.\VNEG \\ &&|&
+     \hex{FD}~~98{:}\Bu32 &\Rightarrow& \I8X16.\VPOPCNT \\ &&|&
+     \hex{FD}~~99{:}\Bu32 &\Rightarrow& \I8X16.\ALLTRUE \\ &&|&
+     \hex{FD}~~100{:}\Bu32 &\Rightarrow& \I8X16.\BITMASK \\ &&|&
+     \hex{FD}~~101{:}\Bu32 &\Rightarrow& \I8X16.\NARROW\K{\_i16x8\_s} \\ &&|&
+     \hex{FD}~~102{:}\Bu32 &\Rightarrow& \I8X16.\NARROW\K{\_i16x8\_u} \\ &&|&
+     \hex{FD}~~107{:}\Bu32 &\Rightarrow& \I8X16.\VSHL \\ &&|&
+     \hex{FD}~~108{:}\Bu32 &\Rightarrow& \I8X16.\VSHR\K{\_s} \\ &&|&
+     \hex{FD}~~109{:}\Bu32 &\Rightarrow& \I8X16.\VSHR\K{\_u} \\ &&|&
+     \hex{FD}~~110{:}\Bu32 &\Rightarrow& \I8X16.\VADD \\ &&|&
+     \hex{FD}~~111{:}\Bu32 &\Rightarrow& \I8X16.\VADD\K{\_sat\_s} \\ &&|&
+     \hex{FD}~~112{:}\Bu32 &\Rightarrow& \I8X16.\VADD\K{\_sat\_u} \\ &&|&
+     \hex{FD}~~113{:}\Bu32 &\Rightarrow& \I8X16.\VSUB \\ &&|&
+     \hex{FD}~~114{:}\Bu32 &\Rightarrow& \I8X16.\VSUB\K{\_sat\_s} \\ &&|&
+     \hex{FD}~~115{:}\Bu32 &\Rightarrow& \I8X16.\VSUB\K{\_sat\_u} \\ &&|&
+     \hex{FD}~~118{:}\Bu32 &\Rightarrow& \I8X16.\VMIN\K{\_s} \\ &&|&
+     \hex{FD}~~119{:}\Bu32 &\Rightarrow& \I8X16.\VMIN\K{\_u} \\ &&|&
+     \hex{FD}~~120{:}\Bu32 &\Rightarrow& \I8X16.\VMAX\K{\_s} \\ &&|&
+     \hex{FD}~~121{:}\Bu32 &\Rightarrow& \I8X16.\VMAX\K{\_u} \\ &&|&
+     \hex{FD}~~123{:}\Bu32 &\Rightarrow& \I8X16.\AVGR\K{\_u} \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~124{:}\Bu32 &\Rightarrow& \I16X8.\EXTADDPAIRWISE\K{\_i8x16\_s}\\ &&|&
+     \hex{FD}~~125{:}\Bu32 &\Rightarrow& \I16X8.\EXTADDPAIRWISE\K{\_i8x16\_u}\\ &&|&
+     \hex{FD}~~128{:}\Bu32 &\Rightarrow& \I16X8.\VABS \\ &&|&
+     \hex{FD}~~129{:}\Bu32 &\Rightarrow& \I16X8.\VNEG \\ &&|&
+     \hex{FD}~~130{:}\Bu32 &\Rightarrow& \I16X8.\Q15MULRSAT\K{\_s} \\ &&|&
+     \hex{FD}~~131{:}\Bu32 &\Rightarrow& \I16X8.\ALLTRUE \\ &&|&
+     \hex{FD}~~132{:}\Bu32 &\Rightarrow& \I16X8.\BITMASK \\ &&|&
+     \hex{FD}~~133{:}\Bu32 &\Rightarrow& \I16X8.\NARROW\K{\_i32x4\_s} \\ &&|&
+     \hex{FD}~~134{:}\Bu32 &\Rightarrow& \I16X8.\NARROW\K{\_i32x4\_u} \\ &&|&
+     \hex{FD}~~135{:}\Bu32 &\Rightarrow& \I16X8.\VEXTEND\K{\_low\_i8x16\_s} \\ &&|&
+     \hex{FD}~~136{:}\Bu32 &\Rightarrow& \I16X8.\VEXTEND\K{\_high\_i8x16\_s} \\ &&|&
+     \hex{FD}~~137{:}\Bu32 &\Rightarrow& \I16X8.\VEXTEND\K{\_low\_i8x16\_u} \\ &&|&
+     \hex{FD}~~138{:}\Bu32 &\Rightarrow& \I16X8.\VEXTEND\K{\_high\_i8x16\_u} \\ &&|&
+     \hex{FD}~~139{:}\Bu32 &\Rightarrow& \I16X8.\VSHL \\ &&|&
+     \hex{FD}~~140{:}\Bu32 &\Rightarrow& \I16X8.\VSHR\K{\_s} \\ &&|&
+     \hex{FD}~~141{:}\Bu32 &\Rightarrow& \I16X8.\VSHR\K{\_u} \\ &&|&
+     \hex{FD}~~142{:}\Bu32 &\Rightarrow& \I16X8.\VADD \\ &&|&
+     \hex{FD}~~143{:}\Bu32 &\Rightarrow& \I16X8.\VADD\K{\_sat\_s} \\ &&|&
+     \hex{FD}~~144{:}\Bu32 &\Rightarrow& \I16X8.\VADD\K{\_sat\_u} \\ &&|&
+     \hex{FD}~~145{:}\Bu32 &\Rightarrow& \I16X8.\VSUB \\ &&|&
+     \hex{FD}~~146{:}\Bu32 &\Rightarrow& \I16X8.\VSUB\K{\_sat\_s} \\ &&|&
+     \hex{FD}~~147{:}\Bu32 &\Rightarrow& \I16X8.\VSUB\K{\_sat\_u} \\ &&|&
+     \hex{FD}~~149{:}\Bu32 &\Rightarrow& \I16X8.\VMUL \\ &&|&
+     \hex{FD}~~150{:}\Bu32 &\Rightarrow& \I16X8.\VMIN\K{\_s} \\ &&|&
+     \hex{FD}~~151{:}\Bu32 &\Rightarrow& \I16X8.\VMIN\K{\_u} \\ &&|&
+     \hex{FD}~~152{:}\Bu32 &\Rightarrow& \I16X8.\VMAX\K{\_s} \\ &&|&
+     \hex{FD}~~153{:}\Bu32 &\Rightarrow& \I16X8.\VMAX\K{\_u} \\ &&|&
+     \hex{FD}~~155{:}\Bu32 &\Rightarrow& \I16X8.\AVGR\K{\_u} \\ &&|&
+     \hex{FD}~~156{:}\Bu32 &\Rightarrow& \I16X8.\EXTMUL\K{\_low\_i8x16\_s}\\ &&|&
+     \hex{FD}~~157{:}\Bu32 &\Rightarrow& \I16X8.\EXTMUL\K{\_high\_i8x16\_s}\\ &&|&
+     \hex{FD}~~158{:}\Bu32 &\Rightarrow& \I16X8.\EXTMUL\K{\_low\_i8x16\_u}\\ &&|&
+     \hex{FD}~~159{:}\Bu32 &\Rightarrow& \I16X8.\EXTMUL\K{\_high\_i8x16\_u}\\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~126{:}\Bu32 &\Rightarrow& \I32X4.\EXTADDPAIRWISE\K{\_i16x8\_s}\\ &&|&
+     \hex{FD}~~127{:}\Bu32 &\Rightarrow& \I32X4.\EXTADDPAIRWISE\K{\_i16x8\_u}\\ &&|&
+     \hex{FD}~~160{:}\Bu32 &\Rightarrow& \I32X4.\VABS \\ &&|&
+     \hex{FD}~~161{:}\Bu32 &\Rightarrow& \I32X4.\VNEG \\ &&|&
+     \hex{FD}~~163{:}\Bu32 &\Rightarrow& \I32X4.\ALLTRUE \\ &&|&
+     \hex{FD}~~164{:}\Bu32 &\Rightarrow& \I32X4.\BITMASK \\ &&|&
+     \hex{FD}~~167{:}\Bu32 &\Rightarrow& \I32X4.\VEXTEND\K{\_low\_i16x8\_s} \\ &&|&
+     \hex{FD}~~168{:}\Bu32 &\Rightarrow& \I32X4.\VEXTEND\K{\_high\_i16x8\_s} \\ &&|&
+     \hex{FD}~~169{:}\Bu32 &\Rightarrow& \I32X4.\VEXTEND\K{\_low\_i16x8\_u} \\ &&|&
+     \hex{FD}~~170{:}\Bu32 &\Rightarrow& \I32X4.\VEXTEND\K{\_high\_i16x8\_u} \\ &&|&
+     \hex{FD}~~171{:}\Bu32 &\Rightarrow& \I32X4.\VSHL \\ &&|&
+     \hex{FD}~~172{:}\Bu32 &\Rightarrow& \I32X4.\VSHR\K{\_s} \\ &&|&
+     \hex{FD}~~173{:}\Bu32 &\Rightarrow& \I32X4.\VSHR\K{\_u} \\ &&|&
+     \hex{FD}~~174{:}\Bu32 &\Rightarrow& \I32X4.\VADD \\ &&|&
+     \hex{FD}~~177{:}\Bu32 &\Rightarrow& \I32X4.\VSUB \\ &&|&
+     \hex{FD}~~181{:}\Bu32 &\Rightarrow& \I32X4.\VMUL \\ &&|&
+     \hex{FD}~~182{:}\Bu32 &\Rightarrow& \I32X4.\VMIN\K{\_s} \\ &&|&
+     \hex{FD}~~183{:}\Bu32 &\Rightarrow& \I32X4.\VMIN\K{\_u} \\ &&|&
+     \hex{FD}~~184{:}\Bu32 &\Rightarrow& \I32X4.\VMAX\K{\_s} \\ &&|&
+     \hex{FD}~~185{:}\Bu32 &\Rightarrow& \I32X4.\VMAX\K{\_u} \\ &&|&
+     \hex{FD}~~186{:}\Bu32 &\Rightarrow& \I32X4.\DOT\K{\_i16x8\_s}\\ &&|&
+     \hex{FD}~~188{:}\Bu32 &\Rightarrow& \I32X4.\EXTMUL\K{\_low\_i16x8\_s}\\ &&|&
+     \hex{FD}~~189{:}\Bu32 &\Rightarrow& \I32X4.\EXTMUL\K{\_high\_i16x8\_s}\\ &&|&
+     \hex{FD}~~190{:}\Bu32 &\Rightarrow& \I32X4.\EXTMUL\K{\_low\_i16x8\_u}\\ &&|&
+     \hex{FD}~~191{:}\Bu32 &\Rightarrow& \I32X4.\EXTMUL\K{\_high\_i16x8\_u}\\
+  \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~192{:}\Bu32 &\Rightarrow& \I64X2.\VABS \\ &&|&
+     \hex{FD}~~193{:}\Bu32 &\Rightarrow& \I64X2.\VNEG \\ &&|&
+     \hex{FD}~~195{:}\Bu32 &\Rightarrow& \I64X2.\ALLTRUE \\ &&|&
+     \hex{FD}~~196{:}\Bu32 &\Rightarrow& \I64X2.\BITMASK \\ &&|&
+     \hex{FD}~~199{:}\Bu32 &\Rightarrow& \I64X2.\VEXTEND\K{\_low\_i32x4\_s} \\ &&|&
+     \hex{FD}~~200{:}\Bu32 &\Rightarrow& \I64X2.\VEXTEND\K{\_high\_i32x4\_s} \\ &&|&
+     \hex{FD}~~201{:}\Bu32 &\Rightarrow& \I64X2.\VEXTEND\K{\_low\_i32x4\_u} \\ &&|&
+     \hex{FD}~~202{:}\Bu32 &\Rightarrow& \I64X2.\VEXTEND\K{\_high\_i32x4\_u} \\ &&|&
+     \hex{FD}~~203{:}\Bu32 &\Rightarrow& \I64X2.\VSHL \\ &&|&
+     \hex{FD}~~204{:}\Bu32 &\Rightarrow& \I64X2.\VSHR\K{\_s} \\ &&|&
+     \hex{FD}~~205{:}\Bu32 &\Rightarrow& \I64X2.\VSHR\K{\_u} \\ &&|&
+     \hex{FD}~~206{:}\Bu32 &\Rightarrow& \I64X2.\VADD \\ &&|&
+     \hex{FD}~~209{:}\Bu32 &\Rightarrow& \I64X2.\VSUB \\ &&|&
+     \hex{FD}~~213{:}\Bu32 &\Rightarrow& \I64X2.\VMUL \\ &&|&
+     \hex{FD}~~220{:}\Bu32 &\Rightarrow& \I64X2.\EXTMUL\K{\_low\_i32x4\_s}\\ &&|&
+     \hex{FD}~~221{:}\Bu32 &\Rightarrow& \I64X2.\EXTMUL\K{\_high\_i32x4\_s}\\ &&|&
+     \hex{FD}~~222{:}\Bu32 &\Rightarrow& \I64X2.\EXTMUL\K{\_low\_i32x4\_u}\\ &&|&
+     \hex{FD}~~223{:}\Bu32 &\Rightarrow& \I64X2.\EXTMUL\K{\_high\_i32x4\_u}\\
+  \end{array}
+
+.. _binary-vfunop:
+.. _binary-vfbinop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~103{:}\Bu32 &\Rightarrow& \F32X4.\VCEIL \\ &&|&
+     \hex{FD}~~104{:}\Bu32 &\Rightarrow& \F32X4.\VFLOOR \\ &&|&
+     \hex{FD}~~105{:}\Bu32 &\Rightarrow& \F32X4.\VTRUNC \\ &&|&
+     \hex{FD}~~106{:}\Bu32 &\Rightarrow& \F32X4.\VNEAREST \\ &&|&
+     \hex{FD}~~224{:}\Bu32 &\Rightarrow& \F32X4.\VABS \\ &&|&
+     \hex{FD}~~225{:}\Bu32 &\Rightarrow& \F32X4.\VNEG \\ &&|&
+     \hex{FD}~~227{:}\Bu32 &\Rightarrow& \F32X4.\VSQRT \\ &&|&
+     \hex{FD}~~228{:}\Bu32 &\Rightarrow& \F32X4.\VADD \\ &&|&
+     \hex{FD}~~229{:}\Bu32 &\Rightarrow& \F32X4.\VSUB \\ &&|&
+     \hex{FD}~~230{:}\Bu32 &\Rightarrow& \F32X4.\VMUL \\ &&|&
+     \hex{FD}~~231{:}\Bu32 &\Rightarrow& \F32X4.\VDIV \\ &&|&
+     \hex{FD}~~232{:}\Bu32 &\Rightarrow& \F32X4.\VMIN \\ &&|&
+     \hex{FD}~~233{:}\Bu32 &\Rightarrow& \F32X4.\VMAX \\ &&|&
+     \hex{FD}~~234{:}\Bu32 &\Rightarrow& \F32X4.\VPMIN \\ &&|&
+     \hex{FD}~~235{:}\Bu32 &\Rightarrow& \F32X4.\VPMAX \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~116{:}\Bu32 &\Rightarrow& \F64X2.\VCEIL \\ &&|&
+     \hex{FD}~~117{:}\Bu32 &\Rightarrow& \F64X2.\VFLOOR \\ &&|&
+     \hex{FD}~~122{:}\Bu32 &\Rightarrow& \F64X2.\VTRUNC \\ &&|&
+     \hex{FD}~~148{:}\Bu32 &\Rightarrow& \F64X2.\VNEAREST \\ &&|&
+     \hex{FD}~~236{:}\Bu32 &\Rightarrow& \F64X2.\VABS \\ &&|&
+     \hex{FD}~~237{:}\Bu32 &\Rightarrow& \F64X2.\VNEG \\ &&|&
+     \hex{FD}~~239{:}\Bu32 &\Rightarrow& \F64X2.\VSQRT \\ &&|&
+     \hex{FD}~~240{:}\Bu32 &\Rightarrow& \F64X2.\VADD \\ &&|&
+     \hex{FD}~~241{:}\Bu32 &\Rightarrow& \F64X2.\VSUB \\ &&|&
+     \hex{FD}~~242{:}\Bu32 &\Rightarrow& \F64X2.\VMUL \\ &&|&
+     \hex{FD}~~243{:}\Bu32 &\Rightarrow& \F64X2.\VDIV \\ &&|&
+     \hex{FD}~~244{:}\Bu32 &\Rightarrow& \F64X2.\VMIN \\ &&|&
+     \hex{FD}~~245{:}\Bu32 &\Rightarrow& \F64X2.\VMAX \\ &&|&
+     \hex{FD}~~246{:}\Bu32 &\Rightarrow& \F64X2.\VPMIN \\ &&|&
+     \hex{FD}~~247{:}\Bu32 &\Rightarrow& \F64X2.\VPMAX \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~248{:}\Bu32 &\Rightarrow& \I32X4.\TRUNC\K{\_sat\_f32x4\_s} \\ &&|&
+     \hex{FD}~~249{:}\Bu32 &\Rightarrow& \I32X4.\TRUNC\K{\_sat\_f32x4\_u} \\ &&|&
+     \hex{FD}~~250{:}\Bu32 &\Rightarrow& \F32X4.\CONVERT\K{\_i32x4\_s} \\ &&|&
+     \hex{FD}~~251{:}\Bu32 &\Rightarrow& \F32X4.\CONVERT\K{\_i32x4\_u} \\ &&|&
+     \hex{FD}~~252{:}\Bu32 &\Rightarrow& \I32X4.\VTRUNC\K{\_sat\_f64x2\_s\_zero}\\ &&|&
+     \hex{FD}~~253{:}\Bu32 &\Rightarrow& \I32X4.\VTRUNC\K{\_sat\_f64x2\_u\_zero}\\ &&|&
+     \hex{FD}~~254{:}\Bu32 &\Rightarrow& \F64X2.\VCONVERT\K{\_low\_i32x4\_s}\\  &&|&
+     \hex{FD}~~255{:}\Bu32 &\Rightarrow& \F64X2.\VCONVERT\K{\_low\_i32x4\_u}\\ &&|&
+     \hex{FD}~~94{:}\Bu32 &\Rightarrow& \F32X4.\VDEMOTE\K{\_f64x2\_zero}\\ &&|&
+     \hex{FD}~~95{:}\Bu32 &\Rightarrow& \F64X2.\VPROMOTE\K{\_low\_f32x4}\\
+   \end{array}
+
+
 .. index:: expression
    pair: binary format; expression
    single: expression; constant
diff --git a/document/core/binary/types.rst b/document/core/binary/types.rst
index 0d1dfec86..f77da6eae 100644
--- a/document/core/binary/types.rst
+++ b/document/core/binary/types.rst
@@ -29,6 +29,22 @@ Number Types
    \end{array}
 
 
+.. index:: vector type
+   pair: binary format; vector type
+.. _binary-vectype:
+
+Vector Types
+~~~~~~~~~~~~
+
+:ref:`Vector types <syntax-vectype>` are also encoded by a single byte.
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{vector type} & \Bvectype &::=&
+     \hex{7B} &\Rightarrow& \V128 \\
+   \end{array}
+
+
 .. index:: reference type
    pair: binary format; reference type
 .. _binary-reftype:
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 907703b49..b46397ca4 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -247,6 +247,705 @@ Reference Instructions
    \end{array}
 
 
+.. index:: vector instruction
+   pair: execution; instruction
+   single: abstract syntax; instruction
+.. _exec-instr-vec:
+
+Vector Instructions
+~~~~~~~~~~~~~~~~~~~
+
+Most vector instructions are defined in terms of generic numeric operators applied lane-wise based on the :ref:`shape <syntax-vec-shape>`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \X{op}_{t\K{x}N}(n_1,\dots,n_k) &=&
+     \lanes^{-1}_{t\K{x}N}(op_t(\lanes_{t\K{x}N}(n_1) ~\dots~ \lanes_{t\K{x}N}(n_k))
+   \end{array}
+
+.. note::
+   For example, the result of instruction :math:`\K{i32x4}.\ADD` applied to operands :math:`i_1, i_2`
+   invokes :math:`\ADD_{\K{i32x4}}(i_1, i_2)`, which maps to
+   :math:`\lanes^{-1}_{\K{i32x4}}(\ADD_{\I32}(i_1^+, i_2^+))`,
+   where :math:`i_1^+` and :math:`i_2^+` are sequences resulting from invoking
+   :math:`\lanes_{\K{i32x4}}(i_1)` and :math:`\lanes_{\K{i32x4}}(i_2)`
+   respectively.
+
+
+.. _exec-vconst:
+
+:math:`\V128\K{.}\VCONST~c`
+...........................
+
+1. Push the value :math:`\V128.\VCONST~c` to the stack.
+
+.. note::
+   No formal reduction rule is required for this instruction, since |VCONST| instructions coincide with :ref:`values <syntax-val>`.
+
+
+.. _exec-vvunop:
+
+:math:`\V128\K{.}\vvunop`
+.........................
+
+1. Assert: due to :ref:`validation <valid-vvunop>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+3. Let :math:`c` be the result of computing :math:`\vvunop_{\I128}(c_1)`.
+
+4. Push the value :math:`\V128.\VCONST~c` to the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~\V128\K{.}\vvunop &\stepto& (\V128\K{.}\VCONST~c)
+     & (\iff c = \vvunop_{\I128}(c_1)) \\
+   \end{array}
+
+
+.. _exec-vvbinop:
+
+:math:`\V128\K{.}\vvbinop`
+..........................
+
+1. Assert: due to :ref:`validation <valid-vvbinop>`, two values of :ref:`value type <syntax-valtype>` |V128| are on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
+
+3. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+4. Let :math:`c` be the result of computing :math:`\vvbinop_{\I128}(c_1, c_2)`.
+
+5. Push the value :math:`\V128.\VCONST~c` to the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~\V128\K{.}\vvbinop &\stepto& (\V128\K{.}\VCONST~c)
+     & (\iff c = \vvbinop_{\I128}(c_1, c_2)) \\
+   \end{array}
+
+
+.. _exec-vvternop:
+
+:math:`\V128\K{.}\vvternop`
+...........................
+
+1. Assert: due to :ref:`validation <valid-vvternop>`, three values of :ref:`value type <syntax-valtype>` |V128| are on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_3` from the stack.
+
+3. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
+
+4. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+5. Let :math:`c` be the result of computing :math:`\vvternop_{\I128}(c_1, c_2, c_3)`.
+
+6. Push the value :math:`\V128.\VCONST~c` to the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~(\V128\K{.}\VCONST~c_3)~\V128\K{.}\vvternop &\stepto& (\V128\K{.}\VCONST~c)
+     & (\iff c = \vvternop_{\I128}(c_1, c_2, c_3)) \\
+   \end{array}
+
+
+.. _exec-vvtestop:
+.. _exec-vec-any_true:
+
+:math:`\V128\K{.}\ANYTRUE`
+..........................
+
+1. Assert: due to :ref:`validation <valid-vvtestop>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+3. Let :math:`i` be the result of computing :math:`\ine_{128}(c_1, 0)`.
+
+4. Push the value :math:`\I32.\CONST~i` onto the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~\V128\K{.}\ANYTRUE &\stepto& (\I32\K{.}\CONST~i)
+     & (\iff i = \ine_{128}(c_1, 0)) \\
+   \end{array}
+
+
+.. _exec-vec-swizzle:
+
+:math:`\K{i8x16.}\SWIZZLE`
+..........................
+
+1. Assert: due to :ref:`validation <valid-vbinop>`, two values of :ref:`value type <syntax-valtype>` |V128| are on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
+
+3. Let :math:`i^\ast` be the sequence :math:`\lanes_{i8x16}(c_2)`.
+
+4. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+5. Let :math:`j^\ast` be the sequence :math:`\lanes_{i8x16}(c_1)`.
+
+6. Let :math:`c^\ast` be the concatenation of the two sequences :math:`j^\ast~0^{240}`
+
+7. Let :math:`c'` be the result of :math:`\lanes^{-1}_{i8x16}(c^\ast[ i^\ast[0] ] \dots c^\ast[ i^\ast[15] ])`.
+
+8. Push the value :math:`\V128.\VCONST~c'` onto the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~\V128\K{.}\SWIZZLE &\stepto& (\V128\K{.}\VCONST~c')
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+      (\iff & i^\ast = \lanes_{i8x16}(c_2) \\
+      \wedge & c^\ast = \lanes_{i8x16}(c_1)~0^{240} \\
+      \wedge & c' = \lanes^{-1}_{i8x16}(c^\ast[ i^\ast[0] ] \dots c^\ast[ i^\ast[15] ])
+     \end{array}
+   \end{array}
+
+
+.. _exec-vec-shuffle:
+
+:math:`\K{i8x16.}\SHUFFLE~x^\ast`
+.................................
+
+1. Assert: due to :ref:`validation <valid-vec-shuffle>`, two values of :ref:`value type <syntax-valtype>` |V128| are on the top of the stack.
+
+2. Assert: due to :ref:`validation <valid-vec-shuffle>`, for all :math:`x_i` in :math:`x^\ast` it holds that :math:`x_i < 32`.
+
+3. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
+
+4. Let :math:`i_2^\ast` be the sequence :math:`\lanes_{i8x16}(c_2)`.
+
+5. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+6. Let :math:`i_1^\ast` be the sequence :math:`\lanes_{i8x16}(c_1)`.
+
+7. Let :math:`i^\ast` be the concatenation of the two sequences :math:`i_1^\ast~i_2^\ast`.
+
+8. Let :math:`c` be the result of :math:`\lanes^{-1}_{i8x16}(i^\ast[x^\ast[0]] \dots i^\ast[x^\ast[15]])`.
+
+9. Push the value :math:`\V128.\VCONST~c` onto the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~\V128\K{.}\SHUFFLE~x^\ast &\stepto& (\V128\K{.}\VCONST~c)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+      (\iff & i^\ast = \lanes_{i8x16}(c_1)~\lanes_{i8x16}(c_2) \\
+      \wedge & c = \lanes^{-1}_{i8x16}(i^\ast[x^\ast[0]] \dots i^\ast[x^\ast[15]])
+     \end{array}
+   \end{array}
+
+
+.. _exec-vec-splat:
+
+:math:`\shape\K{.}\SPLAT`
+.........................
+
+1. Let :math:`t` be the type :math:`\unpacked(\shape)`.
+
+2. Assert: due to :ref:`validation <valid-vec-splat>`, a value of :ref:`value type <syntax-valtype>` :math:`t` is on the top of the stack.
+
+3. Pop the value :math:`t.\CONST~c_1` from the stack.
+
+4. Let :math:`N` be the integer :math:`\dim(\shape)`.
+
+5. Let :math:`c` be the result of :math:`\lanes^{-1}_{\shape}(c_1^N)`.
+
+6. Push the value :math:`\V128.\VCONST~c` to the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (t\K{.}\CONST~c_1)~\shape\K{.}\SPLAT &\stepto& (\V128\K{.}\VCONST~c)
+     & (\iff t = \unpacked(\shape)
+       \wedge c = \lanes^{-1}_{\shape}(c_1^{\dim(\shape)}))
+     \\
+   \end{array}
+
+
+.. _exec-vec-extract_lane:
+
+:math:`t_1\K{x}N\K{.}\EXTRACTLANE\K{\_}\sx^?~x`
+...............................................
+
+1. Assert: due to :ref:`validation <valid-vec-extract_lane>`, :math:`x < N`.
+
+2. Assert: due to :ref:`validation <valid-vec-extract_lane>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+3. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+4. Let :math:`i^\ast` be the sequence :math:`\lanes_{t_1\K{x}N}(c_1)`.
+
+5. Let :math:`t_2` be the type :math:`\unpacked(t_1\K{x}N)`.
+
+6. Let :math:`c_2` be the result of computing :math:`\extend^{sx^?}_{t_1,t_2}(i^\ast[x])`.
+
+7. Push the value :math:`t_2.\CONST~c_2` to the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~t_1\K{x}N\K{.}\EXTRACTLANE~x &\stepto& (t_2\K{.}\CONST~c_2)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+      (\iff & t_2 = \unpacked(t_1\K{x}N) \\
+       \wedge & c_2 = \extend^{sx^?}_{t_1,t_2}(\lanes_{t_1\K{x}N}(c_1)[x])
+     \end{array}
+   \end{array}
+
+
+.. _exec-vec-replace_lane:
+
+:math:`\shape\K{.}\REPLACELANE~x`
+.................................
+
+1. Assert: due to :ref:`validation <valid-vec-replace_lane>`, :math:`x < \dim(\shape)`.
+
+2. Let :math:`t_1` be the type :math:`\unpacked(\shape)`.
+
+3. Assert: due to :ref:`validation <valid-vec-replace_lane>`, a value of :ref:`value type <syntax-valtype>` :math:`t_1` is on the top of the stack.
+
+4. Pop the value :math:`t_1.\CONST~c_1` from the stack.
+
+5. Assert: due to :ref:`validation <valid-vec-replace_lane>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+6. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
+
+7. Let :math:`i^\ast` be the sequence :math:`\lanes_{\shape}(c_2)`.
+
+8. Let :math:`c` be the result of computing :math:`\lanes^{-1}_{\shape}(i^\ast \with [x] = c_1)`
+
+9. Push :math:`\V128.\VCONST~c` on the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (t_1\K{.}\CONST~c_1)~(\V128\K{.}\VCONST~c_2)~\shape\K{.}\REPLACELANE~x &\stepto& (\V128\K{.}\VCONST~c)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+      (\iff & i^\ast = \lanes_{\shape}(c_2)) \\
+       \wedge & c = \lanes^{-1}_{\shape}(i^\ast \with [x] = c_1)
+     \end{array}
+   \end{array}
+
+
+.. _exec-vunop:
+
+:math:`\shape\K{.}\vunop`
+.........................
+
+1. Assert: due to :ref:`validation <valid-vunop>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+3. Let :math:`c` be the result of computing :math:`\vunop_{\shape}(c_1)`.
+
+4. Push the value :math:`\V128.\VCONST~c` to the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~\V128\K{.}\vunop &\stepto& (\V128\K{.}\VCONST~c)
+     & (\iff c = \vunop_{\shape}(c_1))
+   \end{array}
+
+
+.. _exec-vbinop:
+
+:math:`\shape\K{.}\vbinop`
+..........................
+
+1. Assert: due to :ref:`validation <valid-vbinop>`, two values of :ref:`value type <syntax-valtype>` |V128| are on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
+
+3. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+4. If :math:`\vbinop_{\shape}(c_1, c_2)` is defined:
+
+   a. Let :math:`c` be a possible result of computing :math:`\vbinop_{\shape}(c_1, c_2)`.
+
+   b. Push the value :math:`\V128.\VCONST~c` to the stack.
+
+5. Else:
+
+   a. Trap.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~\shape\K{.}\vbinop &\stepto& (\V128\K{.}\VCONST~c)
+     & (\iff c \in \vbinop_{\shape}(c_1, c_2)) \\
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~\shape\K{.}\vbinop &\stepto& \TRAP
+     & (\iff \vbinop_{\shape}(c_1, c_2) = \{\})
+   \end{array}
+
+
+.. _exec-vrelop:
+
+:math:`t\K{x}N\K{.}\vrelop`
+...........................
+
+1. Assert: due to :ref:`validation <valid-vrelop>`, two values of :ref:`value type <syntax-valtype>` |V128| are on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
+
+3. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+4. Let :math:`i^\ast` be the sequence :math:`\lanes_{t\K{x}N}(c_1)`.
+
+5. Let :math:`j^\ast` be the sequence :math:`\lanes_{t\K{x}N}(c_2)`.
+
+6. Let :math:`c` be the result of computing :math:`\lanes^{-1}_{t\K{x}N}(\extends_{1,|t|}(\vrelop_t(i^\ast, j^\ast)))`.
+
+7. Push the value :math:`\V128.\VCONST~c` to the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~t\K{x}N\K{.}\vrelop &\stepto& (\V128\K{.}\VCONST~c)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff c = \lanes^{-1}_{t\K{x}N}(\extends_{1,|t|}(\vrelop_t(\lanes_{t\K{x}N}(c_1), \lanes_{t\K{x}N}(c_2)))))
+     \end{array}
+   \end{array}
+
+
+.. _exec-vishiftop:
+
+:math:`t\K{x}N\K{.}\vishiftop`
+..............................
+
+1. Assert: due to :ref:`validation <valid-vishiftop>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+
+2. Pop the value :math:`\I32.\CONST~s` from the stack.
+
+3. Assert: due to :ref:`validation <valid-vishiftop>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+4. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+5. Let :math:`i^\ast` be the sequence :math:`\lanes_{t\K{x}N}(c_1)`.
+
+6. Let :math:`c` be :math:`\lanes^{-1}_{t\K{x}N}(\vishiftop_{t}(i^\ast, s^N))`.
+
+7. Push the value :math:`\V128.\VCONST~c` to the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~(\I32\K{.}\CONST~s)~t\K{x}N\K{.}\vishiftop &\stepto& (\V128\K{.}\VCONST~c)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & i^\ast = \lanes_{t\K{x}N}(c_1) \\
+     \wedge & c = \lanes^{-1}_{t\K{x}N}(\vishiftop_{t}(i^\ast, s^N)))
+     \end{array}
+   \end{array}
+
+
+.. _exec-vtestop:
+.. _exec-vec-all_true:
+
+:math:`\shape\K{.}\ALLTRUE`
+...........................
+
+1. Assert: due to :ref:`validation <valid-vtestop>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+3. Let :math:`i_1^\ast` be the sequence :math:`\lanes_{\shape}(c_1)`
+
+4. Let :math:`i` be the result of computing :math:`\bool(\bigwedge(i_1 \neq 0)^\ast)`.
+
+5. Push the value :math:`\I32.\CONST~i` onto the stack.
+
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~\shape\K{.}\ALLTRUE &\stepto& (\I32\K{.}\CONST~i)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & i_1^\ast = \lanes_{\shape}(c) \\
+     \wedge & i = \bool(\bigwedge(i_1 \neq 0)^\ast)
+     \end{array}
+   \end{array}
+
+
+.. _exec-vec-bitmask:
+
+:math:`t\K{x}N\K{.}\BITMASK`
+............................
+
+1. Assert: due to :ref:`validation <valid-vec-bitmask>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+3. Let :math:`i_1^N` be the sequence :math:`\lanes_{t\K{x}N}(c)`.
+
+4. Let :math:`B` be the :ref:`bit width <syntax-valtype>` :math:`|t|` of :ref:`value type <syntax-valtype>` :math:`t`.
+
+5. Let :math:`i_2^N` be the sequence as a result of computing :math:`\ilts_{B}(i_1^N, 0^N)`.
+
+6. Let :math:`c` be the integer :math:`\ibits_{32}^{-1}(i_2^N~0^{32-N})`.
+
+7. Push the value :math:`\I32.\CONST~c` onto the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~t\K{x}N\K{.}\BITMASK &\stepto& (\I32\K{.}\CONST~c)
+     & (\iff c = \ibits_{32}^{-1}(\ilts_{|t|}(\lanes_{t\K{x}N}(c), 0^N)))
+     \\
+   \end{array}
+
+
+.. _exec-vec-narrow:
+
+:math:`t_2\K{x}N\K{.}\NARROW\K{\_}t_1\K{x}M\K{\_}\sx`
+.....................................................
+
+1. Assert: due to :ref:`syntax <syntax-instr-vec>`, :math:`N = 2\cdot M`.
+
+2. Assert: due to :ref:`validation <valid-vec-narrow>`, two values of :ref:`value type <syntax-valtype>` |V128| are on the top of the stack.
+
+3. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
+
+4. Let :math:`d_2^M` be the result of computing :math:`\narrow^{\sx}_{|t_1|,|t_2|}(\lanes_{t_1\K{x}M}(c_2))`.
+
+5. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+6. Let :math:`d_1^M` be the result of computing :math:`\narrow^{\sx}_{|t_1|,|t_2|}(\lanes_{t_1\K{x}M}(c_1))`.
+
+7. Let :math:`c` be the result of :math:`\lanes^{-1}_{t_2\K{x}N}(d_1^M~d_2^M)`.
+
+8. Push the value :math:`\V128.\VCONST~c` onto the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~t_2\K{x}N\K{.}\NARROW\_t_1\K{x}M\_\sx &\stepto& (\V128\K{.}\VCONST~c)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & d_1^M = \narrow^{\sx}_{|t_1|,|t_2|}( \lanes_{t_1\K{x}M}(c_1)) \\
+     \wedge & d_2^M = \narrow^{\sx}_{|t_1|,|t_2|}( \lanes_{t_1\K{x}M}(c_2)) \\
+     \wedge & c = \lanes^{-1}_{t_2\K{x}N}(d_1^M~d_2^M)
+     \end{array}
+   \end{array}
+
+
+.. _exec-vcvtop:
+
+:math:`t_2\K{x}N\K{.}\vcvtop\K{\_}t_1\K{x}M\K{\_}\sx`
+.....................................................
+
+1. Assert: due to :ref:`validation <valid-vcvtop>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+3. Let :math:`i^\ast` be the sequence :math:`\lanes_{t_1\K{x}M}(c_1)`.
+
+4. Let :math:`c` be the result of computing :math:`\lanes^{-1}_{t_2\K{x}N}(\vcvtop^{\sx}_{|t_1|,|t_2|}(i^\ast))`
+
+5. Push the value :math:`\V128.\VCONST~c` onto the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~t_2\K{x}N\K{.}\vcvtop\K{\_}t_1\K{x}M\K{\_}\sx &\stepto& (\V128\K{.}\VCONST~c) \\
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & c = \lanes^{-1}_{t_2\K{x}N}(\vcvtop^{\sx}_{|t_1|,|t_2|}(\lanes_{t_1\K{x}M}(c_1)))
+     \end{array}
+   \end{array}
+
+
+:math:`t_2\K{x}N\K{.}\vcvtop\K{\_}\half\K{\_}t_1\K{x}M\K{\_}\sx^?`
+..................................................................
+
+1. Assert: due to :ref:`validation <valid-vcvtop>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+3. If :math:`\half` is :math:`\K{low}`, then:
+
+   a. Let :math:`i^\ast` be the sequence :math:`\lanes_{t_1\K{x}M}(c_1)[0 \slice N]`.
+
+4. Else:
+
+   a. Let :math:`i^\ast` be the sequence :math:`\lanes_{t_1\K{x}M}(c_1)[N \slice N]`.
+
+5. Let :math:`j^\ast` be the result of computing :math:`\vcvtop^{\sx^?}_{|t_1|,|t_2|}(i^\ast)`.
+
+6. Let :math:`c` be the result of computing :math:`\lanes^{-1}_{t_2\K{x}N}(j^\ast)`.
+
+7. Push the value :math:`\V128.\VCONST~c` onto the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~t_2\K{x}N\K{.}\vcvtop\K{\_}\half\K{\_}t_1\K{x}M\K{\_}\sx^? &\stepto& (\V128\K{.}\VCONST~c) \\
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & c = \lanes^{-1}_{t_2\K{x}N}(\vcvtop^{\sx^?}_{|t_1|,|t_2|}(\lanes_{t_1\K{x}M}(c_1)[\half(0, N) \slice N]))
+     \end{array}
+   \end{array}
+
+where:
+
+.. math::
+   \begin{array}{lcl}
+   \K{low}(x, y) &=& x \\
+   \K{high}(x, y) &=& y \\
+   \end{array}
+
+
+:math:`t_2\K{x}N\K{.}\vcvtop\K{\_}t_1\K{x}M\K{\_}\sx\K{\_zero}`
+...............................................................
+
+1. Assert: due to :ref:`validation <valid-vcvtop>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+3. Let :math:`i^\ast` be the sequence :math:`\lanes_{t_1\K{x}M}(c_1)`.
+
+4. Let :math:`j^\ast` be the result of computing :math:`\vcvtop^{\sx}_{|t_1|,|t_2|}(i^\ast)` concatenated with the vector :math:`0^M`.
+
+5. Let :math:`c` be the result of computing :math:`\lanes^{-1}_{t_2\K{x}N}(j^\ast)`.
+
+6. Push the value :math:`\V128.\VCONST~c` onto the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~t_2\K{x}N\K{.}\vcvtop\K{\_}t_1\K{x}M\K{\_}\sx\K{\_zero} &\stepto& (\V128\K{.}\VCONST~c) \\
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & c = \lanes^{-1}_{t_2\K{x}N}(\vcvtop^{\sx}_{|t_1|,|t_2|}(\lanes_{t_1\K{x}M}(c_1))~0^M)
+     \end{array}
+   \end{array}
+
+
+.. _exec-vec-dot:
+
+:math:`\K{i32x4.}\DOT\K{\_i16x8\_s}`
+....................................
+
+1. Assert: due to :ref:`validation <valid-vec-dot>`, two values of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
+
+3. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+4. Let :math:`(i_1~i_2)^\ast` be the result of computing :math:`\imul_{32}(\extends_{16,32}(\lanes_{\I16X8}(c_1)), \extends_{16,32}(\lanes_{\I16X8}(c_2)))`
+
+5. Let :math:`j^\ast` be the result of computing :math:`\iadd_{32}(i_1, i_2)^\ast`.
+
+6. Let :math:`c` be the result of computing :math:`\lanes^{-1}_{\I32X4}(j^\ast)`.
+
+7. Push the value :math:`\V128.\VCONST~c` onto the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~\K{i32x4.}\DOT\K{\_i16x8\_s} &\stepto& (\V128\K{.}\VCONST~c) \\
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & (i_1~i_2)^\ast = \imul_{32}(\extends_{16,32}(\lanes_{\I16X8}(c_1)), \extends_{16,32}(\lanes_{\I16X8}(c_2))) \\
+     \wedge & j^\ast = \iadd_{32}(i_1, i_2)^\ast \\
+     \wedge & c = \lanes^{-1}_{\I32X4}(j^\ast)
+     \end{array}
+   \end{array}
+
+
+.. _exec-vec-extmul:
+
+:math:`t_2\K{x}N\K{.}\EXTMUL\K{\_}\half\K{\_}t_1\K{x}M\K{\_}\sx`
+................................................................
+
+1. Assert: due to :ref:`validation <valid-vec-extmul>`, two values of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
+
+3. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+4. If :math:`\half` is :math:`\K{low}`, then:
+
+   a. Let :math:`i^\ast` be the sequence :math:`\lanes_{t_1\K{x}M}(c_1)[0 \slice N]`.
+
+   b. Let :math:`j^\ast` be the sequence :math:`\lanes_{t_1\K{x}M}(c_2)[0 \slice N]`.
+
+5. Else:
+
+   a. Let :math:`i^\ast` be the sequence :math:`\lanes_{t_1\K{x}M}(c_1)[N \slice N]`.
+
+   b. Let :math:`j^\ast` be the sequence :math:`\lanes_{t_1\K{x}M}(c_2)[N \slice N]`.
+
+6. Let :math:`c` be the result of computing :math:`\lanes^{-1}_{t_2\K{x}N}(\imul_{t_2\K{x}N}(\extend^{\sx}_{|t_1|,|t_2|}(i^\ast), \extend^{\sx}_{|t_1|,|t_2|}(j^\ast)))`
+
+7. Push the value :math:`\V128.\VCONST~c` onto the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~t_2\K{x}N\K{.}\EXTMUL\K{\_}\half\K{\_}t_1\K{x}M\_\sx &\stepto& (\V128\K{.}\VCONST~c) \\
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & i^\ast = \lanes_{t_1\K{x}M}(c_1)[\half(0, N) \slice N] \\
+     \wedge & j^\ast = \lanes_{t_1\K{x}M}(c_2)[\half(0, N) \slice N] \\
+     \wedge & c = \lanes^{-1}_{t_2\K{x}N}(\imul_{t_2\K{x}N}(\extend^{\sx}_{|t_1|,|t_2|}(i^\ast), \extend^{\sx}_{|t_1|,|t_2|}(j^\ast)))
+     \end{array}
+
+where:
+
+.. math::
+   \begin{array}{lcl}
+   \K{low}(x, y) &=& x \\
+   \K{high}(x, y) &=& y \\
+   \end{array}
+
+
+.. _exec-vec-extadd_pairwise:
+
+:math:`t_2\K{x}N\K{.}\EXTADDPAIRWISE\_t_1\K{x}M\_\sx`
+.....................................................
+
+1. Assert: due to :ref:`validation <valid-vec-extadd_pairwise>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+3. Let :math:`(i_1~i_2)^\ast` be the sequence :math:`\extend^{\sx}_{|t_1|,|t_2|}(\lanes_{t_1\K{x}M}(c_1))`.
+
+4. Let :math:`j^\ast` be the result of computing :math:`\iadd_{N}(i_1, i_2)^\ast`.
+
+5. Let `c` be the result of computing :math:`\lanes^{-1}_{t_2\K{x}N}(j^\ast)`.
+
+6. Push the value :math:`\V128.\VCONST~c` to the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~t_2\K{x}N\K{.}\EXTADDPAIRWISE\_t_1\K{x}M\_\sx &\stepto& (\V128\K{.}\VCONST~c) \\
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & (i_1~i_2)^\ast = \extend^{\sx}_{|t_1|,|t_2|}(\lanes_{t_1\K{x}M}(c_1)) \\
+     \wedge & j^\ast = \iadd_{N}(i_1, i_2)^\ast \\
+     \wedge & c = \lanes^{-1}_{t_2\K{x}N}(j^\ast)
+     \end{array}
+   \end{array}
+
+
 .. index:: parametric instructions, value
    pair: execution; instruction
    single: abstract syntax; instruction
@@ -1030,6 +1729,241 @@ Memory Instructions
    \end{array}
 
 
+.. _exec-load-extend:
+
+:math:`\V128\K{.}\LOAD{M}\K{x}N\_\sx~\memarg`
+.............................................
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-load-extend>`, :math:`F.\AMODULE.\MIMEMS[0]` exists.
+
+3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\AMODULE.\MIMEMS[0]`.
+
+4. Assert: due to :ref:`validation <valid-load-extend>`, :math:`S.\SMEMS[a]` exists.
+
+5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\SMEMS[a]`.
+
+6. Assert: due to :ref:`validation <valid-load-extend>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+
+7. Pop the value :math:`\I32.\CONST~i` from the stack.
+
+8. Let :math:`\X{ea}` be the integer :math:`i + \memarg.\OFFSET`.
+
+9. If :math:`\X{ea} + M \cdot N /8` is larger than the length of :math:`\X{mem}.\MIDATA`, then:
+
+    a. Trap.
+
+10. Let :math:`b^\ast` be the byte sequence :math:`\X{mem}.\MIDATA[\X{ea} \slice M \cdot N /8]`.
+
+11. Let :math:`m_k` be the integer for which :math:`\bytes_{\iM}(m_k) = b^\ast[k \cdot M/8 \slice M/8]`.
+
+12. Let :math:`W` be the integer :math:`M \cdot 2`.
+
+13. Let :math:`n_k` be the result of :math:`\extend^{\sx}_{M,W}(m_k)`.
+
+14. Let :math:`c` be the result of computing :math:`\lanes^{-1}_{\X{i}W\K{x}N}(n_0 \dots n_{N-1})`.
+
+15. Push the value :math:`\V128.\CONST~c` to the stack.
+
+.. math::
+   ~\\[-1ex]
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~i)~(\V128.\LOAD{M}\K{x}N\_\sx~\memarg) &\stepto&
+     S; F; (\V128.\CONST~c)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & \X{ea} = i + \memarg.\OFFSET \\
+     \wedge & \X{ea} + M \cdot N / 8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
+     \wedge & \bytes_{\iM}(m_k) = S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} + k \cdot M/8 \slice M/8]) \\
+     \wedge & W = M \cdot 2 \\
+     \wedge & c = \lanes^{-1}_{\X{i}W\K{x}N}(\extend^{\sx}_{M,W}(m_0) \dots \extend^{\sx}_{M,W}(m_{N-1}))
+     \end{array}
+   \\[1ex]
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~k)~(\V128.\LOAD{M}\K{x}N\K{\_}\sx~\memarg) &\stepto& S; F; \TRAP
+   \end{array}
+   \\ \qquad
+     (\otherwise) \\
+   \end{array}
+
+
+.. _exec-load-splat:
+
+:math:`\V128\K{.}\LOAD{N}\K{\_splat}~\memarg`
+.............................................
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-load-extend>`, :math:`F.\AMODULE.\MIMEMS[0]` exists.
+
+3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\AMODULE.\MIMEMS[0]`.
+
+4. Assert: due to :ref:`validation <valid-load-extend>`, :math:`S.\SMEMS[a]` exists.
+
+5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\SMEMS[a]`.
+
+6. Assert: due to :ref:`validation <valid-load-extend>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+
+7. Pop the value :math:`\I32.\CONST~i` from the stack.
+
+8. Let :math:`\X{ea}` be the integer :math:`i + \memarg.\OFFSET`.
+
+9. If :math:`\X{ea} + N/8` is larger than the length of :math:`\X{mem}.\MIDATA`, then:
+
+    a. Trap.
+
+10. Let :math:`b^\ast` be the byte sequence :math:`\X{mem}.\MIDATA[\X{ea} \slice N/8]`.
+
+11. Let :math:`n` be the integer for which :math:`\bytes_{\iN}(n) = b^\ast`.
+
+12. Let :math:`L` be the integer :math:`128 / N`.
+
+13. Let :math:`c` be the result of computing :math:`\lanes^{-1}_{\iN\K{x}L}(n^L)`.
+
+14. Push the value :math:`\V128.\CONST~c` to the stack.
+
+.. math::
+   ~\\[-1ex]
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~i)~(\V128\K{.}\LOAD{N}\K{\_splat}~\memarg) &\stepto& S; F; (\V128.\CONST~c)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & \X{ea} = i + \memarg.\OFFSET \\
+     \wedge & \X{ea} + N/8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
+     \wedge & \bytes_{\iN}(n) = S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8]) \\
+     \wedge & c = \lanes^{-1}_{\iN\K{x}L}(n^L)
+     \end{array}
+   \\[1ex]
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~k)~(\V128.\LOAD{N}\K{\_splat}~\memarg) &\stepto& S; F; \TRAP
+   \end{array}
+   \\ \qquad
+     (\otherwise) \\
+   \end{array}
+
+
+.. _exec-load-zero:
+
+:math:`\V128\K{.}\LOAD{N}\K{\_zero}~\memarg`
+.............................................
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-load-extend>`, :math:`F.\AMODULE.\MIMEMS[0]` exists.
+
+3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\AMODULE.\MIMEMS[0]`.
+
+4. Assert: due to :ref:`validation <valid-load-extend>`, :math:`S.\SMEMS[a]` exists.
+
+5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\SMEMS[a]`.
+
+6. Assert: due to :ref:`validation <valid-load-extend>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+
+7. Pop the value :math:`\I32.\CONST~i` from the stack.
+
+8. Let :math:`\X{ea}` be the integer :math:`i + \memarg.\OFFSET`.
+
+9. If :math:`\X{ea} + N/8` is larger than the length of :math:`\X{mem}.\MIDATA`, then:
+
+    a. Trap.
+
+10. Let :math:`b^\ast` be the byte sequence :math:`\X{mem}.\MIDATA[\X{ea} \slice N/8]`.
+
+11. Let :math:`n` be the integer for which :math:`\bytes_{\iN}(n) = b^\ast`.
+
+12. Let :math:`c` be the result of :math:`\extendu_{N,128}(n)`.
+
+13. Push the value :math:`\V128.\CONST~c` to the stack.
+
+.. math::
+   ~\\[-1ex]
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~i)~(\V128\K{.}\LOAD{N}\K{\_zero}~\memarg) &\stepto& S; F; (\V128.\CONST~c)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & \X{ea} = i + \memarg.\OFFSET \\
+     \wedge & \X{ea} + N/8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
+     \wedge & \bytes_{\iN}(n) = S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8]) \\
+     \wedge & c = \extendu_{N,128}(n)
+     \end{array}
+   \\[1ex]
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~k)~(\V128.\LOAD{N}\K{\_zero}~\memarg) &\stepto& S; F; \TRAP
+   \end{array}
+   \\ \qquad
+     (\otherwise) \\
+   \end{array}
+
+
+.. _exec-load-lane:
+
+:math:`\V128\K{.}\LOAD{N}\K{\_lane}~\memarg~x`
+.....................................................
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-load-extend>`, :math:`F.\AMODULE.\MIMEMS[0]` exists.
+
+3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\AMODULE.\MIMEMS[0]`.
+
+4. Assert: due to :ref:`validation <valid-load-extend>`, :math:`S.\SMEMS[a]` exists.
+
+5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\SMEMS[a]`.
+
+6. Assert: due to :ref:`validation <valid-load-extend>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+7. Pop the value :math:`\V128.\CONST~v` from the stack.
+
+8. Assert: due to :ref:`validation <valid-load-extend>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+
+9. Pop the value :math:`\I32.\CONST~i` from the stack.
+
+10. Let :math:`\X{ea}` be the integer :math:`i + \memarg.\OFFSET`.
+
+11. If :math:`\X{ea} + N/8` is larger than the length of :math:`\X{mem}.\MIDATA`, then:
+
+    a. Trap.
+
+12. Let :math:`b^\ast` be the byte sequence :math:`\X{mem}.\MIDATA[\X{ea} \slice N/8]`.
+
+13. Let :math:`r` be the constant for which :math:`\bytes_{\iN}(r) = b^\ast`.
+
+14. Let :math:`L` be :math:`128 / N`.
+
+15. Let :math:`c` be the result of computing :math:`\lanes^{-1}_{\K{i}N\K{x}L}(\lanes_{\K{i}N\K{x}L}(v) \with [x] = r)`.
+
+16. Push the value :math:`\V128.\CONST~c` to the stack.
+
+.. math::
+   ~\\[-1ex]
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~i)~(\V128.\CONST~v)~(\V128\K{.}\LOAD{N}\K{\_lane}~\memarg~x) &\stepto& S; F; (\V128.\CONST~c)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & \X{ea} = i + \memarg.\OFFSET \\
+     \wedge & \X{ea} + N/8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
+     \wedge & \bytes_{\iN}(r) = S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8]) \\
+     \wedge & L = 128/N \\
+     \wedge & c = \lanes^{-1}_{\K{i}N\K{x}L}(\lanes_{\K{i}N\K{x}L}(v) \with [x] = r)
+     \end{array}
+   \\[1ex]
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~k)~(\V128.\CONST~v)~(\V128.\LOAD{N}\K{\_lane}~\memarg~x) &\stepto& S; F; \TRAP
+   \end{array}
+   \\ \qquad
+     (\otherwise) \\
+   \end{array}
+
+
 .. _exec-store:
 .. _exec-storen:
 
@@ -1107,6 +2041,63 @@ Memory Instructions
    \end{array}
 
 
+.. _exec-store-lane:
+
+:math:`\V128\K{.}\STORE{N}\K{\_lane}~\memarg~x`
+......................................................
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-storen>`, :math:`F.\AMODULE.\MIMEMS[0]` exists.
+
+3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\AMODULE.\MIMEMS[0]`.
+
+4. Assert: due to :ref:`validation <valid-storen>`, :math:`S.\SMEMS[a]` exists.
+
+5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\SMEMS[a]`.
+
+6. Assert: due to :ref:`validation <valid-storen>`, a value of :ref:`value type <syntax-valtype>` :math:`\V128` is on the top of the stack.
+
+7. Pop the value :math:`\V128.\CONST~c` from the stack.
+
+8. Assert: due to :ref:`validation <valid-storen>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+
+9. Pop the value :math:`\I32.\CONST~i` from the stack.
+
+10. Let :math:`\X{ea}` be the integer :math:`i + \memarg.\OFFSET`.
+
+11. If :math:`\X{ea} + N/8` is larger than the length of :math:`\X{mem}.\MIDATA`, then:
+
+    a. Trap.
+
+12. Let :math:`L` be :math:`128/N`.
+
+13. Let :math:`b^\ast` be the byte sequence :math:`\bytes_{\iN}(\lanes_{\K{i}N\K{x}L}(c)[x])`.
+
+14. Replace the bytes :math:`\X{mem}.\MIDATA[\X{ea} \slice N/8]` with :math:`b^\ast`.
+
+.. math::
+   ~\\[-1ex]
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~i)~(\V128.\CONST~c)~(\V128.\STORE{N}\K{\_lane}~\memarg~x) &\stepto& S'; F; \epsilon
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & \X{ea} = i + \memarg.\OFFSET \\
+     \wedge & \X{ea} + N \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
+     \wedge & L = 128/N \\
+     \wedge & S' = S \with \SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8] = \bytes_{\iN}(\lanes_{\K{i}N\K{x}L}(c)[x])
+     \end{array}
+   \\[1ex]
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~k)~(\V128.\CONST~c)~(\V128.\STORE{N}\K{\_lane}~\memarg~x) &\stepto& S; F; \TRAP
+   \end{array}
+   \\ \qquad
+     (\otherwise) \\
+   \end{array}
+
+
 .. _exec-memory.size:
 
 :math:`\MEMORYSIZE`
diff --git a/document/core/exec/numerics.rst b/document/core/exec/numerics.rst
index 748ca605a..b60416874 100644
--- a/document/core/exec/numerics.rst
+++ b/document/core/exec/numerics.rst
@@ -38,6 +38,28 @@ When several of these placeholders occur in a single clause, then they must be r
       \fcopysign_N(- p_1, + p_2) &=& + p_1 \\
       \end{array}
 
+Numeric operators are lifted to input sequences by applying the operator element-wise, returning a sequence of results. When there are multiple inputs, they must be of equal length.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   op(c_1^n, \dots, c_k^n) &=& op(c_1^n[0], \dots, c_k^n[0])~\dots~op(c_1^n[n-1], \dots, c_k^n[n-1])
+   \end{array}
+
+.. note::
+   For example, the unary operator |fabs|, when given a sequence of floating-point values, return a sequence of floating-point results:
+
+   .. math::
+      \begin{array}{lll@{\qquad}l}
+      \fabs_N(z^n) &=& \fabs_N(z[0])~\dots~\fabs_N(z[n])
+      \end{array}
+
+   The binary operator |iadd|, when given two sequences of integers of the same length, :math:`n`, return a sequence of integer results:
+
+   .. math::
+      \begin{array}{lll@{\qquad}l}
+      \iadd_N(i_1^n, i_2^n) &=& \iadd_N(i_1[0], i_2[0])~\dots~\iadd_N(i_1[n], i_2[n])
+      \end{array}
+
 .. _aux-trunc:
 
 Conventions:
@@ -57,6 +79,30 @@ Conventions:
      \trunc(\pm q) &=& \pm i & (\iff i \in \mathbb{N} \wedge +q - 1 < i \leq +q) \\
      \end{array}
 
+.. _aux-sat_u:
+.. _aux-sat_s:
+
+* Saturation of integers is written :math:`\satu_N(i)` and :math:`\sats_N(i)`. The arguments to these two functions range over arbitrary signed integers.
+
+  * Unsigned saturation, :math:`\satu_N(i)` clamps :math:`i` to between :math:`0` and :math:`2^N-1`:
+
+    .. math::
+       \begin{array}{lll@{\qquad}l}
+       \satu_N(i) &=& 2^N-1 & (\iff i > 2^N-1)\\
+       \satu_N(i) &=& 0 & (\iff i < 0) \\
+       \satu_N(i) &=& i & (\otherwise) \\
+       \end{array}
+
+  * Signed saturation, :math:`\sats_N(i)` clamps :math:`i` to between :math:`-2^{N-1}` and :math:`2^{N-1}-1`:
+
+  .. math::
+     \begin{array}{lll@{\qquad}l}
+     \sats_N(i) &=& \signed_N^{-1}(-2^{N-1}) & (\iff i < -2^{N-1})\\
+     \sats_N(i) &=& \signed_N^{-1}(2^{N-1}-1) & (\iff i > 2^{N-1}-1)\\
+     \sats_N(i) &=& i & (\otherwise)
+     \end{array}
+
+
 
 .. index:: bit, integer, floating-point
 .. _aux-bits:
@@ -134,6 +180,31 @@ When a number is stored into :ref:`memory <syntax-mem>`, it is converted into a
 Again these functions are invertable bijections.
 
 
+.. index:: numeric vectors, shape
+.. _aux-lanes:
+
+Vectors
+.......
+
+Numeric vectors have the same underlying representation as an |i128|. They can also be interpreted as a sequence of numeric values packed into a |V128| with a particular |shape|.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lll@{\qquad}l}
+   \lanes_{t\K{x}N}(c) &=&
+     c_0~\dots~c_{N-1} \\
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\where & B = |t| / 8 \\
+     \wedge & b^{16} = bytes_{\i128}(c) \\
+     \wedge & c_i = \bytes_{t}^{-1}(b^{16}[i \cdot B \slice B]))
+     \end{array}
+   \end{array}
+
+These functions are bijections, so they are invertible.
+
+
 .. index:: integer
 .. _int-ops:
 
@@ -302,6 +373,18 @@ The integer result of predicates -- i.e., :ref:`tests <syntax-testop>` and :ref:
    it holds that :math:`i_1 = i_2\cdot\idivs(i_1, i_2) + \irems(i_1, i_2)`.
 
 
+.. _op-inot:
+
+:math:`\inot_N(i)`
+..................
+
+* Return the bitwise negation of :math:`i`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \inot_N(i) &=& \ibits_N^{-1}(\ibits_N(i) \veebar \ibits_N(2^N-1))
+   \end{array}
+
 .. _op-iand:
 
 :math:`\iand_N(i_1, i_2)`
@@ -314,6 +397,18 @@ The integer result of predicates -- i.e., :ref:`tests <syntax-testop>` and :ref:
    \iand_N(i_1, i_2) &=& \ibits_N^{-1}(\ibits_N(i_1) \wedge \ibits_N(i_2))
    \end{array}
 
+.. _op-iandnot:
+
+:math:`\iandnot_N(i_1, i_2)`
+............................
+
+* Return the bitwise conjunction of :math:`i_1` and the bitwise negation of :math:`i_2`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \iandnot_N(i_1, i_2) &=& \iand_N(i_1, \inot_N(i2))
+   \end{array}
+
 .. _op-ior:
 
 :math:`\ior_N(i_1, i_2)`
@@ -625,6 +720,208 @@ The integer result of predicates -- i.e., :ref:`tests <syntax-testop>` and :ref:
    \end{array}
 
 
+.. _op-ibitselect:
+
+:math:`\ibitselect_N(i_1, i_2, i_3)`
+....................................
+
+* Let :math:`j_1` be the bitwise conjunction of :math:`i_1` and :math:`i_3`.
+
+* Let :math:`j_3'` be the bitwise negation of :math:`i_3`.
+
+* Let :math:`j_2` be the bitwise conjunction of :math:`i_2` and :math:`j_3'`.
+
+* Return the bitwise disjunction of :math:`j_1` and :math:`j_2`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \ibitselect_N(i_1, i_2, i_3) &=& \ior_N(\iand_N(i_1, i_3), \iand_N(i_2, \inot_N(i_3)))
+   \end{array}
+
+
+.. _op-iabs:
+
+:math:`\iabs_N(i)`
+..................
+
+* Let :math:`j` be the :ref:`signed interpretation <aux-signed>` of :math:`i`.
+
+* If :math:`j` greater than or equal to :math:`0`, then return :math:`i`.
+
+* Else return the negation of `j`, modulo :math:`2^N`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \iabs_N(i) &=& i & (\iff \signed_N(i) \ge 0) \\
+   \iabs_N(i) &=& -\signed_N(i) \mod 2^N & (\otherwise) \\
+   \end{array}
+
+
+.. _op-ineg:
+
+:math:`\ineg_N(i)`
+..................
+
+* Return the result of negating :math:`i`, modulo :math:`2^N`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \ineg_N(i) &=& (2^N - i) \mod 2^N
+   \end{array}
+
+
+.. _op-imin_u:
+
+:math:`\iminu_N(i_1, i_2)`
+..........................
+
+* Return :math:`i_1` if :math:`\iltu_N(i_1, i_2)` is :math:`1`, return :math:`i_2` otherwise.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \iminu_N(i_1, i_2) &=& i_1 & (\iff \iltu_N(i_1, i_2) = 1)\\
+   \iminu_N(i_1, i_2) &=& i_2 & (\otherwise)
+   \end{array}
+
+
+.. _op-imin_s:
+
+:math:`\imins_N(i_1, i_2)`
+..........................
+
+* Return :math:`i_1` if :math:`\ilts_N(i_1, i_2)` is :math:`1`, return :math:`i_2` otherwise.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \iminu_N(i_1, i_2) &=& i_1 & (\iff \ilts_N(i_1, i_2) = 1)\\
+   \iminu_N(i_1, i_2) &=& i_2 & (\otherwise)
+   \end{array}
+
+
+.. _op-imax_u:
+
+:math:`\imaxu_N(i_1, i_2)`
+..........................
+
+* Return :math:`i_1` if :math:`\igtu_N(i_1, i_2)` is :math:`1`, return :math:`i_2` otherwise.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \iminu_N(i_1, i_2) &=& i_1 & (\iff \igtu_N(i_1, i_2) = 1)\\
+   \iminu_N(i_1, i_2) &=& i_2 & (\otherwise)
+   \end{array}
+
+
+.. _op-imax_s:
+
+:math:`\imaxs_N(i_1, i_2)`
+..........................
+
+* Return :math:`i_1` if :math:`\igts_N(i_1, i_2)` is :math:`1`, return :math:`i_2` otherwise.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \iminu_N(i_1, i_2) &=& i_1 & (\iff \igts_N(i_1, i_2) = 1)\\
+   \iminu_N(i_1, i_2) &=& i_2 & (\otherwise)
+   \end{array}
+
+
+.. _op-iadd_sat_u:
+
+:math:`\iaddsatu_N(i_1, i_2)`
+.............................
+
+* Let :math:`i` be the result of adding :math:`i_1` and :math:`i_2`.
+
+* Return :math:`\satu_N(i)`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \iaddsatu_N(i_1, i_2) &=& \satu_N(i_1 + i_2)
+   \end{array}
+
+
+.. _op-iadd_sat_s:
+
+:math:`\iaddsats_N(i_1, i_2)`
+.............................
+
+* Let :math:`j_1` be the signed interpretation of :math:`i_1`
+
+* Let :math:`j_2` be the signed interpretation of :math:`i_2`
+
+* Let :math:`j` be the result of adding :math:`j_1` and :math:`j_2`.
+
+* Return :math:`\sats_N(j)`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \iaddsats_N(i_1, i_2) &=& \sats_N(\signed_N(i_1) + \signed_N(i_2))
+   \end{array}
+
+
+.. _op-isub_sat_u:
+
+:math:`\isubsatu_N(i_1, i_2)`
+.............................
+
+* Let :math:`i` be the result of subtracting :math:`i_2` from :math:`i_1`.
+
+* Return :math:`\satu_N(i)`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \isubsatu_N(i_1, i_2) &=& \satu_N(i_1 - i_2)
+   \end{array}
+
+
+.. _op-isub_sat_s:
+
+:math:`\isubsats_N(i_1, i_2)`
+.............................
+
+* Let :math:`j_1` be the signed interpretation of :math:`i_1`
+
+* Let :math:`j_2` be the signed interpretation of :math:`i_2`
+
+* Let :math:`j` be the result of subtracting :math:`j_2` from :math:`j_1`.
+
+* Return :math:`\sats_N(j)`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \isubsats_N(i_1, i_2) &=& \sats_N(\signed_N(i_1) - \signed_N(i_2))
+   \end{array}
+
+
+.. _op-iavgr_u:
+
+:math:`\iavgru_N(i_1, i_2)`
+...........................
+
+* Let :math:`j` be the result of adding :math:`i_1`, :math:`i_2`, and :math:`1`.
+
+* Return the result of dividing :math:`j` by :math:`2`, truncated toward zero.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \iavgru_N(i_1, i_2) &=& \trunc((i_1 + i_2 + 1) / 2)
+   \end{array}
+
+
+.. _op-iq15mulrsat_s:
+
+:math:`\iq15mulrsats_N(i_1, i_2)`
+.................................
+
+* Return the result of :math:`\sats_N(\ishrs_N(i_1 \cdot i_2 + 2^{14}, 15))`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \iq15mulrsats_N(i_1, i_2) &=& \sats_N(\ishrs_N(i_1 \cdot i_2 + 2^{14}, 15))
+   \end{array}
+
+
 .. index:: floating-point, IEEE 754
 .. _float-ops:
 
@@ -1378,6 +1675,38 @@ This non-deterministic result is expressed by the following auxiliary function p
    \end{array}
 
 
+.. _op-fpmin:
+
+:math:`\fpmin_N(z_1, z_2)`
+..........................
+
+* If :math:`z_2` is less than :math:`z_1` then return :math:`z_2`.
+
+* Else return :math:`z_1`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \fpmin_N(z_1, z_2) &=& z_2 & (\iff \flt_N(z_2, z_1) = 1) \\
+   \fpmin_N(z_1, z_2) &=& z_1 & (\otherwise)
+   \end{array}
+
+
+.. _op-fpmax:
+
+:math:`\fpmax_N(z_1, z_2)`
+..........................
+
+* If :math:`z_1` is less than :math:`z_2` then return :math:`z_2`.
+
+* Else return :math:`z_1`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \fpmax_N(z_1, z_2) &=& z_2 & (\iff \flt_N(z_1, z_2) = 1) \\
+   \fpmax_N(z_1, z_2) &=& z_1 & (\otherwise)
+   \end{array}
+
+
 .. _convert-ops:
 
 Conversions
@@ -1490,20 +1819,14 @@ Conversions
 
 * Else if :math:`z` is positive infinity, then return :math:`2^N - 1`.
 
-* Else if :math:`\trunc(z)` is less than :math:`0`, then return :math:`0`.
-
-* Else if :math:`\trunc(z)` is greater than :math:`2^N - 1`, then return :math:`2^N - 1`.
-
-* Else, return :math:`\trunc(z)`.
+* Else, return :math:`\satu_N(\trunc(z))`.
 
 .. math::
    \begin{array}{lll@{\qquad}l}
    \truncsatu_{M,N}(\pm \NAN(n)) &=& 0 \\
    \truncsatu_{M,N}(- \infty) &=& 0 \\
    \truncsatu_{M,N}(+ \infty) &=& 2^N - 1 \\
-   \truncsatu_{M,N}(- q) &=& 0 & (\iff \trunc(- q) < 0) \\
-   \truncsatu_{M,N}(+ q) &=& 2^N - 1 & (\iff \trunc(+ q) > 2^N - 1) \\
-   \truncsatu_{M,N}(\pm q) &=& \trunc(\pm q) & (otherwise) \\
+   \truncsatu_{M,N}(z) &=& \satu_N(\trunc(z)) \\
    \end{array}
 
 
@@ -1518,20 +1841,14 @@ Conversions
 
 * Else if :math:`z` is positive infinity, then return :math:`2^{N-1} - 1`.
 
-* Else if :math:`\trunc(z)` is less than :math:`-2^{N-1}`, then return :math:`-2^{N-1}`.
-
-* Else if :math:`\trunc(z)` is greater than :math:`2^{N-1} - 1`, then return :math:`2^{N-1} - 1`.
-
-* Else, return :math:`\trunc(z)`.
+* Else, return :math:`\sats_N(\trunc(z))`.
 
 .. math::
    \begin{array}{lll@{\qquad}l}
    \truncsats_{M,N}(\pm \NAN(n)) &=& 0 \\
    \truncsats_{M,N}(- \infty) &=& -2^{N-1} \\
    \truncsats_{M,N}(+ \infty) &=& 2^{N-1}-1 \\
-   \truncsats_{M,N}(- q) &=& -2^{N-1} & (\iff \trunc(- q) < -2^{N-1}) \\
-   \truncsats_{M,N}(+ q) &=& 2^{N-1} - 1 & (\iff \trunc(+ q) > 2^{N-1} - 1) \\
-   \truncsats_{M,N}(\pm q) &=& \trunc(\pm q) & (otherwise) \\
+   \truncsats_{M,N}(z) &=& \sats_N(\trunc(z)) \\
    \end{array}
 
 
@@ -1620,3 +1937,33 @@ Conversions
    \begin{array}{lll@{\qquad}l}
    \reinterpret_{t_1,t_2}(c) &=& \bits_{t_2}^{-1}(\bits_{t_1}(c)) \\
    \end{array}
+
+
+.. _op-narrow_s:
+
+:math:`\narrows_{M,N}(i)`
+.........................
+
+* Let :math:`j` be the :ref:`signed interpretation <aux-signed>` of :math:`i` of size :math:`M`.
+
+* Return :math:`\sats_N(j)`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \narrows_{M,N}(i) &=& \sats_N(\signed_M(i))
+   \end{array}
+
+
+.. _op-narrow_u:
+
+:math:`\narrowu_{M,N}(i)`
+.........................
+
+* Let :math:`j` be the :ref:`signed interpretation <aux-signed>` of :math:`i` of size :math:`M`.
+
+* Return :math:`\satu_N(j)`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \narrowu_{M,N}(i) &=& \satu_N(\signed_M(i))
+   \end{array}
diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index c1b65f69d..482eea0ad 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -7,9 +7,10 @@ Runtime Structure
 :ref:`Store <store>`, :ref:`stack <stack>`, and other *runtime structure* forming the WebAssembly abstract machine, such as :ref:`values <syntax-val>` or :ref:`module instances <syntax-moduleinst>`, are made precise in terms of additional auxiliary syntax.
 
 
-.. index:: ! value, number, reference, constant, number type, reference type, ! host address, value type, integer, floating-point, ! default value
+.. index:: ! value, number, reference, constant, number type, vector type, reference type, ! host address, value type, integer, floating-point, vector number, ! default value
    pair: abstract syntax; value
 .. _syntax-num:
+.. _syntax-vecc:
 .. _syntax-ref:
 .. _syntax-ref.extern:
 .. _syntax-val:
@@ -17,7 +18,7 @@ Runtime Structure
 Values
 ~~~~~~
 
-WebAssembly computations manipulate *values* of either the four basic :ref:`number types <syntax-numtype>`, i.e., :ref:`integers <syntax-int>` and :ref:`floating-point data <syntax-float>` of 32 or 64 bit width each, or of :ref:`reference type <syntax-reftype>`.
+WebAssembly computations manipulate *values* of either the four basic :ref:`number types <syntax-numtype>`, i.e., :ref:`integers <syntax-int>` and :ref:`floating-point data <syntax-float>` of 32 or 64 bit width each, of :ref:`vectors <syntax-vecnum>` of 128 bit width, or of :ref:`reference type <syntax-reftype>`.
 
 In most places of the semantics, values of different types can occur.
 In order to avoid ambiguities, values are therefore represented with an abstract syntax that makes their type explicit.
@@ -34,12 +35,14 @@ or *external references* pointing to an uninterpreted form of :ref:`extern addre
      \I64.\CONST~\i64 \\&&|&
      \F32.\CONST~\f32 \\&&|&
      \F64.\CONST~\f64 \\
+   \production{(vector)} & \vecc &::=&
+     \V128.\CONST~\i128 \\
    \production{(reference)} & \reff &::=&
      \REFNULL~t \\&&|&
      \REFFUNCADDR~\funcaddr \\&&|&
      \REFEXTERNADDR~\externaddr \\
    \production{(value)} & \val &::=&
-     \num ~|~ \reff \\
+     \num ~|~ \vecc ~|~ \reff \\
    \end{array}
 
 .. note::
diff --git a/document/core/intro/overview.rst b/document/core/intro/overview.rst
index 4b7ec0652..b9e858ccc 100644
--- a/document/core/intro/overview.rst
+++ b/document/core/intro/overview.rst
@@ -13,7 +13,7 @@ This language is structured around the following concepts.
 .. _value:
 
 **Values**
-  WebAssembly provides only four basic *value types*.
+  WebAssembly provides only four basic *number types*.
   These are integers and |IEEE754|_ numbers,
   each in 32 and 64 bit width.
   32 bit integers also serve as Booleans and as memory addresses.
@@ -23,6 +23,13 @@ This language is structured around the following concepts.
   Instead, integers are interpreted by respective operations
   as either unsigned or signed in two’s complement representation.
 
+  In addition to these basic number types, there is a single 128 bit wide
+  vector type representing different types of packed data.
+  The supported representations are 4 32-bit, or 2 64-bit
+  |IEEE754|_ numbers, or different widths of packed integer values
+  specifically 2 64-bit integers, 4 32-bit integers, 8
+  16-bit integers, or 16 8-bit integers.
+
   Finally, values can consist of opaque *references* that represent pointers towards different sorts of entities.
   Unlike with other types, their size or representation is not observable.
 
diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index 9c582d64c..5b869b33f 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -171,6 +171,242 @@ Occasionally, it is convenient to group operators together according to the foll
    \end{array}
 
 
+.. index:: ! vector instruction, numeric vectors, number, value, value type, SIMD
+   pair: abstract syntax; instruction
+.. _syntax-laneidx:
+.. _syntax-shape:
+.. _syntax-half:
+.. _syntax-vvunop:
+.. _syntax-vvbinop:
+.. _syntax-vvternop:
+.. _syntax-vvtestop:
+.. _syntax-vitestop:
+.. _syntax-virelop:
+.. _syntax-vfrelop:
+.. _syntax-vishiftop:
+.. _syntax-viunop:
+.. _syntax-vibinop:
+.. _syntax-viminmaxop:
+.. _syntax-visatbinop:
+.. _syntax-vfunop:
+.. _syntax-vfbinop:
+.. _syntax-instr-vec:
+
+Vector Instructions
+~~~~~~~~~~~~~~~~~~~
+
+Vector instructions (also known as *SIMD* instructions, single data multiple value) provide basic operations over :ref:`values <syntax-value>` of :ref:`vector type <syntax-vectype>`.
+
+.. math::
+   \begin{array}{llcl}
+   \production{ishape} & \ishape &::=&
+     \K{i8x16} ~|~ \K{i16x8} ~|~ \K{i32x4} ~|~ \K{i64x2} \\
+   \production{fshape} & \fshape &::=&
+     \K{f32x4} ~|~ \K{f64x2} \\
+   \production{shape} & \shape &::=&
+     \ishape ~|~ \fshape \\
+   \production{half} & \half &::=&
+     \K{low} ~|~ \K{high} \\
+   \production{lane index} & \laneidx &::=& \u8 \\
+   \production{instruction} & \instr &::=&
+     \dots \\&&|&
+     \K{v128.}\VCONST~\i128 \\&&|&
+     \K{v128.}\vvunop \\&&|&
+     \K{v128.}\vvbinop \\&&|&
+     \K{v128.}\vvternop \\&&|&
+     \K{v128.}\vvtestop \\&&|&
+     \K{i8x16.}\SHUFFLE~\laneidx^{16} \\&&|&
+     \K{i8x16.}\SWIZZLE \\&&|&
+     \shape\K{.}\SPLAT \\&&|&
+     \K{i8x16.}\EXTRACTLANE\K{\_}\sx~\laneidx ~|~
+     \K{i16x8.}\EXTRACTLANE\K{\_}\sx~\laneidx \\&&|&
+     \K{i32x4.}\EXTRACTLANE~\laneidx ~|~
+     \K{i64x2.}\EXTRACTLANE~\laneidx \\&&|&
+     \fshape\K{.}\EXTRACTLANE~\laneidx \\&&|&
+     \shape\K{.}\REPLACELANE~\laneidx \\&&|&
+     \K{i8x16}\K{.}\virelop ~|~
+     \K{i16x8}\K{.}\virelop ~|~
+     \K{i32x4}\K{.}\virelop \\&&|&
+     \K{i64x2.}\K{eq} ~|~
+     \K{i64x2.}\K{ne} ~|~
+     \K{i64x2.}\K{lt\_s} ~|~
+     \K{i64x2.}\K{gt\_s} ~|~
+     \K{i64x2.}\K{le\_s} ~|~
+     \K{i64x2.}\K{ge\_s} \\&&|&
+     \fshape\K{.}\vfrelop \\&&|&
+     \ishape\K{.}\viunop ~|~
+     \K{i8x16.}\VPOPCNT \\&&|&
+     \K{i16x8.}\Q15MULRSAT\K{\_s} \\ &&|&
+     \K{i32x4.}\DOT\K{\_i16x8\_s} \\ &&|&
+     \fshape\K{.}\vfunop \\&&|&
+     \ishape\K{.}\vitestop \\ &&|&
+     \ishape\K{.}\BITMASK \\ &&|&
+     \K{i8x16.}\NARROW\K{\_i16x8\_}\sx ~|~
+     \K{i16x8.}\NARROW\K{\_i32x4\_}\sx \\&&|&
+     \K{i16x8.}\VEXTEND\K{\_}\half\K{\_i8x16\_}\sx ~|~
+     \K{i32x4.}\VEXTEND\K{\_}\half\K{\_i16x8\_}\sx \\&&|&
+     \K{i64x2.}\VEXTEND\K{\_}\half\K{\_i32x4\_}\sx \\&&|&
+     \ishape\K{.}\vishiftop \\&&|&
+     \ishape\K{.}\vibinop \\&&|&
+     \K{i8x16.}\viminmaxop ~|~
+     \K{i16x8.}\viminmaxop ~|~
+     \K{i32x4.}\viminmaxop \\&&|&
+     \K{i8x16.}\visatbinop ~|~
+     \K{i16x8.}\visatbinop \\&&|&
+     \K{i16x8.}\K{mul} ~|~
+     \K{i32x4.}\K{mul} ~|~
+     \K{i64x2.}\K{mul} \\&&|&
+     \K{i8x16.}\AVGR\K{\_u} ~|~
+     \K{i16x8.}\AVGR\K{\_u} \\&&|&
+     \K{i16x8.}\EXTMUL\K{\_}\half\K{\_i8x16\_}\sx ~|~
+     \K{i32x4.}\EXTMUL\K{\_}\half\K{\_i16x8\_}\sx ~|~
+     \K{i64x2.}\EXTMUL\K{\_}\half\K{\_i32x4\_}\sx \\ &&|&
+     \K{i16x8.}\EXTADDPAIRWISE\K{\_i8x16\_}\sx ~|~
+     \K{i32x4.}\EXTADDPAIRWISE\K{\_i16x8\_}\sx \\ &&|&
+     \fshape\K{.}\vfbinop \\&&|&
+     \K{i32x4.}\VTRUNC\K{\_sat\_f32x4\_}\sx ~|~
+     \K{i32x4.}\VTRUNC\K{\_sat\_f64x2\_}\sx\K{\_zero} \\&&|&
+     \K{f32x4.}\VCONVERT\K{\_i32x4\_}\sx ~|~
+     \K{f32x4.}\VDEMOTE\K{\_f64x2\_zero} \\&&|&
+     \K{f64x2.}\VCONVERT\K{\_low\_i32x4\_}\sx ~|~
+     \K{f64x2.}\VPROMOTE\K{\_low\_f32x4} \\&&|&
+     \dots \\
+   \production{vector bitwise unary operator} & \vvunop &::=&
+     \K{not} \\
+   \production{vector bitwise binary operator} & \vvbinop &::=&
+     \K{and} ~|~
+     \K{andnot} ~|~
+     \K{or} ~|~
+     \K{xor} \\
+   \production{vector bitwise ternary operator} & \vvternop &::=&
+     \K{bitselect} \\
+   \production{vector bitwise test operator} & \vvtestop &::=&
+     \K{any\_true} \\
+   \production{vector integer test operator} & \vitestop &::=&
+     \K{all\_true} \\
+   \production{vector integer relational operator} & \virelop &::=&
+     \K{eq} ~|~
+     \K{ne} ~|~
+     \K{lt\_}\sx ~|~
+     \K{gt\_}\sx ~|~
+     \K{le\_}\sx ~|~
+     \K{ge\_}\sx \\
+   \production{vector floating-point relational operator} & \vfrelop &::=&
+     \K{eq} ~|~
+     \K{ne} ~|~
+     \K{lt} ~|~
+     \K{gt} ~|~
+     \K{le} ~|~
+     \K{ge} \\
+   \production{vector integer unary operator} & \viunop &::=&
+     \K{abs} ~|~
+     \K{neg} \\
+   \production{vector integer binary operator} & \vibinop &::=&
+     \K{add} ~|~
+     \K{sub} \\
+   \production{vector integer binary min/max operator} & \viminmaxop &::=&
+     \K{min\_}\sx ~|~
+     \K{max\_}\sx \\
+   \production{vector integer saturating binary operator} & \visatbinop &::=&
+     \K{add\_sat\_}\sx ~|~
+     \K{sub\_sat\_}\sx \\
+   \production{vector integer shift operator} & \vishiftop &::=&
+     \K{shl} ~|~
+     \K{shr\_}\sx \\
+   \production{vector floating-point unary operator} & \vfunop &::=&
+     \K{abs} ~|~
+     \K{neg} ~|~
+     \K{sqrt} ~|~
+     \K{ceil} ~|~
+     \K{floor} ~|~
+     \K{trunc} ~|~
+     \K{nearest} \\
+   \production{vector floating-point binary operator} & \vfbinop &::=&
+     \K{add} ~|~
+     \K{sub} ~|~
+     \K{mul} ~|~
+     \K{div} ~|~
+     \K{min} ~|~
+     \K{max} ~|~
+     \K{pmin} ~|~
+     \K{pmax} \\
+   \end{array}
+
+.. _syntax-vec-shape:
+
+Vector instructions have a naming convention involving a prefix that
+determines how their operands will be interpreted.
+This prefix describes the *shape* of the operand,
+written :math:`t\K{x}N`, and consisting of a packed :ref:`numeric type <syntax-numtype>` :math:`t` and the number of *lanes* :math:`N` of that type.
+Operations are performed point-wise on the values of each lane.
+
+.. note::
+   For example, the shape :math:`\K{i32x4}` interprets the operand
+   as four |i32| values, packed into an |i128|.
+   The bitwidth of the numeric type :math:`t` times :math:`N` always is 128.
+
+Instructions prefixed with :math:`\K{v128}` do not involve a specific interpretation, and treat the |V128| as an |i128| value or a vector of 128 individual bits.
+
+Vector instructions can be grouped into several subcategories:
+
+* *Constants*: return a static constant.
+
+* *Unary Operations*: consume one |V128| operand and produce one |V128| result.
+
+* *Binary Operations*: consume two |V128| operands and produce one |V128| result.
+
+* *Ternary Operations*: consume three |V128| operands and produce one |V128| result.
+
+* *Tests*: consume one |V128| operand and produce a Boolean integer result.
+
+* *Shifts*: consume a |v128| operand and a |i32| operand, producing one |V128| result.
+
+* *Splats*: consume a value of numeric type and produce a |V128| result of a specified shape.
+
+* *Extract lanes*: consume a |V128| operand and return the numeric value in a given lane.
+
+* *Replace lanes*: consume a |V128| operand and a numeric value for a given lane, and produce a |V128| result.
+
+Some vector instructions have a signedness annotation |sx| which distinguishes whether the elements in the operands are to be :ref:`interpreted <aux-signed>` as :ref:`unsigned <syntax-uint>` or :ref:`signed <syntax-sint>` integers.
+For the other vector instructions, the use of two's complement for the signed interpretation means that they behave the same regardless of signedness.
+
+
+.. _syntax-vunop:
+.. _syntax-vbinop:
+.. _syntax-vrelop:
+.. _syntax-vtestop:
+.. _syntax-vcvtop:
+
+Conventions
+...........
+
+Occasionally, it is convenient to group operators together according to the following grammar shorthands:
+
+.. math::
+   \begin{array}{llll}
+   \production{unary operator} & \vunop &::=&
+     \viunop ~|~
+     \vfunop ~|~
+     \VPOPCNT \\
+   \production{binary operator} & \vbinop &::=&
+     \vibinop ~|~ \vfbinop \\&&|&
+     \viminmaxop ~|~ \visatbinop \\&&|&
+     \VMUL ~|~
+     \AVGR\K{\_u} ~|~
+     \Q15MULRSAT\K{\_s} \\
+   \production{test operator} & \vtestop &::=&
+     \vitestop \\
+   \production{relational operator} & \vrelop &::=&
+     \virelop ~|~ \vfrelop \\
+   \production{conversion operator} & \vcvtop &::=&
+     \VEXTEND ~|~
+     \VTRUNC\K{\_sat} ~|~
+     \VCONVERT ~|~
+     \VDEMOTE ~|~
+     \VPROMOTE \\
+   \end{array}
+
+
 .. index:: ! reference instruction, reference, null
    pair: abstract syntax; instruction
 .. _syntax-ref.null:
@@ -293,6 +529,7 @@ An additional instruction that accesses a table is the :ref:`control instruction
 .. _syntax-loadn:
 .. _syntax-storen:
 .. _syntax-memarg:
+.. _syntax-lanewidth:
 .. _syntax-instr-memory:
 
 Memory Instructions
@@ -304,18 +541,30 @@ Instructions in this group are concerned with linear :ref:`memory <syntax-mem>`.
    \begin{array}{llcl}
    \production{memory immediate} & \memarg &::=&
      \{ \OFFSET~\u32, \ALIGN~\u32 \} \\
+   \production{lane width} & \X{ww} &::=&
+     8 ~|~ 16 ~|~ 32 ~|~ 64 \\
    \production{instruction} & \instr &::=&
      \dots \\&&|&
      \K{i}\X{nn}\K{.}\LOAD~\memarg ~|~
-     \K{f}\X{nn}\K{.}\LOAD~\memarg \\&&|&
+     \K{f}\X{nn}\K{.}\LOAD~\memarg ~|~
+     \K{v128.}\LOAD~\memarg \\&&|&
      \K{i}\X{nn}\K{.}\STORE~\memarg ~|~
-     \K{f}\X{nn}\K{.}\STORE~\memarg \\&&|&
+     \K{f}\X{nn}\K{.}\STORE~\memarg ~|~
+     \K{v128.}\STORE~\memarg \\&&|&
      \K{i}\X{nn}\K{.}\LOAD\K{8\_}\sx~\memarg ~|~
      \K{i}\X{nn}\K{.}\LOAD\K{16\_}\sx~\memarg ~|~
      \K{i64.}\LOAD\K{32\_}\sx~\memarg \\&&|&
      \K{i}\X{nn}\K{.}\STORE\K{8}~\memarg ~|~
      \K{i}\X{nn}\K{.}\STORE\K{16}~\memarg ~|~
      \K{i64.}\STORE\K{32}~\memarg \\&&|&
+     \K{v128.}\LOAD\K{8x8\_}\sx~\memarg ~|~
+     \K{v128.}\LOAD\K{16x4\_}\sx~\memarg ~|~
+     \K{v128.}\LOAD\K{32x2\_}\sx~\memarg \\&&|&
+     \K{v128.}\LOAD\K{32\_zero}~\memarg ~|~
+     \K{v128.}\LOAD\K{64\_zero}~\memarg \\&&|&
+     \K{v128.}\LOAD\X{ww}\K{\_splat}~\memarg \\&&|&
+     \K{v128.}\LOAD\X{ww}\K{\_lane}~\memarg~\laneidx ~|~
+     \K{v128.}\STORE\X{ww}\K{\_lane}~\memarg~\laneidx \\&&|&
      \MEMORYSIZE \\&&|&
      \MEMORYGROW \\&&|&
      \MEMORYFILL \\&&|&
@@ -329,6 +578,9 @@ They all take a *memory immediate* |memarg| that contains an address *offset* an
 Integer loads and stores can optionally specify a *storage size* that is smaller than the :ref:`bit width <syntax-numtype>` of the respective value type.
 In the case of loads, a sign extension mode |sx| is then required to select appropriate behavior.
 
+Vector loads can specify a shape that is half the :ref:`bit width <syntax-valtype>` of |V128|. Each lane is half its usual size, and the sign extension mode |sx| then specifies how the smaller lane is extended to the larger lane.
+Alternatively, vector loads can perform a *splat*, such that only a single lane of the specified storage size is loaded, and the result is duplicated to all lanes.
+
 The static address offset is added to the dynamic address operand, yielding a 33 bit *effective address* that is the zero-based index at which the memory is accessed.
 All values are read and written in |LittleEndian|_ byte order.
 A :ref:`trap <trap>` results if any of the accessed memory bytes lies outside the address range implied by the memory's current size.
diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index 8da860629..270450823 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -34,6 +34,8 @@ They correspond to the respective binary floating-point representations, also kn
 Number types are *transparent*, meaning that their bit patterns can be observed.
 Values of number type can be stored in :ref:`memories <syntax-mem>`.
 
+.. _bitwidth:
+
 Conventions
 ...........
 
@@ -41,6 +43,35 @@ Conventions
   That is, :math:`|\I32| = |\F32| = 32` and :math:`|\I64| = |\F64| = 64`.
 
 
+.. index:: ! vector type, integer, floating-point, IEEE 754, bit width, memory, SIMD
+   pair: abstract syntax; number type
+   pair: number; type
+.. _syntax-vectype:
+
+Vector Types
+~~~~~~~~~~~~
+
+*Vector types* classify vectors of :ref:`numeric <syntax-numtype>` values processed by vector instructions (also known as *SIMD* instructions, single instruction multiple data).
+
+.. math::
+   \begin{array}{llll}
+   \production{vector type} & \vectype &::=&
+     \V128 \\
+   \end{array}
+
+The type |V128| corresponds to a 128 bit vector of packed integer or floating-point data. The packed data
+can be interpreted as signed or unsigned integers, single or double precision floating-point
+values, or a single 128 bit type. The interpretation is determined by individual operations.
+
+Vector types, like :ref:`number types <syntax-numtype>` are *transparent*, meaning that their bit patterns can be observed.
+Values of vector type can be stored in :ref:`memories <syntax-mem>`.
+
+Conventions
+...........
+
+* The notation :math:`|t|` for :ref:`bit width <bitwidth>` extends to vector types as well, that is, :math:`|\V128| = 128`.
+
+
 .. index:: ! reference type, reference, table, function, function type, null
    pair: abstract syntax; reference type
    pair: reference; type
@@ -65,7 +96,7 @@ Reference types are *opaque*, meaning that neither their size nor their bit patt
 Values of reference type can be stored in :ref:`tables <syntax-table>`.
 
 
-.. index:: ! value type, number type, reference type
+.. index:: ! value type, number type, vector type, reference type
    pair: abstract syntax; value type
    pair: value; type
 .. _syntax-valtype:
@@ -74,12 +105,12 @@ Value Types
 ~~~~~~~~~~~
 
 *Value types* classify the individual values that WebAssembly code can compute with and the values that a variable accepts.
-They are either :ref:`number types <syntax-numtype>` or :ref:`reference types <syntax-reftype>`.
+They are either :ref:`number types <syntax-numtype>`, :ref:`vector types <syntax-vectype>`, or :ref:`reference types <syntax-reftype>`.
 
 .. math::
    \begin{array}{llll}
    \production{value type} & \valtype &::=&
-     \numtype ~|~ \reftype \\
+     \numtype ~|~ \vectype ~|~ \reftype \\
    \end{array}
 
 Conventions
diff --git a/document/core/syntax/values.rst b/document/core/syntax/values.rst
index 98acc7a69..c4e7f89c3 100644
--- a/document/core/syntax/values.rst
+++ b/document/core/syntax/values.rst
@@ -146,6 +146,17 @@ Conventions
 * The meta variable :math:`z` ranges over floating-point values where clear from context.
 
 
+.. index:: ! numeric vectors, integer, floating-point, lane, SIMD
+   pair: abstract syntax; vector
+.. _syntax-vecnum:
+
+Vectors
+~~~~~~~
+
+*Numeric vectors* are 128-bit values that are processed by vector instructions (also known as *SIMD* instructions, single instruction multiple data).
+They are represented in the abstract syntax using |i128|. The interpretation of lane types (:ref:`integer <syntax-int>` or :ref:`floating-point <syntax-float>` numbers) and lane sizes are determined by the specific instruction operating on them.
+
+
 .. index:: ! name, byte, Unicode, UTF-8, character, binary format
    pair: abstract syntax; name
 .. _syntax-char:
diff --git a/document/core/text/conventions.rst b/document/core/text/conventions.rst
index 7d77c76aa..ddcd8e780 100644
--- a/document/core/text/conventions.rst
+++ b/document/core/text/conventions.rst
@@ -61,11 +61,11 @@ In order to distinguish symbols of the textual syntax from symbols of the abstra
 * A distinction is made between *lexical* and *syntactic* productions. For the latter, arbitrary :ref:`white space <text-space>` is allowed in any place where the grammar contains spaces. The productions defining :ref:`lexical syntax <text-lexical>` and the syntax of :Ref:`values <text-value>` are considered lexical, all others are syntactic.
 
 .. note::
-   For example, the :ref:`textual grammar <text-valtype>` for :ref:`value types <syntax-valtype>` is given as follows:
+   For example, the :ref:`textual grammar <text-numtype>` for :ref:`number types <syntax-numtype>` is given as follows:
 
    .. math::
      \begin{array}{llcll@{\qquad\qquad}l}
-     \production{value types} & \Tvaltype &::=&
+     \production{number types} & \Tnumtype &::=&
        \text{i32} &\Rightarrow& \I32 \\ &&|&
        \text{i64} &\Rightarrow& \I64 \\ &&|&
        \text{f32} &\Rightarrow& \F32 \\ &&|&
diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index 6112a7667..95eb41717 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -533,6 +533,363 @@ Numeric Instructions
    \end{array}
 
 
+.. index:: vector instruction
+   pair: text format; instruction
+.. _text-instr-vec:
+
+Vector Instructions
+~~~~~~~~~~~~~~~~~~~
+
+Vector memory instructions have optional offset and alignment immediates, like the :ref:`memory instructions <text-memarg>`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{instruction} & \Tplaininstr_I &::=& \dots \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\ &&|&
+     \text{v128.load}~~m{:}\Tmemarg_{16} &\Rightarrow& \V128.\LOAD~m \\ &&|&
+     \text{v128.load8x8\_s}~~m{:}\Tmemarg_8 &\Rightarrow& \V128.\LOAD\K{8x8\_s}~m \\ &&|&
+     \text{v128.load8x8\_u}~~m{:}\Tmemarg_8 &\Rightarrow& \V128.\LOAD\K{8x8\_u}~m \\ &&|&
+     \text{v128.load16x4\_s}~~m{:}\Tmemarg_8 &\Rightarrow& \V128.\LOAD\K{16x4\_s}~m \\ &&|&
+     \text{v128.load16x4\_u}~~m{:}\Tmemarg_8 &\Rightarrow& \V128.\LOAD\K{16x4\_u}~m \\ &&|&
+     \text{v128.load32x2\_s}~~m{:}\Tmemarg_8 &\Rightarrow& \V128.\LOAD\K{32x2\_s}~m \\ &&|&
+     \text{v128.load32x2\_u}~~m{:}\Tmemarg_8 &\Rightarrow& \V128.\LOAD\K{32x2\_u}~m \\ &&|&
+     \text{v128.load8\_splat}~~m{:}\Tmemarg_1 &\Rightarrow& \V128.\LOAD\K{8\_splat}~m \\ &&|&
+     \text{v128.load16\_splat}~~m{:}\Tmemarg_2 &\Rightarrow& \V128.\LOAD\K{16\_splat}~m \\ &&|&
+     \text{v128.load32\_splat}~~m{:}\Tmemarg_4 &\Rightarrow& \V128.\LOAD\K{32\_splat}~m \\ &&|&
+     \text{v128.load64\_splat}~~m{:}\Tmemarg_8 &\Rightarrow& \V128.\LOAD\K{64\_splat}~m \\ &&|&
+     \text{v128.load32\_zero}~~m{:}\Tmemarg_4 &\Rightarrow& \V128.\LOAD\K{32\_zero}~m \\ &&|&
+     \text{v128.load64\_zero}~~m{:}\Tmemarg_8 &\Rightarrow& \V128.\LOAD\K{64\_zero}~m \\ &&|&
+     \text{v128.store}~~m{:}\Tmemarg_{16} &\Rightarrow& \V128.\STORE~m \\ &&|&
+     \text{v128.load8\_lane}~~m{:}\Tmemarg_1~~laneidx{:}\Tu8 &\Rightarrow& \V128.\LOAD\K{8\_lane}~m~laneidx \\ &&|&
+     \text{v128.load16\_lane}~~m{:}\Tmemarg_2~~laneidx{:}\Tu8 &\Rightarrow& \V128.\LOAD\K{16\_lane}~m~laneidx \\ &&|&
+     \text{v128.load32\_lane}~~m{:}\Tmemarg_4~~laneidx{:}\Tu8 &\Rightarrow& \V128.\LOAD\K{32\_lane}~m~laneidx \\ &&|&
+     \text{v128.load64\_lane}~~m{:}\Tmemarg_8~~laneidx{:}\Tu8 &\Rightarrow& \V128.\LOAD\K{64\_lane}~m~laneidx \\ &&|&
+     \text{v128.store8\_lane}~~m{:}\Tmemarg_1~~laneidx{:}\Tu8 &\Rightarrow& \V128.\STORE\K{8\_lane}~m~laneidx \\ &&|&
+     \text{v128.store16\_lane}~~m{:}\Tmemarg_2~~laneidx{:}\Tu8 &\Rightarrow& \V128.\STORE\K{16\_lane}~m~laneidx \\ &&|&
+     \text{v128.store32\_lane}~~m{:}\Tmemarg_4~~laneidx{:}\Tu8 &\Rightarrow& \V128.\STORE\K{32\_lane}~m~laneidx \\ &&|&
+     \text{v128.store64\_lane}~~m{:}\Tmemarg_8~~laneidx{:}\Tu8 &\Rightarrow& \V128.\STORE\K{64\_lane}~m~laneidx \\
+   \end{array}
+
+Vector constant instructions have a mandatory :ref:`shape <syntax-vec-shape>` descriptor, which determines how the following values are parsed.
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{v128.const}~~\text{i8x16}~~(n{:}\Ti8)^{16} &\Rightarrow& \V128.\VCONST~\bytes_{i128}^{-1}(\bytes_{i8}(n)^{16}) \\ &&|&
+     \text{v128.const}~~\text{i16x8}~~(n{:}\Ti16)^{8} &\Rightarrow& \V128.\VCONST~\bytes_{i128}^{-1}(\bytes_{i16}(n)^8) \\ &&|&
+     \text{v128.const}~~\text{i32x4}~~(n{:}\Ti32)^{4} &\Rightarrow& \V128.\VCONST~\bytes_{i128}^{-1}(\bytes_{i32}(n)^4) \\ &&|&
+     \text{v128.const}~~\text{i64x2}~~(n{:}\Ti64)^{2} &\Rightarrow& \V128.\VCONST~\bytes_{i128}^{-1}(\bytes_{i64}(n)^2) \\ &&|&
+     \text{v128.const}~~\text{f32x4}~~(z{:}\Tf32)^{4} &\Rightarrow& \V128.\VCONST~\bytes_{i128}^{-1}(\bytes_{f32}(z)^4) \\ &&|&
+     \text{v128.const}~~\text{f64x2}~~(z{:}\Tf64)^{2} &\Rightarrow& \V128.\VCONST~\bytes_{i128}^{-1}(\bytes_{f64}(z)^2)
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i8x16.shuffle}~~(laneidx{:}\Tu8)^{16} &\Rightarrow& \I8X16.\SHUFFLE~laneidx^{16} \\ &&|&
+     \text{i8x16.swizzle} &\Rightarrow& \I8X16.\SWIZZLE
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i8x16.splat} &\Rightarrow& \I8X16.\SPLAT\\ &&|&
+     \text{i16x8.splat} &\Rightarrow& \I16X8.\SPLAT\\ &&|&
+     \text{i32x4.splat} &\Rightarrow& \I32X4.\SPLAT\\ &&|&
+     \text{i64x2.splat} &\Rightarrow& \I64X2.\SPLAT\\ &&|&
+     \text{f32x4.splat} &\Rightarrow& \F32X4.\SPLAT\\ &&|&
+     \text{f64x2.splat} &\Rightarrow& \F64X2.\SPLAT\\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i8x16.extract\_lane\_s}~~laneidx{:}\Tu8 &\Rightarrow& \I8X16.\EXTRACTLANE\K{\_s}~laneidx \\ &&|&
+     \text{i8x16.extract\_lane\_u}~~laneidx{:}\Tu8 &\Rightarrow& \I8X16.\EXTRACTLANE\K{\_u}~laneidx \\ &&|&
+     \text{i8x16.replace\_lane}~~laneidx{:}\Tu8 &\Rightarrow& \I8X16.\REPLACELANE~laneidx \\ &&|&
+     \text{i16x8.extract\_lane\_s}~~laneidx{:}\Tu8 &\Rightarrow& \I16X8.\EXTRACTLANE\K{\_s}~laneidx \\ &&|&
+     \text{i16x8.extract\_lane\_u}~~laneidx{:}\Tu8 &\Rightarrow& \I16X8.\EXTRACTLANE\K{\_u}~laneidx \\ &&|&
+     \text{i16x8.replace\_lane}~~laneidx{:}\Tu8 &\Rightarrow& \I16X8.\REPLACELANE~laneidx \\ &&|&
+     \text{i32x4.extract\_lane}~~laneidx{:}\Tu8 &\Rightarrow& \I32X4.\EXTRACTLANE~laneidx \\ &&|&
+     \text{i32x4.replace\_lane}~~laneidx{:}\Tu8 &\Rightarrow& \I32X4.\REPLACELANE~laneidx \\ &&|&
+     \text{i64x2.extract\_lane}~~laneidx{:}\Tu8 &\Rightarrow& \I64X2.\EXTRACTLANE~laneidx \\ &&|&
+     \text{i64x2.replace\_lane}~~laneidx{:}\Tu8 &\Rightarrow& \I64X2.\REPLACELANE~laneidx \\ &&|&
+     \text{f32x4.extract\_lane}~~laneidx{:}\Tu8 &\Rightarrow& \F32X4.\EXTRACTLANE~laneidx \\ &&|&
+     \text{f32x4.replace\_lane}~~laneidx{:}\Tu8 &\Rightarrow& \F32X4.\REPLACELANE~laneidx \\ &&|&
+     \text{f64x2.extract\_lane}~~laneidx{:}\Tu8 &\Rightarrow& \F64X2.\EXTRACTLANE~laneidx \\ &&|&
+     \text{f64x2.replace\_lane}~~laneidx{:}\Tu8 &\Rightarrow& \F64X2.\REPLACELANE~laneidx \\
+   \end{array}
+
+.. _text-virelop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i8x16.eq} &\Rightarrow& \I8X16.\VEQ\\ &&|&
+     \text{i8x16.ne} &\Rightarrow& \I8X16.\VNE\\ &&|&
+     \text{i8x16.lt\_s} &\Rightarrow& \I8X16.\VLT\K{\_s}\\ &&|&
+     \text{i8x16.lt\_u} &\Rightarrow& \I8X16.\VLT\K{\_u}\\ &&|&
+     \text{i8x16.gt\_s} &\Rightarrow& \I8X16.\VGT\K{\_s}\\ &&|&
+     \text{i8x16.gt\_u} &\Rightarrow& \I8X16.\VGT\K{\_u}\\ &&|&
+     \text{i8x16.le\_s} &\Rightarrow& \I8X16.\VLE\K{\_s}\\ &&|&
+     \text{i8x16.le\_u} &\Rightarrow& \I8X16.\VLE\K{\_u}\\ &&|&
+     \text{i8x16.ge\_s} &\Rightarrow& \I8X16.\VGE\K{\_s}\\ &&|&
+     \text{i8x16.ge\_u} &\Rightarrow& \I8X16.\VGE\K{\_u}\\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i16x8.eq} &\Rightarrow& \I16X8.\VEQ\\ &&|&
+     \text{i16x8.ne} &\Rightarrow& \I16X8.\VNE\\ &&|&
+     \text{i16x8.lt\_s} &\Rightarrow& \I16X8.\VLT\K{\_s}\\ &&|&
+     \text{i16x8.lt\_u} &\Rightarrow& \I16X8.\VLT\K{\_u}\\ &&|&
+     \text{i16x8.gt\_s} &\Rightarrow& \I16X8.\VGT\K{\_s}\\ &&|&
+     \text{i16x8.gt\_u} &\Rightarrow& \I16X8.\VGT\K{\_u}\\ &&|&
+     \text{i16x8.le\_s} &\Rightarrow& \I16X8.\VLE\K{\_s}\\ &&|&
+     \text{i16x8.le\_u} &\Rightarrow& \I16X8.\VLE\K{\_u}\\ &&|&
+     \text{i16x8.ge\_s} &\Rightarrow& \I16X8.\VGE\K{\_s}\\ &&|&
+     \text{i16x8.ge\_u} &\Rightarrow& \I16X8.\VGE\K{\_u}\\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i32x4.eq} &\Rightarrow& \I32X4.\VEQ\\ &&|&
+     \text{i32x4.ne} &\Rightarrow& \I32X4.\VNE\\ &&|&
+     \text{i32x4.lt\_s} &\Rightarrow& \I32X4.\VLT\K{\_s}\\ &&|&
+     \text{i32x4.lt\_u} &\Rightarrow& \I32X4.\VLT\K{\_u}\\ &&|&
+     \text{i32x4.gt\_s} &\Rightarrow& \I32X4.\VGT\K{\_s}\\ &&|&
+     \text{i32x4.gt\_u} &\Rightarrow& \I32X4.\VGT\K{\_u}\\ &&|&
+     \text{i32x4.le\_s} &\Rightarrow& \I32X4.\VLE\K{\_s}\\ &&|&
+     \text{i32x4.le\_u} &\Rightarrow& \I32X4.\VLE\K{\_u}\\ &&|&
+     \text{i32x4.ge\_s} &\Rightarrow& \I32X4.\VGE\K{\_s}\\ &&|&
+     \text{i32x4.ge\_u} &\Rightarrow& \I32X4.\VGE\K{\_u}\\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i64x2.eq} &\Rightarrow& \I64X2.\VEQ\\ &&|&
+     \text{i64x2.ne} &\Rightarrow& \I64X2.\VNE\\ &&|&
+     \text{i64x2.lt\_s} &\Rightarrow& \I64X2.\VLT\K{\_s}\\ &&|&
+     \text{i64x2.gt\_s} &\Rightarrow& \I64X2.\VGT\K{\_s}\\ &&|&
+     \text{i64x2.le\_s} &\Rightarrow& \I64X2.\VLE\K{\_s}\\ &&|&
+     \text{i64x2.ge\_s} &\Rightarrow& \I64X2.\VGE\K{\_s}\\ &&|&
+   \end{array}
+
+.. _text-vfrelop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{f32x4.eq} &\Rightarrow& \F32X4.\VEQ\\ &&|&
+     \text{f32x4.ne} &\Rightarrow& \F32X4.\VNE\\ &&|&
+     \text{f32x4.lt} &\Rightarrow& \F32X4.\VLT\\ &&|&
+     \text{f32x4.gt} &\Rightarrow& \F32X4.\VGT\\ &&|&
+     \text{f32x4.le} &\Rightarrow& \F32X4.\VLE\\ &&|&
+     \text{f32x4.ge} &\Rightarrow& \F32X4.\VGE\\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{f64x2.eq} &\Rightarrow& \F64X2.\VEQ\\ &&|&
+     \text{f64x2.ne} &\Rightarrow& \F64X2.\VNE\\ &&|&
+     \text{f64x2.lt} &\Rightarrow& \F64X2.\VLT\\ &&|&
+     \text{f64x2.gt} &\Rightarrow& \F64X2.\VGT\\ &&|&
+     \text{f64x2.le} &\Rightarrow& \F64X2.\VLE\\ &&|&
+     \text{f64x2.ge} &\Rightarrow& \F64X2.\VGE\\
+   \end{array}
+
+.. _text-vvunop:
+.. _text-vvbinop:
+.. _text-vvternop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{v128.not} &\Rightarrow& \V128.\VNOT\\ &&|&
+     \text{v128.and} &\Rightarrow& \V128.\VAND\\ &&|&
+     \text{v128.andnot} &\Rightarrow& \V128.\VANDNOT\\ &&|&
+     \text{v128.or} &\Rightarrow& \V128.\VOR\\ &&|&
+     \text{v128.xor} &\Rightarrow& \V128.\VXOR\\ &&|&
+     \text{v128.bitselect} &\Rightarrow& \V128.\BITSELECT\\ &&|&
+     \text{v128.any\_true} &\Rightarrow& \V128.\ANYTRUE
+   \end{array}
+
+.. _text-vitestop:
+.. _text-vishiftop:
+.. _text-viunop:
+.. _text-vibinop:
+.. _text-viminmaxop:
+.. _text-visatbinop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i8x16.abs} &\Rightarrow& \I8X16.\VABS\\ &&|&
+     \text{i8x16.neg} &\Rightarrow& \I8X16.\VNEG\\ &&|&
+     \text{i8x16.all\_true} &\Rightarrow& \I8X16.\ALLTRUE\\ &&|&
+     \text{i8x16.bitmask} &\Rightarrow& \I8X16.\BITMASK\\ &&|&
+     \text{i8x16.narrow\_i16x8\_s} &\Rightarrow& \I8X16.\NARROW\K{\_i16x8\_s}\\ &&|&
+     \text{i8x16.narrow\_i16x8\_u} &\Rightarrow& \I8X16.\NARROW\K{\_i16x8\_u}\\ &&|&
+     \text{i8x16.shl} &\Rightarrow& \I8X16.\VSHL\\ &&|&
+     \text{i8x16.shr\_s} &\Rightarrow& \I8X16.\VSHR\K{\_s}\\ &&|&
+     \text{i8x16.shr\_u} &\Rightarrow& \I8X16.\VSHR\K{\_u}\\ &&|&
+     \text{i8x16.add} &\Rightarrow& \I8X16.\VADD\\ &&|&
+     \text{i8x16.add\_sat\_s} &\Rightarrow& \I8X16.\VADD\K{\_sat\_s}\\ &&|&
+     \text{i8x16.add\_sat\_u} &\Rightarrow& \I8X16.\VADD\K{\_sat\_u}\\ &&|&
+     \text{i8x16.sub} &\Rightarrow& \I8X16.\VSUB\\ &&|&
+     \text{i8x16.sub\_sat\_s} &\Rightarrow& \I8X16.\VSUB\K{\_sat\_s}\\ &&|&
+     \text{i8x16.sub\_sat\_u} &\Rightarrow& \I8X16.\VSUB\K{\_sat\_u}\\ &&|&
+     \text{i8x16.min\_s} &\Rightarrow& \I8X16.\VMIN\K{\_s}\\ &&|&
+     \text{i8x16.min\_u} &\Rightarrow& \I8X16.\VMIN\K{\_u}\\ &&|&
+     \text{i8x16.max\_s} &\Rightarrow& \I8X16.\VMAX\K{\_s}\\ &&|&
+     \text{i8x16.max\_u} &\Rightarrow& \I8X16.\VMAX\K{\_u}\\ &&|&
+     \text{i8x16.avgr\_u} &\Rightarrow& \I8X16.\AVGR\K{\_u}\\ &&|&
+     \text{i8x16.popcnt} &\Rightarrow& \I8X16.\VPOPCNT\\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i16x8.abs} &\Rightarrow& \I16X8.\VABS\\ &&|&
+     \text{i16x8.neg} &\Rightarrow& \I16X8.\VNEG\\ &&|&
+     \text{i16x8.all\_true} &\Rightarrow& \I16X8.\ALLTRUE\\ &&|&
+     \text{i16x8.bitmask} &\Rightarrow& \I16X8.\BITMASK\\ &&|&
+     \text{i16x8.narrow\_i32x4\_s} &\Rightarrow& \I16X8.\NARROW\K{\_i32x4\_s}\\ &&|&
+     \text{i16x8.narrow\_i32x4\_u} &\Rightarrow& \I16X8.\NARROW\K{\_i32x4\_u}\\ &&|&
+     \text{i16x8.extend\_low\_i8x16\_s} &\Rightarrow& \I16X8.\VEXTEND\K{\_low\_i8x16\_s}\\ &&|&
+     \text{i16x8.extend\_high\_i8x16\_s} &\Rightarrow& \I16X8.\VEXTEND\K{\_high\_i8x16\_s}\\ &&|&
+     \text{i16x8.extend\_low\_i8x16\_u} &\Rightarrow& \I16X8.\VEXTEND\K{\_low\_i8x16\_u}\\ &&|&
+     \text{i16x8.extend\_high\_i8x16\_u} &\Rightarrow& \I16X8.\VEXTEND\K{\_high\_i8x16\_u}\\ &&|&
+     \text{i16x8.shl} &\Rightarrow& \I16X8.\VSHL\\ &&|&
+     \text{i16x8.shr\_s} &\Rightarrow& \I16X8.\VSHR\K{\_s}\\ &&|&
+     \text{i16x8.shr\_u} &\Rightarrow& \I16X8.\VSHR\K{\_u}\\ &&|&
+     \text{i16x8.add} &\Rightarrow& \I16X8.\VADD\\ &&|&
+     \text{i16x8.add\_sat\_s} &\Rightarrow& \I16X8.\VADD\K{\_sat\_s}\\ &&|&
+     \text{i16x8.add\_sat\_u} &\Rightarrow& \I16X8.\VADD\K{\_sat\_u}\\ &&|&
+     \text{i16x8.sub} &\Rightarrow& \I16X8.\VSUB\\ &&|&
+     \text{i16x8.sub\_sat\_s} &\Rightarrow& \I16X8.\VSUB\K{\_sat\_s}\\ &&|&
+     \text{i16x8.sub\_sat\_u} &\Rightarrow& \I16X8.\VSUB\K{\_sat\_u}\\ &&|&
+     \text{i16x8.mul} &\Rightarrow& \I16X8.\VMUL\\ &&|&
+     \text{i16x8.min\_s} &\Rightarrow& \I16X8.\VMIN\K{\_s}\\ &&|&
+     \text{i16x8.min\_u} &\Rightarrow& \I16X8.\VMIN\K{\_u}\\ &&|&
+     \text{i16x8.max\_s} &\Rightarrow& \I16X8.\VMAX\K{\_s}\\ &&|&
+     \text{i16x8.max\_u} &\Rightarrow& \I16X8.\VMAX\K{\_u}\\ &&|&
+     \text{i16x8.avgr\_u} &\Rightarrow& \I16X8.\AVGR\K{\_u}\\ &&|&
+     \text{i16x8.q15mulr\_sat\_s} &\Rightarrow& \I16X8.\Q15MULRSAT\K{\_s}\\ &&|&
+     \text{i16x8.extmul\_low\_i8x16\_s} &\Rightarrow& \I16X8.\EXTMUL\K{\_low\_i8x16\_s}\\ &&|&
+     \text{i16x8.extmul\_high\_i8x16\_s} &\Rightarrow& \I16X8.\EXTMUL\K{\_high\_i8x16\_s}\\ &&|&
+     \text{i16x8.extmul\_low\_i8x16\_u} &\Rightarrow& \I16X8.\EXTMUL\K{\_low\_i8x16\_u}\\ &&|&
+     \text{i16x8.extmul\_high\_i8x16\_u} &\Rightarrow& \I16X8.\EXTMUL\K{\_high\_i8x16\_u}\\ &&|&
+     \text{i16x8.extadd\_pairwise\_i8x16\_s} &\Rightarrow& \I16X8.\EXTADDPAIRWISE\K{\_i8x16\_s}\\ &&|&
+     \text{i16x8.extadd\_pairwise\_i8x16\_u} &\Rightarrow& \I16X8.\EXTADDPAIRWISE\K{\_i8x16\_u}\\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i32x4.abs} &\Rightarrow& \I32X4.\VABS\\ &&|&
+     \text{i32x4.neg} &\Rightarrow& \I32X4.\VNEG\\ &&|&
+     \text{i32x4.all\_true} &\Rightarrow& \I32X4.\ALLTRUE\\ &&|&
+     \text{i32x4.bitmask} &\Rightarrow& \I32X4.\BITMASK\\ &&|&
+     \text{i32x4.extadd\_pairwise\_i16x8\_s} &\Rightarrow& \I32X4.\EXTADDPAIRWISE\K{\_i16x8\_s}\\ &&|&
+     \text{i32x4.extend\_low\_i16x8\_s} &\Rightarrow& \I32X4.\VEXTEND\K{\_low\_i16x8\_s}\\ &&|&
+     \text{i32x4.extend\_high\_i16x8\_s} &\Rightarrow& \I32X4.\VEXTEND\K{\_high\_i16x8\_s}\\ &&|&
+     \text{i32x4.extend\_low\_i16x8\_u} &\Rightarrow& \I32X4.\VEXTEND\K{\_low\_i16x8\_u}\\ &&|&
+     \text{i32x4.extend\_high\_i16x8\_u} &\Rightarrow& \I32X4.\VEXTEND\K{\_high\_i16x8\_u}\\ &&|&
+     \text{i32x4.shl} &\Rightarrow& \I32X4.\VSHL\\ &&|&
+     \text{i32x4.shr\_s} &\Rightarrow& \I32X4.\VSHR\K{\_s}\\ &&|&
+     \text{i32x4.shr\_u} &\Rightarrow& \I32X4.\VSHR\K{\_u}\\ &&|&
+     \text{i32x4.add} &\Rightarrow& \I32X4.\VADD\\ &&|&
+     \text{i32x4.sub} &\Rightarrow& \I32X4.\VSUB\\ &&|&
+     \text{i32x4.mul} &\Rightarrow& \I32X4.\VMUL\\ &&|&
+     \text{i32x4.min\_s} &\Rightarrow& \I32X4.\VMIN\K{\_s}\\ &&|&
+     \text{i32x4.min\_u} &\Rightarrow& \I32X4.\VMIN\K{\_u}\\ &&|&
+     \text{i32x4.max\_s} &\Rightarrow& \I32X4.\VMAX\K{\_s}\\ &&|&
+     \text{i32x4.max\_u} &\Rightarrow& \I32X4.\VMAX\K{\_u}\\ &&|&
+     \text{i32x4.dot\_i16x8\_s} &\Rightarrow& \I32X4.\DOT\K{\_i16x8\_s}\\ &&|&
+     \text{i32x4.extmul\_low\_i16x8\_s} &\Rightarrow& \I32X4.\EXTMUL\K{\_low\_i16x8\_s}\\ &&|&
+     \text{i32x4.extmul\_high\_i16x8\_s} &\Rightarrow& \I32X4.\EXTMUL\K{\_high\_i16x8\_s}\\ &&|&
+     \text{i32x4.extmul\_low\_i16x8\_u} &\Rightarrow& \I32X4.\EXTMUL\K{\_low\_i16x8\_u}\\ &&|&
+     \text{i32x4.extmul\_high\_i16x8\_u} &\Rightarrow& \I32X4.\EXTMUL\K{\_high\_i16x8\_u}\\
+  \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i64x2.abs} &\Rightarrow& \I64X2.\VABS\\ &&|&
+     \text{i64x2.neg} &\Rightarrow& \I64X2.\VNEG\\ &&|&
+     \text{i64x2.all\_true} &\Rightarrow& \I64X2.\ALLTRUE\\ &&|&
+     \text{i64x2.bitmask} &\Rightarrow& \I64X2.\BITMASK\\ &&|&
+     \text{i64x2.extend\_low\_i32x4\_s} &\Rightarrow& \I64X2.\VEXTEND\K{\_low\_i32x4\_s} \\ &&|&
+     \text{i64x2.extend\_high\_i32x4\_s} &\Rightarrow& \I64X2.\VEXTEND\K{\_high\_i32x4\_s} \\ &&|&
+     \text{i64x2.extend\_low\_i32x4\_u} &\Rightarrow& \I64X2.\VEXTEND\K{\_low\_i32x4\_u} \\ &&|&
+     \text{i64x2.extend\_high\_i32x4\_u} &\Rightarrow& \I64X2.\VEXTEND\K{\_high\_i32x4\_u} \\ &&|&
+     \text{i64x2.shl} &\Rightarrow& \I64X2.\VSHL\\ &&|&
+     \text{i64x2.shr\_s} &\Rightarrow& \I64X2.\VSHR\K{\_s}\\ &&|&
+     \text{i64x2.shr\_u} &\Rightarrow& \I64X2.\VSHR\K{\_u}\\ &&|&
+     \text{i64x2.add} &\Rightarrow& \I64X2.\VADD\\ &&|&
+     \text{i64x2.sub} &\Rightarrow& \I64X2.\VSUB\\ &&|&
+     \text{i64x2.mul} &\Rightarrow& \I64X2.\VMUL\\ &&|&
+     \text{i64x2.extmul\_low\_i32x4\_s} &\Rightarrow& \I64X2.\EXTMUL\K{\_low\_i32x4\_s}\\ &&|&
+     \text{i64x2.extmul\_high\_i32x4\_s} &\Rightarrow& \I64X2.\EXTMUL\K{\_high\_i32x4\_s}\\ &&|&
+     \text{i64x2.extmul\_low\_i32x4\_u} &\Rightarrow& \I64X2.\EXTMUL\K{\_low\_i32x4\_u}\\ &&|&
+     \text{i64x2.extmul\_high\_i32x4\_u} &\Rightarrow& \I64X2.\EXTMUL\K{\_high\_i32x4\_u}\\
+  \end{array}
+
+.. _text-vfunop:
+.. _text-vfbinop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{f32x4.abs} &\Rightarrow& \F32X4.\VABS\\ &&|&
+     \text{f32x4.neg} &\Rightarrow& \F32X4.\VNEG\\ &&|&
+     \text{f32x4.sqrt} &\Rightarrow& \F32X4.\VSQRT\\ &&|&
+     \text{f32x4.add} &\Rightarrow& \F32X4.\VADD\\ &&|&
+     \text{f32x4.sub} &\Rightarrow& \F32X4.\VSUB\\ &&|&
+     \text{f32x4.mul} &\Rightarrow& \F32X4.\VMUL\\ &&|&
+     \text{f32x4.div} &\Rightarrow& \F32X4.\VDIV\\ &&|&
+     \text{f32x4.min} &\Rightarrow& \F32X4.\VMIN\\ &&|&
+     \text{f32x4.max} &\Rightarrow& \F32X4.\VMAX\\ &&|&
+     \text{f32x4.pmin} &\Rightarrow& \F32X4.\VPMIN\\ &&|&
+     \text{f32x4.pmax} &\Rightarrow& \F32X4.\VPMAX\\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{f64x2.abs} &\Rightarrow& \F64X2.\VABS\\ &&|&
+     \text{f64x2.neg} &\Rightarrow& \F64X2.\VNEG\\ &&|&
+     \text{f64x2.sqrt} &\Rightarrow& \F64X2.\VSQRT\\ &&|&
+     \text{f64x2.add} &\Rightarrow& \F64X2.\VADD\\ &&|&
+     \text{f64x2.sub} &\Rightarrow& \F64X2.\VSUB\\ &&|&
+     \text{f64x2.mul} &\Rightarrow& \F64X2.\VMUL\\ &&|&
+     \text{f64x2.div} &\Rightarrow& \F64X2.\VDIV\\ &&|&
+     \text{f64x2.min} &\Rightarrow& \F64X2.\VMIN\\ &&|&
+     \text{f64x2.max} &\Rightarrow& \F64X2.\VMAX\\ &&|&
+     \text{f64x2.pmin} &\Rightarrow& \F64X2.\VPMIN\\ &&|&
+     \text{f64x2.pmax} &\Rightarrow& \F64X2.\VPMAX\\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i32x4.trunc\_sat\_f32x4\_s} &\Rightarrow& \I32X4.\VTRUNC\K{\_sat\_f32x4\_s}\\ &&|&
+     \text{i32x4.trunc\_sat\_f32x4\_u} &\Rightarrow& \I32X4.\VTRUNC\K{\_sat\_f32x4\_u}\\ &&|&
+     \text{i32x4.trunc\_sat\_f64x2\_s\_zero} &\Rightarrow& \I32X4.\VTRUNC\K{\_sat\_f64x2\_s\_zero}\\ &&|&
+     \text{i32x4.trunc\_sat\_f64x2\_u\_zero} &\Rightarrow& \I32X4.\VTRUNC\K{\_sat\_f64x2\_u\_zero}\\ &&|&
+     \text{f32x4.convert\_i32x4\_s} &\Rightarrow& \F32X4.\CONVERT\K{\_i32x4\_s}\\ &&|&
+     \text{f32x4.convert\_i32x4\_u} &\Rightarrow& \F32X4.\CONVERT\K{\_i32x4\_u}\\ &&|&
+     \text{f64x2.convert\_low\_i32x4\_s} &\Rightarrow& \F64X2.\VCONVERT\K{\_low\_i32x4\_s}\\  &&|&
+     \text{f64x2.convert\_low\_i32x4\_u} &\Rightarrow& \F64X2.\VCONVERT\K{\_low\_i32x4\_u}\\ &&|&
+     \text{f32x4.demote\_f64x2\_zero} &\Rightarrow& \F32X4.\VDEMOTE\K{\_f64x2\_zero}\\ &&|&
+     \text{f64x2.promote\_low\_f32x4} &\Rightarrow& \F64X2.\VPROMOTE\K{\_low\_f32x4}\\ &&|&
+   \end{array}
+
+
 .. index:: ! folded instruction, S-expression
 .. _text-foldedinstr:
 
diff --git a/document/core/text/types.rst b/document/core/text/types.rst
index 6d4ee3758..5e63b7c9c 100644
--- a/document/core/text/types.rst
+++ b/document/core/text/types.rst
@@ -22,6 +22,20 @@ Number Types
    \end{array}
 
 
+.. index:: vector type
+   pair: text format; vector type
+.. _text-vectype:
+
+Vector Types
+~~~~~~~~~~~~
+
+.. math::
+   \begin{array}{llcll@{\qquad\qquad}l}
+   \production{vector type} & \Tvectype &::=&
+     \text{v128} &\Rightarrow& \V128 \\
+   \end{array}
+
+
 .. index:: reference type
    pair: text format; reference type
 .. _text-reftype:
@@ -41,7 +55,7 @@ Reference Types
    \end{array}
 
 
-.. index:: value type, number type, reference type
+.. index:: value type, number type, vector type, reference type
    pair: text format; value type
 .. _text-valtype:
 
@@ -52,6 +66,7 @@ Value Types
    \begin{array}{llcll@{\qquad\qquad}l}
    \production{value type} & \Tvaltype &::=&
      t{:}\Tnumtype &\Rightarrow& t \\ &&|&
+     t{:}\Tvectype &\Rightarrow& t \\ &&|&
      t{:}\Treftype &\Rightarrow& t \\
    \end{array}
 
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index cd1bf31d6..d66a8d6fe 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -129,6 +129,7 @@
 .. |sX#1| mathdef:: {\X{s#1}}
 .. |iX#1| mathdef:: {\X{i#1}}
 .. |fX#1| mathdef:: {\X{f#1}}
+.. |vX#1| mathdef:: {\X{v#1}}
 
 .. |uN| mathdef:: \xref{syntax/values}{syntax-int}{\X{u}N}
 .. |uM| mathdef:: \xref{syntax/values}{syntax-int}{\X{u}M}
@@ -144,11 +145,13 @@
 .. |s32| mathdef:: \xref{syntax/values}{syntax-int}{\X{s32}}
 .. |s64| mathdef:: \xref{syntax/values}{syntax-int}{\X{s64}}
 
+.. |iM| mathdef:: \xref{syntax/values}{syntax-int}{\X{i}M}
 .. |iN| mathdef:: \xref{syntax/values}{syntax-int}{\X{i}N}
 .. |i8| mathdef:: \xref{syntax/values}{syntax-int}{\X{i8}}
 .. |i16| mathdef:: \xref{syntax/values}{syntax-int}{\X{i16}}
 .. |i32| mathdef:: \xref{syntax/values}{syntax-int}{\X{i32}}
 .. |i64| mathdef:: \xref{syntax/values}{syntax-int}{\X{i64}}
+.. |i128| mathdef:: \xref{syntax/values}{syntax-int}{\X{i128}}
 
 .. |fN| mathdef:: \xref{syntax/values}{syntax-float}{\X{f}N}
 .. |fNmag| mathdef:: \xref{syntax/values}{syntax-float}{\X{f}\X{Nmag}}
@@ -176,6 +179,14 @@
 .. |I64| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{i64}}
 .. |F32| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{f32}}
 .. |F64| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{f64}}
+.. |V128| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{v128}}
+.. |I8X16| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{i8x16}}
+.. |I16X8| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{i16x8}}
+.. |I32X4| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{i32x4}}
+.. |I64X2| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{i64x2}}
+.. |F32X4| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{f32x4}}
+.. |F64X2| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{f64x2}}
+.. |I128| mathdef:: \K{i128}
 
 .. |FUNCREF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{funcref}}
 .. |EXTERNREF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{externref}}
@@ -195,6 +206,7 @@
 .. Types, non-terminals
 
 .. |numtype| mathdef:: \xref{syntax/types}{syntax-numtype}{\X{numtype}}
+.. |vectype| mathdef:: \xref{syntax/types}{syntax-vectype}{\X{vectype}}
 .. |reftype| mathdef:: \xref{syntax/types}{syntax-reftype}{\X{reftype}}
 .. |valtype| mathdef:: \xref{syntax/types}{syntax-valtype}{\X{valtype}}
 .. |resulttype| mathdef:: \xref{syntax/types}{syntax-resulttype}{\X{resulttype}}
@@ -423,6 +435,56 @@
 .. |DEMOTE| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{demote}}
 .. |REINTERPRET| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{reinterpret}}
 
+.. |VCONST| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{const}}
+.. |SHUFFLE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{shuffle}}
+.. |SWIZZLE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{swizzle}}
+.. |SPLAT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{splat}}
+.. |EXTRACTLANE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{extract\_lane}}
+.. |REPLACELANE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{replace\_lane}}
+.. |VNOT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{not}}
+.. |VAND| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{and}}
+.. |VANDNOT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{andnot}}
+.. |VOR| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{or}}
+.. |VXOR| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{xor}}
+.. |BITSELECT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{bitselect}}
+.. |VEQ| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{eq}}
+.. |VNE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{ne}}
+.. |VLT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{lt}}
+.. |VGT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{gt}}
+.. |VLE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{le}}
+.. |VGE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{ge}}
+.. |VABS| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{abs}}
+.. |VNEG| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{neg}}
+.. |VCEIL| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{ceil}}
+.. |VFLOOR| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{floor}}
+.. |VTRUNC| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{trunc}}
+.. |VNEAREST| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{nearest}}
+.. |VPOPCNT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{popcnt}}
+.. |ANYTRUE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{any\_true}}
+.. |ALLTRUE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{all\_true}}
+.. |BITMASK| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{bitmask}}
+.. |VSHL| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{shl}}
+.. |VSHR| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{shr}}
+.. |VSQRT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{sqrt}}
+.. |VADD| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{add}}
+.. |VSUB| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{sub}}
+.. |VMUL| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{mul}}
+.. |VDIV| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{div}}
+.. |VMIN| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{min}}
+.. |VMAX| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{max}}
+.. |VPMIN| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{pmin}}
+.. |VPMAX| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{pmax}}
+.. |NARROW| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{narrow}}
+.. |VEXTEND| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{extend}}
+.. |AVGR| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{avgr}}
+.. |DOT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{dot}}
+.. |EXTMUL| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{extmul}}
+.. |VCONVERT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{convert}}
+.. |Q15MULRSAT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{q15mulr\_sat}}
+.. |EXTADDPAIRWISE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{extadd\_pairwise}}
+.. |VDEMOTE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{demote}}
+.. |VPROMOTE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{promote}}
+
 
 .. Instructions, non-terminals
 
@@ -442,7 +504,36 @@
 .. |ftestop| mathdef:: \xref{syntax/instructions}{syntax-ftestop}{\X{ftestop}}
 .. |frelop| mathdef:: \xref{syntax/instructions}{syntax-frelop}{\X{frelop}}
 
+.. |ishape| mathdef:: \xref{syntax/instructions}{syntax-shape}{\X{ishape}}
+.. |fshape| mathdef:: \xref{syntax/instructions}{syntax-shape}{\X{fshape}}
+.. |shape| mathdef:: \xref{syntax/instructions}{syntax-shape}{\X{shape}}
+
+.. |vunop| mathdef:: \xref{syntax/instructions}{syntax-vunop}{\X{vunop}}
+.. |vbinop| mathdef:: \xref{syntax/instructions}{syntax-vbinop}{\X{vbinop}}
+.. |vrelop| mathdef:: \xref{syntax/instructions}{syntax-vrelop}{\X{vrelop}}
+.. |vternop| mathdef:: \xref{syntax/instructions}{syntax-vternop}{\X{vternop}}
+.. |vcvtop| mathdef:: \xref{syntax/instructions}{syntax-vcvtop}{\X{vcvtop}}
+.. |vextmul| mathdef:: \xref{syntax/instructions}{syntax-vextmul}{\X{vextmul}}
+
+.. |laneidx| mathdef:: \xref{syntax/instructions}{syntax-laneidx}{\X{laneidx}}
+.. |vvunop| mathdef:: \xref{syntax/instructions}{syntax-vvunop}{\X{vvunop}}
+.. |vvbinop| mathdef:: \xref{syntax/instructions}{syntax-vvbinop}{\X{vvbinop}}
+.. |vvternop| mathdef:: \xref{syntax/instructions}{syntax-vvternop}{\X{vvternop}}
+.. |vvtestop| mathdef:: \xref{syntax/instructions}{syntax-vvtestop}{\X{vvtestop}}
+.. |vishiftop| mathdef:: \xref{syntax/instructions}{syntax-vishiftop}{\X{vishiftop}}
+.. |viunop| mathdef:: \xref{syntax/instructions}{syntax-viunop}{\X{viunop}}
+.. |vibinop| mathdef:: \xref{syntax/instructions}{syntax-vibinop}{\X{vibinop}}
+.. |viminmaxop| mathdef:: \xref{syntax/instructions}{syntax-viminmaxop}{\X{viminmaxop}}
+.. |visatbinop| mathdef:: \xref{syntax/instructions}{syntax-visatbinop}{\X{visatbinop}}
+.. |vfunop| mathdef:: \xref{syntax/instructions}{syntax-vfunop}{\X{vfunop}}
+.. |vfbinop| mathdef:: \xref{syntax/instructions}{syntax-vfbinop}{\X{vfbinop}}
+.. |virelop| mathdef:: \xref{syntax/instructions}{syntax-virelop}{\X{virelop}}
+.. |vfrelop| mathdef:: \xref{syntax/instructions}{syntax-vfrelop}{\X{vfrelop}}
+.. |vitestop| mathdef:: \xref{syntax/instructions}{syntax-vitestop}{\X{vitestop}}
+.. |vtestop| mathdef:: \xref{syntax/instructions}{syntax-vtestop}{\X{vtestop}}
+
 .. |sx| mathdef:: \xref{syntax/instructions}{syntax-sx}{\X{sx}}
+.. |half| mathdef:: \xref{syntax/instructions}{syntax-half}{\X{half}}
 .. |memarg| mathdef:: \xref{syntax/instructions}{syntax-memarg}{\X{memarg}}
 
 .. |blocktype| mathdef:: \xref{syntax/instructions}{syntax-blocktype}{\X{blocktype}}
@@ -501,6 +592,7 @@
 .. Types, non-terminals
 
 .. |Bnumtype| mathdef:: \xref{binary/types}{binary-numtype}{\B{numtype}}
+.. |Bvectype| mathdef:: \xref{binary/types}{binary-vectype}{\B{vectype}}
 .. |Breftype| mathdef:: \xref{binary/types}{binary-reftype}{\B{reftype}}
 .. |Bvaltype| mathdef:: \xref{binary/types}{binary-valtype}{\B{valtype}}
 .. |Bresulttype| mathdef:: \xref{binary/types}{binary-resulttype}{\B{resulttype}}
@@ -574,6 +666,7 @@
 .. |Binstr| mathdef:: \xref{binary/instructions}{binary-instr}{\B{instr}}
 .. |Bexpr| mathdef:: \xref{binary/instructions}{binary-expr}{\B{expr}}
 
+.. |Blaneidx| mathdef:: \xref{binary/instructions}{binary-laneidx}{\B{laneidx}}
 
 
 .. Text Format
@@ -642,6 +735,8 @@
 .. |Ts64| mathdef:: \xref{text/values}{text-int}{\TsX{\T{64}}}
 
 .. |TiN| mathdef:: \xref{text/values}{text-int}{\TiX{N}}
+.. |Ti8| mathdef:: \xref{text/values}{text-int}{\TiX{\T{8}}}
+.. |Ti16| mathdef:: \xref{text/values}{text-int}{\TiX{\T{16}}}
 .. |Ti32| mathdef:: \xref{text/values}{text-int}{\TiX{\T{32}}}
 .. |Ti64| mathdef:: \xref{text/values}{text-int}{\TiX{\T{64}}}
 
@@ -662,6 +757,7 @@
 .. Types, non-terminals
 
 .. |Tnumtype| mathdef:: \xref{text/types}{text-numtype}{\T{numtype}}
+.. |Tvectype| mathdef:: \xref{text/types}{text-vectype}{\T{vectype}}
 .. |Treftype| mathdef:: \xref{text/types}{text-reftype}{\T{reftype}}
 .. |Theaptype| mathdef:: \xref{text/types}{text-heaptype}{\T{heaptype}}
 .. |Tvaltype| mathdef:: \xref{text/types}{text-valtype}{\T{valtype}}
@@ -822,6 +918,9 @@
 .. |vdashimportdesc| mathdef:: \xref{valid/modules}{valid-importdesc}{\vdash}
 .. |vdashmodule| mathdef:: \xref{valid/modules}{valid-module}{\vdash}
 
+.. |unpacked| mathdef:: \xref{valid/instructions}{aux-unpacked}{\F{unpacked}}
+.. |dim| mathdef:: \xref{valid/instructions}{aux-dim}{\F{dim}}
+
 
 .. Execution
 .. ---------
@@ -968,6 +1067,7 @@
 .. Values & Results, non-terminals
 
 .. |num| mathdef:: \xref{exec/runtime}{syntax-num}{\X{num}}
+.. |vecc| mathdef:: \xref{exec/runtime}{syntax-vec}{\X{vec}}
 .. |reff| mathdef:: \xref{exec/runtime}{syntax-ref}{\X{ref}}
 .. |val| mathdef:: \xref{exec/runtime}{syntax-val}{\X{val}}
 .. |result| mathdef:: \xref{exec/runtime}{syntax-result}{\X{result}}
@@ -998,7 +1098,9 @@
 .. |idivs| mathdef:: \xref{exec/numerics}{op-idiv_s}{\F{idiv\_s}}
 .. |iremu| mathdef:: \xref{exec/numerics}{op-irem_u}{\F{irem\_u}}
 .. |irems| mathdef:: \xref{exec/numerics}{op-irem_s}{\F{irem\_s}}
+.. |inot| mathdef:: \xref{exec/numerics}{op-inot}{\F{inot}}
 .. |iand| mathdef:: \xref{exec/numerics}{op-iand}{\F{iand}}
+.. |iandnot| mathdef:: \xref{exec/numerics}{op-iandnot}{\F{iandnot}}
 .. |ior| mathdef:: \xref{exec/numerics}{op-ior}{\F{ior}}
 .. |ixor| mathdef:: \xref{exec/numerics}{op-ixor}{\F{ixor}}
 .. |ishl| mathdef:: \xref{exec/numerics}{op-ishl}{\F{ishl}}
@@ -1021,6 +1123,19 @@
 .. |igeu| mathdef:: \xref{exec/numerics}{op-ige_u}{\F{ige\_u}}
 .. |iges| mathdef:: \xref{exec/numerics}{op-ige_s}{\F{ige\_s}}
 .. |iextendMs| mathdef:: \xref{exec/numerics}{op-iextendn_s}{\F{iextend}M\F{\_s}}
+.. |ibitselect| mathdef:: \xref{exec/numerics}{op-ibitselect}{\F{ibitselect}}
+.. |iabs| mathdef:: \xref{exec/numerics}{op-iabs}{\F{iabs}}
+.. |ineg| mathdef:: \xref{exec/numerics}{op-ineg}{\F{ineg}}
+.. |iminu| mathdef:: \xref{exec/numerics}{op-imin_u}{\F{imin\_u}}
+.. |imins| mathdef:: \xref{exec/numerics}{op-imin_s}{\F{imin\_s}}
+.. |imaxu| mathdef:: \xref{exec/numerics}{op-imax_u}{\F{imax\_u}}
+.. |imaxs| mathdef:: \xref{exec/numerics}{op-imax_s}{\F{imax\_s}}
+.. |iaddsatu| mathdef:: \xref{exec/numerics}{op-iaddsat_u}{\F{iaddsat\_u}}
+.. |iaddsats| mathdef:: \xref{exec/numerics}{op-iaddsat_s}{\F{iaddsat\_s}}
+.. |isubsatu| mathdef:: \xref{exec/numerics}{op-isubsat_u}{\F{isubsat\_u}}
+.. |isubsats| mathdef:: \xref{exec/numerics}{op-isubsat_s}{\F{isubsat\_s}}
+.. |iavgru| mathdef:: \xref{exec/numerics}{op-iavgr_u}{\F{iavgr\_u}}
+.. |iq15mulrsats| mathdef:: \xref{exec/numerics}{op-iq15mulrsat_s}{\F{iq15mulrsat\_s}}
 
 .. |fadd| mathdef:: \xref{exec/numerics}{op-fadd}{\F{fadd}}
 .. |fsub| mathdef:: \xref{exec/numerics}{op-fsub}{\F{fsub}}
@@ -1042,6 +1157,8 @@
 .. |fgt| mathdef:: \xref{exec/numerics}{op-fgt}{\F{fgt}}
 .. |fle| mathdef:: \xref{exec/numerics}{op-fle}{\F{fle}}
 .. |fge| mathdef:: \xref{exec/numerics}{op-fge}{\F{fge}}
+.. |fpmin| mathdef:: \xref{exec/numerics}{op-fpmin}{\F{fpmin}}
+.. |fpmax| mathdef:: \xref{exec/numerics}{op-fpmax}{\F{fpmax}}
 
 .. |extend| mathdef:: \xref{exec/numerics}{op-extend_u}{\F{extend}}
 .. |extendu| mathdef:: \xref{exec/numerics}{op-extend_u}{\F{extend}^{\K{u}}}
@@ -1056,6 +1173,9 @@
 .. |convertu| mathdef:: \xref{exec/numerics}{op-convert_u}{\F{convert}^{\K{u}}}
 .. |converts| mathdef:: \xref{exec/numerics}{op-convert_s}{\F{convert}^{\K{s}}}
 .. |reinterpret| mathdef:: \xref{exec/numerics}{op-reinterpret}{\F{reinterpret}}
+.. |narrow| mathdef:: \xref{exec/numerics}{op-narrow_u}{\F{narrow}}
+.. |narrowu| mathdef:: \xref{exec/numerics}{op-narrow_u}{\F{narrow}^{\K{u}}}
+.. |narrows| mathdef:: \xref{exec/numerics}{op-narrow_s}{\F{narrow}^{\K{s}}}
 
 
 .. Numerics, meta functions
@@ -1073,6 +1193,10 @@
 .. |ieee| mathdef:: \xref{exec/numerics}{aux-ieee}{\F{float}}
 .. |nans| mathdef:: \xref{exec/numerics}{aux-nans}{\F{nans}}
 .. |trunc| mathdef:: \xref{exec/numerics}{aux-trunc}{\F{trunc}}
+.. |satu| mathdef:: \xref{exec/numerics}{aux-sat_u}{\F{sat}^{\K{u}}}
+.. |sats| mathdef:: \xref{exec/numerics}{aux-sat_s}{\F{sat}^{\K{s}}}
+
+.. |lanes| mathdef:: \xref{exec/numerics}{aux-lanes}{\F{lanes}}
 
 
 .. Other meta functions
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 1e041d33c..d60df9646 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -248,6 +248,342 @@ Reference Instructions
      C \vdashinstr \REFFUNC~x : [] \to [\FUNCREF]
    }
 
+.. index:: vector instruction
+   pair: validation; instruction
+   single: abstract syntax; instruction
+
+.. _valid-instr-vec:
+.. _aux-unpacked:
+
+Vector Instructions
+~~~~~~~~~~~~~~~~~~~
+
+Vector instructions can have a prefix to describe the :ref:`shape <syntax-vec-shape>` of the operand. Packed numeric types, |I8| and |I16|, are not :ref:`value type <syntax-valtype>`, we define an auxiliary function to map such packed types into value types:
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \unpacked(\K{i8x16}) &=& \I32 \\
+   \unpacked(\K{i16x8}) &=& \I32 \\
+   \unpacked(t\K{x}N) &=& t
+   \end{array}
+
+
+We also define an auxiliary function to get number of packed numeric types in a |V128|, *dimension*:
+
+.. _aux-dim:
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \dim(t\K{x}N) &=& N
+   \end{array}
+
+
+.. _valid-vconst:
+
+:math:`\V128\K{.}\VCONST~c`
+...........................
+
+* The instruction is valid with type :math:`[] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \V128\K{.}\VCONST~c : [] \to [\V128]
+   }
+
+
+.. _valid-vvunop:
+
+:math:`\V128\K{.}\vvunop`
+.........................
+
+* The instruction is valid with type :math:`[\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \V128\K{.}\vvunop : [\V128] \to [\V128]
+   }
+
+
+.. _valid-vvbinop:
+
+:math:`\V128\K{.}\vvbinop`
+..........................
+
+* The instruction is valid with type :math:`[\V128~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \V128\K{.}\vvbinop : [\V128~\V128] \to [\V128]
+   }
+
+
+.. _valid-vvternop:
+
+:math:`\V128\K{.}\vvternop`
+...........................
+
+* The instruction is valid with type :math:`[\V128~\V128~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \V128\K{.}\vvternop : [\V128~\V128~\V128] \to [\V128]
+   }
+
+
+.. _valid-vvtestop:
+
+:math:`\V128\K{.}\vvtestop`
+...........................
+
+* The instruction is valid with type :math:`[\V128] \to [\I32]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \V128\K{.}\vvtestop : [\V128] \to [\I32]
+   }
+
+
+.. _valid-vec-swizzle:
+
+:math:`\K{i8x16.}\SWIZZLE`
+..........................
+
+* The instruction is valid with type :math:`[\V128~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \K{i8x16.}\SWIZZLE : [\V128~\V128] \to [\V128]
+   }
+
+
+.. _valid-vec-shuffle:
+
+:math:`\K{i8x16.}\SHUFFLE~\laneidx^{16}`
+........................................
+
+* For all :math:`\laneidx_i`, in :math:`\laneidx^{16}`, :math:`\laneidx_i` must be smaller than :math:`32`.
+
+* The instruction is valid with type :math:`[\V128~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+     (\laneidx < 32)^{16}
+   }{
+     C \vdashinstr \K{i8x16.}\SHUFFLE~\laneidx^{16} : [\V128~\V128] \to [\V128]
+   }
+
+
+.. _valid-vec-splat:
+
+:math:`\shape\K{.}\SPLAT`
+.........................
+
+* Let :math:`t` be :math:`\unpacked(\shape)`.
+
+* The instruction is valid with type :math:`[t] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \shape\K{.}\SPLAT : [\unpacked(\shape)] \to [\V128]
+   }
+
+
+.. _valid-vec-extract_lane:
+
+:math:`\shape\K{.}\EXTRACTLANE\K{\_}\sx^?~\laneidx`
+...................................................
+
+* The lane index :math:`\laneidx` must be smaller than :math:`\dim(\shape)`.
+
+* The instruction is valid with type :math:`[\V128] \to [\unpacked(\shape)]`.
+
+.. math::
+   \frac{
+     \laneidx < \dim(\shape)
+   }{
+     C \vdashinstr t\K{x}N\K{.}\EXTRACTLANE\K{\_}\sx^?~\laneidx : [\V128] \to [\unpacked(\shape)]
+   }
+
+
+.. _valid-vec-replace_lane:
+
+:math:`\shape\K{.}\REPLACELANE~\laneidx`
+........................................
+
+* The lane index :math:`\laneidx` must be smaller than :math:`\dim(\shape)`.
+
+* Let :math:`t` be :math:`\unpacked(\shape)`.
+
+* The instruction is valid with type :math:`[\V128~t] \to [\V128]`.
+
+.. math::
+   \frac{
+     \laneidx < \dim(\shape)
+   }{
+     C \vdashinstr \shape\K{.}\REPLACELANE~\laneidx : [\V128~\unpacked(\shape)] \to [\V128]
+   }
+
+
+.. _valid-vunop:
+
+:math:`\shape\K{.}\vunop`
+.........................
+
+* The instruction is valid with type :math:`[\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \shape\K{.}\vunop : [\V128] \to [\V128]
+   }
+
+
+.. _valid-vbinop:
+
+:math:`\shape\K{.}\vbinop`
+..........................
+
+* The instruction is valid with type :math:`[\V128~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \shape\K{.}\vbinop : [\V128~\V128] \to [\V128]
+   }
+
+
+.. _valid-vrelop:
+
+:math:`\shape\K{.}\vrelop`
+..........................
+
+* The instruction is valid with type :math:`[\V128~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \shape\K{.}\vrelop : [\V128~\V128] \to [\V128]
+   }
+
+
+.. _valid-vishiftop:
+
+:math:`\ishape\K{.}\vishiftop`
+..............................
+
+* The instruction is valid with type :math:`[\V128~\I32] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \ishape\K{.}\vishiftop : [\V128~\I32] \to [\V128]
+   }
+
+
+.. _valid-vtestop:
+
+:math:`\shape\K{.}\vtestop`
+...........................
+
+* The instruction is valid with type :math:`[\V128] \to [\I32]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \shape\K{.}\vtestop : [\V128] \to [\I32]
+   }
+
+
+.. _valid-vcvtop:
+
+:math:`\shape\K{.}\vcvtop\K{\_}\half^?\K{\_}\shape\K{\_}\sx^?\K{\_zero}^?`
+..........................................................................
+
+* The instruction is valid with type :math:`[\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \shape\K{.}\vcvtop\K{\_}\half^?\K{\_}\shape\K{\_}\sx^?\K{\_zero}^? : [\V128] \to [\V128]
+   }
+
+
+.. _valid-vec-narrow:
+
+:math:`\ishape_1\K{.}\NARROW\K{\_}\ishape_2\K{\_}\sx`
+.....................................................
+
+* The instruction is valid with type :math:`[\V128~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \ishape_1\K{.}\NARROW\K{\_}\ishape_2\K{\_}\sx : [\V128~\V128] \to [\V128]
+   }
+
+
+.. _valid-vec-bitmask:
+
+:math:`\ishape\K{.}\BITMASK`
+............................
+
+* The instruction is valid with type :math:`[\V128] \to [\I32]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \ishape\K{.}\BITMASK : [\V128] \to [\I32]
+   }
+
+
+.. _valid-vec-dot:
+
+:math:`\ishape_1\K{.}\DOT\K{\_}\ishape_2\K{\_s}`
+................................................
+
+* The instruction is valid with type :math:`[\V128~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \ishape_1\K{.}\DOT\K{\_}\ishape_2\K{\_s} : [\V128~\V128] \to [\V128]
+   }
+
+
+.. _valid-vec-extmul:
+
+:math:`\ishape_1\K{.}\EXTMUL\K{\_}\half\K{\_}\ishape_2\K{\_}\sx`
+................................................................
+
+* The instruction is valid with type :math:`[\V128~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \ishape_1\K{.}\EXTMUL\K{\_}\half\K{\_}\ishape_2\K{\_}\sx : [\V128~\V128] \to [\V128]
+   }
+
+
+.. _valid-vec-extadd_pairwise:
+
+:math:`\ishape_1\K{.}\EXTADDPAIRWISE\K{\_}\ishape_2\K{\_}\sx`
+.............................................................
+
+* The instruction is valid with type :math:`[\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \ishape_1\K{.}\EXTADDPAIRWISE\K{\_}\ishape_2\K{\_}\sx : [\V128] \to [\V128]
+   }
+
 
 .. index:: parametric instructions, value type, polymorphism
    pair: validation; instruction
@@ -288,7 +624,7 @@ Parametric Instructions
 
 * Else:
 
-  * The instruction is valid with type :math:`[t~t~\I32] \to [t]`, for any :ref:`operand type <syntax-opdtype>` :math:`t` that :ref:`matches <match-opdtype>` some :ref:`number type <syntax-numtype>`.
+  * The instruction is valid with type :math:`[t~t~\I32] \to [t]`, for any :ref:`operand type <syntax-opdtype>` :math:`t` that :ref:`matches <match-opdtype>` some :ref:`number type <syntax-numtype>` or :ref:`vector type <syntax-vectype>`.
 
 .. math::
    \frac{
@@ -301,6 +637,12 @@ Parametric Instructions
    }{
      C \vdashinstr \SELECT : [t~t~\I32] \to [t]
    }
+   \qquad
+   \frac{
+     \vdash t \leq \vectype
+   }{
+     C \vdashinstr \SELECT : [t~t~\I32] \to [t]
+   }
 
 .. note::
    In future versions of WebAssembly, |SELECT| may allow more than one value per choice.
@@ -674,6 +1016,118 @@ Memory Instructions
    }
 
 
+.. _valid-load-extend:
+
+:math:`\K{v128.}\LOAD{N}\K{x}M\_\sx~\memarg`
+...............................................
+
+* The memory :math:`C.\CMEMS[0]` must be defined in the context.
+
+* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than :math:`N/8 \cdot M`.
+
+* Then the instruction is valid with type :math:`[\I32] \to [\V128]`.
+
+.. math::
+   \frac{
+     C.\CMEMS[0] = \memtype
+     \qquad
+     2^{\memarg.\ALIGN} \leq N/8 \cdot M
+   }{
+     C \vdashinstr \K{v128.}\K{.}\LOAD{N}\K{x}M\_\sx~\memarg : [\I32] \to [\V128]
+   }
+
+
+.. _valid-load-splat:
+
+:math:`\K{v128.}\LOAD{N}\K{\_splat}~\memarg`
+...............................................
+
+* The memory :math:`C.\CMEMS[0]` must be defined in the context.
+
+* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than :math:`N/8`.
+
+* Then the instruction is valid with type :math:`[\I32] \to [\V128]`.
+
+.. math::
+   \frac{
+     C.\CMEMS[0] = \memtype
+     \qquad
+     2^{\memarg.\ALIGN} \leq N/8
+   }{
+     C \vdashinstr \K{v128.}\LOAD{N}\K{\_splat}~\memarg : [\I32] \to [\V128]
+   }
+
+
+.. _valid-load-zero:
+
+:math:`\K{v128.}\LOAD{N}\K{\_zero}~\memarg`
+...........................................
+
+* The memory :math:`C.\CMEMS[0]` must be defined in the context.
+
+* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than :math:`N/8`.
+
+* Then the instruction is valid with type :math:`[\I32] \to [\V128]`.
+
+.. math::
+   \frac{
+     C.\CMEMS[0] = \memtype
+     \qquad
+     2^{\memarg.\ALIGN} \leq N/8
+   }{
+     C \vdashinstr \K{v128.}\LOAD{N}\K{\_zero}~\memarg : [\I32] \to [\V128]
+   }
+
+
+.. _valid-load-lane:
+
+:math:`\K{v128.}\LOAD{N}\K{\_lane}~\memarg~\laneidx`
+....................................................
+
+* The lane index :math:`\laneidx` must be smaller than :math:`128/N`.
+
+* The memory :math:`C.\CMEMS[0]` must be defined in the context.
+
+* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than :math:`N/8`.
+
+* Then the instruction is valid with type :math:`[\I32~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+     \laneidx < 128/N
+     \qquad
+     C.\CMEMS[0] = \memtype
+     \qquad
+     2^{\memarg.\ALIGN} < N/8
+   }{
+     C \vdashinstr \K{v128.}\LOAD{N}\K{\_lane}~\memarg~\laneidx : [\I32~\V128] \to [\V128]
+   }
+
+.. _valid-store-lane:
+
+:math:`\K{v128.}\STORE{N}\K{\_lane}~\memarg~\laneidx`
+.....................................................
+
+* The lane index :math:`\laneidx` must be smaller than :math:`128/N`.
+
+* The memory :math:`C.\CMEMS[0]` must be defined in the context.
+
+* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than :math:`N/8`.
+
+* Then the instruction is valid with type :math:`[\I32~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+     \laneidx < 128/N
+     \qquad
+     C.\CMEMS[0] = \memtype
+     \qquad
+     2^{\memarg.\ALIGN} < N/8
+   }{
+     C \vdashinstr \K{v128.}\STORE{N}\K{\_lane}~\memarg~\laneidx : [\I32~\V128] \to []
+   }
+
+
 .. _valid-memory.size:
 
 :math:`\MEMORYSIZE`
diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index e3184c2d8..6e3f888ca 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -109,6 +109,7 @@ urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: df
         text: i32.const
         text: f32.const
         text: f64.const
+        text: v128.const
         text: ref.null
         text: ref.func
         text: ref.extern
@@ -153,6 +154,7 @@ urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: df
         text: i64
         text: f32
         text: f64
+        text: v128
     url: syntax/types.html#syntax-reftype
         text: reftype
         text: funcref
@@ -371,6 +373,8 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
                     1. Throw a {{LinkError}} exception.
                 1. If |valtype| is not [=i64=] and [=Type=](|v|) is BigInt,
                     1. Throw a {{LinkError}} exception.
+                1. If |valtype| is [=v128=],
+                    1. Throw a {{LinkError}} exception.
                 1. Let |value| be [=ToWebAssemblyValue=](|v|, |valtype|).
                 1. Let |store| be the [=surrounding agent=]'s [=associated store=].
                 1. Let (|store|, |globaladdr|) be [=global_alloc=](|store|, [=const=] |valtype|, |value|).
@@ -838,6 +842,7 @@ enum ValueType {
   "i64",
   "f32",
   "f64",
+  "v128",
   "externref",
   "anyfunc",
 };
@@ -889,9 +894,11 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. If |s| equals "i64", return [=i64=].
     1. If |s| equals "f32", return [=f32=].
     1. If |s| equals "f64", return [=f64=].
+    1. If |s| equals "v128", return [=v128=].
     1. If |s| equals "anyfunc", return [=funcref=].
     1. If |s| equals "externref", return [=externref=].
     1. Assert: This step is not reached.
+>>>>>>> upstream/master
 </div>
 
 <div algorithm>
@@ -909,6 +916,8 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     The <dfn constructor for="Global">Global(|descriptor|, |v|)</dfn> constructor, when invoked, performs the following steps:
     1. Let |mutable| be |descriptor|["mutable"].
     1. Let |valuetype| be [=ToValueType=](|descriptor|["value"]).
+    1. If |valuetype| is [=v128=],
+        1. Throw a {{LinkError}} exception.
     1. If |v| is missing,
         1. Let |value| be [=DefaultValue=](|valuetype|).
     1. Otherwise,
@@ -924,6 +933,8 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     The algorithm <dfn>GetGlobalValue</dfn>({{Global}} |global|) performs the following steps:
     1. Let |store| be the current agent's [=associated store=].
     1. Let |globaladdr| be |global|.\[[Global]].
+    1. Let |globaltype| be [=global_type=](|store|, |globaladdr|).
+    1. If |globaltype| is of the form <var ignore>mut</var> [=v128=], throw a {{TypeError}}.
     1. Let |value| be [=global_read=](|store|, |globaladdr|).
     1. Return [=ToJSValue=](|value|).
 </div>
@@ -936,6 +947,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. Let |store| be the current agent's [=associated store=].
     1. Let |globaladdr| be **this**.\[[Global]].
     1. Let |mut| |valuetype| be [=global_type=](|store|, |globaladdr|).
+    1. If |valuetype| is [=v128=], throw a {{TypeError}}.
     1. If |mut| is [=const=], throw a {{TypeError}}.
     1. Let |value| be [=ToWebAssemblyValue=](**the given value**, |valuetype|).
     1. Let |store| be [=global_write=](|store|, |globaladdr|, |value|).
@@ -994,6 +1006,9 @@ This slot holds a [=function address=] relative to the [=surrounding agent=]'s [
     1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let |functype| be [=func_type=](|store|, |funcaddr|).
     1. Let [|parameters|] → [<var ignore>results</var>] be |functype|.
+    1. If |parameters| or |results| contain [=v128=], throw a {{TypeError}}.
+
+        Note: the above error is thrown each time the \[[Call]] method is invoked.
     1. Let |args| be « ».
     1. Let |i| be 0.
     1. [=list/iterate|For each=] |t| of |parameters|,
@@ -1022,6 +1037,7 @@ Note: Exported Functions do not have a \[[Construct]] method and thus it is not
   To <dfn>run a host function</dfn> from the JavaScript object |func|, type |functype|, and [=list=] of [=WebAssembly values=] |arguments|, perform the following steps:
 
     1. Let [<var ignore>parameters</var>] → [|results|] be |functype|.
+    1. If |parameters| or |results| contain [=v128=], throw a {{TypeError}}.
     1. Let |jsArguments| be « ».
     1. [=list/iterate|For each=] |arg| of |arguments|,
         1. [=list/Append=] ! [=ToJSValue=](|arg|) to |jsArguments|.
@@ -1065,6 +1081,7 @@ Note: Exported Functions do not have a \[[Construct]] method and thus it is not
 <div algorithm>
 The algorithm <dfn>ToJSValue</dfn>(|w|) coerces a [=WebAssembly value=] to a JavaScript value by performing the following steps:
 
+1. Assert: |w| is not of  the form [=v128.const=] <var ignore>v128</var>.
 1. If |w| is of the form [=i64.const=] |i64|,
     1. Let |v| be [=signed_64=](|i64|).
     1. Return a [=BigInt=] representing the mathematical value |v|.
@@ -1091,6 +1108,7 @@ For <dfn>retrieving an extern value</dfn> from an [=extern address=] |externaddr
 <div algorithm>
 The algorithm <dfn>ToWebAssemblyValue</dfn>(|v|, |type|) coerces a JavaScript value to a [=WebAssembly value=] by performing the following steps:
 
+1. Assert: |type| is not [=v128=].
 1. If |type| is [=i64=],
     1. Let |i64| be ? [=ToBigInt64=](|v|).
     1. Return [=i64.const=] |i64|.
diff --git a/interpreter/Makefile b/interpreter/Makefile
index 175a9493a..4ff333d17 100644
--- a/interpreter/Makefile
+++ b/interpreter/Makefile
@@ -17,7 +17,7 @@ ZIP =		$(NAME).zip
 JSLIB =		wast.js
 WINMAKE =	winmake.bat
 
-DIRS =		util syntax binary text valid runtime exec script host main
+DIRS =		util syntax binary text valid runtime exec script host main tests
 LIBS =		bigarray
 FLAGS = 	-lexflags -ml -cflags '-w +a-4-27-42-44-45 -warn-error +a-3'
 OCBA =		ocamlbuild $(FLAGS) $(DIRS:%=-I %)
@@ -27,7 +27,7 @@ JS =		# set to JS shell command to run JS tests
 
 # Main targets
 
-.PHONY:		default opt unopt libopt libunopt jslib all land zip
+.PHONY:		default opt unopt libopt libunopt jslib all land zip smallint
 
 default:	opt
 debug:		unopt
@@ -39,6 +39,7 @@ jslib:		$(JSLIB)
 all:		unopt opt libunopt libopt test
 land:		$(WINMAKE) all
 zip: 		$(ZIP)
+smallint:	smallint.native
 
 
 # Building executable
@@ -66,6 +67,12 @@ main.byte:	_tags
 main.native:	_tags
 		$(OCB) -quiet $@
 
+.PHONY:		smallint.byte smallint.native
+smallint.byte: _tags
+		$(OCB) -quiet $@
+smallint.native: _tags
+		$(OCB) -quiet $@
+
 
 # Building library
 
@@ -125,36 +132,41 @@ $(WINMAKE):	clean
 # Executing test suite
 
 TESTDIR =	../test/core
-TESTFILES =	$(shell cd $(TESTDIR); ls *.wast)
+# Skip _output directory, since that's a tmp directory, and list all other wast files.
+TESTFILES =	$(shell cd $(TESTDIR); ls *.wast; ls [a-z]*/*.wast)
 TESTS =		$(TESTFILES:%.wast=%)
 
 .PHONY:		test debugtest partest
 
-test:		$(OPT)
+test:		$(OPT) smallint
 		$(TESTDIR)/run.py --wasm `pwd`/$(OPT) $(if $(JS),--js '$(JS)',)
-debugtest:	$(UNOPT)
+		./smallint.native
+debugtest:	$(UNOPT) smallint
 		$(TESTDIR)/run.py --wasm `pwd`/$(UNOPT) $(if $(JS),--js '$(JS)',)
+		./smallint.native
 
 test/%:		$(OPT)
-		$(TESTDIR)/run.py --wasm `pwd`/$(OPT) $(if $(JS),--js '$(JS)',) $(TESTDIR)/$(@F).wast
+		$(TESTDIR)/run.py --wasm `pwd`/$(OPT) $(if $(JS),--js '$(JS)',) $(TESTDIR)/$*.wast
 debugtest/%:	$(UNOPT)
-		$(TESTDIR)/run.py --wasm `pwd`/$(UNOPT) $(if $(JS),--js '$(JS)',) $(TESTDIR)/$(@F).wast
+		$(TESTDIR)/run.py --wasm `pwd`/$(UNOPT) $(if $(JS),--js '$(JS)',) $(TESTDIR)/$*.wast
 
 run/%:		$(OPT)
-		./$(OPT) $(TESTDIR)/$(@F).wast
+		./$(OPT) $(TESTDIR)/$*.wast
 debug/%:	$(UNOPT)
-		./$(UNOPT) $(TESTDIR)/$(@F).wast
+		./$(UNOPT) $(TESTDIR)/$*.wast
 
 partest: 	$(TESTS:%=quiettest/%)
 		@echo All tests passed.
 
 quiettest/%:	$(OPT)
 		@ ( \
-		  $(TESTDIR)/run.py 2>$(@F).out --wasm `pwd`/$(OPT) $(if $(JS),--js '$(JS)',) $(@F:%=$(TESTDIR)/%.wast) && \
+		  $(TESTDIR)/run.py 2>$(@F).out --wasm `pwd`/$(OPT) $(if $(JS),--js '$(JS)',) $(TESTDIR)/$*.wast && \
 		  rm $(@F).out \
 		) || \
 		cat $(@F).out || rm $(@F).out || exit 1
 
+smallinttest:	smallint
+		@./smallint.native
 
 # Miscellaneous targets
 
diff --git a/interpreter/README.md b/interpreter/README.md
index f2ebad9aa..63900136b 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -15,7 +15,7 @@ The text format defines modules in S-expression syntax. Moreover, it is generali
 
 ## Building
 
-You'll need OCaml 4.07 or higher. Instructions for installing a recent version of OCaml on multiple platforms are available [here](https://ocaml.org/docs/install.html). On most platforms, the recommended way is through [OPAM](https://ocaml.org/docs/install.html#OPAM).
+You'll need OCaml 4.08 or higher. Instructions for installing a recent version of OCaml on multiple platforms are available [here](https://ocaml.org/docs/install.html). On most platforms, the recommended way is through [OPAM](https://ocaml.org/docs/install.html#OPAM).
 
 Once you have OCaml, simply do
 
@@ -175,26 +175,37 @@ float:  <num>.<num>?(e|E <num>)? | 0x<hexnum>.<hexnum>?(p|P <num>)?
 name:   $(<letter> | <digit> | _ | . | + | - | * | / | \ | ^ | ~ | = | < | > | ! | ? | @ | # | $ | % | & | | | : | ' | `)+
 string: "(<char> | \n | \t | \\ | \' | \" | \<hex><hex> | \u{<hex>+})*"
 
+num_type: i32 | i64 | f32 | f64
+vec_type: v128
+vec_shape: i8x16 | i16x8 | i32x4 | i64x2 | f32x4 | f64x2 | v128
+ref_kind: func | extern
+ref_type: funcref | externref
+val_type: <num_type> | <vec_type> | <ref_type>
+block_type : ( result <val_type>* )*
+func_type:   ( type <var> )? <param>* <result>*
+global_type: <val_type> | ( mut <val_type> )
+table_type:  <nat> <nat>? <ref_type>
+memory_type: <nat> <nat>?
+
 num: <int> | <float>
 var: <nat> | <name>
 
 unop:  ctz | clz | popcnt | ...
 binop: add | sub | mul | ...
+testop: eqz
 relop: eq | ne | lt | ...
 sign:  s | u
 offset: offset=<nat>
 align: align=(1|2|4|8|...)
 cvtop: trunc | extend | wrap | ...
 
-num_type: i32 | i64 | f32 | f64
-ref_kind: func | extern
-ref_type: funcref | externref
-val_type: num_type | ref_type
-block_type : ( result <val_type>* )*
-func_type:   ( type <var> )? <param>* <result>*
-global_type: <val_type> | ( mut <val_type> )
-table_type:  <nat> <nat>? <ref_type>
-memory_type: <nat> <nat>?
+vecunop: abs | neg | ...
+vecbinop: add | sub | min_<sign> | ...
+vecternop: bitselect
+vectestop: all_true | any_true
+vecrelop: eq | ne | lt | ...
+veccvtop: extend_low | extend_high | trunc_sat | ...
+vecshiftop: shl | shr_<sign>
 
 expr:
   ( <op> )
@@ -238,6 +249,10 @@ op:
   elem.drop <var>
   <num_type>.load((8|16|32)_<sign>)? <offset>? <align>?
   <num_type>.store(8|16|32)? <offset>? <align>?
+  <vec_type>.load((8x8|16x4|32x2)_<sign>)? <offset>? <align>?
+  <vec_type>.store <offset>? <align>?
+  <vec_type>.load(8|16|32|64)_(lane|splat|zero) <offset>? <align>?
+  <vec_type>.store(8|16|32|64)_lane <offset>? <align>?
   memory.size
   memory.grow
   memory.fill
@@ -247,12 +262,24 @@ op:
   ref.null <ref_kind>
   ref.is_null <ref_kind>
   ref.func <var>
-  <num_type>.const <value>
+  <num_type>.const <num>
   <num_type>.<unop>
   <num_type>.<binop>
   <num_type>.<testop>
   <num_type>.<relop>
   <num_type>.<cvtop>_<num_type>(_<sign>)?
+  <vec_type>.const <vec_shape> <num>+
+  <vec_shape>.<vecunop>
+  <vec_shape>.<vecbinop>
+  <vec_shape>.<vecternop>
+  <vec_shape>.<vectestop>
+  <vec_shape>.<vecrelop>
+  <vec_shape>.<veccvtop>_<vec_shape>(_<sign>)?(_<zero>)?
+  <vec_shape>.<vecshiftop>
+  <vec_shape>.bitmask
+  <vec_shape>.splat
+  <vec_shape>.extract_lane(_<sign>)? <nat>
+  <vec_shape>.replace_lane <nat>
 
 func:    ( func <name>? <func_type> <local>* <instr>* )
          ( func <name>? ( export <string> ) <...> )                         ;; = (export <string> (func <N>)) (func <name>? <...>)
@@ -352,8 +379,9 @@ action:
 
 const:
   ( <num_type>.const <num> )                 ;; number value
+  ( <vec_type> <vec_shape> <num>+ )          ;; vector value
   ( ref.null <ref_kind> )                    ;; null reference
-  ( ref.host <nat> )                         ;; host reference
+  ( ref.extern <nat> )                       ;; host reference
 
 assertion:
   ( assert_return <action> <result>* )       ;; assert action has expected results
@@ -365,12 +393,14 @@ assertion:
   ( assert_trap <module> <failure> )         ;; assert module traps on instantiation
 
 result:
+  <const>
   ( <num_type>.const <num_pat> )
+  ( <vec_type>.const <vec_shape> <num_pat>+ )
   ( ref.extern )
   ( ref.func )
 
 num_pat:
-  <value>                                    ;; literal result
+  <num>                                      ;; literal result
   nan:canonical                              ;; NaN in canonical form
   nan:arithmetic                             ;; NaN with 1 in MSB of payload
 
diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 37b5aabca..78b466776 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -105,6 +105,7 @@ let vs33 s = I32_convert.wrap_i64 (vsN 33 s)
 let vs64 s = vsN 64 s
 let f32 s = F32.of_bits (u32 s)
 let f64 s = F64.of_bits (u64 s)
+let v128 s = V128.of_bits (get_string (Types.vec_size Types.V128Type) s)
 
 let len32 s =
   let pos = pos s in
@@ -143,6 +144,11 @@ let num_type s =
   | -0x04 -> F64Type
   | _ -> error s (pos s - 1) "malformed number type"
 
+let vec_type s =
+  match vs7 s with
+  | -0x05 -> V128Type
+  | _ -> error s (pos s - 1) "malformed vector type"
+
 let ref_type s =
   match vs7 s with
   | -0x10 -> FuncRefType
@@ -151,7 +157,8 @@ let ref_type s =
 
 let value_type s =
   match peek s with
-  | Some n when n > 0x70 -> NumType (num_type s)
+  | Some n when n >= ((-0x04) land 0x7f) -> NumType (num_type s)
+  | Some n when n >= ((-0x0f) land 0x7f) -> VecType (vec_type s)
   | _ -> RefType (ref_type s)
 
 let result_type s = vec value_type s
@@ -491,6 +498,271 @@ let rec instr s =
     | n -> illegal2 s pos b n
     )
 
+  | 0xfd ->
+    (match vu32 s with
+    | 0x00l -> let a, o = memop s in v128_load a o
+    | 0x01l -> let a, o = memop s in v128_load8x8_s a o
+    | 0x02l -> let a, o = memop s in v128_load8x8_u a o
+    | 0x03l -> let a, o = memop s in v128_load16x4_s a o
+    | 0x04l -> let a, o = memop s in v128_load16x4_u a o
+    | 0x05l -> let a, o = memop s in v128_load32x2_s a o
+    | 0x06l -> let a, o = memop s in v128_load32x2_u a o
+    | 0x07l -> let a, o = memop s in v128_load8_splat a o
+    | 0x08l -> let a, o = memop s in v128_load16_splat a o
+    | 0x09l -> let a, o = memop s in v128_load32_splat a o
+    | 0x0al -> let a, o = memop s in v128_load64_splat a o
+    | 0x0bl -> let a, o = memop s in v128_store a o
+    | 0x0cl -> v128_const (at v128 s)
+    | 0x0dl -> i8x16_shuffle (List.init 16 (fun x -> u8 s))
+    | 0x0el -> i8x16_swizzle
+    | 0x0fl -> i8x16_splat
+    | 0x10l -> i16x8_splat
+    | 0x11l -> i32x4_splat
+    | 0x12l -> i64x2_splat
+    | 0x13l -> f32x4_splat
+    | 0x14l -> f64x2_splat
+    | 0x15l -> let i = u8 s in i8x16_extract_lane_s i
+    | 0x16l -> let i = u8 s in i8x16_extract_lane_u i
+    | 0x17l -> let i = u8 s in i8x16_replace_lane i
+    | 0x18l -> let i = u8 s in i16x8_extract_lane_s i
+    | 0x19l -> let i = u8 s in i16x8_extract_lane_u i
+    | 0x1al -> let i = u8 s in i16x8_replace_lane i
+    | 0x1bl -> let i = u8 s in i32x4_extract_lane i
+    | 0x1cl -> let i = u8 s in i32x4_replace_lane i
+    | 0x1dl -> let i = u8 s in i64x2_extract_lane i
+    | 0x1el -> let i = u8 s in i64x2_replace_lane i
+    | 0x1fl -> let i = u8 s in f32x4_extract_lane i
+    | 0x20l -> let i = u8 s in f32x4_replace_lane i
+    | 0x21l -> let i = u8 s in f64x2_extract_lane i
+    | 0x22l -> let i = u8 s in f64x2_replace_lane i
+    | 0x23l -> i8x16_eq
+    | 0x24l -> i8x16_ne
+    | 0x25l -> i8x16_lt_s
+    | 0x26l -> i8x16_lt_u
+    | 0x27l -> i8x16_gt_s
+    | 0x28l -> i8x16_gt_u
+    | 0x29l -> i8x16_le_s
+    | 0x2al -> i8x16_le_u
+    | 0x2bl -> i8x16_ge_s
+    | 0x2cl -> i8x16_ge_u
+    | 0x2dl -> i16x8_eq
+    | 0x2el -> i16x8_ne
+    | 0x2fl -> i16x8_lt_s
+    | 0x30l -> i16x8_lt_u
+    | 0x31l -> i16x8_gt_s
+    | 0x32l -> i16x8_gt_u
+    | 0x33l -> i16x8_le_s
+    | 0x34l -> i16x8_le_u
+    | 0x35l -> i16x8_ge_s
+    | 0x36l -> i16x8_ge_u
+    | 0x37l -> i32x4_eq
+    | 0x38l -> i32x4_ne
+    | 0x39l -> i32x4_lt_s
+    | 0x3al -> i32x4_lt_u
+    | 0x3bl -> i32x4_gt_s
+    | 0x3cl -> i32x4_gt_u
+    | 0x3dl -> i32x4_le_s
+    | 0x3el -> i32x4_le_u
+    | 0x3fl -> i32x4_ge_s
+    | 0x40l -> i32x4_ge_u
+    | 0x41l -> f32x4_eq
+    | 0x42l -> f32x4_ne
+    | 0x43l -> f32x4_lt
+    | 0x44l -> f32x4_gt
+    | 0x45l -> f32x4_le
+    | 0x46l -> f32x4_ge
+    | 0x47l -> f64x2_eq
+    | 0x48l -> f64x2_ne
+    | 0x49l -> f64x2_lt
+    | 0x4al -> f64x2_gt
+    | 0x4bl -> f64x2_le
+    | 0x4cl -> f64x2_ge
+    | 0x4dl -> v128_not
+    | 0x4el -> v128_and
+    | 0x4fl -> v128_andnot
+    | 0x50l -> v128_or
+    | 0x51l -> v128_xor
+    | 0x52l -> v128_bitselect
+    | 0x53l -> v128_any_true
+    | 0x54l ->
+      let a, o = memop s in
+      let lane = u8 s in
+      v128_load8_lane a o lane
+    | 0x55l ->
+      let a, o = memop s in
+      let lane = u8 s in
+      v128_load16_lane a o lane
+    | 0x56l ->
+      let a, o = memop s in
+      let lane = u8 s in
+      v128_load32_lane a o lane
+    | 0x57l ->
+      let a, o = memop s in
+      let lane = u8 s in
+      v128_load64_lane a o lane
+    | 0x58l ->
+      let a, o = memop s in
+      let lane = u8 s in
+      v128_store8_lane a o lane
+    | 0x59l ->
+      let a, o = memop s in
+      let lane = u8 s in
+      v128_store16_lane a o lane
+    | 0x5al ->
+      let a, o = memop s in
+      let lane = u8 s in
+      v128_store32_lane a o lane
+    | 0x5bl ->
+      let a, o = memop s in
+      let lane = u8 s in
+      v128_store64_lane a o lane
+    | 0x5cl -> let a, o = memop s in v128_load32_zero a o
+    | 0x5dl -> let a, o = memop s in v128_load64_zero a o
+    | 0x5el -> f32x4_demote_f64x2_zero
+    | 0x5fl -> f64x2_promote_low_f32x4
+    | 0x60l -> i8x16_abs
+    | 0x61l -> i8x16_neg
+    | 0x62l -> i8x16_popcnt
+    | 0x63l -> i8x16_all_true
+    | 0x64l -> i8x16_bitmask
+    | 0x65l -> i8x16_narrow_i16x8_s
+    | 0x66l -> i8x16_narrow_i16x8_u
+    | 0x67l -> f32x4_ceil
+    | 0x68l -> f32x4_floor
+    | 0x69l -> f32x4_trunc
+    | 0x6al -> f32x4_nearest
+    | 0x6bl -> i8x16_shl
+    | 0x6cl -> i8x16_shr_s
+    | 0x6dl -> i8x16_shr_u
+    | 0x6el -> i8x16_add
+    | 0x6fl -> i8x16_add_sat_s
+    | 0x70l -> i8x16_add_sat_u
+    | 0x71l -> i8x16_sub
+    | 0x72l -> i8x16_sub_sat_s
+    | 0x73l -> i8x16_sub_sat_u
+    | 0x74l -> f64x2_ceil
+    | 0x75l -> f64x2_floor
+    | 0x76l -> i8x16_min_s
+    | 0x77l -> i8x16_min_u
+    | 0x78l -> i8x16_max_s
+    | 0x79l -> i8x16_max_u
+    | 0x7al -> f64x2_trunc
+    | 0x7bl -> i8x16_avgr_u
+    | 0x7cl -> i16x8_extadd_pairwise_i8x16_s
+    | 0x7dl -> i16x8_extadd_pairwise_i8x16_u
+    | 0x7el -> i32x4_extadd_pairwise_i16x8_s
+    | 0x7fl -> i32x4_extadd_pairwise_i16x8_u
+    | 0x80l -> i16x8_abs
+    | 0x81l -> i16x8_neg
+    | 0x82l -> i16x8_q15mulr_sat_s
+    | 0x83l -> i16x8_all_true
+    | 0x84l -> i16x8_bitmask
+    | 0x85l -> i16x8_narrow_i32x4_s
+    | 0x86l -> i16x8_narrow_i32x4_u
+    | 0x87l -> i16x8_extend_low_i8x16_s
+    | 0x88l -> i16x8_extend_high_i8x16_s
+    | 0x89l -> i16x8_extend_low_i8x16_u
+    | 0x8al -> i16x8_extend_high_i8x16_u
+    | 0x8bl -> i16x8_shl
+    | 0x8cl -> i16x8_shr_s
+    | 0x8dl -> i16x8_shr_u
+    | 0x8el -> i16x8_add
+    | 0x8fl -> i16x8_add_sat_s
+    | 0x90l -> i16x8_add_sat_u
+    | 0x91l -> i16x8_sub
+    | 0x92l -> i16x8_sub_sat_s
+    | 0x93l -> i16x8_sub_sat_u
+    | 0x94l -> f64x2_nearest
+    | 0x95l -> i16x8_mul
+    | 0x96l -> i16x8_min_s
+    | 0x97l -> i16x8_min_u
+    | 0x98l -> i16x8_max_s
+    | 0x99l -> i16x8_max_u
+    | 0x9bl -> i16x8_avgr_u
+    | 0x9cl -> i16x8_extmul_low_i8x16_s
+    | 0x9dl -> i16x8_extmul_high_i8x16_s
+    | 0x9el -> i16x8_extmul_low_i8x16_u
+    | 0x9fl -> i16x8_extmul_high_i8x16_u
+    | 0xa0l -> i32x4_abs
+    | 0xa1l -> i32x4_neg
+    | 0xa3l -> i32x4_all_true
+    | 0xa4l -> i32x4_bitmask
+    | 0xa7l -> i32x4_extend_low_i16x8_s
+    | 0xa8l -> i32x4_extend_high_i16x8_s
+    | 0xa9l -> i32x4_extend_low_i16x8_u
+    | 0xaal -> i32x4_extend_high_i16x8_u
+    | 0xabl -> i32x4_shl
+    | 0xacl -> i32x4_shr_s
+    | 0xadl -> i32x4_shr_u
+    | 0xael -> i32x4_add
+    | 0xb1l -> i32x4_sub
+    | 0xb5l -> i32x4_mul
+    | 0xb6l -> i32x4_min_s
+    | 0xb7l -> i32x4_min_u
+    | 0xb8l -> i32x4_max_s
+    | 0xb9l -> i32x4_max_u
+    | 0xbal -> i32x4_dot_i16x8_s
+    | 0xbcl -> i32x4_extmul_low_i16x8_s
+    | 0xbdl -> i32x4_extmul_high_i16x8_s
+    | 0xbel -> i32x4_extmul_low_i16x8_u
+    | 0xbfl -> i32x4_extmul_high_i16x8_u
+    | 0xc0l -> i64x2_abs
+    | 0xc1l -> i64x2_neg
+    | 0xc3l -> i64x2_all_true
+    | 0xc4l -> i64x2_bitmask
+    | 0xc7l -> i64x2_extend_low_i32x4_s
+    | 0xc8l -> i64x2_extend_high_i32x4_s
+    | 0xc9l -> i64x2_extend_low_i32x4_u
+    | 0xcal -> i64x2_extend_high_i32x4_u
+    | 0xcbl -> i64x2_shl
+    | 0xccl -> i64x2_shr_s
+    | 0xcdl -> i64x2_shr_u
+    | 0xcel -> i64x2_add
+    | 0xd1l -> i64x2_sub
+    | 0xd5l -> i64x2_mul
+    | 0xd6l -> i64x2_eq
+    | 0xd7l -> i64x2_ne
+    | 0xd8l -> i64x2_lt_s
+    | 0xd9l -> i64x2_gt_s
+    | 0xdal -> i64x2_le_s
+    | 0xdbl -> i64x2_ge_s
+    | 0xdcl -> i64x2_extmul_low_i32x4_s
+    | 0xddl -> i64x2_extmul_high_i32x4_s
+    | 0xdel -> i64x2_extmul_low_i32x4_u
+    | 0xdfl -> i64x2_extmul_high_i32x4_u
+    | 0xe0l -> f32x4_abs
+    | 0xe1l -> f32x4_neg
+    | 0xe3l -> f32x4_sqrt
+    | 0xe4l -> f32x4_add
+    | 0xe5l -> f32x4_sub
+    | 0xe6l -> f32x4_mul
+    | 0xe7l -> f32x4_div
+    | 0xe8l -> f32x4_min
+    | 0xe9l -> f32x4_max
+    | 0xeal -> f32x4_pmin
+    | 0xebl -> f32x4_pmax
+    | 0xecl -> f64x2_abs
+    | 0xedl -> f64x2_neg
+    | 0xefl -> f64x2_sqrt
+    | 0xf0l -> f64x2_add
+    | 0xf1l -> f64x2_sub
+    | 0xf2l -> f64x2_mul
+    | 0xf3l -> f64x2_div
+    | 0xf4l -> f64x2_min
+    | 0xf5l -> f64x2_max
+    | 0xf6l -> f64x2_pmin
+    | 0xf7l -> f64x2_pmax
+    | 0xf8l -> i32x4_trunc_sat_f32x4_s
+    | 0xf9l -> i32x4_trunc_sat_f32x4_u
+    | 0xfal -> f32x4_convert_i32x4_s
+    | 0xfbl -> f32x4_convert_i32x4_u
+    | 0xfcl -> i32x4_trunc_sat_f64x2_s_zero
+    | 0xfdl -> i32x4_trunc_sat_f64x2_u_zero
+    | 0xfel -> f64x2_convert_low_i32x4_s
+    | 0xffl -> f64x2_convert_low_i32x4_u
+    | n -> illegal s pos (I32.to_int_u n)
+    )
+
   | b -> illegal s pos b
 
 and instr_block s = List.rev (instr_block' s [])
diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index 861af0e73..254b341b2 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -63,6 +63,7 @@ struct
   let vs33 i = vs64 (I64_convert.extend_i32_s i)
   let f32 x = u32 (F32.to_bits x)
   let f64 x = u64 (F64.to_bits x)
+  let v128 v = String.iter (put s) (V128.to_bits v)
 
   let len i =
     if Int32.to_int (Int32.of_int i) <> i then
@@ -97,12 +98,16 @@ struct
     | F32Type -> vs7 (-0x03)
     | F64Type -> vs7 (-0x04)
 
+  let vec_type = function
+    | V128Type -> vs7 (-0x05)
+
   let ref_type = function
     | FuncRefType -> vs7 (-0x10)
     | ExternRefType -> vs7 (-0x11)
 
   let value_type = function
     | NumType t -> num_type t
+    | VecType t -> vec_type t
     | RefType t -> ref_type t
 
   let func_type = function
@@ -130,8 +135,10 @@ struct
   open Source
   open Ast
   open Values
+  open V128
 
   let op n = u8 n
+  let vecop n = op 0xfd; vu32 n
   let end_ () = op 0x0b
 
   let memop {align; offset; _} = vu32 (Int32.of_int align); vu32 offset
@@ -181,46 +188,97 @@ struct
     | TableInit (x, y) -> op 0xfc; vu32 0x0cl; var y; var x
     | ElemDrop x -> op 0xfc; vu32 0x0dl; var x
 
-    | Load ({ty = I32Type; sz = None; _} as mo) -> op 0x28; memop mo
-    | Load ({ty = I64Type; sz = None; _} as mo) -> op 0x29; memop mo
-    | Load ({ty = F32Type; sz = None; _} as mo) -> op 0x2a; memop mo
-    | Load ({ty = F64Type; sz = None; _} as mo) -> op 0x2b; memop mo
-    | Load ({ty = I32Type; sz = Some (Pack8, SX); _} as mo) ->
+    | Load ({ty = I32Type; pack = None; _} as mo) -> op 0x28; memop mo
+    | Load ({ty = I64Type; pack = None; _} as mo) -> op 0x29; memop mo
+    | Load ({ty = F32Type; pack = None; _} as mo) -> op 0x2a; memop mo
+    | Load ({ty = F64Type; pack = None; _} as mo) -> op 0x2b; memop mo
+    | Load ({ty = I32Type; pack = Some (Pack8, SX); _} as mo) ->
       op 0x2c; memop mo
-    | Load ({ty = I32Type; sz = Some (Pack8, ZX); _} as mo) ->
+    | Load ({ty = I32Type; pack = Some (Pack8, ZX); _} as mo) ->
       op 0x2d; memop mo
-    | Load ({ty = I32Type; sz = Some (Pack16, SX); _} as mo) ->
+    | Load ({ty = I32Type; pack = Some (Pack16, SX); _} as mo) ->
       op 0x2e; memop mo
-    | Load ({ty = I32Type; sz = Some (Pack16, ZX); _} as mo) ->
+    | Load ({ty = I32Type; pack = Some (Pack16, ZX); _} as mo) ->
       op 0x2f; memop mo
-    | Load {ty = I32Type; sz = Some (Pack32, _); _} ->
+    | Load {ty = I32Type; pack = Some (Pack32, _); _} ->
       assert false
-    | Load ({ty = I64Type; sz = Some (Pack8, SX); _} as mo) ->
+    | Load ({ty = I64Type; pack = Some (Pack8, SX); _} as mo) ->
       op 0x30; memop mo
-    | Load ({ty = I64Type; sz = Some (Pack8, ZX); _} as mo) ->
+    | Load ({ty = I64Type; pack = Some (Pack8, ZX); _} as mo) ->
       op 0x31; memop mo
-    | Load ({ty = I64Type; sz = Some (Pack16, SX); _} as mo) ->
+    | Load ({ty = I64Type; pack = Some (Pack16, SX); _} as mo) ->
       op 0x32; memop mo
-    | Load ({ty = I64Type; sz = Some (Pack16, ZX); _} as mo) ->
+    | Load ({ty = I64Type; pack = Some (Pack16, ZX); _} as mo) ->
       op 0x33; memop mo
-    | Load ({ty = I64Type; sz = Some (Pack32, SX); _} as mo) ->
+    | Load ({ty = I64Type; pack = Some (Pack32, SX); _} as mo) ->
       op 0x34; memop mo
-    | Load ({ty = I64Type; sz = Some (Pack32, ZX); _} as mo) ->
+    | Load ({ty = I64Type; pack = Some (Pack32, ZX); _} as mo) ->
       op 0x35; memop mo
-    | Load {ty = F32Type | F64Type; sz = Some _; _} ->
+    | Load {ty = F32Type | F64Type; pack = Some _; _} ->
+      assert false
+    | Load {ty = I32Type | I64Type; pack = Some (Pack64, _); _} ->
       assert false
 
-    | Store ({ty = I32Type; sz = None; _} as mo) -> op 0x36; memop mo
-    | Store ({ty = I64Type; sz = None; _} as mo) -> op 0x37; memop mo
-    | Store ({ty = F32Type; sz = None; _} as mo) -> op 0x38; memop mo
-    | Store ({ty = F64Type; sz = None; _} as mo) -> op 0x39; memop mo
-    | Store ({ty = I32Type; sz = Some Pack8; _} as mo) -> op 0x3a; memop mo
-    | Store ({ty = I32Type; sz = Some Pack16; _} as mo) -> op 0x3b; memop mo
-    | Store {ty = I32Type; sz = Some Pack32; _} -> assert false
-    | Store ({ty = I64Type; sz = Some Pack8; _} as mo) -> op 0x3c; memop mo
-    | Store ({ty = I64Type; sz = Some Pack16; _} as mo) -> op 0x3d; memop mo
-    | Store ({ty = I64Type; sz = Some Pack32; _} as mo) -> op 0x3e; memop mo
-    | Store {ty = F32Type | F64Type; sz = Some _; _} -> assert false
+    | Store ({ty = I32Type; pack = None; _} as mo) -> op 0x36; memop mo
+    | Store ({ty = I64Type; pack = None; _} as mo) -> op 0x37; memop mo
+    | Store ({ty = F32Type; pack = None; _} as mo) -> op 0x38; memop mo
+    | Store ({ty = F64Type; pack = None; _} as mo) -> op 0x39; memop mo
+    | Store ({ty = I32Type; pack = Some Pack8; _} as mo) -> op 0x3a; memop mo
+    | Store ({ty = I32Type; pack = Some Pack16; _} as mo) -> op 0x3b; memop mo
+    | Store {ty = I32Type; pack = Some Pack32; _} -> assert false
+    | Store ({ty = I64Type; pack = Some Pack8; _} as mo) -> op 0x3c; memop mo
+    | Store ({ty = I64Type; pack = Some Pack16; _} as mo) -> op 0x3d; memop mo
+    | Store ({ty = I64Type; pack = Some Pack32; _} as mo) -> op 0x3e; memop mo
+    | Store {ty = F32Type | F64Type; pack = Some _; _} -> assert false
+    | Store {ty = (I32Type | I64Type); pack = Some Pack64; _} -> assert false
+
+    | VecLoad ({ty = V128Type; pack = None; _} as mo) ->
+      vecop 0x00l; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtLane (Pack8x8, SX)); _} as mo) ->
+      vecop 0x01l; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtLane (Pack8x8, ZX)); _} as mo) ->
+      vecop 0x02l; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtLane (Pack16x4, SX)); _} as mo) ->
+      vecop 0x03l; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtLane (Pack16x4, ZX)); _} as mo) ->
+      vecop 0x04l; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtLane (Pack32x2, SX)); _} as mo) ->
+      vecop 0x05l; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtLane (Pack32x2, ZX)); _} as mo) ->
+      vecop 0x06l; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack8, ExtSplat); _} as mo) ->
+      vecop 0x07l; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack16, ExtSplat); _} as mo) ->
+      vecop 0x08l; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack32, ExtSplat); _} as mo) ->
+      vecop 0x09l; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtSplat); _} as mo) ->
+      vecop 0x0al; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack32, ExtZero); _} as mo) ->
+      vecop 0x5cl; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtZero); _} as mo) ->
+      vecop 0x5dl; memop mo
+    | VecLoad _ -> assert false
+
+    | VecLoadLane ({ty = V128Type; pack = Pack8; _} as mo, i) ->
+      vecop 0x54l; memop mo; u8 i;
+    | VecLoadLane ({ty = V128Type; pack = Pack16; _} as mo, i) ->
+      vecop 0x55l; memop mo; u8 i;
+    | VecLoadLane ({ty = V128Type; pack = Pack32; _} as mo, i) ->
+      vecop 0x56l; memop mo; u8 i;
+    | VecLoadLane ({ty = V128Type; pack = Pack64; _} as mo, i) ->
+      vecop 0x57l; memop mo; u8 i;
+
+    | VecStore ({ty = V128Type; _} as mo) -> vecop 0x0bl; memop mo
+
+    | VecStoreLane ({ty = V128Type; pack = Pack8; _} as mo, i) ->
+      vecop 0x58l; memop mo; u8 i;
+    | VecStoreLane ({ty = V128Type; pack = Pack16; _} as mo, i) ->
+      vecop 0x59l; memop mo; u8 i;
+    | VecStoreLane ({ty = V128Type; pack = Pack32; _} as mo, i) ->
+      vecop 0x5al; memop mo; u8 i;
+    | VecStoreLane ({ty = V128Type; pack = Pack64; _} as mo, i) ->
+      vecop 0x5bl; memop mo; u8 i;
 
     | MemorySize -> op 0x3f; u8 0x00
     | MemoryGrow -> op 0x40; u8 0x00
@@ -240,8 +298,7 @@ struct
 
     | Test (I32 I32Op.Eqz) -> op 0x45
     | Test (I64 I64Op.Eqz) -> op 0x50
-    | Test (F32 _) -> assert false
-    | Test (F64 _) -> assert false
+    | Test (F32 _ | F64 _) -> .
 
     | Compare (I32 I32Op.Eq) -> op 0x46
     | Compare (I32 I32Op.Ne) -> op 0x47
@@ -284,7 +341,7 @@ struct
     | Unary (I32 I32Op.Popcnt) -> op 0x69
     | Unary (I32 (I32Op.ExtendS Pack8)) -> op 0xc0
     | Unary (I32 (I32Op.ExtendS Pack16)) -> op 0xc1
-    | Unary (I32 (I32Op.ExtendS Pack32)) -> assert false
+    | Unary (I32 (I32Op.ExtendS (Pack32 | Pack64))) -> assert false
 
     | Unary (I64 I64Op.Clz) -> op 0x79
     | Unary (I64 I64Op.Ctz) -> op 0x7a
@@ -292,6 +349,7 @@ struct
     | Unary (I64 (I64Op.ExtendS Pack8)) -> op 0xc2
     | Unary (I64 (I64Op.ExtendS Pack16)) -> op 0xc3
     | Unary (I64 (I64Op.ExtendS Pack32)) -> op 0xc4
+    | Unary (I64 (I64Op.ExtendS Pack64)) -> assert false
 
     | Unary (F32 F32Op.Abs) -> op 0x8b
     | Unary (F32 F32Op.Neg) -> op 0x8c
@@ -399,6 +457,248 @@ struct
     | Convert (F64 F64Op.DemoteF64) -> assert false
     | Convert (F64 F64Op.ReinterpretInt) -> op 0xbf
 
+    | VecConst {it = V128 c; _} -> vecop 0x0cl; v128 c
+
+    | VecTest (V128 (I8x16 V128Op.AllTrue)) -> vecop 0x63l
+    | VecTest (V128 (I16x8 V128Op.AllTrue)) -> vecop 0x83l
+    | VecTest (V128 (I32x4 V128Op.AllTrue)) -> vecop 0xa3l
+    | VecTest (V128 (I64x2 V128Op.AllTrue)) -> vecop 0xc3l
+    | VecTest (V128 _) -> .
+
+    | VecUnary (V128 (I8x16 V128Op.Abs)) -> vecop 0x60l
+    | VecUnary (V128 (I8x16 V128Op.Neg)) -> vecop 0x61l
+    | VecUnary (V128 (I8x16 V128Op.Popcnt)) -> vecop 0x62l
+    | VecUnary (V128 (I16x8 V128Op.Abs)) -> vecop 0x80l
+    | VecUnary (V128 (I16x8 V128Op.Neg)) -> vecop 0x81l
+    | VecUnary (V128 (I16x8 V128Op.Popcnt)) -> assert false
+    | VecUnary (V128 (I32x4 V128Op.Abs)) -> vecop 0xa0l
+    | VecUnary (V128 (I32x4 V128Op.Neg)) -> vecop 0xa1l
+    | VecUnary (V128 (I32x4 V128Op.Popcnt)) -> assert false
+    | VecUnary (V128 (I64x2 V128Op.Abs)) -> vecop 0xc0l
+    | VecUnary (V128 (I64x2 V128Op.Neg)) -> vecop 0xc1l
+    | VecUnary (V128 (I64x2 V128Op.Popcnt)) -> assert false
+    | VecUnary (V128 (F32x4 V128Op.Ceil)) -> vecop 0x67l
+    | VecUnary (V128 (F32x4 V128Op.Floor)) -> vecop 0x68l
+    | VecUnary (V128 (F32x4 V128Op.Trunc)) -> vecop 0x69l
+    | VecUnary (V128 (F32x4 V128Op.Nearest)) -> vecop 0x6al
+    | VecUnary (V128 (F64x2 V128Op.Ceil)) -> vecop 0x74l
+    | VecUnary (V128 (F64x2 V128Op.Floor)) -> vecop 0x75l
+    | VecUnary (V128 (F64x2 V128Op.Trunc)) -> vecop 0x7al
+    | VecUnary (V128 (F64x2 V128Op.Nearest)) -> vecop 0x94l
+    | VecUnary (V128 (F32x4 V128Op.Abs)) -> vecop 0xe0l
+    | VecUnary (V128 (F32x4 V128Op.Neg)) -> vecop 0xe1l
+    | VecUnary (V128 (F32x4 V128Op.Sqrt)) -> vecop 0xe3l
+    | VecUnary (V128 (F64x2 V128Op.Abs)) -> vecop 0xecl
+    | VecUnary (V128 (F64x2 V128Op.Neg)) -> vecop 0xedl
+    | VecUnary (V128 (F64x2 V128Op.Sqrt)) -> vecop 0xefl
+
+    | VecCompare (V128 (I8x16 V128Op.Eq)) -> vecop 0x23l
+    | VecCompare (V128 (I8x16 V128Op.Ne)) -> vecop 0x24l
+    | VecCompare (V128 (I8x16 V128Op.LtS)) -> vecop 0x25l
+    | VecCompare (V128 (I8x16 V128Op.LtU)) -> vecop 0x26l
+    | VecCompare (V128 (I8x16 V128Op.GtS)) -> vecop 0x27l
+    | VecCompare (V128 (I8x16 V128Op.GtU)) -> vecop 0x28l
+    | VecCompare (V128 (I8x16 V128Op.LeS)) -> vecop 0x29l
+    | VecCompare (V128 (I8x16 V128Op.LeU)) -> vecop 0x2al
+    | VecCompare (V128 (I8x16 V128Op.GeS)) -> vecop 0x2bl
+    | VecCompare (V128 (I8x16 V128Op.GeU)) -> vecop 0x2cl
+    | VecCompare (V128 (I16x8 V128Op.Eq)) -> vecop 0x2dl
+    | VecCompare (V128 (I16x8 V128Op.Ne)) -> vecop 0x2el
+    | VecCompare (V128 (I16x8 V128Op.LtS)) -> vecop 0x2fl
+    | VecCompare (V128 (I16x8 V128Op.LtU)) -> vecop 0x30l
+    | VecCompare (V128 (I16x8 V128Op.GtS)) -> vecop 0x31l
+    | VecCompare (V128 (I16x8 V128Op.GtU)) -> vecop 0x32l
+    | VecCompare (V128 (I16x8 V128Op.LeS)) -> vecop 0x33l
+    | VecCompare (V128 (I16x8 V128Op.LeU)) -> vecop 0x34l
+    | VecCompare (V128 (I16x8 V128Op.GeS)) -> vecop 0x35l
+    | VecCompare (V128 (I16x8 V128Op.GeU)) -> vecop 0x36l
+    | VecCompare (V128 (I32x4 V128Op.Eq)) -> vecop 0x37l
+    | VecCompare (V128 (I32x4 V128Op.Ne)) -> vecop 0x38l
+    | VecCompare (V128 (I32x4 V128Op.LtS)) -> vecop 0x39l
+    | VecCompare (V128 (I32x4 V128Op.LtU)) -> vecop 0x3al
+    | VecCompare (V128 (I32x4 V128Op.GtS)) -> vecop 0x3bl
+    | VecCompare (V128 (I32x4 V128Op.GtU)) -> vecop 0x3cl
+    | VecCompare (V128 (I32x4 V128Op.LeS)) -> vecop 0x3dl
+    | VecCompare (V128 (I32x4 V128Op.LeU)) -> vecop 0x3el
+    | VecCompare (V128 (I32x4 V128Op.GeS)) -> vecop 0x3fl
+    | VecCompare (V128 (I32x4 V128Op.GeU)) -> vecop 0x40l
+    | VecCompare (V128 (I64x2 V128Op.Eq)) -> vecop 0xd6l
+    | VecCompare (V128 (I64x2 V128Op.Ne)) -> vecop 0xd7l
+    | VecCompare (V128 (I64x2 V128Op.LtS)) -> vecop 0xd8l
+    | VecCompare (V128 (I64x2 V128Op.LtU)) -> assert false
+    | VecCompare (V128 (I64x2 V128Op.GtS)) -> vecop 0xd9l
+    | VecCompare (V128 (I64x2 V128Op.GtU)) -> assert false
+    | VecCompare (V128 (I64x2 V128Op.LeS)) -> vecop 0xdal
+    | VecCompare (V128 (I64x2 V128Op.LeU)) -> assert false
+    | VecCompare (V128 (I64x2 V128Op.GeS)) -> vecop 0xdbl
+    | VecCompare (V128 (I64x2 V128Op.GeU)) -> assert false
+    | VecCompare (V128 (F32x4 V128Op.Eq)) -> vecop 0x41l
+    | VecCompare (V128 (F32x4 V128Op.Ne)) -> vecop 0x42l
+    | VecCompare (V128 (F32x4 V128Op.Lt)) -> vecop 0x43l
+    | VecCompare (V128 (F32x4 V128Op.Gt)) -> vecop 0x44l
+    | VecCompare (V128 (F32x4 V128Op.Le)) -> vecop 0x45l
+    | VecCompare (V128 (F32x4 V128Op.Ge)) -> vecop 0x46l
+    | VecCompare (V128 (F64x2 V128Op.Eq)) -> vecop 0x47l
+    | VecCompare (V128 (F64x2 V128Op.Ne)) -> vecop 0x48l
+    | VecCompare (V128 (F64x2 V128Op.Lt)) -> vecop 0x49l
+    | VecCompare (V128 (F64x2 V128Op.Gt)) -> vecop 0x4al
+    | VecCompare (V128 (F64x2 V128Op.Le)) -> vecop 0x4bl
+    | VecCompare (V128 (F64x2 V128Op.Ge)) -> vecop 0x4cl
+
+    | VecBinary (V128 (I8x16 (V128Op.Shuffle is))) -> vecop 0x0dl; List.iter u8 is
+    | VecBinary (V128 (I8x16 V128Op.Swizzle)) -> vecop 0x0el
+    | VecBinary (V128 (I8x16 V128Op.NarrowS)) -> vecop 0x65l
+    | VecBinary (V128 (I8x16 V128Op.NarrowU)) -> vecop 0x66l
+    | VecBinary (V128 (I8x16 V128Op.Add)) -> vecop 0x6el
+    | VecBinary (V128 (I8x16 V128Op.AddSatS)) -> vecop 0x6fl
+    | VecBinary (V128 (I8x16 V128Op.AddSatU)) -> vecop 0x70l
+    | VecBinary (V128 (I8x16 V128Op.Sub)) -> vecop 0x71l
+    | VecBinary (V128 (I8x16 V128Op.SubSatS)) -> vecop 0x72l
+    | VecBinary (V128 (I8x16 V128Op.SubSatU)) -> vecop 0x73l
+    | VecBinary (V128 (I8x16 V128Op.MinS)) -> vecop 0x76l
+    | VecBinary (V128 (I8x16 V128Op.MinU)) -> vecop 0x77l
+    | VecBinary (V128 (I8x16 V128Op.MaxS)) -> vecop 0x78l
+    | VecBinary (V128 (I8x16 V128Op.MaxU)) -> vecop 0x79l
+    | VecBinary (V128 (I8x16 V128Op.AvgrU)) -> vecop 0x7bl
+    | VecBinary (V128 (I16x8 V128Op.NarrowS)) -> vecop 0x85l
+    | VecBinary (V128 (I16x8 V128Op.NarrowU)) -> vecop 0x86l
+    | VecBinary (V128 (I16x8 V128Op.Add)) -> vecop 0x8el
+    | VecBinary (V128 (I16x8 V128Op.AddSatS)) -> vecop 0x8fl
+    | VecBinary (V128 (I16x8 V128Op.AddSatU)) -> vecop 0x90l
+    | VecBinary (V128 (I16x8 V128Op.Sub)) -> vecop 0x91l
+    | VecBinary (V128 (I16x8 V128Op.SubSatS)) -> vecop 0x92l
+    | VecBinary (V128 (I16x8 V128Op.SubSatU)) -> vecop 0x93l
+    | VecBinary (V128 (I16x8 V128Op.Mul)) -> vecop 0x95l
+    | VecBinary (V128 (I16x8 V128Op.MinS)) -> vecop 0x96l
+    | VecBinary (V128 (I16x8 V128Op.MinU)) -> vecop 0x97l
+    | VecBinary (V128 (I16x8 V128Op.MaxS)) -> vecop 0x98l
+    | VecBinary (V128 (I16x8 V128Op.MaxU)) -> vecop 0x99l
+    | VecBinary (V128 (I16x8 V128Op.AvgrU)) -> vecop 0x9bl
+    | VecBinary (V128 (I16x8 V128Op.ExtMulLowS)) -> vecop 0x9cl
+    | VecBinary (V128 (I16x8 V128Op.ExtMulHighS)) -> vecop 0x9dl
+    | VecBinary (V128 (I16x8 V128Op.ExtMulLowU)) -> vecop 0x9el
+    | VecBinary (V128 (I16x8 V128Op.ExtMulHighU)) -> vecop 0x9fl
+    | VecBinary (V128 (I16x8 V128Op.Q15MulRSatS)) -> vecop 0x82l
+    | VecBinary (V128 (I32x4 V128Op.Add)) -> vecop 0xael
+    | VecBinary (V128 (I32x4 V128Op.Sub)) -> vecop 0xb1l
+    | VecBinary (V128 (I32x4 V128Op.MinS)) -> vecop 0xb6l
+    | VecBinary (V128 (I32x4 V128Op.MinU)) -> vecop 0xb7l
+    | VecBinary (V128 (I32x4 V128Op.MaxS)) -> vecop 0xb8l
+    | VecBinary (V128 (I32x4 V128Op.MaxU)) -> vecop 0xb9l
+    | VecBinary (V128 (I32x4 V128Op.DotS)) -> vecop 0xbal
+    | VecBinary (V128 (I32x4 V128Op.Mul)) -> vecop 0xb5l
+    | VecBinary (V128 (I32x4 V128Op.ExtMulLowS)) -> vecop 0xbcl
+    | VecBinary (V128 (I32x4 V128Op.ExtMulHighS)) -> vecop 0xbdl
+    | VecBinary (V128 (I32x4 V128Op.ExtMulLowU)) -> vecop 0xbel
+    | VecBinary (V128 (I32x4 V128Op.ExtMulHighU)) -> vecop 0xbfl
+    | VecBinary (V128 (I64x2 V128Op.Add)) -> vecop 0xcel
+    | VecBinary (V128 (I64x2 V128Op.Sub)) -> vecop 0xd1l
+    | VecBinary (V128 (I64x2 V128Op.Mul)) -> vecop 0xd5l
+    | VecBinary (V128 (I64x2 V128Op.ExtMulLowS)) -> vecop 0xdcl
+    | VecBinary (V128 (I64x2 V128Op.ExtMulHighS)) -> vecop 0xddl
+    | VecBinary (V128 (I64x2 V128Op.ExtMulLowU)) -> vecop 0xdel
+    | VecBinary (V128 (I64x2 V128Op.ExtMulHighU)) -> vecop 0xdfl
+    | VecBinary (V128 (F32x4 V128Op.Add)) -> vecop 0xe4l
+    | VecBinary (V128 (F32x4 V128Op.Sub)) -> vecop 0xe5l
+    | VecBinary (V128 (F32x4 V128Op.Mul)) -> vecop 0xe6l
+    | VecBinary (V128 (F32x4 V128Op.Div)) -> vecop 0xe7l
+    | VecBinary (V128 (F32x4 V128Op.Min)) -> vecop 0xe8l
+    | VecBinary (V128 (F32x4 V128Op.Max)) -> vecop 0xe9l
+    | VecBinary (V128 (F32x4 V128Op.Pmin)) -> vecop 0xeal
+    | VecBinary (V128 (F32x4 V128Op.Pmax)) -> vecop 0xebl
+    | VecBinary (V128 (F64x2 V128Op.Add)) -> vecop 0xf0l
+    | VecBinary (V128 (F64x2 V128Op.Sub)) -> vecop 0xf1l
+    | VecBinary (V128 (F64x2 V128Op.Mul)) -> vecop 0xf2l
+    | VecBinary (V128 (F64x2 V128Op.Div)) -> vecop 0xf3l
+    | VecBinary (V128 (F64x2 V128Op.Min)) -> vecop 0xf4l
+    | VecBinary (V128 (F64x2 V128Op.Max)) -> vecop 0xf5l
+    | VecBinary (V128 (F64x2 V128Op.Pmin)) -> vecop 0xf6l
+    | VecBinary (V128 (F64x2 V128Op.Pmax)) -> vecop 0xf7l
+    | VecBinary (V128 _) -> assert false
+
+    | VecConvert (V128 (I8x16 _)) -> assert false
+    | VecConvert (V128 (I16x8 V128Op.ExtendLowS)) -> vecop 0x87l
+    | VecConvert (V128 (I16x8 V128Op.ExtendHighS)) -> vecop 0x88l
+    | VecConvert (V128 (I16x8 V128Op.ExtendLowU)) -> vecop 0x89l
+    | VecConvert (V128 (I16x8 V128Op.ExtendHighU)) -> vecop 0x8al
+    | VecConvert (V128 (I16x8 V128Op.ExtAddPairwiseS)) -> vecop 0x7cl
+    | VecConvert (V128 (I16x8 V128Op.ExtAddPairwiseU)) -> vecop 0x7dl
+    | VecConvert (V128 (I16x8 _)) -> assert false
+    | VecConvert (V128 (I32x4 V128Op.ExtendLowS)) -> vecop 0xa7l
+    | VecConvert (V128 (I32x4 V128Op.ExtendHighS)) -> vecop 0xa8l
+    | VecConvert (V128 (I32x4 V128Op.ExtendLowU)) -> vecop 0xa9l
+    | VecConvert (V128 (I32x4 V128Op.ExtendHighU)) -> vecop 0xaal
+    | VecConvert (V128 (I32x4 V128Op.ExtAddPairwiseS)) -> vecop 0x7el
+    | VecConvert (V128 (I32x4 V128Op.ExtAddPairwiseU)) -> vecop 0x7fl
+    | VecConvert (V128 (I32x4 V128Op.TruncSatSF32x4)) -> vecop 0xf8l
+    | VecConvert (V128 (I32x4 V128Op.TruncSatUF32x4)) -> vecop 0xf9l
+    | VecConvert (V128 (I32x4 V128Op.TruncSatSZeroF64x2)) -> vecop 0xfcl
+    | VecConvert (V128 (I32x4 V128Op.TruncSatUZeroF64x2)) -> vecop 0xfdl
+    | VecConvert (V128 (I64x2 V128Op.ExtendLowS)) -> vecop 0xc7l
+    | VecConvert (V128 (I64x2 V128Op.ExtendHighS)) -> vecop 0xc8l
+    | VecConvert (V128 (I64x2 V128Op.ExtendLowU)) -> vecop 0xc9l
+    | VecConvert (V128 (I64x2 V128Op.ExtendHighU)) -> vecop 0xcal
+    | VecConvert (V128 (I64x2 _)) -> assert false
+    | VecConvert (V128 (F32x4 V128Op.DemoteZeroF64x2)) -> vecop 0x5el
+    | VecConvert (V128 (F32x4 V128Op.PromoteLowF32x4)) -> assert false
+    | VecConvert (V128 (F32x4 V128Op.ConvertSI32x4)) -> vecop 0xfal
+    | VecConvert (V128 (F32x4 V128Op.ConvertUI32x4)) -> vecop 0xfbl
+    | VecConvert (V128 (F64x2 V128Op.DemoteZeroF64x2)) -> assert false
+    | VecConvert (V128 (F64x2 V128Op.PromoteLowF32x4)) -> vecop 0x5fl
+    | VecConvert (V128 (F64x2 V128Op.ConvertSI32x4)) -> vecop 0xfel
+    | VecConvert (V128 (F64x2 V128Op.ConvertUI32x4)) -> vecop 0xffl
+
+    | VecShift (V128 (I8x16 V128Op.Shl)) -> vecop 0x6bl
+    | VecShift (V128 (I8x16 V128Op.ShrS)) -> vecop 0x6cl
+    | VecShift (V128 (I8x16 V128Op.ShrU)) -> vecop 0x6dl
+    | VecShift (V128 (I16x8 V128Op.Shl)) -> vecop 0x8bl
+    | VecShift (V128 (I16x8 V128Op.ShrS)) -> vecop 0x8cl
+    | VecShift (V128 (I16x8 V128Op.ShrU)) -> vecop 0x8dl
+    | VecShift (V128 (I32x4 V128Op.Shl)) -> vecop 0xabl
+    | VecShift (V128 (I32x4 V128Op.ShrS)) -> vecop 0xacl
+    | VecShift (V128 (I32x4 V128Op.ShrU)) -> vecop 0xadl
+    | VecShift (V128 (I64x2 V128Op.Shl)) -> vecop 0xcbl
+    | VecShift (V128 (I64x2 V128Op.ShrS)) -> vecop 0xccl
+    | VecShift (V128 (I64x2 V128Op.ShrU)) -> vecop 0xcdl
+    | VecShift (V128 _) -> .
+
+    | VecBitmask (V128 (I8x16 V128Op.Bitmask)) -> vecop 0x64l
+    | VecBitmask (V128 (I16x8 V128Op.Bitmask)) -> vecop 0x84l
+    | VecBitmask (V128 (I32x4 V128Op.Bitmask)) -> vecop 0xa4l
+    | VecBitmask (V128 (I64x2 V128Op.Bitmask)) -> vecop 0xc4l
+    | VecBitmask (V128 _) -> .
+
+    | VecTestBits (V128 V128Op.AnyTrue) -> vecop 0x53l
+    | VecUnaryBits (V128 V128Op.Not) -> vecop 0x4dl
+    | VecBinaryBits (V128 V128Op.And) -> vecop 0x4el
+    | VecBinaryBits (V128 V128Op.AndNot) -> vecop 0x4fl
+    | VecBinaryBits (V128 V128Op.Or) -> vecop 0x50l
+    | VecBinaryBits (V128 V128Op.Xor) -> vecop 0x51l
+    | VecTernaryBits (V128 V128Op.Bitselect) -> vecop 0x52l
+
+    | VecSplat (V128 ((I8x16 V128Op.Splat))) -> vecop 0x0fl
+    | VecSplat (V128 ((I16x8 V128Op.Splat))) -> vecop 0x10l
+    | VecSplat (V128 ((I32x4 V128Op.Splat))) -> vecop 0x11l
+    | VecSplat (V128 ((I64x2 V128Op.Splat))) -> vecop 0x12l
+    | VecSplat (V128 ((F32x4 V128Op.Splat))) -> vecop 0x13l
+    | VecSplat (V128 ((F64x2 V128Op.Splat))) -> vecop 0x14l
+
+    | VecExtract (V128 (I8x16 (V128Op.Extract (i, SX)))) -> vecop 0x15l; u8 i
+    | VecExtract (V128 (I8x16 (V128Op.Extract (i, ZX)))) -> vecop 0x16l; u8 i
+    | VecExtract (V128 (I16x8 (V128Op.Extract (i, SX)))) -> vecop 0x18l; u8 i
+    | VecExtract (V128 (I16x8 (V128Op.Extract (i, ZX)))) -> vecop 0x19l; u8 i
+    | VecExtract (V128 (I32x4 (V128Op.Extract (i, ())))) -> vecop 0x1bl; u8 i
+    | VecExtract (V128 (I64x2 (V128Op.Extract (i, ())))) -> vecop 0x1dl; u8 i
+    | VecExtract (V128 (F32x4 (V128Op.Extract (i, ())))) -> vecop 0x1fl; u8 i
+    | VecExtract (V128 (F64x2 (V128Op.Extract (i, ())))) -> vecop 0x21l; u8 i
+
+    | VecReplace (V128 (I8x16 (V128Op.Replace i))) -> vecop 0x17l; u8 i
+    | VecReplace (V128 (I16x8 (V128Op.Replace i))) -> vecop 0x1al; u8 i
+    | VecReplace (V128 (I32x4 (V128Op.Replace i))) -> vecop 0x1cl; u8 i
+    | VecReplace (V128 (I64x2 (V128Op.Replace i))) -> vecop 0x1el; u8 i
+    | VecReplace (V128 (F32x4 (V128Op.Replace i))) -> vecop 0x20l; u8 i
+    | VecReplace (V128 (F64x2 (V128Op.Replace i))) -> vecop 0x22l; u8 i
+
   let const c =
     list instr c.it; end_ ()
 
diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index 4a0134dd9..fb7beac05 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -32,10 +32,10 @@ let memory_error at = function
   | exn -> raise exn
 
 let numeric_error at = function
-  | Numeric_error.IntegerOverflow -> "integer overflow"
-  | Numeric_error.IntegerDivideByZero -> "integer divide by zero"
-  | Numeric_error.InvalidConversionToInteger -> "invalid conversion to integer"
-  | Eval_numeric.TypeError (i, v, t) ->
+  | Ixx.Overflow -> "integer overflow"
+  | Ixx.DivideByZero -> "integer divide by zero"
+  | Ixx.InvalidConversion -> "invalid conversion to integer"
+  | Values.TypeError (i, v, t) ->
     Crash.error at
       ("type error, expected " ^ Types.string_of_num_type t ^ " as operand " ^
        string_of_int i ^ ", got " ^ Types.string_of_num_type (type_of_num v))
@@ -318,27 +318,86 @@ let rec step (c : config) : config =
         seg := [];
         vs, []
 
-      | Load {offset; ty; sz; _}, Num (I32 i) :: vs' ->
+      | Load {offset; ty; pack; _}, Num (I32 i) :: vs' ->
         let mem = memory frame.inst (0l @@ e.at) in
         let a = I64_convert.extend_i32_u i in
         (try
           let n =
-            match sz with
+            match pack with
             | None -> Memory.load_num mem a offset ty
-            | Some (sz, ext) -> Memory.load_packed sz ext mem a offset ty
+            | Some (sz, ext) -> Memory.load_num_packed sz ext mem a offset ty
           in Num n :: vs', []
         with exn -> vs', [Trapping (memory_error e.at exn) @@ e.at])
 
-      | Store {offset; sz; _}, Num n :: Num (I32 i) :: vs' ->
+      | Store {offset; pack; _}, Num n :: Num (I32 i) :: vs' ->
         let mem = memory frame.inst (0l @@ e.at) in
         let a = I64_convert.extend_i32_u i in
         (try
-          (match sz with
+          (match pack with
           | None -> Memory.store_num mem a offset n
-          | Some sz -> Memory.store_packed sz mem a offset n
+          | Some sz -> Memory.store_num_packed sz mem a offset n
           );
           vs', []
         with exn -> vs', [Trapping (memory_error e.at exn) @@ e.at]);
+
+      | VecLoad {offset; ty; pack; _}, Num (I32 i) :: vs' ->
+        let mem = memory frame.inst (0l @@ e.at) in
+        let addr = I64_convert.extend_i32_u i in
+        (try
+          let v =
+            match pack with
+            | None -> Memory.load_vec mem addr offset ty
+            | Some (sz, ext) ->
+              Memory.load_vec_packed sz ext mem addr offset ty
+          in Vec v :: vs', []
+        with exn -> vs', [Trapping (memory_error e.at exn) @@ e.at])
+
+      | VecStore {offset; _}, Vec v :: Num (I32 i) :: vs' ->
+        let mem = memory frame.inst (0l @@ e.at) in
+        let addr = I64_convert.extend_i32_u i in
+        (try
+          Memory.store_vec mem addr offset v;
+          vs', []
+        with exn -> vs', [Trapping (memory_error e.at exn) @@ e.at]);
+
+      | VecLoadLane ({offset; ty; pack; _}, j), Vec (V128 v) :: Num (I32 i) :: vs' ->
+        let mem = memory frame.inst (0l @@ e.at) in
+        let addr = I64_convert.extend_i32_u i in
+        (try
+          let v =
+            match pack with
+            | Pack8 ->
+              V128.I8x16.replace_lane j v
+                (I32Num.of_num 0 (Memory.load_num_packed Pack8 SX mem addr offset I32Type))
+            | Pack16 ->
+              V128.I16x8.replace_lane j v
+                (I32Num.of_num 0 (Memory.load_num_packed Pack16 SX mem addr offset I32Type))
+            | Pack32 ->
+              V128.I32x4.replace_lane j v
+                (I32Num.of_num 0 (Memory.load_num mem addr offset I32Type))
+            | Pack64 ->
+              V128.I64x2.replace_lane j v
+                (I64Num.of_num 0 (Memory.load_num mem addr offset I64Type))
+          in Vec (V128 v) :: vs', []
+        with exn -> vs', [Trapping (memory_error e.at exn) @@ e.at])
+
+      | VecStoreLane ({offset; ty; pack; _}, j), Vec (V128 v) :: Num (I32 i) :: vs' ->
+        let mem = memory frame.inst (0l @@ e.at) in
+        let addr = I64_convert.extend_i32_u i in
+        (try
+          (match pack with
+          | Pack8 ->
+            Memory.store_num_packed Pack8 mem addr offset (I32 (V128.I8x16.extract_lane_s j v))
+          | Pack16 ->
+            Memory.store_num_packed Pack16 mem addr offset (I32 (V128.I16x8.extract_lane_s j v))
+          | Pack32 ->
+            Memory.store_num mem addr offset (I32 (V128.I32x4.extract_lane_s j v))
+          | Pack64 ->
+            Memory.store_num mem addr offset (I64 (V128.I64x2.extract_lane_s j v))
+          );
+          vs', []
+        with exn -> vs', [Trapping (memory_error e.at exn) @@ e.at])
+
       | MemorySize, vs ->
         let mem = memory frame.inst (0l @@ e.at) in
         Num (I32 (Memory.size mem)) :: vs, []
@@ -361,7 +420,7 @@ let rec step (c : config) : config =
             Plain (Const (I32 i @@ e.at));
             Plain (Const (k @@ e.at));
             Plain (Store
-              {ty = I32Type; align = 0; offset = 0l; sz = Some Pack8});
+              {ty = I32Type; align = 0; offset = 0l; pack = Some Pack8});
             Plain (Const (I32 (I32.add i 1l) @@ e.at));
             Plain (Const (k @@ e.at));
             Plain (Const (I32 (I32.sub n 1l) @@ e.at));
@@ -378,9 +437,9 @@ let rec step (c : config) : config =
             Plain (Const (I32 d @@ e.at));
             Plain (Const (I32 s @@ e.at));
             Plain (Load
-              {ty = I32Type; align = 0; offset = 0l; sz = Some (Pack8, ZX)});
+              {ty = I32Type; align = 0; offset = 0l; pack = Some (Pack8, ZX)});
             Plain (Store
-              {ty = I32Type; align = 0; offset = 0l; sz = Some Pack8});
+              {ty = I32Type; align = 0; offset = 0l; pack = Some Pack8});
             Plain (Const (I32 (I32.add d 1l) @@ e.at));
             Plain (Const (I32 (I32.add s 1l) @@ e.at));
             Plain (Const (I32 (I32.sub n 1l) @@ e.at));
@@ -395,9 +454,9 @@ let rec step (c : config) : config =
             Plain (Const (I32 d @@ e.at));
             Plain (Const (I32 s @@ e.at));
             Plain (Load
-              {ty = I32Type; align = 0; offset = 0l; sz = Some (Pack8, ZX)});
+              {ty = I32Type; align = 0; offset = 0l; pack = Some (Pack8, ZX)});
             Plain (Store
-              {ty = I32Type; align = 0; offset = 0l; sz = Some Pack8});
+              {ty = I32Type; align = 0; offset = 0l; pack = Some Pack8});
           ]
 
       | MemoryInit x, Num (I32 n) :: Num (I32 s) :: Num (I32 d) :: vs' ->
@@ -412,7 +471,7 @@ let rec step (c : config) : config =
             Plain (Const (I32 d @@ e.at));
             Plain (Const (I32 b @@ e.at));
             Plain (Store
-              {ty = I32Type; align = 0; offset = 0l; sz = Some Pack8});
+              {ty = I32Type; align = 0; offset = 0l; pack = Some Pack8});
             Plain (Const (I32 (I32.add d 1l) @@ e.at));
             Plain (Const (I32 (I32.add s 1l) @@ e.at));
             Plain (Const (I32 (I32.sub n 1l) @@ e.at));
@@ -443,23 +502,82 @@ let rec step (c : config) : config =
         Num n.it :: vs, []
 
       | Test testop, Num n :: vs' ->
-        (try value_of_bool (Eval_numeric.eval_testop testop n) :: vs', []
+        (try value_of_bool (Eval_num.eval_testop testop n) :: vs', []
         with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
 
       | Compare relop, Num n2 :: Num n1 :: vs' ->
-        (try value_of_bool (Eval_numeric.eval_relop relop n1 n2) :: vs', []
+        (try value_of_bool (Eval_num.eval_relop relop n1 n2) :: vs', []
         with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
 
       | Unary unop, Num n :: vs' ->
-        (try Num (Eval_numeric.eval_unop unop n) :: vs', []
+        (try Num (Eval_num.eval_unop unop n) :: vs', []
         with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
 
       | Binary binop, Num n2 :: Num n1 :: vs' ->
-        (try Num (Eval_numeric.eval_binop binop n1 n2) :: vs', []
+        (try Num (Eval_num.eval_binop binop n1 n2) :: vs', []
         with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
 
       | Convert cvtop, Num n :: vs' ->
-        (try Num (Eval_numeric.eval_cvtop cvtop n) :: vs', []
+        (try Num (Eval_num.eval_cvtop cvtop n) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecConst v, vs ->
+        Vec v.it :: vs, []
+
+      | VecTest testop, Vec n :: vs' ->
+        (try value_of_bool (Eval_vec.eval_testop testop n) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecUnary unop, Vec n :: vs' ->
+        (try Vec (Eval_vec.eval_unop unop n) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecBinary binop, Vec n2 :: Vec n1 :: vs' ->
+        (try Vec (Eval_vec.eval_binop binop n1 n2) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecCompare relop, Vec n2 :: Vec n1 :: vs' ->
+        (try Vec (Eval_vec.eval_relop relop n1 n2) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecConvert cvtop, Vec n :: vs' ->
+        (try Vec (Eval_vec.eval_cvtop cvtop n) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecShift shiftop, Num s :: Vec v :: vs' ->
+        (try Vec (Eval_vec.eval_shiftop shiftop v s) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecBitmask bitmaskop, Vec v :: vs' ->
+        (try Num (Eval_vec.eval_bitmaskop bitmaskop v) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecTestBits vtestop, Vec n :: vs' ->
+        (try value_of_bool (Eval_vec.eval_vtestop vtestop n) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecUnaryBits vunop, Vec n :: vs' ->
+        (try Vec (Eval_vec.eval_vunop vunop n) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecBinaryBits vbinop, Vec n2 :: Vec n1 :: vs' ->
+        (try Vec (Eval_vec.eval_vbinop vbinop n1 n2) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecTernaryBits vternop, Vec v3 :: Vec v2 :: Vec v1 :: vs' ->
+        (try Vec (Eval_vec.eval_vternop vternop v1 v2 v3) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecSplat splatop, Num n :: vs' ->
+        (try Vec (Eval_vec.eval_splatop splatop n) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecExtract extractop, Vec v :: vs' ->
+        (try Num (Eval_vec.eval_extractop extractop v) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecReplace replaceop, Num r :: Vec v :: vs' ->
+        (try Vec (Eval_vec.eval_replaceop replaceop v r) :: vs', []
         with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
 
       | _ ->
diff --git a/interpreter/exec/eval_numeric.ml b/interpreter/exec/eval_num.ml
similarity index 86%
rename from interpreter/exec/eval_numeric.ml
rename to interpreter/exec/eval_num.ml
index 3caf4d45e..f1245a133 100644
--- a/interpreter/exec/eval_numeric.ml
+++ b/interpreter/exec/eval_num.ml
@@ -2,49 +2,9 @@ open Types
 open Values
 
 
-(* Injection & projection *)
-
-exception TypeError of int * num * num_type
-
-module type NumType =
-sig
-  type t
-  val to_num : t -> num
-  val of_num : int -> num -> t
-end
-
-module I32Num =
-struct
-  type t = I32.t
-  let to_num i = I32 i
-  let of_num n = function I32 i -> i | v -> raise (TypeError (n, v, I32Type))
-end
-
-module I64Num =
-struct
-  type t = I64.t
-  let to_num i = I64 i
-  let of_num n = function I64 i -> i | v -> raise (TypeError (n, v, I64Type))
-end
-
-module F32Num =
-struct
-  type t = F32.t
-  let to_num i = F32 i
-  let of_num n = function F32 z -> z | v -> raise (TypeError (n, v, F32Type))
-end
-
-module F64Num =
-struct
-  type t = F64.t
-  let to_num i = F64 i
-  let of_num n = function F64 z -> z | v -> raise (TypeError (n, v, F64Type))
-end
-
-
 (* Int operators *)
 
-module IntOp (IXX : Int.S) (Num : NumType with type t = IXX.t) =
+module IntOp (IXX : Ixx.S) (Num : NumType with type t = IXX.t) =
 struct
   open Ast.IntOp
   open Num
@@ -102,7 +62,7 @@ module I64Op = IntOp (I64) (I64Num)
 
 (* Float operators *)
 
-module FloatOp (FXX : Float.S) (Num : NumType with type t = FXX.t) =
+module FloatOp (FXX : Fxx.S) (Num : NumType with type t = FXX.t) =
 struct
   open Ast.FloatOp
   open Num
@@ -222,7 +182,6 @@ struct
     in F64Num.to_num z
 end
 
-
 (* Dispatch *)
 
 let op i32 i64 f32 f64 = function
@@ -236,3 +195,4 @@ let eval_binop = op I32Op.binop I64Op.binop F32Op.binop F64Op.binop
 let eval_testop = op I32Op.testop I64Op.testop F32Op.testop F64Op.testop
 let eval_relop = op I32Op.relop I64Op.relop F32Op.relop F64Op.relop
 let eval_cvtop = op I32CvtOp.cvtop I64CvtOp.cvtop F32CvtOp.cvtop F64CvtOp.cvtop
+
diff --git a/interpreter/exec/eval_numeric.mli b/interpreter/exec/eval_num.mli
similarity index 82%
rename from interpreter/exec/eval_numeric.mli
rename to interpreter/exec/eval_num.mli
index 969e44749..719c16f40 100644
--- a/interpreter/exec/eval_numeric.mli
+++ b/interpreter/exec/eval_num.mli
@@ -1,7 +1,5 @@
 open Values
 
-exception TypeError of int * num * Types.num_type
-
 val eval_unop : Ast.unop -> num -> num
 val eval_binop : Ast.binop -> num -> num -> num
 val eval_testop : Ast.testop -> num -> bool
diff --git a/interpreter/exec/eval_vec.ml b/interpreter/exec/eval_vec.ml
new file mode 100644
index 000000000..d4c6e9648
--- /dev/null
+++ b/interpreter/exec/eval_vec.ml
@@ -0,0 +1,314 @@
+open Types
+open Values
+
+module V128Op =
+struct
+  open Ast.V128Op
+  open V128Vec
+  open V128
+
+  let testop (op : testop) =
+    let f = match op with
+      | I8x16 AllTrue -> V128.I8x16.all_true
+      | I16x8 AllTrue -> V128.I16x8.all_true
+      | I32x4 AllTrue -> V128.I32x4.all_true
+      | I64x2 AllTrue -> V128.I64x2.all_true
+      | _ -> .
+    in fun v -> f (of_vec 1 v)
+
+  let unop (op : unop) =
+    let f = match op with
+      | I8x16 Neg -> V128.I8x16.neg
+      | I8x16 Abs -> V128.I8x16.abs
+      | I8x16 Popcnt -> V128.I8x16.popcnt
+      | I16x8 Neg -> V128.I16x8.neg
+      | I16x8 Abs -> V128.I16x8.abs
+      | I32x4 Abs -> V128.I32x4.abs
+      | I32x4 Neg -> V128.I32x4.neg
+      | I64x2 Abs -> V128.I64x2.abs
+      | I64x2 Neg -> V128.I64x2.neg
+      | F32x4 Abs -> V128.F32x4.abs
+      | F32x4 Neg -> V128.F32x4.neg
+      | F32x4 Sqrt -> V128.F32x4.sqrt
+      | F32x4 Ceil -> V128.F32x4.ceil
+      | F32x4 Floor -> V128.F32x4.floor
+      | F32x4 Trunc -> V128.F32x4.trunc
+      | F32x4 Nearest -> V128.F32x4.nearest
+      | F64x2 Abs -> V128.F64x2.abs
+      | F64x2 Neg -> V128.F64x2.neg
+      | F64x2 Sqrt -> V128.F64x2.sqrt
+      | F64x2 Ceil -> V128.F64x2.ceil
+      | F64x2 Floor -> V128.F64x2.floor
+      | F64x2 Trunc -> V128.F64x2.trunc
+      | F64x2 Nearest -> V128.F64x2.nearest
+      | _ -> assert false
+    in fun v -> to_vec (f (of_vec 1 v))
+
+  let binop (op : binop) =
+    let f = match op with
+      | I8x16 Swizzle -> V128.V8x16.swizzle
+      | I8x16 (Shuffle is) -> fun a b -> V128.V8x16.shuffle a b is
+      | I8x16 NarrowS -> V128.I8x16_convert.narrow_s
+      | I8x16 NarrowU -> V128.I8x16_convert.narrow_u
+      | I8x16 Add -> V128.I8x16.add
+      | I8x16 AddSatS -> V128.I8x16.add_sat_s
+      | I8x16 AddSatU -> V128.I8x16.add_sat_u
+      | I8x16 Sub -> V128.I8x16.sub
+      | I8x16 SubSatS -> V128.I8x16.sub_sat_s
+      | I8x16 SubSatU -> V128.I8x16.sub_sat_u
+      | I8x16 MinS -> V128.I8x16.min_s
+      | I8x16 MinU -> V128.I8x16.min_u
+      | I8x16 MaxS -> V128.I8x16.max_s
+      | I8x16 MaxU -> V128.I8x16.max_u
+      | I8x16 AvgrU -> V128.I8x16.avgr_u
+      | I16x8 NarrowS -> V128.I16x8_convert.narrow_s
+      | I16x8 NarrowU -> V128.I16x8_convert.narrow_u
+      | I16x8 Add -> V128.I16x8.add
+      | I16x8 AddSatS -> V128.I16x8.add_sat_s
+      | I16x8 AddSatU -> V128.I16x8.add_sat_u
+      | I16x8 Sub -> V128.I16x8.sub
+      | I16x8 SubSatS -> V128.I16x8.sub_sat_s
+      | I16x8 SubSatU -> V128.I16x8.sub_sat_u
+      | I16x8 Mul -> V128.I16x8.mul
+      | I16x8 MinS -> V128.I16x8.min_s
+      | I16x8 MinU -> V128.I16x8.min_u
+      | I16x8 MaxS -> V128.I16x8.max_s
+      | I16x8 MaxU -> V128.I16x8.max_u
+      | I16x8 AvgrU -> V128.I16x8.avgr_u
+      | I16x8 ExtMulLowS -> V128.I16x8_convert.extmul_low_s
+      | I16x8 ExtMulHighS -> V128.I16x8_convert.extmul_high_s
+      | I16x8 ExtMulLowU -> V128.I16x8_convert.extmul_low_u
+      | I16x8 ExtMulHighU -> V128.I16x8_convert.extmul_high_u
+      | I16x8 Q15MulRSatS -> V128.I16x8.q15mulr_sat_s
+      | I32x4 Add -> V128.I32x4.add
+      | I32x4 Sub -> V128.I32x4.sub
+      | I32x4 MinS -> V128.I32x4.min_s
+      | I32x4 MinU -> V128.I32x4.min_u
+      | I32x4 MaxS -> V128.I32x4.max_s
+      | I32x4 MaxU -> V128.I32x4.max_u
+      | I32x4 Mul -> V128.I32x4.mul
+      | I32x4 ExtMulLowS -> V128.I32x4_convert.extmul_low_s
+      | I32x4 ExtMulHighS -> V128.I32x4_convert.extmul_high_s
+      | I32x4 ExtMulLowU -> V128.I32x4_convert.extmul_low_u
+      | I32x4 ExtMulHighU -> V128.I32x4_convert.extmul_high_u
+      | I64x2 Add -> V128.I64x2.add
+      | I64x2 Sub -> V128.I64x2.sub
+      | I64x2 Mul -> V128.I64x2.mul
+      | I32x4 DotS -> V128.I32x4_convert.dot_s
+      | I64x2 ExtMulLowS -> V128.I64x2_convert.extmul_low_s
+      | I64x2 ExtMulHighS -> V128.I64x2_convert.extmul_high_s
+      | I64x2 ExtMulLowU -> V128.I64x2_convert.extmul_low_u
+      | I64x2 ExtMulHighU -> V128.I64x2_convert.extmul_high_u
+      | F32x4 Add -> V128.F32x4.add
+      | F32x4 Sub -> V128.F32x4.sub
+      | F32x4 Mul -> V128.F32x4.mul
+      | F32x4 Div -> V128.F32x4.div
+      | F32x4 Min -> V128.F32x4.min
+      | F32x4 Max -> V128.F32x4.max
+      | F32x4 Pmin -> V128.F32x4.pmin
+      | F32x4 Pmax -> V128.F32x4.pmax
+      | F64x2 Add -> V128.F64x2.add
+      | F64x2 Sub -> V128.F64x2.sub
+      | F64x2 Mul -> V128.F64x2.mul
+      | F64x2 Div -> V128.F64x2.div
+      | F64x2 Min -> V128.F64x2.min
+      | F64x2 Max -> V128.F64x2.max
+      | F64x2 Pmin -> V128.F64x2.pmin
+      | F64x2 Pmax -> V128.F64x2.pmax
+      | _ -> assert false
+    in fun v1 v2 -> to_vec (f (of_vec 1 v1) (of_vec 2 v2))
+
+  let relop (op : relop) =
+    let f = match op with
+      | I8x16 Eq -> V128.I8x16.eq
+      | I8x16 Ne -> V128.I8x16.ne
+      | I8x16 LtS -> V128.I8x16.lt_s
+      | I8x16 LtU -> V128.I8x16.lt_u
+      | I8x16 LeS -> V128.I8x16.le_s
+      | I8x16 LeU -> V128.I8x16.le_u
+      | I8x16 GtS -> V128.I8x16.gt_s
+      | I8x16 GtU -> V128.I8x16.gt_u
+      | I8x16 GeS -> V128.I8x16.ge_s
+      | I8x16 GeU -> V128.I8x16.ge_u
+      | I16x8 Eq -> V128.I16x8.eq
+      | I16x8 Ne -> V128.I16x8.ne
+      | I16x8 LtS -> V128.I16x8.lt_s
+      | I16x8 LtU -> V128.I16x8.lt_u
+      | I16x8 LeS -> V128.I16x8.le_s
+      | I16x8 LeU -> V128.I16x8.le_u
+      | I16x8 GtS -> V128.I16x8.gt_s
+      | I16x8 GtU -> V128.I16x8.gt_u
+      | I16x8 GeS -> V128.I16x8.ge_s
+      | I16x8 GeU -> V128.I16x8.ge_u
+      | I32x4 Eq -> V128.I32x4.eq
+      | I32x4 Ne -> V128.I32x4.ne
+      | I32x4 LtS -> V128.I32x4.lt_s
+      | I32x4 LtU -> V128.I32x4.lt_u
+      | I32x4 LeS -> V128.I32x4.le_s
+      | I32x4 LeU -> V128.I32x4.le_u
+      | I32x4 GtS -> V128.I32x4.gt_s
+      | I32x4 GtU -> V128.I32x4.gt_u
+      | I32x4 GeS -> V128.I32x4.ge_s
+      | I32x4 GeU -> V128.I32x4.ge_u
+      | I64x2 Eq -> V128.I64x2.eq
+      | I64x2 Ne -> V128.I64x2.ne
+      | I64x2 LtS -> V128.I64x2.lt_s
+      | I64x2 LeS -> V128.I64x2.le_s
+      | I64x2 GtS -> V128.I64x2.gt_s
+      | I64x2 GeS -> V128.I64x2.ge_s
+      | F32x4 Eq -> V128.F32x4.eq
+      | F32x4 Ne -> V128.F32x4.ne
+      | F32x4 Lt -> V128.F32x4.lt
+      | F32x4 Le -> V128.F32x4.le
+      | F32x4 Gt -> V128.F32x4.gt
+      | F32x4 Ge -> V128.F32x4.ge
+      | F64x2 Eq -> V128.F64x2.eq
+      | F64x2 Ne -> V128.F64x2.ne
+      | F64x2 Lt -> V128.F64x2.lt
+      | F64x2 Le -> V128.F64x2.le
+      | F64x2 Gt -> V128.F64x2.gt
+      | F64x2 Ge -> V128.F64x2.ge
+      | _ -> assert false
+    in fun v1 v2 -> to_vec (f (of_vec 1 v1) (of_vec 2 v2))
+
+  let cvtop (op : cvtop) =
+    let f = match op with
+      | I16x8 ExtendLowS -> V128.I16x8_convert.extend_low_s
+      | I16x8 ExtendHighS -> V128.I16x8_convert.extend_high_s
+      | I16x8 ExtendLowU -> V128.I16x8_convert.extend_low_u
+      | I16x8 ExtendHighU -> V128.I16x8_convert.extend_high_u
+      | I16x8 ExtAddPairwiseS -> V128.I16x8_convert.extadd_pairwise_s
+      | I16x8 ExtAddPairwiseU -> V128.I16x8_convert.extadd_pairwise_u
+      | I32x4 ExtendLowS -> V128.I32x4_convert.extend_low_s
+      | I32x4 ExtendHighS -> V128.I32x4_convert.extend_high_s
+      | I32x4 ExtendLowU -> V128.I32x4_convert.extend_low_u
+      | I32x4 ExtendHighU -> V128.I32x4_convert.extend_high_u
+      | I32x4 TruncSatSF32x4 -> V128.I32x4_convert.trunc_sat_f32x4_s
+      | I32x4 TruncSatUF32x4 -> V128.I32x4_convert.trunc_sat_f32x4_u
+      | I32x4 TruncSatSZeroF64x2 -> V128.I32x4_convert.trunc_sat_f64x2_s_zero
+      | I32x4 TruncSatUZeroF64x2 -> V128.I32x4_convert.trunc_sat_f64x2_u_zero
+      | I32x4 ExtAddPairwiseS -> V128.I32x4_convert.extadd_pairwise_s
+      | I32x4 ExtAddPairwiseU -> V128.I32x4_convert.extadd_pairwise_u
+      | I64x2 ExtendLowS -> V128.I64x2_convert.extend_low_s
+      | I64x2 ExtendHighS -> V128.I64x2_convert.extend_high_s
+      | I64x2 ExtendLowU -> V128.I64x2_convert.extend_low_u
+      | I64x2 ExtendHighU -> V128.I64x2_convert.extend_high_u
+      | F32x4 ConvertSI32x4 -> V128.F32x4_convert.convert_i32x4_s
+      | F32x4 ConvertUI32x4 -> V128.F32x4_convert.convert_i32x4_u
+      | F32x4 DemoteZeroF64x2 -> V128.F32x4_convert.demote_f64x2_zero
+      | F64x2 PromoteLowF32x4 -> V128.F64x2_convert.promote_low_f32x4
+      | F64x2 ConvertSI32x4 -> V128.F64x2_convert.convert_i32x4_s
+      | F64x2 ConvertUI32x4 -> V128.F64x2_convert.convert_i32x4_u
+      | _ -> assert false
+    in fun v -> to_vec (f (of_vec 1 v))
+
+  let shiftop (op : shiftop) =
+    let f = match op with
+      | I8x16 Shl -> V128.I8x16.shl
+      | I8x16 ShrS -> V128.I8x16.shr_s
+      | I8x16 ShrU -> V128.I8x16.shr_u
+      | I16x8 Shl -> V128.I16x8.shl
+      | I16x8 ShrS -> V128.I16x8.shr_s
+      | I16x8 ShrU -> V128.I16x8.shr_u
+      | I32x4 Shl -> V128.I32x4.shl
+      | I32x4 ShrS -> V128.I32x4.shr_s
+      | I32x4 ShrU -> V128.I32x4.shr_u
+      | I64x2 Shl -> V128.I64x2.shl
+      | I64x2 ShrS -> V128.I64x2.shr_s
+      | I64x2 ShrU -> V128.I64x2.shr_u
+      | _ -> .
+    in fun v n -> to_vec (f (of_vec 1 v) (I32Num.of_num 2 n))
+
+  let bitmaskop (op : bitmaskop) v =
+    let f = match op with
+      | I8x16 Bitmask -> V128.I8x16.bitmask
+      | I16x8 Bitmask -> V128.I16x8.bitmask
+      | I32x4 Bitmask -> V128.I32x4.bitmask
+      | I64x2 Bitmask -> V128.I64x2.bitmask
+      | _ -> .
+    in I32 (f (of_vec 1 v))
+
+  let vtestop (op : vtestop) =
+    let f = match op with
+      | AnyTrue -> V128.I8x16.any_true
+    in fun v -> f (of_vec 1 v)
+
+  let vunop (op : vunop) =
+    let f = match op with
+      | Not -> V128.V1x128.lognot
+    in fun v -> to_vec (f (of_vec 1 v))
+
+  let vbinop (op : vbinop) =
+    let f = match op with
+      | And -> V128.V1x128.and_
+      | Or -> V128.V1x128.or_
+      | Xor -> V128.V1x128.xor
+      | AndNot -> V128.V1x128.andnot
+    in fun v1 v2 -> to_vec (f (of_vec 1 v1) (of_vec 2 v2))
+
+  let vternop (op : vternop) =
+    let f = match op with
+      | Bitselect -> V128.V1x128.bitselect
+    in fun v1 v2 v3 -> to_vec (f (of_vec 1 v1) (of_vec 2 v2) (of_vec 3 v3))
+end
+
+module V128CvtOp =
+struct
+  open Ast.V128Op
+  open V128Vec
+  open V128
+
+  let splatop (op : splatop) v =
+    let i =
+      match op with
+      | I8x16 Splat -> V128.I8x16.splat (I32Num.of_num 1 v)
+      | I16x8 Splat -> V128.I16x8.splat (I32Num.of_num 1 v)
+      | I32x4 Splat -> V128.I32x4.splat (I32Num.of_num 1 v)
+      | I64x2 Splat -> V128.I64x2.splat (I64Num.of_num 1 v)
+      | F32x4 Splat -> V128.F32x4.splat (F32Num.of_num 1 v)
+      | F64x2 Splat -> V128.F64x2.splat (F64Num.of_num 1 v)
+    in to_vec i
+
+  let extractop (op : extractop) v =
+    let v128 = of_vec 1 v in
+    match op with
+    | I8x16 (Extract (i, SX)) -> I32 (V128.I8x16.extract_lane_s i v128)
+    | I8x16 (Extract (i, ZX)) -> I32 (V128.I8x16.extract_lane_u i v128)
+    | I16x8 (Extract (i, SX)) -> I32 (V128.I16x8.extract_lane_s i v128)
+    | I16x8 (Extract (i, ZX)) -> I32 (V128.I16x8.extract_lane_u i v128)
+    | I32x4 (Extract (i, ())) -> I32 (V128.I32x4.extract_lane_u i v128)
+    | I64x2 (Extract (i, ())) -> I64 (V128.I64x2.extract_lane_u i v128)
+    | F32x4 (Extract (i, ())) -> F32 (V128.F32x4.extract_lane i v128)
+    | F64x2 (Extract (i, ())) -> F64 (V128.F64x2.extract_lane i v128)
+
+  let replaceop (op : replaceop) v (n : Values.num) =
+    let v128 = of_vec 1 v in
+    let v128' = match op with
+      | I8x16 (Replace i) -> V128.I8x16.replace_lane i v128 (I32Num.of_num 1 n)
+      | I16x8 (Replace i) -> V128.I16x8.replace_lane i v128 (I32Num.of_num 1 n)
+      | I32x4 (Replace i) -> V128.I32x4.replace_lane i v128 (I32Num.of_num 1 n)
+      | I64x2 (Replace i) -> V128.I64x2.replace_lane i v128 (I64Num.of_num 1 n)
+      | F32x4 (Replace i) -> V128.F32x4.replace_lane i v128 (F32Num.of_num 1 n)
+      | F64x2 (Replace i) -> V128.F64x2.replace_lane i v128 (F64Num.of_num 1 n)
+    in to_vec v128'
+end
+
+(* Dispatch *)
+
+let op v128 = function
+  | V128 x -> v128 x
+
+let eval_testop = op V128Op.testop
+let eval_unop = op V128Op.unop
+let eval_binop = op V128Op.binop
+let eval_relop = op V128Op.relop
+let eval_cvtop = op V128Op.cvtop
+let eval_shiftop = op V128Op.shiftop
+let eval_bitmaskop = op V128Op.bitmaskop
+let eval_vtestop = op V128Op.vtestop
+let eval_vunop = op V128Op.vunop
+let eval_vbinop = op V128Op.vbinop
+let eval_vternop = op V128Op.vternop
+let eval_splatop = op V128CvtOp.splatop
+let eval_extractop = op V128CvtOp.extractop
+let eval_replaceop = op V128CvtOp.replaceop
diff --git a/interpreter/exec/eval_vec.mli b/interpreter/exec/eval_vec.mli
new file mode 100644
index 000000000..be54f20b7
--- /dev/null
+++ b/interpreter/exec/eval_vec.mli
@@ -0,0 +1,16 @@
+open Values
+
+val eval_testop : Ast.vec_testop -> vec -> bool
+val eval_unop : Ast.vec_unop -> vec -> vec
+val eval_binop : Ast.vec_binop -> vec -> vec -> vec
+val eval_relop : Ast.vec_relop -> vec -> vec -> vec
+val eval_cvtop : Ast.vec_cvtop -> vec -> vec
+val eval_shiftop : Ast.vec_shiftop -> vec -> num -> vec
+val eval_bitmaskop : Ast.vec_bitmaskop -> vec -> num
+val eval_vtestop : Ast.vec_vtestop -> vec -> bool
+val eval_vunop : Ast.vec_vunop -> vec -> vec
+val eval_vbinop : Ast.vec_vbinop -> vec -> vec -> vec
+val eval_vternop : Ast.vec_vternop -> vec -> vec -> vec -> vec
+val eval_splatop : Ast.vec_splatop -> num -> vec
+val eval_extractop : Ast.vec_extractop -> vec -> num
+val eval_replaceop : Ast.vec_replaceop -> vec -> num -> vec
diff --git a/interpreter/exec/f32.ml b/interpreter/exec/f32.ml
index 5f26a0394..11983ccf6 100644
--- a/interpreter/exec/f32.ml
+++ b/interpreter/exec/f32.ml
@@ -3,7 +3,7 @@
  * using 64-bit floats, as described in the paper
  * "When is double rounding innocuous?" by Samuel A. Figueroa.
  *)
-include Float.Make
+include Fxx.Make
   (struct
     include Int32
     let mantissa = 23
diff --git a/interpreter/exec/f64.ml b/interpreter/exec/f64.ml
index 623150fe7..9a9f7ebca 100644
--- a/interpreter/exec/f64.ml
+++ b/interpreter/exec/f64.ml
@@ -1,4 +1,4 @@
-include Float.Make
+include Fxx.Make
   (struct
     include Int64
     let mantissa = 52
diff --git a/interpreter/exec/float.ml b/interpreter/exec/fxx.ml
similarity index 100%
rename from interpreter/exec/float.ml
rename to interpreter/exec/fxx.ml
diff --git a/interpreter/exec/i16.ml b/interpreter/exec/i16.ml
new file mode 100644
index 000000000..54eb9ed84
--- /dev/null
+++ b/interpreter/exec/i16.ml
@@ -0,0 +1,12 @@
+(* Uses Int32 as the underlying storage. All int16 values will be
+ * stored signed-extended. E.g. -1 will be stored with all high bits set.
+ *)
+include Ixx.Make (struct
+  include Int32
+
+  let bitwidth = 16
+  let to_hex_string i = Printf.sprintf "%lx" (Int32.logand i 0xffffl)
+
+  let of_int64 = Int64.to_int32
+  let to_int64 = Int64.of_int32
+end)
diff --git a/interpreter/exec/i32.ml b/interpreter/exec/i32.ml
index 573622a60..49c85e2fa 100644
--- a/interpreter/exec/i32.ml
+++ b/interpreter/exec/i32.ml
@@ -1,8 +1,11 @@
 (* WebAssembly-compatible i32 implementation *)
 
-include Int.Make
+include Ixx.Make
   (struct
     include Int32
     let bitwidth = 32
     let to_hex_string = Printf.sprintf "%lx"
+
+    let of_int64 = Int64.to_int32
+    let to_int64 = Int64.of_int32
   end)
diff --git a/interpreter/exec/i32_convert.ml b/interpreter/exec/i32_convert.ml
index 05814fa49..166d5ff0f 100644
--- a/interpreter/exec/i32_convert.ml
+++ b/interpreter/exec/i32_convert.ml
@@ -4,41 +4,41 @@ let wrap_i64 x = Int64.to_int32 x
 
 let trunc_f32_s x =
   if F32.ne x x then
-    raise Numeric_error.InvalidConversionToInteger
+    raise Ixx.InvalidConversion
   else
     let xf = F32.to_float x in
     if xf >= -.Int32.(to_float min_int) || xf < Int32.(to_float min_int) then
-      raise Numeric_error.IntegerOverflow
+      raise Ixx.Overflow
     else
       Int32.of_float xf
 
 let trunc_f32_u x =
   if F32.ne x x then
-    raise Numeric_error.InvalidConversionToInteger
+    raise Ixx.InvalidConversion
   else
     let xf = F32.to_float x in
     if xf >= -.Int32.(to_float min_int) *. 2.0 || xf <= -1.0 then
-      raise Numeric_error.IntegerOverflow
+      raise Ixx.Overflow
     else
       Int64.(to_int32 (of_float xf))
 
 let trunc_f64_s x =
   if F64.ne x x then
-    raise Numeric_error.InvalidConversionToInteger
+    raise Ixx.InvalidConversion
   else
     let xf = F64.to_float x in
     if xf >= -.Int32.(to_float min_int) || xf <= Int32.(to_float min_int) -. 1.0 then
-      raise Numeric_error.IntegerOverflow
+      raise Ixx.Overflow
     else
       Int32.of_float xf
 
 let trunc_f64_u x =
   if F64.ne x x then
-    raise Numeric_error.InvalidConversionToInteger
+    raise Ixx.InvalidConversion
   else
     let xf = F64.to_float x in
     if xf >= -.Int32.(to_float min_int) *. 2.0 || xf <= -1.0 then
-      raise Numeric_error.IntegerOverflow
+      raise Ixx.Overflow
     else
       Int64.(to_int32 (of_float xf))
 
diff --git a/interpreter/exec/i64.ml b/interpreter/exec/i64.ml
index c6d7a84d6..f43235dd3 100644
--- a/interpreter/exec/i64.ml
+++ b/interpreter/exec/i64.ml
@@ -1,8 +1,11 @@
 (* WebAssembly-compatible i64 implementation *)
 
-include Int.Make
+include Ixx.Make
   (struct
     include Int64
     let bitwidth = 64
     let to_hex_string = Printf.sprintf "%Lx"
+
+    let of_int64 i = i
+    let to_int64 i = i
   end)
diff --git a/interpreter/exec/i64_convert.ml b/interpreter/exec/i64_convert.ml
index 0c14e6c4c..835cdf6c7 100644
--- a/interpreter/exec/i64_convert.ml
+++ b/interpreter/exec/i64_convert.ml
@@ -6,21 +6,21 @@ let extend_i32_u x = Int64.logand (Int64.of_int32 x) 0x0000_0000_ffff_ffffL
 
 let trunc_f32_s x =
   if F32.ne x x then
-    raise Numeric_error.InvalidConversionToInteger
+    raise Ixx.InvalidConversion
   else
     let xf = F32.to_float x in
     if xf >= -.Int64.(to_float min_int) || xf < Int64.(to_float min_int) then
-      raise Numeric_error.IntegerOverflow
+      raise Ixx.Overflow
     else
       Int64.of_float xf
 
 let trunc_f32_u x =
   if F32.ne x x then
-    raise Numeric_error.InvalidConversionToInteger
+    raise Ixx.InvalidConversion
   else
     let xf = F32.to_float x in
     if xf >= -.Int64.(to_float min_int) *. 2.0 || xf <= -1.0 then
-      raise Numeric_error.IntegerOverflow
+      raise Ixx.Overflow
     else if xf >= -.Int64.(to_float min_int) then
       Int64.(logxor (of_float (xf -. 0x1p63)) min_int)
     else
@@ -28,21 +28,21 @@ let trunc_f32_u x =
 
 let trunc_f64_s x =
   if F64.ne x x then
-    raise Numeric_error.InvalidConversionToInteger
+    raise Ixx.InvalidConversion
   else
     let xf = F64.to_float x in
     if xf >= -.Int64.(to_float min_int) || xf < Int64.(to_float min_int) then
-      raise Numeric_error.IntegerOverflow
+      raise Ixx.Overflow
     else
       Int64.of_float xf
 
 let trunc_f64_u x =
   if F64.ne x x then
-    raise Numeric_error.InvalidConversionToInteger
+    raise Ixx.InvalidConversion
   else
     let xf = F64.to_float x in
     if xf >= -.Int64.(to_float min_int) *. 2.0 || xf <= -1.0 then
-      raise Numeric_error.IntegerOverflow
+      raise Ixx.Overflow
     else if xf >= -.Int64.(to_float min_int) then
       Int64.(logxor (of_float (xf -. 0x1p63)) min_int)
     else
diff --git a/interpreter/exec/i8.ml b/interpreter/exec/i8.ml
new file mode 100644
index 000000000..bd15d39da
--- /dev/null
+++ b/interpreter/exec/i8.ml
@@ -0,0 +1,12 @@
+(* Uses Int32 as the underlying storage. All int8 values will be
+ * stored signed-extended. E.g. -1 will be stored with all high bits set.
+ *)
+include Ixx.Make (struct
+  include Int32
+
+  let bitwidth = 8
+  let to_hex_string i = Printf.sprintf "%lx" (Int32.logand i 0xffl)
+
+  let of_int64 = Int64.to_int32
+  let to_int64 = Int64.of_int32
+end)
diff --git a/interpreter/exec/int.ml b/interpreter/exec/ixx.ml
similarity index 60%
rename from interpreter/exec/int.ml
rename to interpreter/exec/ixx.ml
index 375475dfb..18f8b7d06 100644
--- a/interpreter/exec/int.ml
+++ b/interpreter/exec/ixx.ml
@@ -1,3 +1,7 @@
+exception Overflow
+exception DivideByZero
+exception InvalidConversion
+
 module type RepType =
 sig
   type t
@@ -8,12 +12,13 @@ sig
   val max_int : t
   val min_int : t
 
+  val abs : t -> t
   val neg : t -> t
   val add : t -> t -> t
   val sub : t -> t -> t
   val mul : t -> t -> t
-  val div : t -> t -> t (* raises Division_by_zero *)
-  val rem : t -> t -> t (* raises Division_by_zero *)
+  val div : t -> t -> t (* raises DivideByZero *)
+  val rem : t -> t -> t (* raises DivideByZero *)
 
   val logand : t -> t -> t
   val lognot : t -> t
@@ -25,6 +30,8 @@ sig
 
   val of_int : int -> t
   val to_int : t -> int
+  val of_int64: int64 -> t
+  val to_int64: t -> int64
   val to_string : t -> string
   val to_hex_string : t -> string
 
@@ -41,6 +48,9 @@ sig
 
   val zero : t
 
+  val lognot : t -> t
+  val abs : t -> t
+  val neg : t -> t
   val add : t -> t -> t
   val sub : t -> t -> t
   val mul : t -> t -> t
@@ -48,6 +58,7 @@ sig
   val div_u : t -> t -> t (* raises IntegerDivideByZero *)
   val rem_s : t -> t -> t (* raises IntegerDivideByZero *)
   val rem_u : t -> t -> t (* raises IntegerDivideByZero *)
+  val avgr_u : t -> t -> t
   val and_ : t -> t -> t
   val or_ : t -> t -> t
   val xor : t -> t -> t
@@ -72,6 +83,17 @@ sig
   val ge_s : t -> t -> bool
   val ge_u : t -> t -> bool
 
+  val as_unsigned : t -> t
+
+  (* Saturating arithmetic, used for small ints. *)
+  val saturate_s : t -> t
+  val saturate_u : t -> t
+  val add_sat_s : t -> t -> t
+  val add_sat_u : t -> t -> t
+  val sub_sat_s : t -> t -> t
+  val sub_sat_u : t -> t -> t
+  val q15mulr_sat_s : t -> t -> t
+
   val of_int_s : int -> t
   val of_int_u : int -> t
   val of_string_s : string -> t
@@ -98,7 +120,7 @@ struct
    * "Unsigned Short Division from Signed Division".
    *)
   let divrem_u n d =
-    if d = Rep.zero then raise Numeric_error.IntegerDivideByZero else
+    if d = Rep.zero then raise DivideByZero else
     let t = Rep.shift_right d (Rep.bitwidth - 1) in
     let n' = Rep.logand n (Rep.lognot t) in
     let q = Rep.shift_left (Rep.div (Rep.shift_right_logical n' 1) d) 1 in
@@ -118,17 +140,36 @@ struct
   let one = Rep.one
   let ten = Rep.of_int 10
 
+  let lognot = Rep.lognot
+  let abs = Rep.abs
+  let neg = Rep.neg
+
+  (* If bit (bitwidth - 1) is set, sx will sign-extend t to maintain the
+   * invariant that small ints are stored sign-extended inside a wider int. *)
+  let sx x =
+    let i = 64 - Rep.bitwidth in
+    Rep.of_int64 Int64.(shift_right (shift_left (Rep.to_int64 x) i) i)
+
   (* add, sub, and mul are sign-agnostic and do not trap on overflow. *)
-  let add = Rep.add
-  let sub = Rep.sub
-  let mul = Rep.mul
+  let add x y = sx (Rep.add x y)
+  let sub x y = sx (Rep.sub x y)
+
+  let mul x y = sx (Rep.mul x y)
+
+  (* We don't override min_int and max_int since those are used
+   * by other functions (like parsing), and rely on it being
+   * min/max for int32 *)
+  (* The smallest signed |bitwidth|-bits int. *)
+  let low_int = Rep.shift_left Rep.minus_one (Rep.bitwidth - 1)
+  (* The largest signed |bitwidth|-bits int. *)
+  let high_int = Rep.logxor low_int Rep.minus_one
 
   (* result is truncated toward zero *)
   let div_s x y =
     if y = Rep.zero then
-      raise Numeric_error.IntegerDivideByZero
-    else if x = Rep.min_int && y = Rep.minus_one then
-      raise Numeric_error.IntegerOverflow
+      raise DivideByZero
+    else if x = low_int && y = Rep.minus_one then
+      raise Overflow
     else
       Rep.div x y
 
@@ -139,29 +180,51 @@ struct
   (* result has the sign of the dividend *)
   let rem_s x y =
     if y = Rep.zero then
-      raise Numeric_error.IntegerDivideByZero
+      raise DivideByZero
     else
       Rep.rem x y
 
   let rem_u x y =
     let q, r = divrem_u x y in r
 
+  let avgr_u x y =
+    let open Int64 in
+    (* Mask with bottom #bitwidth bits set *)
+    let mask = shift_right_logical minus_one (64 - Rep.bitwidth) in
+    let x64 = logand mask (Rep.to_int64 x) in
+    let y64 = logand mask (Rep.to_int64 y) in
+    Rep.of_int64 (div (add (add x64 y64) one) (of_int 2))
+
   let and_ = Rep.logand
   let or_ = Rep.logor
   let xor = Rep.logxor
 
   (* WebAssembly's shifts mask the shift count according to the bitwidth. *)
   let shift f x y =
-    f x (Rep.to_int (Rep.logand y (Rep.of_int (Rep.bitwidth - 1))))
+    f x Rep.(to_int (logand y (of_int (bitwidth - 1))))
 
   let shl x y =
-    shift Rep.shift_left x y
+    sx (shift Rep.shift_left x y)
 
   let shr_s x y =
     shift Rep.shift_right x y
 
+  (* Check if we are storing smaller ints. *)
+  let needs_extend = shl one (Rep.of_int (Rep.bitwidth - 1)) <> Rep.min_int
+
+  (*
+   * When Int is used to store a smaller int, it is stored in signed extended
+   * form. Some instructions require the unsigned form, which requires masking
+   * away the top 32-bitwidth bits.
+   *)
+  let as_unsigned x =
+    if not needs_extend then x else
+    (* Mask with bottom #bitwidth bits set *)
+    let mask = Rep.(shift_right_logical minus_one (32 - bitwidth)) in
+    Rep.logand x mask
+
   let shr_u x y =
-    shift Rep.shift_right_logical x y
+    sx (shift Rep.shift_right_logical (as_unsigned x) y)
 
   (* We must mask the count to implement rotates via shifts. *)
   let clamp_rotate_count n =
@@ -169,11 +232,11 @@ struct
 
   let rotl x y =
     let n = clamp_rotate_count y in
-    or_ (Rep.shift_left x n) (Rep.shift_right_logical x (Rep.bitwidth - n))
+    or_ (shl x (Rep.of_int n)) (shr_u x (Rep.of_int (Rep.bitwidth - n)))
 
   let rotr x y =
     let n = clamp_rotate_count y in
-    or_ (Rep.shift_right_logical x n) (Rep.shift_left x (Rep.bitwidth - n))
+    or_ (shr_u x (Rep.of_int n)) (shl x (Rep.of_int (Rep.bitwidth - n)))
 
   (* clz is defined for all values, including all-zeros. *)
   let clz x =
@@ -223,8 +286,33 @@ struct
   let ge_s x y = x >= y
   let ge_u x y = cmp_u x (>=) y
 
+  let saturate_s x = sx (min (max x low_int) high_int)
+  let saturate_u x = sx (min (max x Rep.zero) (as_unsigned Rep.minus_one))
+
+  (* add/sub for int, used for higher-precision arithmetic for I8 and I16 *)
+  let add_int x y =
+    assert (Rep.bitwidth < 32);
+    Rep.(of_int ((to_int x) + (to_int y)))
+
+  let sub_int x y =
+    assert (Rep.bitwidth < 32);
+    Rep.(of_int ((to_int x) - (to_int y)))
+
+  let add_sat_s x y = saturate_s (add_int x y)
+  let add_sat_u x y = saturate_u (add_int (as_unsigned x) (as_unsigned y))
+  let sub_sat_s x y = saturate_s (sub_int x y)
+  let sub_sat_u x y = saturate_u (sub_int (as_unsigned x) (as_unsigned y))
+
+  let q15mulr_sat_s x y =
+    (* mul x64 y64 can overflow int64 when both are int32 min, but this is only
+     * used by i16x8, so we are fine for now. *)
+    assert (Rep.bitwidth < 32);
+    let x64 = Rep.to_int64 x in
+    let y64 = Rep.to_int64 y in
+    saturate_s (Rep.of_int64 Int64.((shift_right (add (mul x64 y64) 0x4000L) 15)))
+
   let to_int_s = Rep.to_int
-  let to_int_u i = Rep.to_int i land (Rep.to_int Rep.max_int lsl 1) lor 1
+  let to_int_u i = Rep.to_int i land ((Rep.to_int Rep.max_int lsl 1) lor 1)
 
   let of_int_s = Rep.of_int
   let of_int_u i = and_ (Rep.of_int i) (or_ (shl (Rep.of_int max_int) one) one)
@@ -245,6 +333,23 @@ struct
 
   let max_upper, max_lower = divrem_u Rep.minus_one ten
 
+  let sign_extend i =
+    (* This module is used with I32 and I64, but the bitwidth can be less
+     * than that, e.g. for I16. When used for smaller integers, the stored value
+     * needs to be signed extended, e.g. parsing -1 into a I16 (backed by Int32)
+     * should have all high bits set. We can do that by logor with a mask,
+     * where the mask is minus_one left shifted by bitwidth. But if bitwidth
+     * matches the number of bits of Rep, the shift will be incorrect.
+     *   -1 (Int32) << 32 = -1
+     * Then the logor will be also wrong. So we check and bail out early.
+     * *)
+    if not needs_extend then i else
+    let sign_bit = Rep.logand (Rep.of_int (1 lsl (Rep.bitwidth - 1))) i in
+    if sign_bit = Rep.zero then i else
+    (* Build a sign-extension mask *)
+    let sign_mask = (Rep.shift_left Rep.minus_one Rep.bitwidth) in
+    Rep.logor sign_mask i
+
   let of_string s =
     let open Rep in
     let len = String.length s in
@@ -269,13 +374,18 @@ struct
       else parse_dec i zero
     in
     require (len > 0);
-    match s.[0] with
-    | '+' -> parse_int 1
-    | '-' ->
-      let n = parse_int 1 in
-      require (ge_s (sub n one) minus_one);
-      Rep.neg n
-    | _ -> parse_int 0
+    let parsed =
+      match s.[0] with
+      | '+' -> parse_int 1
+      | '-' ->
+        let n = parse_int 1 in
+        require (ge_s (sub n one) minus_one);
+        Rep.neg n
+      | _ -> parse_int 0
+    in
+    let n = sign_extend parsed in
+    require (low_int <= n && n <= high_int);
+    n
 
   let of_string_s s =
     let n = of_string s in
diff --git a/interpreter/exec/numeric_error.ml b/interpreter/exec/numeric_error.ml
deleted file mode 100644
index 0dcf7bc19..000000000
--- a/interpreter/exec/numeric_error.ml
+++ /dev/null
@@ -1,3 +0,0 @@
-exception IntegerOverflow
-exception IntegerDivideByZero
-exception InvalidConversionToInteger
diff --git a/interpreter/exec/v128.ml b/interpreter/exec/v128.ml
new file mode 100644
index 000000000..550fd9bfa
--- /dev/null
+++ b/interpreter/exec/v128.ml
@@ -0,0 +1,506 @@
+(* Types *)
+
+type t = string
+type bits = string
+
+type ('i8x16, 'i16x8, 'i32x4, 'i64x2, 'f32x4, 'f64x2) laneop =
+  | I8x16 of 'i8x16 | I16x8 of 'i16x8 | I32x4 of 'i32x4 | I64x2 of 'i64x2
+  | F32x4 of 'f32x4 | F64x2 of 'f64x2
+
+type shape = (unit, unit, unit, unit, unit, unit) laneop
+
+
+(* Basics *)
+
+let bitwidth = 128
+let bytewidth = bitwidth / 8
+
+let zero = String.make bytewidth '\x00'
+let of_bits x = x
+let to_bits x = x
+
+let num_lanes shape =
+  match shape with
+  | I8x16 _ -> 16
+  | I16x8 _ -> 8
+  | I32x4 _ -> 4
+  | I64x2 _ -> 2
+  | F32x4 _ -> 4
+  | F64x2 _ -> 2
+
+let type_of_lane = function
+  | I8x16 _ | I16x8 _ | I32x4 _ -> Types.I32Type
+  | I64x2 _ -> Types.I64Type
+  | F32x4 _ -> Types.F32Type
+  | F64x2 _ -> Types.F64Type
+
+
+(* Shape-based operations *)
+
+module Convert (Lane : sig type t end) =
+struct
+  module type S =
+  sig
+    val shape : shape
+    val to_lanes : t -> Lane.t list
+    val of_lanes : Lane.t list -> t
+  end
+end
+
+module type IntShape =
+sig
+  type lane
+
+  val num_lanes : int
+  val to_lanes : t -> lane list
+  val of_lanes : lane list -> t
+
+  val splat : lane -> t
+  val extract_lane_s : int -> t -> lane
+  val extract_lane_u : int -> t -> lane
+  val replace_lane : int -> t -> lane -> t
+
+  val eq : t -> t -> t
+  val ne : t -> t -> t
+  val lt_s : t -> t -> t
+  val lt_u : t -> t -> t
+  val le_s : t -> t -> t
+  val le_u : t -> t -> t
+  val gt_s : t -> t -> t
+  val gt_u : t -> t -> t
+  val ge_s : t -> t -> t
+  val ge_u : t -> t -> t
+  val abs : t -> t
+  val neg : t -> t
+  val popcnt : t -> t
+  val add : t -> t -> t
+  val sub : t -> t -> t
+  val min_s : t -> t -> t
+  val min_u : t -> t -> t
+  val max_s : t -> t -> t
+  val max_u : t -> t -> t
+  val mul : t -> t -> t
+  val avgr_u : t -> t -> t
+  val any_true : t -> bool
+  val all_true : t -> bool
+  val bitmask : t -> Int32.t
+  val shl : t -> I32.t -> t
+  val shr_s : t -> I32.t -> t
+  val shr_u : t -> I32.t -> t
+  val add_sat_s : t -> t -> t
+  val add_sat_u : t -> t -> t
+  val sub_sat_s : t -> t -> t
+  val sub_sat_u : t -> t -> t
+  val q15mulr_sat_s : t -> t -> t
+end
+
+module MakeIntShape (IXX : Ixx.S) (Cvt : Convert(IXX).S) :
+  IntShape with type lane = IXX.t =
+struct
+  type lane = IXX.t
+
+  let num_lanes = num_lanes Cvt.shape
+  let of_lanes = Cvt.of_lanes
+  let to_lanes = Cvt.to_lanes
+
+  let unop f x = of_lanes (List.map f (to_lanes x))
+  let unopi f x = of_lanes (List.mapi f (to_lanes x))
+  let binop f x y = of_lanes (List.map2 f (to_lanes x) (to_lanes y))
+  let reduceop f a s = List.fold_left (fun a b -> f a (b <> IXX.zero)) a (to_lanes s)
+  let cmp f x y = if f x y then IXX.of_int_s (-1) else IXX.zero
+
+  let splat x = of_lanes (List.init num_lanes (fun i -> x))
+  let extract_lane_s i s = List.nth (to_lanes s) i
+  let extract_lane_u i s = IXX.as_unsigned (extract_lane_s i s)
+  let replace_lane i v x = unopi (fun j y -> if j = i then x else y) v
+
+  let eq = binop (cmp IXX.eq)
+  let ne = binop (cmp IXX.ne)
+  let lt_s = binop (cmp IXX.lt_s)
+  let lt_u = binop (cmp IXX.lt_u)
+  let le_s = binop (cmp IXX.le_s)
+  let le_u = binop (cmp IXX.le_u)
+  let gt_s = binop (cmp IXX.gt_s)
+  let gt_u = binop (cmp IXX.gt_u)
+  let ge_s = binop (cmp IXX.ge_s)
+  let ge_u = binop (cmp IXX.ge_u)
+  let abs = unop IXX.abs
+  let neg = unop IXX.neg
+  let popcnt = unop IXX.popcnt
+  let add = binop IXX.add
+  let sub = binop IXX.sub
+  let mul = binop IXX.mul
+  let choose f x y = if f x y then x else y
+  let min_s = binop (choose IXX.le_s)
+  let min_u = binop (choose IXX.le_u)
+  let max_s = binop (choose IXX.ge_s)
+  let max_u = binop (choose IXX.ge_u)
+  (* The result of avgr_u will not overflow this type, but the intermediate might,
+   * so have the Int type implement it so they can extend it accordingly *)
+  let avgr_u = binop IXX.avgr_u
+  let any_true = reduceop (||) false
+  let all_true = reduceop (&&) true
+  (* Extract top bits using signed-comparision with zero *)
+  let bitmask x =
+    let xs = to_lanes x in
+    let negs = List.map (fun x -> if IXX.(lt_s x zero) then Int32.one else Int32.zero) xs in
+    List.fold_right (fun a b -> Int32.(logor a (shift_left b 1))) negs Int32.zero
+  let shl v s =
+    let shift = IXX.of_int_u (Int32.to_int s) in
+    unop (fun a -> IXX.shl a shift) v
+  let shr_s v s =
+    let shift = IXX.of_int_u (Int32.to_int s) in
+    unop (fun a -> IXX.shr_s a shift) v
+  let shr_u v s =
+    let shift = IXX.of_int_u (Int32.to_int s) in
+    unop (fun a -> IXX.shr_u a shift) v
+  let add_sat_s = binop IXX.add_sat_s
+  let add_sat_u = binop IXX.add_sat_u
+  let sub_sat_s = binop IXX.sub_sat_s
+  let sub_sat_u = binop IXX.sub_sat_u
+  (* The intermediate will overflow lane.t, so have Int implement this. *)
+  let q15mulr_sat_s = binop IXX.q15mulr_sat_s
+end
+
+module type FloatShape =
+sig
+  type lane
+
+  val num_lanes : int
+  val to_lanes : t -> lane list
+  val of_lanes : lane list -> t
+
+  val splat : lane -> t
+  val extract_lane : int -> t -> lane
+  val replace_lane : int -> t -> lane -> t
+
+  val eq : t -> t -> t
+  val ne : t -> t -> t
+  val lt : t -> t -> t
+  val le : t -> t -> t
+  val gt : t -> t -> t
+  val ge : t -> t -> t
+  val abs : t -> t
+  val neg : t -> t
+  val sqrt : t -> t
+  val ceil : t -> t
+  val floor : t -> t
+  val trunc : t -> t
+  val nearest : t -> t
+  val add : t -> t -> t
+  val sub : t -> t -> t
+  val mul : t -> t -> t
+  val div : t -> t -> t
+  val min : t -> t -> t
+  val max : t -> t -> t
+  val pmin : t -> t -> t
+  val pmax : t -> t -> t
+end
+
+module MakeFloatShape (FXX : Fxx.S) (Cvt : Convert(FXX).S) :
+  FloatShape with type lane = FXX.t =
+struct
+  type lane = FXX.t
+
+  let num_lanes = num_lanes Cvt.shape
+  let of_lanes = Cvt.of_lanes
+  let to_lanes = Cvt.to_lanes
+
+  let unop f x = of_lanes (List.map f (to_lanes x))
+  let unopi f x = of_lanes (List.mapi f (to_lanes x))
+  let binop f x y = of_lanes (List.map2 f (to_lanes x) (to_lanes y))
+  let all_ones = FXX.of_float (Int64.float_of_bits (Int64.minus_one))
+  let cmp f x y = if f x y then all_ones else FXX.zero
+
+  let splat x = of_lanes (List.init num_lanes (fun i -> x))
+  let extract_lane i s = List.nth (to_lanes s) i
+  let replace_lane i v x = unopi (fun j y -> if j = i then x else y) v
+
+  let eq = binop (cmp FXX.eq)
+  let ne = binop (cmp FXX.ne)
+  let lt = binop (cmp FXX.lt)
+  let le = binop (cmp FXX.le)
+  let gt = binop (cmp FXX.gt)
+  let ge = binop (cmp FXX.ge)
+  let abs = unop FXX.abs
+  let neg = unop FXX.neg
+  let sqrt = unop FXX.sqrt
+  let ceil = unop FXX.ceil
+  let floor = unop FXX.floor
+  let trunc = unop FXX.trunc
+  let nearest = unop FXX.nearest
+  let add = binop FXX.add
+  let sub = binop FXX.sub
+  let mul = binop FXX.mul
+  let div = binop FXX.div
+  let min = binop FXX.min
+  let max = binop FXX.max
+  let pmin = binop (fun x y -> if FXX.lt y x then y else x)
+  let pmax = binop (fun x y -> if FXX.lt x y then y else x)
+end
+
+module I8x16 = MakeIntShape (I8)
+  (struct
+    let shape = I8x16 ()
+    let to_lanes s =
+      List.init 16 (fun i -> Int32.of_int (Bytes.get_int8 (Bytes.of_string s) i))
+    let of_lanes fs =
+      let b = Bytes.create bytewidth in
+      List.iteri (fun i f -> Bytes.set_int8 b i (Int32.to_int f)) fs;
+      Bytes.to_string b
+  end)
+
+module I16x8 = MakeIntShape (I16)
+  (struct
+    let shape = I16x8 ()
+    let to_lanes s =
+      List.init 8 (fun i -> Int32.of_int (Bytes.get_int16_le (Bytes.of_string s) (i*2)))
+    let of_lanes fs =
+      let b = Bytes.create bytewidth in
+      List.iteri (fun i f -> Bytes.set_int16_le b (i*2) (Int32.to_int f)) fs;
+      Bytes.to_string b
+  end)
+
+module I32x4 = MakeIntShape (I32)
+  (struct
+    let shape = I32x4 ()
+    let to_lanes s =
+      List.init 4 (fun i -> I32.of_bits (Bytes.get_int32_le (Bytes.of_string s) (i*4)))
+    let of_lanes fs =
+      let b = Bytes.create bytewidth in
+      List.iteri (fun i f -> Bytes.set_int32_le b (i*4) (I32.to_bits f)) fs;
+      Bytes.to_string b
+  end)
+
+module I64x2 = MakeIntShape (I64)
+  (struct
+    let shape = I64x2 ()
+    let to_lanes s =
+      List.init 2 (fun i -> I64.of_bits (Bytes.get_int64_le (Bytes.of_string s) (i*8)))
+    let of_lanes fs =
+      let b = Bytes.create bytewidth in
+      List.iteri (fun i f -> Bytes.set_int64_le b (i*8) (I64.to_bits f)) fs;
+      Bytes.to_string b
+  end)
+
+module F32x4 = MakeFloatShape (F32)
+  (struct
+    let shape = F32x4 ()
+    let to_lanes s =
+      List.init 4 (fun i -> F32.of_bits (Bytes.get_int32_le (Bytes.of_string s) (i*4)))
+    let of_lanes fs =
+      let b = Bytes.create bytewidth in
+      List.iteri (fun i f -> Bytes.set_int32_le b (i*4) (F32.to_bits f)) fs;
+      Bytes.to_string b
+  end)
+
+module F64x2 = MakeFloatShape (F64)
+  (struct
+    let shape = F64x2 ()
+    let to_lanes s =
+      List.init 2 (fun i -> F64.of_bits (Bytes.get_int64_le (Bytes.of_string s) (i*8)))
+    let of_lanes fs =
+      let b = Bytes.create bytewidth in
+      List.iteri (fun i f -> Bytes.set_int64_le b (i*8) (F64.to_bits f)) fs;
+      Bytes.to_string b
+  end)
+
+
+(* Special shapes *)
+
+module V1x128 =
+struct
+  let unop f x = I64x2.of_lanes (List.map f (I64x2.to_lanes x))
+  let binop f x y =
+    I64x2.of_lanes (List.map2 f (I64x2.to_lanes x) (I64x2.to_lanes y))
+
+  let lognot = unop I64.lognot
+  let and_ = binop I64.and_
+  let or_ = binop I64.or_
+  let xor = binop I64.xor
+  let andnot = binop (fun x y -> I64.and_ x (I64.lognot y))
+
+  let bitselect v1 v2 c =
+    let v2_andnot_c = andnot v2 c in
+    let v1_and_c = binop I64.and_ v1 c in
+    binop I64.or_ v1_and_c v2_andnot_c
+end
+
+module V8x16 =
+struct
+  let swizzle v1 v2 =
+    let ns = I8x16.to_lanes v1 in
+    let is = I8x16.to_lanes v2 in
+    let select i =
+      Option.value (List.nth_opt ns (I32.to_int_u i)) ~default: I32.zero
+    in I8x16.of_lanes (List.map select is)
+
+  let shuffle v1 v2 is =
+    let ns = I8x16.to_lanes v1 @ I8x16.to_lanes v2 in
+    I8x16.of_lanes (List.map (List.nth ns) is)
+end
+
+
+(* Conversions *)
+
+let narrow to_lanes of_lanes sat_op x y =
+  let xy = to_lanes x @ to_lanes y in
+  of_lanes (List.map sat_op xy)
+
+module I8x16_convert =
+struct
+  let narrow_s = narrow I16x8.to_lanes I8x16.of_lanes I8.saturate_s
+  let narrow_u = narrow I16x8.to_lanes I8x16.of_lanes I8.saturate_u
+end
+
+module I16x8_convert =
+struct
+  let narrow_s = narrow I32x4.to_lanes I16x8.of_lanes I16.saturate_s
+  let narrow_u = narrow I32x4.to_lanes I16x8.of_lanes I16.saturate_u
+
+  let ext_s = Int32.logand 0xffffffffl
+  let ext_u = Int32.logand 0xffl
+
+  let extend take_or_drop ext x =
+    I16x8.of_lanes (List.map ext (take_or_drop 8 (I8x16.to_lanes x)))
+  let extend_low_s = extend Lib.List.take ext_s
+  let extend_high_s = extend Lib.List.drop ext_s
+  let extend_low_u = extend Lib.List.take ext_u
+  let extend_high_u = extend Lib.List.drop ext_u
+
+  let extmul_low_s x y = I16x8.mul (extend_low_s x) (extend_low_s y)
+  let extmul_high_s x y = I16x8.mul (extend_high_s x) (extend_high_s y)
+  let extmul_low_u x y = I16x8.mul (extend_low_u x) (extend_low_u y)
+  let extmul_high_u x y = I16x8.mul (extend_high_u x) (extend_high_u y)
+
+  let extadd ext x y = Int32.add (ext x) (ext y)
+  let extadd_pairwise_s x =
+    I16x8.of_lanes (Lib.List.pairwise (extadd ext_s) (I8x16.to_lanes x))
+  let extadd_pairwise_u x =
+    I16x8.of_lanes (Lib.List.pairwise (extadd ext_u) (I8x16.to_lanes x))
+end
+
+module I32x4_convert =
+struct
+  let convert f v = I32x4.of_lanes (List.map f (F32x4.to_lanes v))
+  let trunc_sat_f32x4_s = convert I32_convert.trunc_sat_f32_s
+  let trunc_sat_f32x4_u = convert I32_convert.trunc_sat_f32_u
+
+  let convert_zero f v =
+    I32x4.of_lanes (List.map f (F64x2.to_lanes v) @ I32.[zero; zero])
+  let trunc_sat_f64x2_s_zero = convert_zero I32_convert.trunc_sat_f64_s
+  let trunc_sat_f64x2_u_zero = convert_zero I32_convert.trunc_sat_f64_u
+
+  let ext_s = Int32.logand 0xffffffffl
+  let ext_u = Int32.logand 0xffffl
+
+  let extend take_or_drop ext x =
+    I32x4.of_lanes (List.map ext (take_or_drop 4 (I16x8.to_lanes x)))
+  let extend_low_s = extend Lib.List.take ext_s
+  let extend_high_s = extend Lib.List.drop ext_s
+  let extend_low_u = extend Lib.List.take ext_u
+  let extend_high_u = extend Lib.List.drop ext_u
+
+  let dot_s x y =
+    let xs = I16x8.to_lanes x in
+    let ys = I16x8.to_lanes y in
+    let rec dot xs ys =
+      match xs, ys with
+      | x1::x2::xss, y1::y2::yss ->
+        Int32.(add (mul x1 y1) (mul x2 y2)) :: dot xss yss
+      | [], [] -> []
+      | _, _ -> assert false
+    in I32x4.of_lanes (dot xs ys)
+
+  let extmul_low_s x y = I32x4.mul (extend_low_s x) (extend_low_s y)
+  let extmul_high_s x y = I32x4.mul (extend_high_s x) (extend_high_s y)
+  let extmul_low_u x y = I32x4.mul (extend_low_u x) (extend_low_u y)
+  let extmul_high_u x y = I32x4.mul (extend_high_u x) (extend_high_u y)
+
+  let extadd ext x y = Int32.add (ext x) (ext y)
+  let extadd_pairwise_s x =
+    I32x4.of_lanes (Lib.List.pairwise (extadd ext_s) (I16x8.to_lanes x))
+  let extadd_pairwise_u x =
+    I32x4.of_lanes (Lib.List.pairwise (extadd ext_u) (I16x8.to_lanes x))
+end
+
+module I64x2_convert =
+struct
+  let ext_s = Int64.logand 0xffffffffffffffffL
+  let ext_u = Int64.logand 0xffffffffL
+
+  let extend take_or_drop ext x =
+    I64x2.of_lanes
+      (List.map
+        (fun i32 -> ext (Int64.of_int32 i32))
+        (take_or_drop 2 (I32x4.to_lanes x)))
+  let extend_low_s = extend Lib.List.take ext_s
+  let extend_high_s = extend Lib.List.drop ext_s
+  let extend_low_u = extend Lib.List.take ext_u
+  let extend_high_u = extend Lib.List.drop ext_u
+
+  let extmul_low_s x y = I64x2.mul (extend_low_s x) (extend_low_s y)
+  let extmul_high_s x y = I64x2.mul (extend_high_s x) (extend_high_s y)
+  let extmul_low_u x y = I64x2.mul (extend_low_u x) (extend_low_u y)
+  let extmul_high_u x y = I64x2.mul (extend_high_u x) (extend_high_u y)
+end
+
+module F32x4_convert =
+struct
+  let convert f v = F32x4.of_lanes (List.map f (I32x4.to_lanes v))
+  let convert_i32x4_s = convert F32_convert.convert_i32_s
+  let convert_i32x4_u = convert F32_convert.convert_i32_u
+  let demote_f64x2_zero v =
+    F32x4.of_lanes
+      (List.map F32_convert.demote_f64 (F64x2.to_lanes v) @ F32.[zero; zero])
+end
+
+module F64x2_convert =
+struct
+  let convert f v =
+    F64x2.of_lanes (List.map f (Lib.List.take 2 (I32x4.to_lanes v)))
+  let convert_i32x4_s = convert F64_convert.convert_i32_s
+  let convert_i32x4_u = convert F64_convert.convert_i32_u
+  let promote_low_f32x4 v =
+    F64x2.of_lanes
+      (List.map F64_convert.promote_f32 (Lib.List.take 2 (F32x4.to_lanes v)))
+end
+
+
+(* String conversion *)
+
+let to_string s =
+  String.concat " " (List.map I32.to_string_s (I32x4.to_lanes s))
+
+let to_hex_string s =
+  String.concat " " (List.map I32.to_hex_string (I32x4.to_lanes s))
+
+let of_strings shape ss =
+  if List.length ss <> num_lanes shape then
+    raise (Invalid_argument "wrong length");
+  let open Bytes in
+  let b = create bytewidth in
+  (match shape with
+  | I8x16 () ->
+    List.iteri (fun i s -> set_uint8 b i (I8.to_int_u (I8.of_string s))) ss
+  | I16x8 () ->
+    List.iteri (fun i s -> set_int16_le b (i * 2) (I16.to_int_u (I16.of_string s))) ss
+  | I32x4 () ->
+    List.iteri (fun i s -> set_int32_le b (i * 4) (I32.of_string s)) ss
+  | I64x2 () ->
+    List.iteri (fun i s -> set_int64_le b (i * 8) (I64.of_string s)) ss
+  | F32x4 () ->
+    List.iteri (fun i s -> set_int32_le b (i * 4) (F32.to_bits (F32.of_string s))) ss
+  | F64x2 () ->
+    List.iteri (fun i s -> set_int64_le b (i * 8) (F64.to_bits (F64.of_string s))) ss
+  );
+  to_string b
+
+
+let string_of_shape = function
+  | I8x16 _ -> "i8x16"
+  | I16x8 _ -> "i16x8"
+  | I32x4 _ -> "i32x4"
+  | I64x2 _ -> "i64x2"
+  | F32x4 _ -> "f32x4"
+  | F64x2 _ -> "f64x2"
diff --git a/interpreter/exec/v128.mli b/interpreter/exec/v128.mli
new file mode 100644
index 000000000..f9535c158
--- /dev/null
+++ b/interpreter/exec/v128.mli
@@ -0,0 +1,211 @@
+(* Types *)
+
+type t
+type bits = string
+
+type ('i8x16, 'i16x8, 'i32x4, 'i64x2, 'f32x4, 'f64x2) laneop =
+  | I8x16 of 'i8x16 | I16x8 of 'i16x8 | I32x4 of 'i32x4 | I64x2 of 'i64x2
+  | F32x4 of 'f32x4 | F64x2 of 'f64x2
+
+type shape = (unit, unit, unit, unit, unit, unit) laneop
+
+
+(* Basics *)
+
+val bitwidth : int
+
+val num_lanes : ('a, 'b, 'c, 'd, 'e, 'f) laneop -> int
+val type_of_lane : ('a, 'b, 'c, 'd, 'e, 'f) laneop -> Types.num_type
+val string_of_shape : ('a, 'b, 'c, 'd, 'e, 'f) laneop -> string
+
+val zero : t
+val of_bits : bits -> t
+val to_bits : t -> bits
+
+
+(* String conversion *)
+
+val to_string : t -> string
+val to_hex_string : t -> string
+val of_strings : shape -> string list -> t
+
+
+(* Shape-based operations *)
+
+module type IntShape =
+sig
+  type lane
+
+  val num_lanes : int
+  val to_lanes : t -> lane list
+  val of_lanes : lane list -> t
+
+  val splat : lane -> t
+  val extract_lane_s : int -> t -> lane
+  val extract_lane_u : int -> t -> lane
+  val replace_lane : int -> t -> lane -> t
+
+  val eq : t -> t -> t
+  val ne : t -> t -> t
+  val lt_s : t -> t -> t
+  val lt_u : t -> t -> t
+  val le_s : t -> t -> t
+  val le_u : t -> t -> t
+  val gt_s : t -> t -> t
+  val gt_u : t -> t -> t
+  val ge_s : t -> t -> t
+  val ge_u : t -> t -> t
+  val abs : t -> t
+  val neg : t -> t
+  val popcnt : t -> t
+  val add : t -> t -> t
+  val sub : t -> t -> t
+  val min_s : t -> t -> t
+  val min_u : t -> t -> t
+  val max_s : t -> t -> t
+  val max_u : t -> t -> t
+  val mul : t -> t -> t
+  val avgr_u : t -> t -> t
+  val any_true : t -> bool
+  val all_true : t -> bool
+  val bitmask : t -> Int32.t
+  val shl : t -> I32.t -> t
+  val shr_s : t -> I32.t -> t
+  val shr_u : t -> I32.t -> t
+  val add_sat_s : t -> t -> t
+  val add_sat_u : t -> t -> t
+  val sub_sat_s : t -> t -> t
+  val sub_sat_u : t -> t -> t
+  val q15mulr_sat_s : t -> t -> t
+end
+
+module type FloatShape =
+sig
+  type lane
+
+  val num_lanes : int
+  val to_lanes : t -> lane list
+  val of_lanes : lane list -> t
+
+  val splat : lane -> t
+  val extract_lane : int -> t -> lane
+  val replace_lane : int -> t -> lane -> t
+
+  val eq : t -> t -> t
+  val ne : t -> t -> t
+  val lt : t -> t -> t
+  val le : t -> t -> t
+  val gt : t -> t -> t
+  val ge : t -> t -> t
+  val abs : t -> t
+  val neg : t -> t
+  val sqrt : t -> t
+  val ceil : t -> t
+  val floor : t -> t
+  val trunc : t -> t
+  val nearest : t -> t
+  val add : t -> t -> t
+  val sub : t -> t -> t
+  val mul : t -> t -> t
+  val div : t -> t -> t
+  val min : t -> t -> t
+  val max : t -> t -> t
+  val pmin : t -> t -> t
+  val pmax : t -> t -> t
+end
+
+module I8x16 : IntShape with type lane = I8.t
+module I16x8 : IntShape with type lane = I16.t
+module I32x4 : IntShape with type lane = I32.t
+module I64x2 : IntShape with type lane = I64.t
+module F32x4 : FloatShape with type lane = F32.t
+module F64x2 : FloatShape with type lane = F64.t
+
+
+(* Special shapes *)
+
+module V1x128 :
+sig
+  val lognot : t -> t
+  val and_ : t -> t -> t
+  val or_ : t -> t -> t
+  val xor : t -> t -> t
+  val andnot : t -> t -> t
+  val bitselect : t -> t -> t -> t
+end
+
+module V8x16 :
+sig
+  val swizzle : t -> t -> t
+  val shuffle : t -> t -> int list -> t
+end
+
+
+(* Conversions *)
+
+module I8x16_convert :
+sig
+  val narrow_s : t -> t -> t
+  val narrow_u : t -> t -> t
+end
+
+module I16x8_convert :
+sig
+  val narrow_s : t -> t -> t
+  val narrow_u : t -> t -> t
+  val extend_low_s : t -> t
+  val extend_high_s : t -> t
+  val extend_low_u : t -> t
+  val extend_high_u : t -> t
+  val extmul_low_s : t -> t -> t
+  val extmul_high_s : t -> t -> t
+  val extmul_low_u : t -> t -> t
+  val extmul_high_u : t -> t -> t
+  val extadd_pairwise_s : t -> t
+  val extadd_pairwise_u : t -> t
+end
+
+module I32x4_convert :
+sig
+  val trunc_sat_f32x4_s : t -> t
+  val trunc_sat_f32x4_u : t -> t
+  val trunc_sat_f64x2_s_zero : t -> t
+  val trunc_sat_f64x2_u_zero : t -> t
+  val extend_low_s : t -> t
+  val extend_high_s : t -> t
+  val extend_low_u : t -> t
+  val extend_high_u : t -> t
+  val dot_s : t -> t -> t
+  val extmul_low_s : t -> t -> t
+  val extmul_high_s : t -> t -> t
+  val extmul_low_u : t -> t -> t
+  val extmul_high_u : t -> t -> t
+  val extadd_pairwise_s : t -> t
+  val extadd_pairwise_u : t -> t
+end
+
+module I64x2_convert :
+sig
+  val extend_low_s : t -> t
+  val extend_high_s : t -> t
+  val extend_low_u : t -> t
+  val extend_high_u : t -> t
+  val extmul_low_s : t -> t -> t
+  val extmul_high_s : t -> t -> t
+  val extmul_low_u : t -> t -> t
+  val extmul_high_u : t -> t -> t
+end
+
+module F32x4_convert :
+sig
+  val convert_i32x4_s : t -> t
+  val convert_i32x4_u : t -> t
+  val demote_f64x2_zero : t -> t
+end
+
+module F64x2_convert :
+sig
+  val promote_low_f32x4 : t -> t
+  val convert_i32x4_s : t -> t
+  val convert_i32x4_u : t -> t
+end
diff --git a/interpreter/host/spectest.ml b/interpreter/host/spectest.ml
index 77b711601..c3a783786 100644
--- a/interpreter/host/spectest.ml
+++ b/interpreter/host/spectest.ml
@@ -14,6 +14,7 @@ let global (GlobalType (t, _) as gt) =
     | NumType I64Type -> Num (I64 666L)
     | NumType F32Type -> Num (F32 (F32.of_float 666.6))
     | NumType F64Type -> Num (F64 (F64.of_float 666.6))
+    | VecType V128Type -> Vec (V128 (V128.I32x4.of_lanes [666l; 666l; 666l; 666l]))
     | RefType t -> Ref (NullRef t)
   in Global.alloc gt v
 
diff --git a/interpreter/runtime/instance.ml b/interpreter/runtime/instance.ml
index efc230e0f..4d4fece07 100644
--- a/interpreter/runtime/instance.ml
+++ b/interpreter/runtime/instance.ml
@@ -43,6 +43,13 @@ let () =
     | FuncRef _ -> "func"
     | r -> string_of_ref' r
 
+let () =
+  let eq_ref' = !Values.eq_ref' in
+  Values.eq_ref' := fun r1 r2 ->
+    match r1, r2 with
+    | FuncRef f1, FuncRef f2 -> f1 == f2
+    | _, _ -> eq_ref' r1 r2
+
 
 (* Auxiliary functions *)
 
diff --git a/interpreter/runtime/memory.ml b/interpreter/runtime/memory.ml
index 263c9687a..e2c1fbf70 100644
--- a/interpreter/runtime/memory.ml
+++ b/interpreter/runtime/memory.ml
@@ -103,7 +103,7 @@ let storen mem a o n x =
   in loop (effective_address a o) n x
 
 let load_num mem a o t =
-  let n = loadn mem a o (Types.size t) in
+  let n = loadn mem a o (Types.num_size t) in
   match t with
   | I32Type -> I32 (Int64.to_int32 n)
   | I64Type -> I64 n
@@ -111,20 +111,19 @@ let load_num mem a o t =
   | F64Type -> F64 (F64.of_bits n)
 
 let store_num mem a o n =
-  let x =
-    match n with
-    | I32 x -> Int64.of_int32 x
-    | I64 x -> x
-    | F32 x -> Int64.of_int32 (F32.to_bits x)
-    | F64 x -> F64.to_bits x
-  in storen mem a o (Types.size (Values.type_of_num n)) x
+  let store = storen mem a o (Types.num_size (Values.type_of_num n)) in
+  match n with
+  | I32 x -> store (Int64.of_int32 x)
+  | I64 x -> store x
+  | F32 x -> store (Int64.of_int32 (F32.to_bits x))
+  | F64 x -> store (F64.to_bits x)
 
 let extend x n = function
   | ZX -> x
   | SX -> let sh = 64 - 8 * n in Int64.(shift_right (shift_left x sh) sh)
 
-let load_packed sz ext mem a o t =
-  assert (packed_size sz <= Types.size t);
+let load_num_packed sz ext mem a o t =
+  assert (packed_size sz <= num_size t);
   let w = packed_size sz in
   let x = extend (loadn mem a o w) w ext in
   match t with
@@ -132,8 +131,8 @@ let load_packed sz ext mem a o t =
   | I64Type -> I64 x
   | _ -> raise Type
 
-let store_packed sz mem a o n =
-  assert (packed_size sz <= Types.size (Values.type_of_num n));
+let store_num_packed sz mem a o n =
+  assert (packed_size sz <= num_size (Values.type_of_num n));
   let w = packed_size sz in
   let x =
     match n with
@@ -141,3 +140,36 @@ let store_packed sz mem a o n =
     | I64 x -> x
     | _ -> raise Type
   in storen mem a o w x
+
+let load_vec mem a o t =
+  match t with
+  | V128Type ->
+    V128 (V128.of_bits (load_bytes mem (effective_address a o) (Types.vec_size t)))
+
+let store_vec mem a o n =
+  match n with
+  | V128 x -> store_bytes mem (effective_address a o) (V128.to_bits x)
+
+let load_vec_packed sz ext mem a o t =
+  assert (packed_size sz < vec_size t);
+  let x = loadn mem a o (packed_size sz) in
+  let b = Bytes.make 16 '\x00' in
+  Bytes.set_int64_le b 0 x;
+  let v = V128.of_bits (Bytes.to_string b) in
+  let r =
+    match sz, ext with
+    | Pack64, ExtLane (Pack8x8, SX) -> V128.I16x8_convert.extend_low_s v
+    | Pack64, ExtLane (Pack8x8, ZX) -> V128.I16x8_convert.extend_low_u v
+    | Pack64, ExtLane (Pack16x4, SX) -> V128.I32x4_convert.extend_low_s v
+    | Pack64, ExtLane (Pack16x4, ZX) -> V128.I32x4_convert.extend_low_u v
+    | Pack64, ExtLane (Pack32x2, SX) -> V128.I64x2_convert.extend_low_s v
+    | Pack64, ExtLane (Pack32x2, ZX) -> V128.I64x2_convert.extend_low_u v
+    | _, ExtLane _ -> assert false
+    | Pack8, ExtSplat -> V128.I8x16.splat (I8.of_int_s (Int64.to_int x))
+    | Pack16, ExtSplat -> V128.I16x8.splat (I16.of_int_s (Int64.to_int x))
+    | Pack32, ExtSplat -> V128.I32x4.splat (I32.of_int_s (Int64.to_int x))
+    | Pack64, ExtSplat -> V128.I64x2.splat x
+    | Pack32, ExtZero -> v
+    | Pack64, ExtZero -> v
+    | _, ExtZero -> assert false
+  in V128 r
diff --git a/interpreter/runtime/memory.mli b/interpreter/runtime/memory.mli
index 2ed721e89..d3ee9c532 100644
--- a/interpreter/runtime/memory.mli
+++ b/interpreter/runtime/memory.mli
@@ -33,9 +33,18 @@ val load_num :
   memory -> address -> offset -> num_type -> num (* raises Bounds *)
 val store_num :
   memory -> address -> offset -> num -> unit (* raises Bounds *)
-val load_packed :
+val load_num_packed :
   pack_size -> extension -> memory -> address -> offset -> num_type -> num
     (* raises Type, Bounds *)
-val store_packed :
+val store_num_packed :
   pack_size -> memory -> address -> offset -> num -> unit
     (* raises Type, Bounds *)
+
+val load_vec :
+  memory -> address -> offset -> vec_type -> vec (* raises Bounds *)
+val store_vec :
+  memory -> address -> offset -> vec -> unit
+    (* raises Type, Bounds *)
+val load_vec_packed :
+  pack_size -> vec_extension -> memory -> address -> offset -> vec_type -> vec
+    (* raises Type, Bounds *)
diff --git a/interpreter/script/js.ml b/interpreter/script/js.ml
index 827c97a6e..093da2463 100644
--- a/interpreter/script/js.ml
+++ b/interpreter/script/js.ml
@@ -260,7 +260,8 @@ let abs_mask_of = function
 
 let value v =
   match v.it with
-  | Values.Num num -> [Const (num @@ v.at) @@ v.at]
+  | Values.Num n -> [Const (n @@ v.at) @@ v.at]
+  | Values.Vec s -> [VecConst (s @@ v.at) @@ v.at]
   | Values.Ref (Values.NullRef t) -> [RefNull t @@ v.at]
   | Values.Ref (ExternRef n) ->
     [Const (Values.I32 n @@ v.at) @@ v.at; Call (externref_idx @@ v.at) @@ v.at]
@@ -278,8 +279,12 @@ let run ts at =
 
 let assert_return ress ts at =
   let test res =
+    let nan_bitmask_of = function
+      | CanonicalNan -> abs_mask_of (* must only differ from the canonical NaN in its sign bit *)
+      | ArithmeticNan -> canonical_nan_of (* can be any NaN that's one everywhere the canonical NaN is one *)
+    in
     match res.it with
-    | LitResult {it = Values.Num num; at = at'} ->
+    | NumResult (NumPat {it = num; at = at'}) ->
       let t', reinterpret = reinterpret_of (Values.type_of_num num) in
       [ reinterpret @@ at;
         Const (num @@ at')  @@ at;
@@ -287,39 +292,80 @@ let assert_return ress ts at =
         Compare (eq_of t') @@ at;
         Test (Values.I32 I32Op.Eqz) @@ at;
         BrIf (0l @@ at) @@ at ]
-    | LitResult {it = Values.Ref (Values.NullRef t); _} ->
-      [ RefIsNull @@ at;
-        Test (Values.I32 I32Op.Eqz) @@ at;
-        BrIf (0l @@ at) @@ at ]
-    | LitResult {it = Values.Ref (ExternRef n); _} ->
-      [ Const (Values.I32 n @@ at) @@ at;
-        Call (externref_idx @@ at) @@ at;
-        Call (eq_externref_idx @@ at)  @@ at;
-        Test (Values.I32 I32Op.Eqz) @@ at;
-        BrIf (0l @@ at) @@ at ]
-    | LitResult {it = Values.Ref _; _} ->
-      assert false
-    | NanResult nanop ->
+    | NumResult (NanPat nanop) ->
       let nan =
         match nanop.it with
-        | Values.I32 _ | Values.I64 _ -> assert false
+        | Values.I32 _ | Values.I64 _ -> .
         | Values.F32 n | Values.F64 n -> n
       in
-      let nan_bitmask_of =
-        match nan with
-        | CanonicalNan -> abs_mask_of (* must only differ from the canonical NaN in its sign bit *)
-        | ArithmeticNan -> canonical_nan_of (* can be any NaN that's one everywhere the canonical NaN is one *)
-      in
       let t = Values.type_of_num nanop.it in
       let t', reinterpret = reinterpret_of t in
       [ reinterpret @@ at;
-        Const (nan_bitmask_of t' @@ at) @@ at;
+        Const (nan_bitmask_of nan t' @@ at) @@ at;
         Binary (and_of t') @@ at;
         Const (canonical_nan_of t' @@ at) @@ at;
         Compare (eq_of t') @@ at;
         Test (Values.I32 I32Op.Eqz) @@ at;
         BrIf (0l @@ at) @@ at ]
-    | RefResult t ->
+    | VecResult (VecPat (Values.V128 (shape, pats))) ->
+      let open Values in
+      (* VecResult is a list of NumPat or LitPat. For float shapes, we can have a mix of literals
+       * and NaNs. For NaNs, we need to mask it and compare with a canonical NaN. To simplify
+       * comparison, we build masks even for literals (will just be all set), collect them into
+       * a v128, then compare the entire 128 bits.
+       *)
+      let mask_and_canonical = function
+        | NumPat {it = I32 _ as i; _} -> I32 (Int32.minus_one), i
+        | NumPat {it = I64 _ as i; _} -> I64 (Int64.minus_one), i
+        | NumPat {it = F32 f; _} ->
+          I32 (Int32.minus_one), I32 (I32_convert.reinterpret_f32 f)
+        | NumPat {it = F64 f; _} ->
+          I64 (Int64.minus_one), I64 (I64_convert.reinterpret_f64 f)
+        | NanPat {it = F32 nan; _} ->
+          nan_bitmask_of nan I32Type, canonical_nan_of I32Type
+        | NanPat {it = F64 nan; _} ->
+          nan_bitmask_of nan I64Type, canonical_nan_of I64Type
+        | _ -> .
+      in
+      let masks, canons = List.split (List.map (fun p -> mask_and_canonical p) pats) in
+      let all_ones = V128.I32x4.of_lanes (List.init 4 (fun _ -> Int32.minus_one)) in
+      let mask, expected = match shape with
+        | V128.I8x16 () ->
+          all_ones, V128.I8x16.of_lanes (List.map (I32Num.of_num 0) canons)
+        | V128.I16x8 () ->
+          all_ones, V128.I16x8.of_lanes (List.map (I32Num.of_num 0) canons)
+        | V128.I32x4 () ->
+          all_ones, V128.I32x4.of_lanes (List.map (I32Num.of_num 0) canons)
+        | V128.I64x2 () ->
+          all_ones, V128.I64x2.of_lanes (List.map (I64Num.of_num 0) canons)
+        | V128.F32x4 () ->
+          V128.I32x4.of_lanes (List.map (I32Num.of_num 0) masks),
+          V128.I32x4.of_lanes (List.map (I32Num.of_num 0) canons)
+        | V128.F64x2 () ->
+          V128.I64x2.of_lanes (List.map (I64Num.of_num 0) masks),
+          V128.I64x2.of_lanes (List.map (I64Num.of_num 0) canons)
+      in
+      [ VecConst (V128 mask @@ at) @@ at;
+        VecBinaryBits (V128 V128Op.And) @@ at;
+        VecConst (V128 expected @@ at) @@ at;
+        VecCompare (V128 (V128.I8x16 V128Op.Eq)) @@ at;
+        (* If all lanes are non-zero, then they are equal *)
+        VecTest (V128 (V128.I8x16 V128Op.AllTrue)) @@ at;
+        Test (I32 I32Op.Eqz) @@ at;
+        BrIf (0l @@ at) @@ at ]
+    | RefResult (RefPat {it = Values.NullRef t; _}) ->
+      [ RefIsNull @@ at;
+        Test (Values.I32 I32Op.Eqz) @@ at;
+        BrIf (0l @@ at) @@ at ]
+    | RefResult (RefPat {it = ExternRef n; _}) ->
+      [ Const (Values.I32 n @@ at) @@ at;
+        Call (externref_idx @@ at) @@ at;
+        Call (eq_externref_idx @@ at)  @@ at;
+        Test (Values.I32 I32Op.Eqz) @@ at;
+        BrIf (0l @@ at) @@ at ]
+    | RefResult (RefPat _) ->
+      assert false
+    | RefResult (RefTypePat t) ->
       let is_ref_idx =
         match t with
         | FuncRefType -> is_funcref_idx
@@ -378,6 +424,7 @@ let is_js_num_type = function
 
 let is_js_value_type = function
   | NumType t -> is_js_num_type t
+  | VecType t -> false
   | RefType t -> true
 
 let is_js_global_type = function
@@ -421,30 +468,57 @@ let of_float z =
   | "-inf" -> "-Infinity"
   | s -> s
 
+let of_num n =
+  let open Values in
+  match n with
+  | I32 i -> I32.to_string_s i
+  | I64 i -> "int64(\"" ^ I64.to_string_s i ^ "\")"
+  | F32 z -> of_float (F32.to_float z)
+  | F64 z -> of_float (F64.to_float z)
+
+let of_vec v =
+  let open Values in
+  match v with
+  | V128 v -> "v128(\"" ^ V128.to_string v ^ "\")"
+
+let of_ref r =
+  let open Values in
+  match r with
+  | NullRef _ -> "null"
+  | ExternRef n -> "externref(" ^ Int32.to_string n ^ ")"
+  | _ -> assert false
+
 let of_value v =
   let open Values in
   match v.it with
-  | Num (I32 i) -> I32.to_string_s i
-  | Num (I64 i) -> "int64(\"" ^ I64.to_string_s i ^ "\")"
-  | Num (F32 z) -> of_float (F32.to_float z)
-  | Num (F64 z) -> of_float (F64.to_float z)
-  | Ref (NullRef _) -> "null"
-  | Ref (ExternRef n) -> "externref(" ^ Int32.to_string n ^ ")"
-  | _ -> assert false
+  | Num n -> of_num n
+  | Vec v -> of_vec v
+  | Ref r -> of_ref r
 
 let of_nan = function
   | CanonicalNan -> "\"nan:canonical\""
   | ArithmeticNan -> "\"nan:arithmetic\""
 
+let of_num_pat = function
+  | NumPat num -> of_num num.it
+  | NanPat nanop ->
+    match nanop.it with
+    | Values.I32 _ | Values.I64 _ -> .
+    | Values.F32 n | Values.F64 n -> of_nan n
+
+let of_vec_pat = function
+  | VecPat (Values.V128 (shape, pats)) ->
+    Printf.sprintf "v128(\"%s\")" (String.concat " " (List.map of_num_pat pats))
+
+let of_ref_pat = function
+  | RefPat r -> of_ref r.it
+  | RefTypePat t -> "\"ref." ^ string_of_refed_type t ^ "\""
+
 let of_result res =
   match res.it with
-  | LitResult value -> of_value value
-  | NanResult nanop ->
-    (match nanop.it with
-    | Values.I32 _ | Values.I64 _ -> assert false
-    | Values.F32 n | Values.F64 n -> of_nan n
-    )
-  | RefResult t -> "\"ref." ^ string_of_refed_type t ^ "\""
+  | NumResult np -> of_num_pat np
+  | VecResult vp -> of_vec_pat vp
+  | RefResult rp -> of_ref_pat rp
 
 let rec of_definition def =
   match def.it with
diff --git a/interpreter/script/run.ml b/interpreter/script/run.ml
index 3eacaccaf..e0019d84a 100644
--- a/interpreter/script/run.ml
+++ b/interpreter/script/run.ml
@@ -252,19 +252,35 @@ let string_of_nan = function
 
 let type_of_result r =
   match r with
-  | LitResult v -> Values.type_of_value v.it
-  | NanResult n -> Types.NumType (Values.type_of_num n.it)
-  | RefResult t -> Types.RefType t
+  | NumResult (NumPat n) -> Types.NumType (Values.type_of_num n.it)
+  | NumResult (NanPat n) -> Types.NumType (Values.type_of_num n.it)
+  | VecResult (VecPat _) -> Types.VecType Types.V128Type
+  | RefResult (RefPat r) -> Types.RefType (Values.type_of_ref r.it)
+  | RefResult (RefTypePat t) -> Types.RefType t
+
+let string_of_num_pat (p : num_pat) =
+  match p with
+  | NumPat n -> Values.string_of_num n.it
+  | NanPat nanop ->
+    match nanop.it with
+    | Values.I32 _ | Values.I64 _ -> assert false
+    | Values.F32 n | Values.F64 n -> string_of_nan n
+
+let string_of_vec_pat (p : vec_pat) =
+  match p with
+  | VecPat (Values.V128 (shape, ns)) ->
+    String.concat " " (List.map string_of_num_pat ns)
+
+let string_of_ref_pat (p : ref_pat) =
+  match p with
+  | RefPat r -> Values.string_of_ref r.it
+  | RefTypePat t -> Types.string_of_refed_type t
 
 let string_of_result r =
   match r with
-  | LitResult v -> Values.string_of_value v.it
-  | NanResult nanop ->
-    (match nanop.it with
-    | Values.I32 _ | Values.I64 _ -> assert false
-    | Values.F32 n | Values.F64 n -> string_of_nan n
-    )
-  | RefResult t -> Types.string_of_refed_type t
+  | NumResult np -> string_of_num_pat np
+  | VecResult vp -> string_of_vec_pat vp
+  | RefResult rp -> string_of_ref_pat rp
 
 let string_of_results = function
   | [r] -> string_of_result r
@@ -352,34 +368,59 @@ let run_action act : Values.value list =
     | None -> Assert.error act.at "undefined export"
     )
 
-let assert_result at got expect =
+
+let assert_nan_pat n nan =
+  let open Values in
+  match n, nan.it with
+  | F32 z, F32 CanonicalNan -> z = F32.pos_nan || z = F32.neg_nan
+  | F64 z, F64 CanonicalNan -> z = F64.pos_nan || z = F64.neg_nan
+  | F32 z, F32 ArithmeticNan ->
+    let pos_nan = F32.to_bits F32.pos_nan in
+    Int32.logand (F32.to_bits z) pos_nan = pos_nan
+  | F64 z, F64 ArithmeticNan ->
+    let pos_nan = F64.to_bits F64.pos_nan in
+    Int64.logand (F64.to_bits z) pos_nan = pos_nan
+  | _, _ -> false
+
+let assert_num_pat n np =
+  match np with
+    | NumPat n' -> n = n'.it
+    | NanPat nanop -> assert_nan_pat n nanop
+
+let assert_vec_pat v p =
   let open Values in
+  match v, p with
+  | V128 v, VecPat (V128 (shape, ps)) ->
+    let extract = match shape with
+      | V128.I8x16 () -> fun v i -> I32 (V128.I8x16.extract_lane_s i v)
+      | V128.I16x8 () -> fun v i -> I32 (V128.I16x8.extract_lane_s i v)
+      | V128.I32x4 () -> fun v i -> I32 (V128.I32x4.extract_lane_s i v)
+      | V128.I64x2 () -> fun v i -> I64 (V128.I64x2.extract_lane_s i v)
+      | V128.F32x4 () -> fun v i -> F32 (V128.F32x4.extract_lane i v)
+      | V128.F64x2 () -> fun v i -> F64 (V128.F64x2.extract_lane i v)
+    in
+    List.for_all2 assert_num_pat
+      (List.init (V128.num_lanes shape) (extract v)) ps
+
+let assert_ref_pat r p =
+  match r, p with
+  | r, RefPat r' -> r = r'.it
+  | Instance.FuncRef _, RefTypePat Types.FuncRefType
+  | ExternRef _, RefTypePat Types.ExternRefType -> true
+  | _ -> false
+
+let assert_pat v r =
+  let open Values in
+  match v, r with
+  | Num n, NumResult np -> assert_num_pat n np
+  | Vec v, VecResult vp -> assert_vec_pat v vp
+  | Ref r, RefResult rp -> assert_ref_pat r rp
+  | _, _ -> false
+
+let assert_result at got expect =
   if
     List.length got <> List.length expect ||
-    List.exists2 (fun v r ->
-      match r with
-      | LitResult v' -> v <> v'.it
-      | NanResult nanop ->
-        (match nanop.it, v with
-        | F32 CanonicalNan, Num (F32 z) ->
-          z <> F32.pos_nan && z <> F32.neg_nan
-        | F64 CanonicalNan, Num (F64 z) ->
-          z <> F64.pos_nan && z <> F64.neg_nan
-        | F32 ArithmeticNan, Num (F32 z) ->
-          let pos_nan = F32.to_bits F32.pos_nan in
-          Int32.logand (F32.to_bits z) pos_nan <> pos_nan
-        | F64 ArithmeticNan, Num (F64 z) ->
-          let pos_nan = F64.to_bits F64.pos_nan in
-          Int64.logand (F64.to_bits z) pos_nan <> pos_nan
-        | _, _ -> false
-        )
-      | RefResult t ->
-        (match t, v with
-        | Types.FuncRefType, Ref (Instance.FuncRef _)
-        | Types.ExternRefType, Ref (ExternRef _) -> false
-        | _ -> true
-        )
-    ) got expect
+    List.exists2 (fun v r -> not (assert_pat v r)) got expect
   then begin
     print_string "Result: "; print_values got;
     print_string "Expect: "; print_results expect;
diff --git a/interpreter/script/script.ml b/interpreter/script/script.ml
index 6fe11950c..4c4f550f2 100644
--- a/interpreter/script/script.ml
+++ b/interpreter/script/script.ml
@@ -1,6 +1,8 @@
 type var = string Source.phrase
 
 type Values.ref_ += ExternRef of int32
+type num = Values.num Source.phrase
+type ref_ = Values.ref_ Source.phrase
 type literal = Values.value Source.phrase
 
 type definition = definition' Source.phrase
@@ -18,11 +20,22 @@ type nanop = nanop' Source.phrase
 and nanop' = (Lib.void, Lib.void, nan, nan) Values.op
 and nan = CanonicalNan | ArithmeticNan
 
+type num_pat =
+  | NumPat of num
+  | NanPat of nanop
+
+type vec_pat =
+  | VecPat of (V128.shape * num_pat list) Values.vecop
+
+type ref_pat =
+  | RefPat of ref_
+  | RefTypePat of Types.ref_type
+
 type result = result' Source.phrase
 and result' =
-  | LitResult of literal
-  | NanResult of nanop
-  | RefResult of Types.ref_type
+  | NumResult of num_pat
+  | VecResult of vec_pat
+  | RefResult of ref_pat
 
 type assertion = assertion' Source.phrase
 and assertion' =
@@ -64,3 +77,10 @@ let () =
   Values.string_of_ref' := function
     | ExternRef n -> "ref " ^ Int32.to_string n
     | r -> string_of_ref' r
+
+let () =
+  let eq_ref' = !Values.eq_ref' in
+  Values.eq_ref' := fun r1 r2 ->
+    match r1, r2 with
+    | ExternRef n1, ExternRef n2 -> n1 = n2
+    | _, _ -> eq_ref' r1 r2
diff --git a/interpreter/syntax/ast.ml b/interpreter/syntax/ast.ml
index d258986ea..b5e3ae6ee 100644
--- a/interpreter/syntax/ast.ml
+++ b/interpreter/syntax/ast.ml
@@ -18,6 +18,8 @@
 
 open Types
 
+type void = Lib.void
+
 
 (* Operators *)
 
@@ -38,7 +40,7 @@ module FloatOp =
 struct
   type unop = Neg | Abs | Ceil | Floor | Trunc | Nearest | Sqrt
   type binop = Add | Sub | Mul | Div | Min | Max | CopySign
-  type testop
+  type testop = |
   type relop = Eq | Ne | Lt | Gt | Le | Ge
   type cvtop = ConvertSI32 | ConvertUI32 | ConvertSI64 | ConvertUI64
              | PromoteF32 | DemoteF64
@@ -50,21 +52,84 @@ module I64Op = IntOp
 module F32Op = FloatOp
 module F64Op = FloatOp
 
+module V128Op =
+struct
+  type itestop = AllTrue
+  type iunop = Abs | Neg | Popcnt
+  type funop = Abs | Neg | Sqrt | Ceil | Floor | Trunc | Nearest
+  type ibinop = Add | Sub | Mul | MinS | MinU | MaxS | MaxU | AvgrU
+              | AddSatS | AddSatU | SubSatS | SubSatU | DotS | Q15MulRSatS
+              | ExtMulLowS | ExtMulHighS | ExtMulLowU | ExtMulHighU
+              | Swizzle | Shuffle of int list | NarrowS | NarrowU
+  type fbinop = Add | Sub | Mul | Div | Min | Max | Pmin | Pmax
+  type irelop = Eq | Ne | LtS | LtU | LeS | LeU | GtS | GtU | GeS | GeU
+  type frelop = Eq | Ne | Lt | Le | Gt | Ge
+  type icvtop = ExtendLowS | ExtendLowU | ExtendHighS | ExtendHighU
+              | ExtAddPairwiseS | ExtAddPairwiseU
+              | TruncSatSF32x4 | TruncSatUF32x4
+              | TruncSatSZeroF64x2 | TruncSatUZeroF64x2
+  type fcvtop = DemoteZeroF64x2 | PromoteLowF32x4
+              | ConvertSI32x4 | ConvertUI32x4
+  type ishiftop = Shl | ShrS | ShrU
+  type ibitmaskop = Bitmask
+
+  type vtestop = AnyTrue
+  type vunop = Not
+  type vbinop = And | Or | Xor | AndNot
+  type vternop = Bitselect
+
+  type testop = (itestop, itestop, itestop, itestop, void, void) V128.laneop
+  type unop = (iunop, iunop, iunop, iunop, funop, funop) V128.laneop
+  type binop = (ibinop, ibinop, ibinop, ibinop, fbinop, fbinop) V128.laneop
+  type relop = (irelop, irelop, irelop, irelop, frelop, frelop) V128.laneop
+  type cvtop = (icvtop, icvtop, icvtop, icvtop, fcvtop, fcvtop) V128.laneop
+  type shiftop = (ishiftop, ishiftop, ishiftop, ishiftop, void, void) V128.laneop
+  type bitmaskop = (ibitmaskop, ibitmaskop, ibitmaskop, ibitmaskop, void, void) V128.laneop
+
+  type nsplatop = Splat
+  type 'a nextractop = Extract of int * 'a
+  type nreplaceop = Replace of int
+
+  type splatop = (nsplatop, nsplatop, nsplatop, nsplatop, nsplatop, nsplatop) V128.laneop
+  type extractop = (extension nextractop, extension nextractop, unit nextractop, unit nextractop, unit nextractop, unit nextractop) V128.laneop
+  type replaceop = (nreplaceop, nreplaceop, nreplaceop, nreplaceop, nreplaceop, nreplaceop) V128.laneop
+end
+
+type testop = (I32Op.testop, I64Op.testop, F32Op.testop, F64Op.testop) Values.op
 type unop = (I32Op.unop, I64Op.unop, F32Op.unop, F64Op.unop) Values.op
 type binop = (I32Op.binop, I64Op.binop, F32Op.binop, F64Op.binop) Values.op
-type testop = (I32Op.testop, I64Op.testop, F32Op.testop, F64Op.testop) Values.op
 type relop = (I32Op.relop, I64Op.relop, F32Op.relop, F64Op.relop) Values.op
 type cvtop = (I32Op.cvtop, I64Op.cvtop, F32Op.cvtop, F64Op.cvtop) Values.op
 
-type 'a memop = {ty : num_type; align : int; offset : int32; sz : 'a option}
-type loadop = (pack_size * extension) memop
-type storeop = pack_size memop
+type vec_testop = (V128Op.testop) Values.vecop
+type vec_relop = (V128Op.relop) Values.vecop
+type vec_unop = (V128Op.unop) Values.vecop
+type vec_binop = (V128Op.binop) Values.vecop
+type vec_cvtop = (V128Op.cvtop) Values.vecop
+type vec_shiftop = (V128Op.shiftop) Values.vecop
+type vec_bitmaskop = (V128Op.bitmaskop) Values.vecop
+type vec_vtestop = (V128Op.vtestop) Values.vecop
+type vec_vunop = (V128Op.vunop) Values.vecop
+type vec_vbinop = (V128Op.vbinop) Values.vecop
+type vec_vternop = (V128Op.vternop) Values.vecop
+type vec_splatop = (V128Op.splatop) Values.vecop
+type vec_extractop = (V128Op.extractop) Values.vecop
+type vec_replaceop = (V128Op.replaceop) Values.vecop
+
+type ('t, 'p) memop = {ty : 't; align : int; offset : int32; pack : 'p}
+type loadop = (num_type, (pack_size * extension) option) memop
+type storeop = (num_type, pack_size option) memop
+
+type vec_loadop = (vec_type, (pack_size * vec_extension) option) memop
+type vec_storeop = (vec_type, unit) memop
+type vec_laneop = (vec_type, pack_size) memop * int
 
 
 (* Expressions *)
 
 type var = int32 Source.phrase
 type num = Values.num Source.phrase
+type vec = Values.vec Source.phrase
 type name = int list
 
 type block_type = VarBlockType of var | ValBlockType of value_type option
@@ -99,6 +164,10 @@ and instr' =
   | ElemDrop of var                   (* drop passive element segment *)
   | Load of loadop                    (* read memory at address *)
   | Store of storeop                  (* write memory at address *)
+  | VecLoad of vec_loadop             (* read memory at address *)
+  | VecStore of vec_storeop           (* write memory at address *)
+  | VecLoadLane of vec_laneop         (* read single lane at address *)
+  | VecStoreLane of vec_laneop        (* write single lane to address *)
   | MemorySize                        (* size of memory *)
   | MemoryGrow                        (* grow memory *)
   | MemoryFill                        (* fill memory range with value *)
@@ -114,6 +183,21 @@ and instr' =
   | Unary of unop                     (* unary numeric operator *)
   | Binary of binop                   (* binary numeric operator *)
   | Convert of cvtop                  (* conversion *)
+  | VecConst of vec                   (* constant *)
+  | VecTest of vec_testop             (* vector test *)
+  | VecCompare of vec_relop           (* vector comparison *)
+  | VecUnary of vec_unop              (* unary vector operator *)
+  | VecBinary of vec_binop            (* binary vector operator *)
+  | VecConvert of vec_cvtop           (* vector conversion *)
+  | VecShift of vec_shiftop           (* vector shifts *)
+  | VecBitmask of vec_bitmaskop       (* vector masking *)
+  | VecTestBits of vec_vtestop        (* vector bit test *)
+  | VecUnaryBits of vec_vunop         (* unary bit vector operator *)
+  | VecBinaryBits of vec_vbinop       (* binary bit vector operator *)
+  | VecTernaryBits of vec_vternop     (* ternary bit vector operator *)
+  | VecSplat of vec_splatop           (* number to vector conversion *)
+  | VecExtract of vec_extractop       (* extract lane from vector *)
+  | VecReplace of vec_replaceop       (* replace lane in vector *)
 
 
 (* Globals & Functions *)
diff --git a/interpreter/syntax/free.ml b/interpreter/syntax/free.ml
index 60d580334..78c09baf3 100644
--- a/interpreter/syntax/free.ml
+++ b/interpreter/syntax/free.ml
@@ -83,7 +83,14 @@ let rec instr (e : instr) =
   | TableCopy (x, y) -> tables (var x) ++ tables (var y)
   | TableInit (x, y) -> tables (var x) ++ elems (var y)
   | ElemDrop x -> elems (var x)
-  | Load _ | Store _ | MemorySize | MemoryGrow | MemoryCopy | MemoryFill ->
+  | Load _ | Store _
+  | VecLoad _ | VecStore _ | VecLoadLane _ | VecStoreLane _
+  | MemorySize | MemoryGrow | MemoryCopy | MemoryFill ->
+    memories zero
+  | VecConst _ | VecTest _ | VecUnary _ | VecBinary _ | VecCompare _
+  | VecConvert _ | VecShift _ | VecBitmask _
+  | VecTestBits _ | VecUnaryBits _ | VecBinaryBits _ | VecTernaryBits _
+  | VecSplat _ | VecExtract _ | VecReplace _ ->
     memories zero
   | MemoryInit x -> memories zero ++ datas (var x)
   | DataDrop x -> datas (var x)
diff --git a/interpreter/syntax/operators.ml b/interpreter/syntax/operators.ml
index d8467a595..296bb1e77 100644
--- a/interpreter/syntax/operators.ml
+++ b/interpreter/syntax/operators.ml
@@ -1,6 +1,7 @@
 open Source
 open Types
 open Values
+open V128
 open Ast
 
 
@@ -8,6 +9,7 @@ let i32_const n = Const (I32 n.it @@ n.at)
 let i64_const n = Const (I64 n.it @@ n.at)
 let f32_const n = Const (F32 n.it @@ n.at)
 let f64_const n = Const (F64 n.it @@ n.at)
+let v128_const n = VecConst (V128 n.it @@ n.at)
 let ref_null t = RefNull t
 let ref_func x = RefFunc x
 
@@ -41,45 +43,45 @@ let table_copy x y = TableCopy (x, y)
 let table_init x y = TableInit (x, y)
 let elem_drop x = ElemDrop x
 
-let i32_load align offset = Load {ty = I32Type; align; offset; sz = None}
-let i64_load align offset = Load {ty = I64Type; align; offset; sz = None}
-let f32_load align offset = Load {ty = F32Type; align; offset; sz = None}
-let f64_load align offset = Load {ty = F64Type; align; offset; sz = None}
+let i32_load align offset = Load {ty = I32Type; align; offset; pack = None}
+let i64_load align offset = Load {ty = I64Type; align; offset; pack = None}
+let f32_load align offset = Load {ty = F32Type; align; offset; pack = None}
+let f64_load align offset = Load {ty = F64Type; align; offset; pack = None}
 let i32_load8_s align offset =
-  Load {ty = I32Type; align; offset; sz = Some (Pack8, SX)}
+  Load {ty = I32Type; align; offset; pack = Some (Pack8, SX)}
 let i32_load8_u align offset =
-  Load {ty = I32Type; align; offset; sz = Some (Pack8, ZX)}
+  Load {ty = I32Type; align; offset; pack = Some (Pack8, ZX)}
 let i32_load16_s align offset =
-  Load {ty = I32Type; align; offset; sz = Some (Pack16, SX)}
+  Load {ty = I32Type; align; offset; pack = Some (Pack16, SX)}
 let i32_load16_u align offset =
-  Load {ty = I32Type; align; offset; sz = Some (Pack16, ZX)}
+  Load {ty = I32Type; align; offset; pack = Some (Pack16, ZX)}
 let i64_load8_s align offset =
-  Load {ty = I64Type; align; offset; sz = Some (Pack8, SX)}
+  Load {ty = I64Type; align; offset; pack = Some (Pack8, SX)}
 let i64_load8_u align offset =
-  Load {ty = I64Type; align; offset; sz = Some (Pack8, ZX)}
+  Load {ty = I64Type; align; offset; pack = Some (Pack8, ZX)}
 let i64_load16_s align offset =
-  Load {ty = I64Type; align; offset; sz = Some (Pack16, SX)}
+  Load {ty = I64Type; align; offset; pack = Some (Pack16, SX)}
 let i64_load16_u align offset =
-  Load {ty = I64Type; align; offset; sz = Some (Pack16, ZX)}
+  Load {ty = I64Type; align; offset; pack = Some (Pack16, ZX)}
 let i64_load32_s align offset =
-  Load {ty = I64Type; align; offset; sz = Some (Pack32, SX)}
+  Load {ty = I64Type; align; offset; pack = Some (Pack32, SX)}
 let i64_load32_u align offset =
-  Load {ty = I64Type; align; offset; sz = Some (Pack32, ZX)}
+  Load {ty = I64Type; align; offset; pack = Some (Pack32, ZX)}
 
-let i32_store align offset = Store {ty = I32Type; align; offset; sz = None}
-let i64_store align offset = Store {ty = I64Type; align; offset; sz = None}
-let f32_store align offset = Store {ty = F32Type; align; offset; sz = None}
-let f64_store align offset = Store {ty = F64Type; align; offset; sz = None}
+let i32_store align offset = Store {ty = I32Type; align; offset; pack = None}
+let i64_store align offset = Store {ty = I64Type; align; offset; pack = None}
+let f32_store align offset = Store {ty = F32Type; align; offset; pack = None}
+let f64_store align offset = Store {ty = F64Type; align; offset; pack = None}
 let i32_store8 align offset =
-  Store {ty = I32Type; align; offset; sz = Some Pack8}
+  Store {ty = I32Type; align; offset; pack = Some Pack8}
 let i32_store16 align offset =
-  Store {ty = I32Type; align; offset; sz = Some Pack16}
+  Store {ty = I32Type; align; offset; pack = Some Pack16}
 let i64_store8 align offset =
-  Store {ty = I64Type; align; offset; sz = Some Pack8}
+  Store {ty = I64Type; align; offset; pack = Some Pack8}
 let i64_store16 align offset =
-  Store {ty = I64Type; align; offset; sz = Some Pack16}
+  Store {ty = I64Type; align; offset; pack = Some Pack16}
 let i64_store32 align offset =
-  Store {ty = I64Type; align; offset; sz = Some Pack32}
+  Store {ty = I64Type; align; offset; pack = Some Pack32}
 
 let memory_size = MemorySize
 let memory_grow = MemoryGrow
@@ -231,3 +233,270 @@ let i32_reinterpret_f32 = Convert (I32 I32Op.ReinterpretFloat)
 let i64_reinterpret_f64 = Convert (I64 I64Op.ReinterpretFloat)
 let f32_reinterpret_i32 = Convert (F32 F32Op.ReinterpretInt)
 let f64_reinterpret_i64 = Convert (F64 F64Op.ReinterpretInt)
+
+let v128_load align offset = VecLoad {ty = V128Type; align; offset; pack = None}
+let v128_load8x8_s align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtLane (Pack8x8, SX))}
+let v128_load8x8_u align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtLane (Pack8x8, ZX))}
+let v128_load16x4_s align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtLane (Pack16x4, SX))}
+let v128_load16x4_u align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtLane (Pack16x4, ZX))}
+let v128_load32x2_s align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtLane (Pack32x2, SX))}
+let v128_load32x2_u align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtLane (Pack32x2, ZX))}
+let v128_load8_splat align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack8, ExtSplat)}
+let v128_load16_splat align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack16, ExtSplat)}
+let v128_load32_splat align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack32, ExtSplat)}
+let v128_load64_splat align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtSplat)}
+let v128_load32_zero align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack32, ExtZero)}
+let v128_load64_zero align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtZero)}
+
+let v128_store align offset = VecStore {ty = V128Type; align; offset; pack = ()}
+
+let v128_load8_lane align offset i =
+  VecLoadLane ({ty = V128Type; align; offset; pack = Pack8}, i)
+let v128_load16_lane align offset i =
+  VecLoadLane ({ty = V128Type; align; offset; pack = Pack16}, i)
+let v128_load32_lane align offset i =
+  VecLoadLane ({ty = V128Type; align; offset; pack = Pack32}, i)
+let v128_load64_lane align offset i =
+  VecLoadLane ({ty = V128Type; align; offset; pack = Pack64}, i)
+
+let v128_store8_lane align offset i =
+  VecStoreLane ({ty = V128Type; align; offset; pack = Pack8}, i)
+let v128_store16_lane align offset i =
+  VecStoreLane ({ty = V128Type; align; offset; pack = Pack16}, i)
+let v128_store32_lane align offset i =
+  VecStoreLane ({ty = V128Type; align; offset; pack = Pack32}, i)
+let v128_store64_lane align offset i =
+  VecStoreLane ({ty = V128Type; align; offset; pack = Pack64}, i)
+
+let v128_not = VecUnaryBits (V128 V128Op.Not)
+let v128_and = VecBinaryBits (V128 V128Op.And)
+let v128_andnot = VecBinaryBits (V128 V128Op.AndNot)
+let v128_or = VecBinaryBits (V128 V128Op.Or)
+let v128_xor = VecBinaryBits (V128 V128Op.Xor)
+let v128_bitselect = VecTernaryBits (V128 V128Op.Bitselect)
+let v128_any_true = VecTestBits (V128 V128Op.AnyTrue)
+
+let i8x16_swizzle = VecBinary (V128 (I8x16 V128Op.Swizzle))
+let i8x16_shuffle is = VecBinary (V128 (I8x16 (V128Op.Shuffle is)))
+
+let i8x16_splat = VecSplat (V128 (I8x16 V128Op.Splat))
+let i8x16_extract_lane_s i = VecExtract (V128 (I8x16 (V128Op.Extract (i, SX))))
+let i8x16_extract_lane_u i = VecExtract (V128 (I8x16 (V128Op.Extract (i, ZX))))
+let i8x16_replace_lane i = VecReplace (V128 (I8x16 (V128Op.Replace i)))
+let i8x16_eq = VecCompare (V128 (I8x16 V128Op.Eq))
+let i8x16_ne = VecCompare (V128 (I8x16 V128Op.Ne))
+let i8x16_lt_s = VecCompare (V128 (I8x16 V128Op.LtS))
+let i8x16_lt_u = VecCompare (V128 (I8x16 V128Op.LtU))
+let i8x16_le_s = VecCompare (V128 (I8x16 V128Op.LeS))
+let i8x16_le_u = VecCompare (V128 (I8x16 V128Op.LeU))
+let i8x16_gt_s = VecCompare (V128 (I8x16 V128Op.GtS))
+let i8x16_gt_u = VecCompare (V128 (I8x16 V128Op.GtU))
+let i8x16_ge_s = VecCompare (V128 (I8x16 V128Op.GeS))
+let i8x16_ge_u = VecCompare (V128 (I8x16 V128Op.GeU))
+let i8x16_neg = VecUnary (V128 (I8x16 V128Op.Neg))
+let i8x16_bitmask = VecBitmask (V128 (I8x16 V128Op.Bitmask))
+let i8x16_all_true = VecTest (V128 (I8x16 V128Op.AllTrue))
+let i8x16_narrow_i16x8_s = VecBinary (V128 (I8x16 V128Op.NarrowS))
+let i8x16_narrow_i16x8_u = VecBinary (V128 (I8x16 V128Op.NarrowU))
+let i16x8_extend_low_i8x16_s = VecConvert (V128 (I16x8 V128Op.ExtendLowS))
+let i16x8_extend_high_i8x16_s = VecConvert (V128 (I16x8 V128Op.ExtendHighS))
+let i16x8_extend_low_i8x16_u = VecConvert (V128 (I16x8 V128Op.ExtendLowU))
+let i16x8_extend_high_i8x16_u = VecConvert (V128 (I16x8 V128Op.ExtendHighU))
+let i8x16_shl = VecShift (V128 (I8x16 V128Op.Shl))
+let i8x16_shr_s = VecShift (V128 (I8x16 V128Op.ShrS))
+let i8x16_shr_u = VecShift (V128 (I8x16 V128Op.ShrU))
+let i8x16_add = VecBinary (V128 (I8x16 V128Op.Add))
+let i8x16_add_sat_s = VecBinary (V128 (I8x16 V128Op.AddSatS))
+let i8x16_add_sat_u = VecBinary (V128 (I8x16 V128Op.AddSatU))
+let i8x16_sub = VecBinary (V128 (I8x16 V128Op.Sub))
+let i8x16_sub_sat_s = VecBinary (V128 (I8x16 V128Op.SubSatS))
+let i8x16_sub_sat_u = VecBinary (V128 (I8x16 V128Op.SubSatU))
+let i8x16_abs = VecUnary (V128 (I8x16 V128Op.Abs))
+let i8x16_popcnt = VecUnary (V128 (I8x16 V128Op.Popcnt))
+let i8x16_min_s = VecBinary (V128 (I8x16 V128Op.MinS))
+let i8x16_min_u = VecBinary (V128 (I8x16 V128Op.MinU))
+let i8x16_max_s = VecBinary (V128 (I8x16 V128Op.MaxS))
+let i8x16_max_u = VecBinary (V128 (I8x16 V128Op.MaxU))
+let i8x16_avgr_u = VecBinary (V128 (I8x16 V128Op.AvgrU))
+
+let i16x8_splat = VecSplat (V128 (I16x8 V128Op.Splat))
+let i16x8_extract_lane_s i = VecExtract (V128 (I16x8 (V128Op.Extract (i, SX))))
+let i16x8_extract_lane_u i = VecExtract (V128 (I16x8 (V128Op.Extract (i, ZX))))
+let i16x8_replace_lane i = VecReplace (V128 (I16x8 (V128Op.Replace i)))
+let i16x8_eq = VecCompare (V128 (I16x8 V128Op.Eq))
+let i16x8_ne = VecCompare (V128 (I16x8 V128Op.Ne))
+let i16x8_lt_s = VecCompare (V128 (I16x8 V128Op.LtS))
+let i16x8_lt_u = VecCompare (V128 (I16x8 V128Op.LtU))
+let i16x8_le_s = VecCompare (V128 (I16x8 V128Op.LeS))
+let i16x8_le_u = VecCompare (V128 (I16x8 V128Op.LeU))
+let i16x8_gt_s = VecCompare (V128 (I16x8 V128Op.GtS))
+let i16x8_gt_u = VecCompare (V128 (I16x8 V128Op.GtU))
+let i16x8_ge_s = VecCompare (V128 (I16x8 V128Op.GeS))
+let i16x8_ge_u = VecCompare (V128 (I16x8 V128Op.GeU))
+let i16x8_neg = VecUnary (V128 (I16x8 V128Op.Neg))
+let i16x8_bitmask = VecBitmask (V128 (I16x8 V128Op.Bitmask))
+let i16x8_all_true = VecTest (V128 (I16x8 V128Op.AllTrue))
+let i16x8_narrow_i32x4_s = VecBinary (V128 (I16x8 V128Op.NarrowS))
+let i16x8_narrow_i32x4_u = VecBinary (V128 (I16x8 V128Op.NarrowU))
+let i16x8_shl = VecShift (V128 (I16x8 V128Op.Shl))
+let i16x8_shr_s = VecShift (V128 (I16x8 V128Op.ShrS))
+let i16x8_shr_u = VecShift (V128 (I16x8 V128Op.ShrU))
+let i16x8_add = VecBinary (V128 (I16x8 V128Op.Add))
+let i16x8_add_sat_s = VecBinary (V128 (I16x8 V128Op.AddSatS))
+let i16x8_add_sat_u = VecBinary (V128 (I16x8 V128Op.AddSatU))
+let i16x8_sub = VecBinary (V128 (I16x8 V128Op.Sub))
+let i16x8_sub_sat_s = VecBinary (V128 (I16x8 V128Op.SubSatS))
+let i16x8_sub_sat_u = VecBinary (V128 (I16x8 V128Op.SubSatU))
+let i16x8_mul = VecBinary (V128 (I16x8 V128Op.Mul))
+let i16x8_abs = VecUnary (V128 (I16x8 V128Op.Abs))
+let i16x8_min_s = VecBinary (V128 (I16x8 V128Op.MinS))
+let i16x8_min_u = VecBinary (V128 (I16x8 V128Op.MinU))
+let i16x8_max_s = VecBinary (V128 (I16x8 V128Op.MaxS))
+let i16x8_max_u = VecBinary (V128 (I16x8 V128Op.MaxU))
+let i16x8_avgr_u = VecBinary (V128 (I16x8 V128Op.AvgrU))
+let i16x8_extmul_low_i8x16_s = VecBinary (V128 (I16x8 V128Op.ExtMulLowS))
+let i16x8_extmul_high_i8x16_s = VecBinary (V128 (I16x8 V128Op.ExtMulHighS))
+let i16x8_extmul_low_i8x16_u = VecBinary (V128 (I16x8 V128Op.ExtMulLowU))
+let i16x8_extmul_high_i8x16_u = VecBinary (V128 (I16x8 V128Op.ExtMulHighU))
+let i16x8_q15mulr_sat_s = VecBinary (V128 (I16x8 V128Op.Q15MulRSatS))
+let i16x8_extadd_pairwise_i8x16_s = VecConvert (V128 (I16x8 V128Op.ExtAddPairwiseS))
+let i16x8_extadd_pairwise_i8x16_u = VecConvert (V128 (I16x8 V128Op.ExtAddPairwiseU))
+
+let i32x4_splat = VecSplat (V128 (I32x4 V128Op.Splat))
+let i32x4_extract_lane i = VecExtract (V128 (I32x4 (V128Op.Extract (i, ()))))
+let i32x4_replace_lane i = VecReplace (V128 (I32x4 (V128Op.Replace i)))
+let i32x4_eq = VecCompare (V128 (I32x4 V128Op.Eq))
+let i32x4_ne = VecCompare (V128 (I32x4 V128Op.Ne))
+let i32x4_lt_s = VecCompare (V128 (I32x4 V128Op.LtS))
+let i32x4_lt_u = VecCompare (V128 (I32x4 V128Op.LtU))
+let i32x4_le_s = VecCompare (V128 (I32x4 V128Op.LeS))
+let i32x4_le_u = VecCompare (V128 (I32x4 V128Op.LeU))
+let i32x4_gt_s = VecCompare (V128 (I32x4 V128Op.GtS))
+let i32x4_gt_u = VecCompare (V128 (I32x4 V128Op.GtU))
+let i32x4_ge_s = VecCompare (V128 (I32x4 V128Op.GeS))
+let i32x4_ge_u = VecCompare (V128 (I32x4 V128Op.GeU))
+let i32x4_abs = VecUnary (V128 (I32x4 V128Op.Abs))
+let i32x4_neg = VecUnary (V128 (I32x4 V128Op.Neg))
+let i32x4_bitmask = VecBitmask (V128 (I32x4 V128Op.Bitmask))
+let i32x4_all_true = VecTest (V128 (I32x4 V128Op.AllTrue))
+let i32x4_extend_low_i16x8_s = VecConvert (V128 (I32x4 V128Op.ExtendLowS))
+let i32x4_extend_high_i16x8_s = VecConvert (V128 (I32x4 V128Op.ExtendHighS))
+let i32x4_extend_low_i16x8_u = VecConvert (V128 (I32x4 V128Op.ExtendLowU))
+let i32x4_extend_high_i16x8_u = VecConvert (V128 (I32x4 V128Op.ExtendHighU))
+let i32x4_shl = VecShift (V128 (I32x4 V128Op.Shl))
+let i32x4_shr_s = VecShift (V128 (I32x4 V128Op.ShrS))
+let i32x4_shr_u = VecShift (V128 (I32x4 V128Op.ShrU))
+let i32x4_add = VecBinary (V128 (I32x4 V128Op.Add))
+let i32x4_sub = VecBinary (V128 (I32x4 V128Op.Sub))
+let i32x4_min_s = VecBinary (V128 (I32x4 V128Op.MinS))
+let i32x4_min_u = VecBinary (V128 (I32x4 V128Op.MinU))
+let i32x4_max_s = VecBinary (V128 (I32x4 V128Op.MaxS))
+let i32x4_max_u = VecBinary (V128 (I32x4 V128Op.MaxU))
+let i32x4_mul = VecBinary (V128 (I32x4 V128Op.Mul))
+let i32x4_dot_i16x8_s = VecBinary (V128 (I32x4 V128Op.DotS))
+let i32x4_trunc_sat_f32x4_s = VecConvert (V128 (I32x4 V128Op.TruncSatSF32x4))
+let i32x4_trunc_sat_f32x4_u = VecConvert (V128 (I32x4 V128Op.TruncSatUF32x4))
+let i32x4_trunc_sat_f64x2_s_zero = VecConvert (V128 (I32x4 V128Op.TruncSatSZeroF64x2))
+let i32x4_trunc_sat_f64x2_u_zero = VecConvert (V128 (I32x4 V128Op.TruncSatUZeroF64x2))
+let i32x4_extmul_low_i16x8_s = VecBinary (V128 (I32x4 V128Op.ExtMulLowS))
+let i32x4_extmul_high_i16x8_s = VecBinary (V128 (I32x4 V128Op.ExtMulHighS))
+let i32x4_extmul_low_i16x8_u = VecBinary (V128 (I32x4 V128Op.ExtMulLowU))
+let i32x4_extmul_high_i16x8_u = VecBinary (V128 (I32x4 V128Op.ExtMulHighU))
+let i32x4_extadd_pairwise_i16x8_s = VecConvert (V128 (I32x4 V128Op.ExtAddPairwiseS))
+let i32x4_extadd_pairwise_i16x8_u = VecConvert (V128 (I32x4 V128Op.ExtAddPairwiseU))
+
+let i64x2_splat = VecSplat (V128 (I64x2 V128Op.Splat))
+let i64x2_extract_lane i = VecExtract (V128 (I64x2 (V128Op.Extract (i, ()))))
+let i64x2_replace_lane i = VecReplace (V128 (I64x2 (V128Op.Replace i)))
+let i64x2_extend_low_i32x4_s = VecConvert (V128 (I64x2 V128Op.ExtendLowS))
+let i64x2_extend_high_i32x4_s = VecConvert (V128 (I64x2 V128Op.ExtendHighS))
+let i64x2_extend_low_i32x4_u = VecConvert (V128 (I64x2 V128Op.ExtendLowU))
+let i64x2_extend_high_i32x4_u = VecConvert (V128 (I64x2 V128Op.ExtendHighU))
+let i64x2_eq = VecCompare (V128 (I64x2 V128Op.Eq))
+let i64x2_ne = VecCompare (V128 (I64x2 V128Op.Ne))
+let i64x2_lt_s = VecCompare (V128 (I64x2 V128Op.LtS))
+let i64x2_le_s = VecCompare (V128 (I64x2 V128Op.LeS))
+let i64x2_gt_s = VecCompare (V128 (I64x2 V128Op.GtS))
+let i64x2_ge_s = VecCompare (V128 (I64x2 V128Op.GeS))
+let i64x2_abs = VecUnary (V128 (I64x2 V128Op.Abs))
+let i64x2_neg = VecUnary (V128 (I64x2 V128Op.Neg))
+let i64x2_bitmask = VecBitmask (V128 (I64x2 V128Op.Bitmask))
+let i64x2_all_true = VecTest (V128 (I64x2 V128Op.AllTrue))
+let i64x2_add = VecBinary (V128 (I64x2 V128Op.Add))
+let i64x2_sub = VecBinary (V128 (I64x2 V128Op.Sub))
+let i64x2_mul = VecBinary (V128 (I64x2 V128Op.Mul))
+let i64x2_shl = VecShift (V128 (I64x2 V128Op.Shl))
+let i64x2_shr_s = VecShift (V128 (I64x2 V128Op.ShrS))
+let i64x2_shr_u = VecShift (V128 (I64x2 V128Op.ShrU))
+let i64x2_extmul_low_i32x4_s = VecBinary (V128 (I64x2 V128Op.ExtMulLowS))
+let i64x2_extmul_high_i32x4_s = VecBinary (V128 (I64x2 V128Op.ExtMulHighS))
+let i64x2_extmul_low_i32x4_u = VecBinary (V128 (I64x2 V128Op.ExtMulLowU))
+let i64x2_extmul_high_i32x4_u = VecBinary (V128 (I64x2 V128Op.ExtMulHighU))
+
+let f32x4_splat = VecSplat (V128 (F32x4 V128Op.Splat))
+let f32x4_extract_lane i = VecExtract (V128 (F32x4 (V128Op.Extract (i, ()))))
+let f32x4_replace_lane i = VecReplace (V128 (F32x4 (V128Op.Replace i)))
+let f32x4_eq = VecCompare (V128 (F32x4 V128Op.Eq))
+let f32x4_ne = VecCompare (V128 (F32x4 V128Op.Ne))
+let f32x4_lt = VecCompare (V128 (F32x4 V128Op.Lt))
+let f32x4_le = VecCompare (V128 (F32x4 V128Op.Le))
+let f32x4_gt = VecCompare (V128 (F32x4 V128Op.Gt))
+let f32x4_ge = VecCompare (V128 (F32x4 V128Op.Ge))
+let f32x4_abs = VecUnary (V128 (F32x4 V128Op.Abs))
+let f32x4_neg = VecUnary (V128 (F32x4 V128Op.Neg))
+let f32x4_sqrt = VecUnary (V128 (F32x4 V128Op.Sqrt))
+let f32x4_ceil = VecUnary (V128 (F32x4 V128Op.Ceil))
+let f32x4_floor = VecUnary (V128 (F32x4 V128Op.Floor))
+let f32x4_trunc = VecUnary (V128 (F32x4 V128Op.Trunc))
+let f32x4_nearest = VecUnary (V128 (F32x4 V128Op.Nearest))
+let f32x4_add = VecBinary (V128 (F32x4 V128Op.Add))
+let f32x4_sub = VecBinary (V128 (F32x4 V128Op.Sub))
+let f32x4_mul = VecBinary (V128 (F32x4 V128Op.Mul))
+let f32x4_div = VecBinary (V128 (F32x4 V128Op.Div))
+let f32x4_min = VecBinary (V128 (F32x4 V128Op.Min))
+let f32x4_max = VecBinary (V128 (F32x4 V128Op.Max))
+let f32x4_pmin = VecBinary (V128 (F32x4 V128Op.Pmin))
+let f32x4_pmax = VecBinary (V128 (F32x4 V128Op.Pmax))
+let f32x4_demote_f64x2_zero = VecConvert (V128 (F32x4 V128Op.DemoteZeroF64x2))
+let f32x4_convert_i32x4_s = VecConvert (V128 (F32x4 V128Op.ConvertSI32x4))
+let f32x4_convert_i32x4_u = VecConvert (V128 (F32x4 V128Op.ConvertUI32x4))
+
+let f64x2_splat = VecSplat (V128 (F64x2 V128Op.Splat))
+let f64x2_extract_lane i = VecExtract (V128 (F64x2 (V128Op.Extract (i, ()))))
+let f64x2_replace_lane i = VecReplace (V128 (F64x2 (V128Op.Replace i)))
+let f64x2_eq = VecCompare (V128 (F64x2 V128Op.Eq))
+let f64x2_ne = VecCompare (V128 (F64x2 V128Op.Ne))
+let f64x2_lt = VecCompare (V128 (F64x2 V128Op.Lt))
+let f64x2_le = VecCompare (V128 (F64x2 V128Op.Le))
+let f64x2_gt = VecCompare (V128 (F64x2 V128Op.Gt))
+let f64x2_ge = VecCompare (V128 (F64x2 V128Op.Ge))
+let f64x2_neg = VecUnary (V128 (F64x2 V128Op.Neg))
+let f64x2_sqrt = VecUnary (V128 (F64x2 V128Op.Sqrt))
+let f64x2_ceil = VecUnary (V128 (F64x2 V128Op.Ceil))
+let f64x2_floor = VecUnary (V128 (F64x2 V128Op.Floor))
+let f64x2_trunc = VecUnary (V128 (F64x2 V128Op.Trunc))
+let f64x2_nearest = VecUnary (V128 (F64x2 V128Op.Nearest))
+let f64x2_add = VecBinary (V128 (F64x2 V128Op.Add))
+let f64x2_sub = VecBinary (V128 (F64x2 V128Op.Sub))
+let f64x2_mul = VecBinary (V128 (F64x2 V128Op.Mul))
+let f64x2_div = VecBinary (V128 (F64x2 V128Op.Div))
+let f64x2_min = VecBinary (V128 (F64x2 V128Op.Min))
+let f64x2_max = VecBinary (V128 (F64x2 V128Op.Max))
+let f64x2_abs = VecUnary (V128 (F64x2 V128Op.Abs))
+let f64x2_pmin = VecBinary (V128 (F64x2 V128Op.Pmin))
+let f64x2_pmax = VecBinary (V128 (F64x2 V128Op.Pmax))
+let f64x2_promote_low_f32x4 = VecConvert (V128 (F64x2 V128Op.PromoteLowF32x4))
+let f64x2_convert_low_i32x4_s = VecConvert (V128 (F64x2 V128Op.ConvertSI32x4))
+let f64x2_convert_low_i32x4_u = VecConvert (V128 (F64x2 V128Op.ConvertUI32x4))
diff --git a/interpreter/syntax/types.ml b/interpreter/syntax/types.ml
index 15f09e36c..e878cc8c2 100644
--- a/interpreter/syntax/types.ml
+++ b/interpreter/syntax/types.ml
@@ -1,8 +1,9 @@
 (* Types *)
 
 type num_type = I32Type | I64Type | F32Type | F64Type
+type vec_type = V128Type
 type ref_type = FuncRefType | ExternRefType
-type value_type = NumType of num_type | RefType of ref_type
+type value_type = NumType of num_type | VecType of vec_type | RefType of ref_type
 type result_type = value_type list
 type func_type = FuncType of result_type * result_type
 
@@ -17,28 +18,45 @@ type extern_type =
   | ExternMemoryType of memory_type
   | ExternGlobalType of global_type
 
-type pack_size = Pack8 | Pack16 | Pack32
+(* TODO: these types should move somewhere else *)
+type pack_size = Pack8 | Pack16 | Pack32 | Pack64
 type extension = SX | ZX
+type pack_shape = Pack8x8 | Pack16x4 | Pack32x2
+type vec_extension =
+  | ExtLane of pack_shape * extension
+  | ExtSplat
+  | ExtZero
 
 
 (* Attributes *)
 
-let size = function
+let num_size = function
   | I32Type | F32Type -> 4
   | I64Type | F64Type -> 8
 
+let vec_size = function
+  | V128Type -> 16
+
 let packed_size = function
   | Pack8 -> 1
   | Pack16 -> 2
   | Pack32 -> 4
+  | Pack64 -> 8
+
+let packed_shape_size = function
+  | Pack8x8 | Pack16x4 | Pack32x2 -> 8
 
 let is_num_type = function
   | NumType _ -> true
-  | RefType _ -> false
+  | _ -> false
+
+let is_vec_type = function
+  | VecType _ -> true
+  | _ -> false
 
 let is_ref_type = function
-  | NumType _ -> false
   | RefType _ -> true
+  | _ -> false
 
 
 (* Filters *)
@@ -91,6 +109,9 @@ let string_of_num_type = function
   | F32Type -> "f32"
   | F64Type -> "f64"
 
+let string_of_vec_type = function
+  | V128Type -> "v128"
+
 let string_of_ref_type = function
   | FuncRefType -> "funcref"
   | ExternRefType -> "externref"
@@ -101,6 +122,7 @@ let string_of_refed_type = function
 
 let string_of_value_type = function
   | NumType t -> string_of_num_type t
+  | VecType t -> string_of_vec_type t
   | RefType t -> string_of_ref_type t
 
 let string_of_value_types = function
diff --git a/interpreter/syntax/values.ml b/interpreter/syntax/values.ml
index 634166092..eefe37d5d 100644
--- a/interpreter/syntax/values.ml
+++ b/interpreter/syntax/values.ml
@@ -6,12 +6,83 @@ open Types
 type ('i32, 'i64, 'f32, 'f64) op =
   I32 of 'i32 | I64 of 'i64 | F32 of 'f32 | F64 of 'f64
 
+type ('v128) vecop =
+  V128 of 'v128
+
 type num = (I32.t, I64.t, F32.t, F64.t) op
+type vec = (V128.t) vecop
 
 type ref_ = ..
 type ref_ += NullRef of ref_type
 
-type value = Num of num | Ref of ref_
+type value = Num of num | Vec of vec | Ref of ref_
+
+
+(* Injection & projection *)
+
+let as_num = function
+  | Num n -> n
+  | _ -> failwith "as_num"
+
+let as_vec = function
+  | Vec i -> i
+  | _ -> failwith "as_vec"
+
+let as_ref = function
+  | Ref r -> r
+  | _ -> failwith "as_ref"
+
+
+exception TypeError of int * num * num_type
+
+module type NumType =
+sig
+  type t
+  val to_num : t -> num
+  val of_num : int -> num -> t
+end
+
+module I32Num =
+struct
+  type t = I32.t
+  let to_num i = I32 i
+  let of_num n = function I32 i -> i | v -> raise (TypeError (n, v, I32Type))
+end
+
+module I64Num =
+struct
+  type t = I64.t
+  let to_num i = I64 i
+  let of_num n = function I64 i -> i | v -> raise (TypeError (n, v, I64Type))
+end
+
+module F32Num =
+struct
+  type t = F32.t
+  let to_num i = F32 i
+  let of_num n = function F32 z -> z | v -> raise (TypeError (n, v, F32Type))
+end
+
+module F64Num =
+struct
+  type t = F64.t
+  let to_num i = F64 i
+  let of_num n = function F64 z -> z | v -> raise (TypeError (n, v, F64Type))
+end
+
+module type VecType =
+sig
+  type t
+  val to_vec : t -> vec
+  val of_vec : int -> vec -> t
+end
+
+module V128Vec =
+struct
+  type t = V128.t
+  let to_vec i = V128 i
+  let of_vec n = function V128 z -> z
+end
 
 
 (* Typing *)
@@ -22,23 +93,38 @@ let type_of_num = function
   | F32 _ -> F32Type
   | F64 _ -> F64Type
 
+let type_of_vec = function
+  | V128 _ -> V128Type
+
 let type_of_ref' = ref (function NullRef t -> t | _ -> assert false)
 let type_of_ref r = !type_of_ref' r
 
 let type_of_value = function
   | Num n -> NumType (type_of_num n)
+  | Vec i -> VecType (type_of_vec i)
   | Ref r -> RefType (type_of_ref r)
 
 
-(* Projections *)
+(* Comparison *)
 
-let as_num = function
-  | Num n -> n
-  | Ref _ -> failwith "as_num"
+let eq_num n1 n2 = n1 = n2
 
-let as_ref = function
-  | Num _ -> failwith "as_ref"
-  | Ref r -> r
+let eq_vec v1 v2 = v1 = v2
+
+let eq_ref' = ref (fun r1 r2 ->
+  match r1, r2 with
+  | NullRef _, NullRef _ -> true
+  | _, _ -> false
+)
+
+let eq_ref r1 r2 = !eq_ref' r1 r2
+
+let eq v1 v2 =
+  match v1, v2 with
+  | Num n1, Num n2 -> eq_num n1 n2
+  | Vec v1, Vec v2 -> eq_vec v1 v2
+  | Ref r1, Ref r2 -> eq_ref r1 r2
+  | _, _ -> false
 
 
 (* Defaults *)
@@ -49,11 +135,15 @@ let default_num = function
   | F32Type -> F32 F32.zero
   | F64Type -> F64 F64.zero
 
+let default_vec = function
+  | V128Type -> V128 V128.zero
+
 let default_ref = function
   | t -> NullRef t
 
 let default_value = function
   | NumType t' -> Num (default_num t')
+  | VecType t' -> Vec (default_vec t')
   | RefType t' -> Ref (default_ref t')
 
 
@@ -67,11 +157,24 @@ let string_of_num = function
   | F32 z -> F32.to_string z
   | F64 z -> F64.to_string z
 
+let hex_string_of_num = function
+  | I32 i -> I32.to_hex_string i
+  | I64 i -> I64.to_hex_string i
+  | F32 z -> F32.to_hex_string z
+  | F64 z -> F64.to_hex_string z
+
+let string_of_vec = function
+  | V128 v -> V128.to_string v
+
+let hex_string_of_vec = function
+  | V128 v -> V128.to_hex_string v
+
 let string_of_ref' = ref (function NullRef t -> "null" | _ -> "ref")
 let string_of_ref r = !string_of_ref' r
 
 let string_of_value = function
   | Num n -> string_of_num n
+  | Vec i -> string_of_vec i
   | Ref r -> string_of_ref r
 
 let string_of_values = function
diff --git a/interpreter/tests/smallint.ml b/interpreter/tests/smallint.ml
new file mode 100644
index 000000000..3fe21c7c6
--- /dev/null
+++ b/interpreter/tests/smallint.ml
@@ -0,0 +1,108 @@
+(* Simple, non-exhaustive tests for small ints (i8, i16). *)
+
+let s32max = 0x7fffffffl
+let s32min = 0x80000000l
+let u32max = 0xffffffffl
+let u32min = 0l
+
+(* Smaller ints are stored sign extended in an Int32. *)
+let s16max = 32767l
+let s16min = -32768l
+let u16max = u32max
+let u16min = 0l
+
+let s8max = 127l
+let s8min = -128l
+let u8max = u32max
+let u8min = 0l
+
+let assert_equal x y =
+  if x <> y then raise (Failure
+  (Printf.sprintf "Expected: %ld, but got %ld." x y))
+
+let () =
+  (* test addition wrap around *)
+  assert_equal u32min (I32.add u32max 1l);
+  assert_equal u16min (I16.add u16max 1l);
+  assert_equal u8min (I8.add u8max 1l);
+  assert_equal s32min (I32.add s32max 1l);
+  assert_equal s16min (I16.add s16max 1l);
+  assert_equal s8min (I8.add s8max 1l);
+
+  (* test subtraction wrap around *)
+  assert_equal u32max (I32.sub u32min 1l);
+  assert_equal u16max (I16.sub u16min 1l);
+  assert_equal u8max (I8.sub u8min 1l);
+  assert_equal s32max (I32.sub s32min 1l);
+  assert_equal s16max (I16.sub s16min 1l);
+  assert_equal s8max (I8.sub s8min 1l);
+
+  (* test mul wrap around *)
+  assert_equal 1l (I32.mul u32max u32max);
+  assert_equal 1l (I16.mul u16max u16max);
+  assert_equal 1l (I8.mul u8max u8max);
+  assert_equal 1l (I32.mul s32max s32max);
+  assert_equal 1l (I16.mul s16max s16max);
+  assert_equal 1l (I8.mul s8max s8max);
+
+  (* test add_sat_s *)
+  assert_equal s16max (I16.add_sat_s s16max 1l);
+  assert_equal s8max (I8.add_sat_s s8max 1l);
+  assert_equal u16max (I16.add_sat_u u16max 1l);
+  assert_equal u8max (I8.add_sat_u u8max 1l);
+
+  (* test sub_sat_s *)
+  assert_equal s16min (I16.sub_sat_s s16min 1l);
+  assert_equal s8min (I8.sub_sat_s s8min 1l);
+  assert_equal 0l (I16.sub_sat_u 0l 1l);
+  assert_equal 0l (I8.sub_sat_u 0l 1l);
+
+  (* test div wrap around *)
+  try
+    ignore (I32.div_s s32min (-1l));
+    ignore (I16.div_s s16min (-1l));
+    ignore (I8.div_s s8min (-1l));
+    assert false
+  with Ixx.Overflow ->
+    ();
+
+  (* test shifts overflow *)
+  assert_equal s16min (I16.shl 16384l 1l);
+  assert_equal s8min (I8.shl 64l 1l);
+  assert_equal 0x7fffl (I16.shr_u u16max 1l);
+  assert_equal 0x7fl (I8.shr_u u8max 1l);
+  (* check that the top bits are not messed with *)
+  assert_equal u16max (I16.shr_u u16max 0l);
+  assert_equal u8max (I8.shr_u u8max 0l);
+
+  (* check rotation *)
+  assert_equal 1l (I16.rotl s16min 1l);
+  assert_equal 1l (I8.rotl s8min 1l);
+  assert_equal s16min (I16.rotl 0x4000l 1l);
+  assert_equal s8min (I8.rotl 0x40l 1l);
+
+  assert_equal s32min (I32.rotr 1l 1l);
+  assert_equal s16min (I16.rotr 1l 1l);
+  assert_equal s8min (I8.rotr 1l 1l);
+
+  assert_equal 1l (I32.rotr s32min 31l);
+  assert_equal 1l (I16.rotr s16min 15l);
+  assert_equal 1l (I8.rotr s8min 7l);
+  assert_equal 0x40000000l (I32.rotr s32min 1l);
+  assert_equal 0x4000l (I16.rotr s16min 1l);
+  assert_equal 0x40l (I8.rotr s8min 1l);
+
+  (* check clz *)
+  assert_equal 0l (I16.clz s16min);
+  assert_equal 0l (I8.clz s8min);
+  assert_equal 1l (I16.clz s16max);
+  assert_equal 1l (I8.clz s8max);
+
+  (* check popcnt *)
+  assert_equal 1l (I32.popcnt s32min);
+  assert_equal 1l (I16.popcnt s16min);
+  assert_equal 1l (I8.popcnt s8min);
+  assert_equal 16l (I16.popcnt (-1l));
+  assert_equal 8l (I8.popcnt (-1l));
+  assert_equal 15l (I16.popcnt s16max);
+  assert_equal 7l (I8.popcnt s8max);
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index 01e9c8adb..cdcd4f84d 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -56,6 +56,7 @@ let break_string s =
 (* Types *)
 
 let num_type t = string_of_num_type t
+let vec_type t = string_of_vec_type t
 let ref_type t = string_of_ref_type t
 let refed_type t = string_of_refed_type t
 let value_type t = string_of_value_type t
@@ -78,11 +79,22 @@ let pack_size = function
   | Pack8 -> "8"
   | Pack16 -> "16"
   | Pack32 -> "32"
+  | Pack64 -> "64"
 
 let extension = function
   | SX -> "_s"
   | ZX -> "_u"
 
+let pack_shape = function
+  | Pack8x8 -> "8x8"
+  | Pack16x4 -> "16x4"
+  | Pack32x2 -> "32x2"
+
+let vec_extension sz = function
+  | ExtLane (sh, ext) -> pack_shape sh ^ extension ext
+  | ExtSplat -> pack_size sz ^ "_splat"
+  | ExtZero -> pack_size sz ^ "_zero"
+
 
 (* Operators *)
 
@@ -147,7 +159,7 @@ module FloatOp =
 struct
   open Ast.FloatOp
 
-  let testop xx = fun _ -> assert false
+  let testop xx = function (_ : testop) -> .
 
   let relop xx = function
     | Eq -> "eq"
@@ -185,43 +197,235 @@ struct
     | ReinterpretInt -> "reinterpret_i" ^ xx
 end
 
-let oper (intop, floatop) op =
+module V128Op =
+struct
+  open Ast.V128Op
+
+  let half = function
+    | "16x8" -> "8x16"
+    | "32x4" -> "16x8"
+    | "64x2" -> "32x4"
+    | _ -> assert false
+
+  let double = function
+    | "8x16" -> "16x8"
+    | "16x8" -> "32x4"
+    | "32x4" -> "64x2"
+    | _ -> assert false
+
+  let voidop xxxx = function (_ : void) -> .
+
+  let itestop xxxx (op : itestop) = match op with
+    | AllTrue -> "all_true"
+
+  let iunop xxxx (op : iunop) = match op with
+    | Neg -> "neg"
+    | Abs -> "abs"
+    | Popcnt -> "popcnt"
+
+  let funop xxxx (op : funop) = match op with
+    | Neg -> "neg"
+    | Abs -> "abs"
+    | Sqrt -> "sqrt"
+    | Ceil -> "ceil"
+    | Floor -> "floor"
+    | Trunc -> "trunc"
+    | Nearest -> "nearest"
+
+  let ibinop xxxx (op : ibinop) = match op with
+    | Add -> "add"
+    | AddSatS -> "add_sat_s"
+    | AddSatU -> "add_sat_u"
+    | Sub -> "sub"
+    | SubSatS -> "sub_sat_s"
+    | SubSatU -> "sub_sat_u"
+    | Mul -> "mul"
+    | DotS -> "dot_i" ^ half xxxx ^ "_s"
+    | ExtMulLowS -> "extmul_low_i" ^ half xxxx ^ "_s"
+    | ExtMulHighS -> "extmul_high_i" ^ half xxxx ^ "_s"
+    | ExtMulLowU -> "extmul_low_i" ^ half xxxx ^ "_u"
+    | ExtMulHighU -> "extmul_high_i" ^ half xxxx ^ "_u"
+    | Q15MulRSatS -> "q15mulr_sat_s"
+    | MinS -> "min_s"
+    | MinU -> "min_u"
+    | MaxS -> "max_s"
+    | MaxU -> "max_u"
+    | AvgrU -> "avgr_u"
+    | NarrowS -> "narrow_i" ^ double xxxx ^ "_s"
+    | NarrowU -> "narrow_i" ^ double xxxx ^ "_u"
+    | Shuffle is -> "shuffle " ^ String.concat " " (List.map nat is)
+    | Swizzle -> "swizzle"
+
+  let fbinop xxxx (op : fbinop) = match op with
+    | Add -> "add"
+    | Sub -> "sub"
+    | Mul -> "mul"
+    | Div -> "div"
+    | Min -> "min"
+    | Max -> "max"
+    | Pmin -> "pmin"
+    | Pmax -> "pmax"
+
+  let irelop xxxx (op : irelop) = match op with
+    | Eq -> "eq"
+    | Ne -> "ne"
+    | LtS -> "lt_s"
+    | LtU -> "lt_u"
+    | GtS -> "gt_s"
+    | GtU -> "gt_u"
+    | LeS -> "le_s"
+    | LeU -> "le_u"
+    | GeS -> "ge_s"
+    | GeU -> "ge_u"
+
+  let frelop xxxx (op : frelop) = match op with
+    | Eq -> "eq"
+    | Ne -> "ne"
+    | Lt -> "lt"
+    | Le -> "le"
+    | Gt -> "gt"
+    | Ge -> "ge"
+
+  let icvtop xxxx (op : icvtop) = match op with
+    | ExtendLowS -> "extend_low_i" ^ half xxxx ^ "_s"
+    | ExtendLowU -> "extend_low_i" ^ half xxxx ^ "_u"
+    | ExtendHighS -> "extend_high_i" ^ half xxxx ^ "_s"
+    | ExtendHighU -> "extend_high_i" ^ half xxxx ^ "_u"
+    | ExtAddPairwiseS -> "extadd_pairwise_i" ^ half xxxx ^ "_s"
+    | ExtAddPairwiseU -> "extadd_pairwise_i" ^ half xxxx ^ "_u"
+    | TruncSatSF32x4 -> "trunc_sat_f32x4_s"
+    | TruncSatUF32x4 -> "trunc_sat_f32x4_u"
+    | TruncSatSZeroF64x2 -> "trunc_sat_f64x2_s_zero"
+    | TruncSatUZeroF64x2 -> "trunc_sat_f64x2_u_zero"
+
+  let fcvtop xxxx (op : fcvtop) = match op with
+    | DemoteZeroF64x2  -> "demote_f64x2_zero"
+    | PromoteLowF32x4  -> "promote_low_f32x4"
+    | ConvertSI32x4 ->
+      "convert_" ^ (if xxxx = "32x4" then "" else "low_") ^ "i32x4_s"
+    | ConvertUI32x4 ->
+      "convert_" ^ (if xxxx = "32x4" then "" else "low_") ^ "i32x4_u"
+
+  let ishiftop xxxx (op : ishiftop) = match op with
+    | Shl -> "shl"
+    | ShrS -> "shr_s"
+    | ShrU -> "shr_u"
+
+  let ibitmaskop xxxx (op : ibitmaskop) = match op with
+    | Bitmask -> "bitmask"
+
+  let vtestop (op : vtestop) = match op with
+    | AnyTrue -> "any_true"
+
+  let vunop (op : vunop) = match op with
+    | Not -> "not"
+
+  let vbinop (op : vbinop) = match op with
+    | And -> "and"
+    | AndNot -> "andnot"
+    | Or -> "or"
+    | Xor -> "xor"
+
+  let vternop (op : vternop) = match op with
+    | Bitselect -> "bitselect"
+
+  let splatop xxxx (op : nsplatop) = match op with
+    | Splat -> "splat"
+
+  let pextractop xxxx (op : extension nextractop) = match op with
+    | Extract (i, ext) -> "extract_lane" ^ extension ext ^ " " ^ nat i
+
+  let extractop xxxx (op : unit nextractop) = match op with
+    | Extract (i, ()) -> "extract_lane " ^ nat i
+
+  let replaceop xxxx (op : nreplaceop) = match op with
+    | Replace i -> "replace_lane " ^ nat i
+
+  let lane_oper (pop, iop, fop) op =
+    match op with
+    | V128.I8x16 o -> pop "8x16" o
+    | V128.I16x8 o -> pop "16x8" o
+    | V128.I32x4 o -> iop "32x4" o
+    | V128.I64x2 o -> iop "64x2" o
+    | V128.F32x4 o -> fop "32x4" o
+    | V128.F64x2 o -> fop "64x2" o
+end
+
+let oper (iop, fop) op =
   num_type (type_of_num op) ^ "." ^
   (match op with
-  | I32 o -> intop "32" o
-  | I64 o -> intop "64" o
-  | F32 o -> floatop "32" o
-  | F64 o -> floatop "64" o
+  | I32 o -> iop "32" o
+  | I64 o -> iop "64" o
+  | F32 o -> fop "32" o
+  | F64 o -> fop "64" o
   )
 
+let vec_oper (vop) op =
+  match op with
+  | V128 o -> "v128." ^ vop o
+
+let vec_shape_oper (pop, iop, fop) op =
+  match op with
+  | V128 o -> V128.string_of_shape o ^ "." ^ V128Op.lane_oper (pop, iop, fop) o
+
 let unop = oper (IntOp.unop, FloatOp.unop)
 let binop = oper (IntOp.binop, FloatOp.binop)
 let testop = oper (IntOp.testop, FloatOp.testop)
 let relop = oper (IntOp.relop, FloatOp.relop)
 let cvtop = oper (IntOp.cvtop, FloatOp.cvtop)
 
-let memop name {ty; align; offset; _} sz =
-  num_type ty ^ "." ^ name ^
+let vec_unop = vec_shape_oper (V128Op.iunop, V128Op.iunop, V128Op.funop)
+let vec_binop = vec_shape_oper (V128Op.ibinop, V128Op.ibinop, V128Op.fbinop)
+let vec_testop = vec_shape_oper (V128Op.itestop, V128Op.itestop, V128Op.voidop)
+let vec_relop = vec_shape_oper (V128Op.irelop, V128Op.irelop, V128Op.frelop)
+let vec_cvtop = vec_shape_oper (V128Op.icvtop, V128Op.icvtop, V128Op.fcvtop)
+let vec_shiftop = vec_shape_oper (V128Op.ishiftop, V128Op.ishiftop, V128Op.voidop)
+let vec_bitmaskop = vec_shape_oper (V128Op.ibitmaskop, V128Op.ibitmaskop, V128Op.voidop)
+let vec_vunop = vec_oper (V128Op.vunop)
+let vec_vbinop = vec_oper (V128Op.vbinop)
+let vec_vternop = vec_oper (V128Op.vternop)
+let vec_vtestop = vec_oper (V128Op.vtestop)
+let vec_splatop = vec_shape_oper (V128Op.splatop, V128Op.splatop, V128Op.splatop)
+let vec_extractop = vec_shape_oper (V128Op.pextractop, V128Op.extractop, V128Op.extractop)
+let vec_replaceop = vec_shape_oper (V128Op.replaceop, V128Op.replaceop, V128Op.replaceop)
+
+let memop name typ {ty; align; offset; _} sz =
+  typ ty ^ "." ^ name ^
   (if offset = 0l then "" else " offset=" ^ nat32 offset) ^
   (if 1 lsl align = sz then "" else " align=" ^ nat (1 lsl align))
 
 let loadop op =
-  match op.sz with
-  | None -> memop "load" op (size op.ty)
+  match op.pack with
+  | None -> memop "load" num_type op (num_size op.ty)
   | Some (sz, ext) ->
-    memop ("load" ^ pack_size sz ^ extension ext) op (packed_size sz)
+    memop ("load" ^ pack_size sz ^ extension ext) num_type op (packed_size sz)
 
 let storeop op =
-  match op.sz with
-  | None -> memop "store" op (size op.ty)
-  | Some sz -> memop ("store" ^ pack_size sz) op (packed_size sz)
+  match op.pack with
+  | None -> memop "store" num_type op (num_size op.ty)
+  | Some sz -> memop ("store" ^ pack_size sz) num_type op (packed_size sz)
+
+let vec_loadop (op : vec_loadop) =
+  match op.pack with
+  | None -> memop "load" vec_type op (vec_size op.ty)
+  | Some (sz, ext) ->
+    memop ("load" ^ vec_extension sz ext) vec_type op (packed_size sz)
+
+let vec_storeop op =
+  memop "store" vec_type op (vec_size op.ty)
+
+let vec_laneop instr (op, i) =
+  memop (instr ^ pack_size op.pack ^ "_lane") vec_type op
+    (packed_size op.pack) ^ " " ^ nat i
 
 
 (* Expressions *)
 
 let var x = nat32 x.it
 let num v = string_of_num v.it
-let constop v = num_type (type_of_num v.it) ^ ".const"
+let vec v = string_of_vec v.it
+let constop v = num_type (type_of_num v) ^ ".const"
+let vec_constop v = vec_type (type_of_vec v) ^ ".const i32x4"
 
 let block_type = function
   | VarBlockType x -> [Node ("type " ^ var x, [])]
@@ -264,6 +468,10 @@ let rec instr e =
     | ElemDrop x -> "elem.drop " ^ var x, []
     | Load op -> loadop op, []
     | Store op -> storeop op, []
+    | VecLoad op -> vec_loadop op, []
+    | VecStore op -> vec_storeop op, []
+    | VecLoadLane op -> vec_laneop "load" op, []
+    | VecStoreLane op -> vec_laneop "store" op, []
     | MemorySize -> "memory.size", []
     | MemoryGrow -> "memory.grow", []
     | MemoryFill -> "memory.fill", []
@@ -273,12 +481,27 @@ let rec instr e =
     | RefNull t -> "ref.null", [Atom (refed_type t)]
     | RefIsNull -> "ref.is_null", []
     | RefFunc x -> "ref.func " ^ var x, []
-    | Const n -> constop n ^ " " ^ num n, []
+    | Const n -> constop n.it ^ " " ^ num n, []
     | Test op -> testop op, []
     | Compare op -> relop op, []
     | Unary op -> unop op, []
     | Binary op -> binop op, []
     | Convert op -> cvtop op, []
+    | VecConst v -> vec_constop v.it ^ " " ^ vec v, []
+    | VecTest op -> vec_testop op, []
+    | VecUnary op -> vec_unop op, []
+    | VecBinary op -> vec_binop op, []
+    | VecCompare op -> vec_relop op, []
+    | VecConvert op -> vec_cvtop op, []
+    | VecShift op -> vec_shiftop op, []
+    | VecBitmask op -> vec_bitmaskop op, []
+    | VecTestBits op -> vec_vtestop op, []
+    | VecUnaryBits op -> vec_vunop op, []
+    | VecBinaryBits op -> vec_vbinop op, []
+    | VecTernaryBits op -> vec_vternop op, []
+    | VecSplat op -> vec_splatop op, []
+    | VecExtract op -> vec_extractop op, []
+    | VecReplace op -> vec_replaceop op, []
   in Node (head, inner)
 
 let const head c =
@@ -433,26 +656,19 @@ let module_ = module_with_var_opt None
 
 (* Scripts *)
 
+let num mode = if mode = `Binary then hex_string_of_num else string_of_num
+let vec mode = if mode = `Binary then hex_string_of_vec else string_of_vec
+
+let ref_ = function
+  | NullRef t -> Node ("ref.null " ^ refed_type t, [])
+  | ExternRef n -> Node ("ref.extern " ^ nat32 n, [])
+  | _ -> assert false
+
 let literal mode lit =
   match lit.it with
-  | Num (Values.I32 i) ->
-    let f = if mode = `Binary then I32.to_hex_string else I32.to_string_s in
-    Node ("i32.const " ^ f i, [])
-  | Num (Values.I64 i) ->
-    let f = if mode = `Binary then I64.to_hex_string else I64.to_string_s in
-    Node ("i64.const " ^ f i, [])
-  | Num (Values.F32 z) ->
-    let f = if mode = `Binary then F32.to_hex_string else F32.to_string in
-    Node ("f32.const " ^ f z, [])
-  | Num (Values.F64 z) ->
-    let f = if mode = `Binary then F64.to_hex_string else F64.to_string in
-    Node ("f64.const " ^ f z, [])
-  | Ref (NullRef t) ->
-    Node ("ref.null " ^ refed_type t, [])
-  | Ref (ExternRef n) ->
-    Node ("ref.extern " ^ nat32 n, [])
-  | Ref _ ->
-    assert false
+  | Num n -> Node (constop n ^ " " ^ num mode n, [])
+  | Vec v -> Node (vec_constop v ^ " " ^ vec mode v, [])
+  | Ref r -> ref_ r
 
 let definition mode x_opt def =
   try
@@ -493,16 +709,39 @@ let nan = function
   | CanonicalNan -> "nan:canonical"
   | ArithmeticNan -> "nan:arithmetic"
 
+let nanop (n : nanop) =
+  match n.it with
+  | F32 n' | F64 n' -> nan n'
+  | _ -> .
+
+let num_pat mode = function
+  | NumPat n -> literal mode (Values.Num n.it @@ n.at)
+  | NanPat nan -> Node (constop nan.it ^ " " ^ nanop nan, [])
+
+let lane_pat mode pat shape =
+  let choose fb ft = if mode = `Binary then fb else ft in
+  match pat, shape with
+  | NumPat {it = Values.I32 i; _}, V128.I8x16 () ->
+    choose I8.to_hex_string I8.to_string_s i
+  | NumPat {it = Values.I32 i; _}, V128.I16x8 () ->
+    choose I16.to_hex_string I16.to_string_s i
+  | NumPat n, _ -> num mode n.it
+  | NanPat nan, _ -> nanop nan
+
+let vec_pat mode = function
+  | VecPat (V128 (shape, pats)) ->
+    let lanes = List.map (fun p -> Atom (lane_pat mode p shape)) pats in
+    Node ("v128.const " ^ V128.string_of_shape shape, lanes)
+
+let ref_pat = function
+  | RefPat r -> ref_ r.it
+  | RefTypePat t -> Node ("ref." ^ refed_type t, [])
+
 let result mode res =
   match res.it with
-  | LitResult lit -> literal mode lit
-  | NanResult nanop ->
-    (match nanop.it with
-    | Values.I32 _ | Values.I64 _ -> assert false
-    | Values.F32 n -> Node ("f32.const " ^ nan n, [])
-    | Values.F64 n -> Node ("f64.const " ^ nan n, [])
-    )
-  | RefResult t -> Node ("ref." ^ refed_type t, [])
+  | NumResult np -> num_pat mode np
+  | VecResult vp -> vec_pat mode vp
+  | RefResult rp -> ref_pat rp
 
 let assertion mode ass =
   match ass.it with
diff --git a/interpreter/text/lexer.mll b/interpreter/text/lexer.mll
index a4e914014..c5d759fb8 100644
--- a/interpreter/text/lexer.mll
+++ b/interpreter/text/lexer.mll
@@ -18,6 +18,8 @@ let error_nest start lexbuf msg =
   lexbuf.Lexing.lex_start_p <- start;
   error lexbuf msg
 
+let unknown lexbuf = error lexbuf ("unknown operator " ^ Lexing.lexeme lexbuf)
+
 let string s =
   let b = Buffer.create (String.length s) in
   let i = ref 1 in
@@ -52,6 +54,10 @@ let num_type = function
   | "f64" -> Types.F64Type
   | _ -> assert false
 
+let vec_type = function
+  | "v128" -> Types.V128Type
+  | _ -> assert false
+
 let intop t i32 i64 =
   match t with
   | "i32" -> i32
@@ -72,6 +78,30 @@ let numop t i32 i64 f32 f64 =
   | "f64" -> f64
   | _ -> assert false
 
+let v128op s i8x16 i16x8 i32x4 i64x2 f32x4 f64x2 =
+  match s with
+  | "i8x16" -> i8x16
+  | "i16x8" -> i16x8
+  | "i32x4" -> i32x4
+  | "i64x2" -> i64x2
+  | "f32x4" -> f32x4
+  | "f64x2" -> f64x2
+  | _ -> assert false
+
+let v128intop s i8x16 i16x8 i32x4 i64x2 =
+  match s with
+  | "i8x16" -> i8x16
+  | "i16x8" -> i16x8
+  | "i32x4" -> i32x4
+  | "i64x2" -> i64x2
+  | _ -> assert false
+
+let v128floatop s f32x4 f64x2 =
+  match s with
+  | "f32x4" -> f32x4
+  | "f64x2" -> f64x2
+  | _ -> assert false
+
 let memsz sz m8 m16 m32 =
   match sz with
   | "8" -> m8
@@ -86,6 +116,23 @@ let ext e s u =
   | _ -> assert false
 
 let opt = Lib.Option.get
+
+let v128_shape = function
+  | "i8x16" -> V128.I8x16 ()
+  | "i16x8" -> V128.I16x8 ()
+  | "i32x4" -> V128.I32x4 ()
+  | "i64x2" -> V128.I64x2 ()
+  | "f32x4" -> V128.F32x4 ()
+  | "f64x2" -> V128.F64x2 ()
+  | _ -> assert false
+
+let only shapes s lexbuf =
+  if not (List.mem s shapes) then
+    unknown lexbuf
+
+let except shapes s lexbuf =
+  if (List.mem s shapes) then
+    unknown lexbuf
 }
 
 let sign = '+' | '-'
@@ -140,10 +187,14 @@ let name = '$' reserved
 let ixx = "i" ("32" | "64")
 let fxx = "f" ("32" | "64")
 let nxx = ixx | fxx
+let vxxx = "v128"
 let mixx = "i" ("8" | "16" | "32" | "64")
 let mfxx = "f" ("32" | "64")
 let sign = "s" | "u"
 let mem_size = "8" | "16" | "32"
+let v128_int_shape = "i8x16" | "i16x8" | "i32x4" | "i64x2"
+let v128_float_shape = "f32x4" | "f64x2"
+let v128_shape = v128_int_shape | v128_float_shape
 
 rule token = parse
   | "(" { LPAR }
@@ -163,9 +214,12 @@ rule token = parse
   | "extern" { EXTERN }
   | "externref" { EXTERNREF }
   | "funcref" { FUNCREF }
-  | (nxx as t) { NUM_TYPE (num_type t) }
+  | nxx as t { NUM_TYPE (num_type t) }
+  | vxxx as t { VEC_TYPE (vec_type t) }
   | "mut" { MUT }
 
+  | v128_shape as s { VEC_SHAPE (v128_shape s) }
+
   | (nxx as t)".const"
     { let open Source in
       CONST (numop t
@@ -178,6 +232,13 @@ rule token = parse
         (fun s -> let n = F64.of_string s.it in
           f64_const (n @@ s.at), Values.F64 n))
     }
+  | vxxx".const"
+    { let open Source in
+      VEC_CONST
+        (fun shape ss at ->
+          let v = V128.of_strings shape (List.map (fun s -> s.it) ss) in
+          (v128_const (v @@ at), Values.V128 v))
+    }
   | "ref.null" { REF_NULL }
   | "ref.func" { REF_FUNC }
   | "ref.extern" { REF_EXTERN }
@@ -231,7 +292,7 @@ rule token = parse
         numop t (i32_store (opt a 2)) (i64_store (opt a 3))
                 (f32_store (opt a 2)) (f64_store (opt a 3)) o) }
   | (ixx as t)".load"(mem_size as sz)"_"(sign as s)
-    { if t = "i32" && sz = "32" then error lexbuf "unknown operator";
+    { if t = "i32" && sz = "32" then unknown lexbuf;
       LOAD (fun a o ->
         intop t
           (memsz sz
@@ -243,7 +304,7 @@ rule token = parse
             (ext s i64_load16_s i64_load16_u (opt a 1))
             (ext s i64_load32_s i64_load32_u (opt a 2)) o)) }
   | (ixx as t)".store"(mem_size as sz)
-    { if t = "i32" && sz = "32" then error lexbuf "unknown operator";
+    { if t = "i32" && sz = "32" then unknown lexbuf;
       STORE (fun a o ->
         intop t
           (memsz sz
@@ -254,6 +315,44 @@ rule token = parse
             (i64_store8 (opt a 0))
             (i64_store16 (opt a 1))
             (i64_store32 (opt a 2)) o)) }
+  | "v128.load"
+    { VEC_LOAD (fun a o -> (v128_load (opt a 4)) o) }
+  | "v128.store"
+    { VEC_STORE (fun a o -> (v128_store (opt a 4)) o) }
+  | "v128.load8x8_"(sign as s)
+    { VEC_LOAD (fun a o -> (ext s v128_load8x8_s v128_load8x8_u (opt a 3)) o) }
+  | "v128.load16x4_"(sign as s)
+    { VEC_LOAD (fun a o -> (ext s v128_load16x4_s v128_load16x4_u (opt a 3)) o) }
+  | "v128.load32x2_"(sign as s)
+    { VEC_LOAD (fun a o -> (ext s v128_load32x2_s v128_load32x2_u (opt a 3)) o) }
+  | "v128.load8_splat"
+    { VEC_LOAD (fun a o -> (v128_load8_splat (opt a 0)) o) }
+  | "v128.load16_splat"
+    { VEC_LOAD (fun a o -> (v128_load16_splat (opt a 1)) o) }
+  | "v128.load32_splat"
+    { VEC_LOAD (fun a o -> (v128_load32_splat (opt a 2)) o) }
+  | "v128.load64_splat"
+    { VEC_LOAD (fun a o -> (v128_load64_splat (opt a 3)) o) }
+  | "v128.load32_zero"
+    { VEC_LOAD (fun a o -> (v128_load32_zero (opt a 2)) o) }
+  | "v128.load64_zero"
+    { VEC_LOAD (fun a o -> (v128_load64_zero (opt a 3)) o) }
+  | "v128.load8_lane"
+    { VEC_LOAD_LANE (fun a o i -> (v128_load8_lane (opt a 0)) o i) }
+  | "v128.load16_lane"
+    { VEC_LOAD_LANE (fun a o i -> (v128_load16_lane (opt a 1)) o i) }
+  | "v128.load32_lane"
+    { VEC_LOAD_LANE (fun a o i -> (v128_load32_lane (opt a 2)) o i) }
+  | "v128.load64_lane"
+    { VEC_LOAD_LANE (fun a o i -> (v128_load64_lane (opt a 3)) o i) }
+  | "v128.store8_lane"
+    { VEC_STORE_LANE (fun a o i -> (v128_store8_lane (opt a 0)) o i) }
+  | "v128.store16_lane"
+    { VEC_STORE_LANE (fun a o i -> (v128_store16_lane (opt a 1)) o i) }
+  | "v128.store32_lane"
+    { VEC_STORE_LANE (fun a o i -> (v128_store32_lane (opt a 2)) o i) }
+  | "v128.store64_lane"
+    { VEC_STORE_LANE (fun a o i -> (v128_store64_lane (opt a 3)) o i) }
 
   | "offset="(nat as s) { OFFSET_EQ_NAT s }
   | "align="(nat as s) { ALIGN_EQ_NAT s }
@@ -384,6 +483,196 @@ rule token = parse
   | "input" { INPUT }
   | "output" { OUTPUT }
 
+  | vxxx".not" { VEC_UNARY v128_not }
+  | vxxx".and" { VEC_UNARY v128_and }
+  | vxxx".andnot" { VEC_UNARY v128_andnot }
+  | vxxx".or" { VEC_UNARY v128_or }
+  | vxxx".xor" { VEC_UNARY v128_xor }
+  | vxxx".bitselect" { VEC_TERNARY v128_bitselect }
+  | vxxx".any_true" { VEC_TEST (v128_any_true) }
+
+  | (v128_shape as s)".neg"
+    { VEC_UNARY
+        (v128op s i8x16_neg i16x8_neg i32x4_neg i64x2_neg f32x4_neg f64x2_neg) }
+  | (v128_float_shape as s)".sqrt"
+    { VEC_UNARY (v128floatop s f32x4_sqrt f64x2_sqrt) }
+  | (v128_float_shape as s)".ceil"
+    { VEC_UNARY (v128floatop s f32x4_ceil f64x2_ceil) }
+  | (v128_float_shape as s)".floor"
+    { VEC_UNARY (v128floatop s f32x4_floor f64x2_floor) }
+  | (v128_float_shape as s)".trunc"
+    { VEC_UNARY (v128floatop s f32x4_trunc f64x2_trunc) }
+  | (v128_float_shape as s)".nearest"
+    { VEC_UNARY (v128floatop s f32x4_nearest f64x2_nearest) }
+  | (v128_shape as s)".abs"
+    { VEC_UNARY
+        (v128op s i8x16_abs i16x8_abs i32x4_abs i64x2_abs f32x4_abs f64x2_abs) }
+  | "i8x16.popcnt" { VEC_UNARY i8x16_popcnt }
+  | (v128_int_shape as s)".avgr_u"
+    { only ["i8x16"; "i16x8"] s lexbuf;
+      VEC_UNARY (v128intop s i8x16_avgr_u i16x8_avgr_u unreachable unreachable) }
+  | "i32x4.trunc_sat_f32x4_"(sign as s)
+    { VEC_UNARY (ext s i32x4_trunc_sat_f32x4_s i32x4_trunc_sat_f32x4_u) }
+  | "i32x4.trunc_sat_f64x2_"(sign as s)"_zero"
+    { VEC_UNARY (ext s i32x4_trunc_sat_f64x2_s_zero i32x4_trunc_sat_f64x2_u_zero) }
+  | "f64x2.promote_low_f32x4"
+    { VEC_UNARY f64x2_promote_low_f32x4 }
+  | "f32x4.demote_f64x2_zero"
+    { VEC_UNARY f32x4_demote_f64x2_zero }
+  | "f32x4.convert_i32x4_"(sign as s)
+    { VEC_UNARY (ext s f32x4_convert_i32x4_s f32x4_convert_i32x4_u) }
+  | "f64x2.convert_low_i32x4_"(sign as s)
+    { VEC_UNARY (ext s f64x2_convert_low_i32x4_s f64x2_convert_low_i32x4_u) }
+  | "i16x8.extadd_pairwise_i8x16_"(sign as s)
+    { VEC_UNARY (ext s i16x8_extadd_pairwise_i8x16_s i16x8_extadd_pairwise_i8x16_u) }
+  | "i32x4.extadd_pairwise_i16x8_"(sign as s)
+    { VEC_UNARY (ext s i32x4_extadd_pairwise_i16x8_s i32x4_extadd_pairwise_i16x8_u) }
+
+  | (v128_shape as s)".eq"
+    { VEC_BINARY (v128op s i8x16_eq i16x8_eq i32x4_eq i64x2_eq f32x4_eq f64x2_eq) }
+  | (v128_shape as s)".ne"
+    { VEC_BINARY (v128op s i8x16_ne i16x8_ne i32x4_ne i64x2_ne f32x4_ne f64x2_ne) }
+  | (v128_int_shape as s)".lt_s"
+    { VEC_BINARY (v128intop s i8x16_lt_s i16x8_lt_s i32x4_lt_s i64x2_lt_s) }
+  | (v128_int_shape as s)".lt_u"
+    { except ["i64x2"] s lexbuf;
+      VEC_BINARY (v128intop s i8x16_lt_u i16x8_lt_u i32x4_lt_u unreachable) }
+  | (v128_int_shape as s)".le_s"
+    { VEC_BINARY (v128intop s i8x16_le_s i16x8_le_s i32x4_le_s i64x2_le_s) }
+  | (v128_int_shape as s)".le_u"
+    { except ["i64x2"] s lexbuf;
+      VEC_BINARY (v128intop s i8x16_le_u i16x8_le_u i32x4_le_u unreachable) }
+  | (v128_int_shape as s)".gt_s"
+    { VEC_BINARY (v128intop s i8x16_gt_s i16x8_gt_s i32x4_gt_s i64x2_gt_s) }
+  | (v128_int_shape as s)".gt_u"
+    { except ["i64x2"] s lexbuf;
+      VEC_BINARY (v128intop s i8x16_gt_u i16x8_gt_u i32x4_gt_u unreachable) }
+  | (v128_int_shape as s)".ge_s"
+    { VEC_BINARY (v128intop s i8x16_ge_s i16x8_ge_s i32x4_ge_s i64x2_ge_s) }
+  | (v128_int_shape as s)".ge_u"
+    { except ["i64x2"] s lexbuf;
+      VEC_BINARY (v128intop s i8x16_ge_u i16x8_ge_u i32x4_ge_u unreachable) }
+  | (v128_float_shape as s)".lt" { VEC_BINARY (v128floatop s f32x4_lt f64x2_lt) }
+  | (v128_float_shape as s)".le" { VEC_BINARY (v128floatop s f32x4_le f64x2_le) }
+  | (v128_float_shape as s)".gt" { VEC_BINARY (v128floatop s f32x4_gt f64x2_gt) }
+  | (v128_float_shape as s)".ge" { VEC_BINARY (v128floatop s f32x4_ge f64x2_ge) }
+  | "i8x16.swizzle" { VEC_BINARY i8x16_swizzle }
+
+  | (v128_shape as s)".add"
+    { VEC_BINARY
+        (v128op s i8x16_add i16x8_add i32x4_add i64x2_add f32x4_add f64x2_add) }
+  | (v128_shape as s)".sub"
+    { VEC_BINARY
+        (v128op s i8x16_sub i16x8_sub i32x4_sub i64x2_sub f32x4_sub f64x2_sub) }
+  | (v128_shape as s)".min_s"
+    { only ["i8x16"; "i16x8"; "i32x4"] s lexbuf;
+      VEC_BINARY
+        (v128op s i8x16_min_s i16x8_min_s i32x4_min_s unreachable
+                  unreachable unreachable) }
+  | (v128_shape as s)".min_u"
+    { only ["i8x16"; "i16x8"; "i32x4"] s lexbuf;
+      VEC_BINARY
+        (v128op s i8x16_min_u i16x8_min_u i32x4_min_u unreachable
+                  unreachable unreachable) }
+  | (v128_shape as s)".max_s"
+    { only ["i8x16"; "i16x8"; "i32x4"] s lexbuf;
+      VEC_BINARY
+        (v128op s i8x16_max_s i16x8_max_s i32x4_max_s unreachable
+                  unreachable unreachable) }
+  | (v128_shape as s)".max_u"
+    { only ["i8x16"; "i16x8"; "i32x4"] s lexbuf;
+      VEC_BINARY
+        (v128op s i8x16_max_u i16x8_max_u i32x4_max_u unreachable
+                  unreachable unreachable) }
+  | (v128_shape as s)".mul"
+    { only ["i16x8"; "i32x4"; "i64x2"; "f32x4"; "f64x2"] s lexbuf;
+      VEC_BINARY
+        (v128op s unreachable i16x8_mul i32x4_mul i64x2_mul f32x4_mul f64x2_mul) }
+  | (v128_float_shape as s)".div"
+    { VEC_BINARY (v128floatop s f32x4_div f64x2_div) }
+  | (v128_float_shape as s)".min"
+    { VEC_BINARY (v128floatop s f32x4_min f64x2_min) }
+  | (v128_float_shape as s)".max"
+    { VEC_BINARY (v128floatop s f32x4_max f64x2_max) }
+  | (v128_float_shape as s)".pmin"
+    { VEC_BINARY (v128floatop s f32x4_pmin f64x2_pmin) }
+  | (v128_float_shape as s)".pmax"
+    { VEC_BINARY (v128floatop s f32x4_pmax f64x2_pmax) }
+  | "i8x16.add_sat_"(sign as s)
+    { VEC_BINARY (ext s i8x16_add_sat_s i8x16_add_sat_u) }
+  | "i8x16.sub_sat_"(sign as s)
+    { VEC_BINARY (ext s i8x16_sub_sat_s i8x16_sub_sat_u) }
+  | "i16x8.add_sat_"(sign as s)
+    { VEC_BINARY (ext s i16x8_add_sat_s i16x8_add_sat_u) }
+  | "i16x8.sub_sat_"(sign as s)
+    { VEC_BINARY (ext s i16x8_sub_sat_s i16x8_sub_sat_u) }
+  | "i32x4.dot_i16x8_s"
+    { VEC_BINARY i32x4_dot_i16x8_s }
+  | "i8x16.narrow_i16x8_"(sign as s)
+    { VEC_BINARY (ext s i8x16_narrow_i16x8_s i8x16_narrow_i16x8_u) }
+  | "i16x8.narrow_i32x4_"(sign as s)
+    { VEC_BINARY (ext s i16x8_narrow_i32x4_s i16x8_narrow_i32x4_u) }
+  | "i16x8.extend_low_i8x16_"(sign as s)
+    { VEC_UNARY (ext s i16x8_extend_low_i8x16_s i16x8_extend_low_i8x16_u) }
+  | "i16x8.extend_high_i8x16_"(sign as s)
+    { VEC_UNARY (ext s i16x8_extend_high_i8x16_s i16x8_extend_high_i8x16_u) }
+  | "i32x4.extend_low_i16x8_"(sign as s)
+    { VEC_UNARY (ext s i32x4_extend_low_i16x8_s i32x4_extend_low_i16x8_u) }
+  | "i32x4.extend_high_i16x8_"(sign as s)
+    { VEC_UNARY (ext s i32x4_extend_high_i16x8_s i32x4_extend_high_i16x8_u) }
+  | "i64x2.extend_low_i32x4_"(sign as s)
+    { VEC_UNARY (ext s i64x2_extend_low_i32x4_s i64x2_extend_low_i32x4_u) }
+  | "i64x2.extend_high_i32x4_"(sign as s)
+    { VEC_UNARY (ext s i64x2_extend_high_i32x4_s i64x2_extend_high_i32x4_u) }
+  | "i16x8.extmul_low_i8x16_"(sign as s)
+    { VEC_BINARY (ext s i16x8_extmul_low_i8x16_s i16x8_extmul_low_i8x16_u) }
+  | "i16x8.extmul_high_i8x16_"(sign as s)
+    { VEC_BINARY (ext s i16x8_extmul_high_i8x16_s i16x8_extmul_high_i8x16_u) }
+  | "i32x4.extmul_low_i16x8_"(sign as s)
+    { VEC_BINARY (ext s i32x4_extmul_low_i16x8_s i32x4_extmul_low_i16x8_u) }
+  | "i32x4.extmul_high_i16x8_"(sign as s)
+    { VEC_BINARY (ext s i32x4_extmul_high_i16x8_s i32x4_extmul_high_i16x8_u) }
+  | "i64x2.extmul_low_i32x4_"(sign as s)
+    { VEC_BINARY (ext s i64x2_extmul_low_i32x4_s i64x2_extmul_low_i32x4_u) }
+  | "i64x2.extmul_high_i32x4_"(sign as s)
+    { VEC_BINARY (ext s i64x2_extmul_high_i32x4_s i64x2_extmul_high_i32x4_u) }
+  | "i16x8.q15mulr_sat_s"
+    { VEC_BINARY i16x8_q15mulr_sat_s }
+
+  | (v128_int_shape as s)".all_true"
+    { VEC_TEST
+        (v128intop s i8x16_all_true i16x8_all_true i32x4_all_true i64x2_all_true) }
+  | (v128_int_shape as s)".bitmask"
+    { VEC_BITMASK
+        (v128intop s i8x16_bitmask i16x8_bitmask i32x4_bitmask i64x2_bitmask) }
+  | (v128_int_shape as s)".shl"
+    { VEC_SHIFT (v128intop s i8x16_shl i16x8_shl i32x4_shl i64x2_shl) }
+  | (v128_int_shape as s)".shr_s"
+    { VEC_SHIFT (v128intop s i8x16_shr_s i16x8_shr_s i32x4_shr_s i64x2_shr_s) }
+  | (v128_int_shape as s)".shr_u"
+    { VEC_SHIFT (v128intop s i8x16_shr_u i16x8_shr_u i32x4_shr_u i64x2_shr_u) }
+  | "i8x16.shuffle" { VEC_SHUFFLE }
+
+  | (v128_shape as s)".splat"
+    { VEC_SPLAT (v128op s i8x16_splat i16x8_splat i32x4_splat
+                           i64x2_splat f32x4_splat f64x2_splat) }
+  | (v128_shape as s)".extract_lane"
+    { except ["i8x16"; "i16x8"] s lexbuf;
+      VEC_EXTRACT (fun i ->
+        v128op s
+          (fun _ -> unreachable) (fun _ -> unreachable)
+          i32x4_extract_lane i64x2_extract_lane
+          f32x4_extract_lane f64x2_extract_lane i) }
+  | (("i8x16"|"i16x8") as t)".extract_lane_"(sign as s)
+    { VEC_EXTRACT (fun i ->
+        if t = "i8x16"
+        then ext s i8x16_extract_lane_s i8x16_extract_lane_u i
+        else ext s i16x8_extract_lane_s i16x8_extract_lane_u i )}
+  | (v128_shape as s)".replace_lane"
+    { VEC_REPLACE
+        (v128op s i8x16_replace_lane i16x8_replace_lane i32x4_replace_lane
+                  i64x2_replace_lane f32x4_replace_lane f64x2_replace_lane) }
+
   | name as s { VAR s }
 
   | ";;"utf8_no_nl*eof { EOF }
@@ -394,7 +683,7 @@ rule token = parse
   | '\n' { Lexing.new_line lexbuf; token lexbuf }
   | eof { EOF }
 
-  | reserved { error lexbuf "unknown operator" }
+  | reserved { unknown lexbuf }
   | utf8 { error lexbuf "malformed operator" }
   | _ { error lexbuf "malformed UTF-8 encoding" }
 
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index 4e328b69e..e91c3fe86 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -39,6 +39,38 @@ let ati i =
 let num f s =
   try f s with Failure _ -> error s.at "constant out of range"
 
+let vec f shape ss at =
+  try f shape ss at with
+  | Failure _ -> error at "constant out of range"
+  | Invalid_argument _ -> error at "wrong number of lane literals"
+
+let vec_lane_nan shape l at =
+  let open Values in
+  match shape with
+  | V128.F32x4 () -> NanPat (F32 l @@ at)
+  | V128.F64x2 () -> NanPat (F64 l @@ at)
+  | _ -> error at "invalid vector constant"
+
+let vec_lane_lit shape l at =
+  let open Values in
+  match shape with
+  | V128.I8x16 () -> NumPat (I32 (I8.of_string l) @@ at)
+  | V128.I16x8 () -> NumPat (I32 (I16.of_string l) @@ at)
+  | V128.I32x4 () -> NumPat (I32 (I32.of_string l) @@ at)
+  | V128.I64x2 () -> NumPat (I64 (I64.of_string l) @@ at)
+  | V128.F32x4 () -> NumPat (F32 (F32.of_string l) @@ at)
+  | V128.F64x2 () -> NumPat (F64 (F64.of_string l) @@ at)
+
+let vec_lane_index s at =
+  match int_of_string s with
+  | n when 0 <= n && n < 256 -> n
+  | _ | exception Failure _ -> error at "malformed lane index"
+
+let shuffle_lit ss at =
+  if not (List.length ss = 16) then
+    error at "invalid lane length";
+  List.map (fun s -> vec_lane_index s.it s.at) ss
+
 let nanop f nan =
   let open Source in
   let open Values in
@@ -174,7 +206,7 @@ let inline_type_explicit (c : context) x ft at =
 
 %token LPAR RPAR
 %token NAT INT FLOAT STRING VAR
-%token NUM_TYPE FUNCREF EXTERNREF EXTERN MUT
+%token NUM_TYPE VEC_TYPE VEC_SHAPE FUNCREF EXTERNREF EXTERN MUT
 %token UNREACHABLE NOP DROP SELECT
 %token BLOCK END IF THEN ELSE LOOP BR BR_IF BR_TABLE
 %token CALL CALL_INDIRECT RETURN
@@ -185,6 +217,10 @@ let inline_type_explicit (c : context) x ft at =
 %token LOAD STORE OFFSET_EQ_NAT ALIGN_EQ_NAT
 %token CONST UNARY BINARY TEST COMPARE CONVERT
 %token REF_NULL REF_FUNC REF_EXTERN REF_IS_NULL
+%token VEC_LOAD VEC_STORE VEC_LOAD_LANE VEC_STORE_LANE
+%token VEC_CONST VEC_UNARY VEC_BINARY VEC_TERNARY VEC_TEST
+%token VEC_SHIFT VEC_BITMASK VEC_SHUFFLE
+%token VEC_EXTRACT VEC_REPLACE
 %token FUNC START TYPE PARAM RESULT LOCAL GLOBAL
 %token TABLE ELEM MEMORY DATA DECLARE OFFSET ITEM IMPORT EXPORT
 %token MODULE BIN QUOTE
@@ -201,7 +237,9 @@ let inline_type_explicit (c : context) x ft at =
 %token<string> STRING
 %token<string> VAR
 %token<Types.num_type> NUM_TYPE
+%token<Types.vec_type> VEC_TYPE
 %token<string Source.phrase -> Ast.instr' * Values.num> CONST
+%token<V128.shape -> string Source.phrase list -> Source.region -> Ast.instr' * Values.vec> VEC_CONST
 %token<Ast.instr'> UNARY
 %token<Ast.instr'> BINARY
 %token<Ast.instr'> TEST
@@ -209,8 +247,22 @@ let inline_type_explicit (c : context) x ft at =
 %token<Ast.instr'> CONVERT
 %token<int option -> Memory.offset -> Ast.instr'> LOAD
 %token<int option -> Memory.offset -> Ast.instr'> STORE
+%token<int option -> Memory.offset -> Ast.instr'> VEC_LOAD
+%token<int option -> Memory.offset -> Ast.instr'> VEC_STORE
+%token<int option -> Memory.offset -> int -> Ast.instr'> VEC_LOAD_LANE
+%token<int option -> Memory.offset -> int -> Ast.instr'> VEC_STORE_LANE
+%token<Ast.instr'> VEC_UNARY
+%token<Ast.instr'> VEC_BINARY
+%token<Ast.instr'> VEC_TERNARY
+%token<Ast.instr'> VEC_TEST
+%token<Ast.instr'> VEC_SHIFT
+%token<Ast.instr'> VEC_BITMASK
+%token<Ast.instr'> VEC_SPLAT
+%token<int -> Ast.instr'> VEC_EXTRACT
+%token<int -> Ast.instr'> VEC_REPLACE
 %token<string> OFFSET_EQ_NAT
 %token<string> ALIGN_EQ_NAT
+%token<V128.shape> VEC_SHAPE
 
 %token<Script.nan> NAN
 
@@ -246,6 +298,7 @@ ref_type :
 
 value_type :
   | NUM_TYPE { NumType $1 }
+  | VEC_TYPE { VecType $1 }
   | ref_type { RefType $1 }
 
 value_type_list :
@@ -294,6 +347,10 @@ num :
   | INT { $1 @@ at () }
   | FLOAT { $1 @@ at () }
 
+num_list:
+  | /* empty */ { [] }
+  | num num_list { $1 :: $2 }
+
 var :
   | NAT { let at = at () in fun c lookup -> nat32 $1 at @@ at }
   | VAR { let at = at () in fun c lookup -> lookup c ($1 @@ at) @@ at }
@@ -381,6 +438,12 @@ plain_instr :
   | ELEM_DROP var { fun c -> elem_drop ($2 c elem) }
   | LOAD offset_opt align_opt { fun c -> $1 $3 $2 }
   | STORE offset_opt align_opt { fun c -> $1 $3 $2 }
+  | VEC_LOAD offset_opt align_opt { fun c -> $1 $3 $2 }
+  | VEC_STORE offset_opt align_opt { fun c -> $1 $3 $2 }
+  | VEC_LOAD_LANE offset_opt align_opt NAT
+    { let at = at () in fun c -> $1 $3 $2 (vec_lane_index $4 at) }
+  | VEC_STORE_LANE offset_opt align_opt NAT
+    { let at = at () in fun c -> $1 $3 $2 (vec_lane_index $4 at) }
   | MEMORY_SIZE { fun c -> memory_size }
   | MEMORY_GROW { fun c -> memory_grow }
   | MEMORY_FILL { fun c -> memory_fill }
@@ -396,6 +459,17 @@ plain_instr :
   | UNARY { fun c -> $1 }
   | BINARY { fun c -> $1 }
   | CONVERT { fun c -> $1 }
+  | VEC_CONST VEC_SHAPE num_list { let at = at () in fun c -> fst (vec $1 $2 $3 at) }
+  | VEC_UNARY { fun c -> $1 }
+  | VEC_BINARY { fun c -> $1 }
+  | VEC_TERNARY { fun c -> $1 }
+  | VEC_TEST { fun c -> $1 }
+  | VEC_SHIFT { fun c -> $1 }
+  | VEC_BITMASK { fun c -> $1 }
+  | VEC_SHUFFLE num_list { let at = at () in fun c -> i8x16_shuffle (shuffle_lit $2 at) }
+  | VEC_SPLAT { fun c -> $1 }
+  | VEC_EXTRACT NAT { let at = at () in fun c -> $1 (vec_lane_index $2 at) }
+  | VEC_REPLACE NAT { let at = at () in fun c -> $1 (vec_lane_index $2 at) }
 
 
 select_instr :
@@ -1011,7 +1085,7 @@ script_module :
     { $3, Quoted ("quote:" ^ string_of_pos (at()).left, $5) @@ at() }
 
 action :
-  | LPAR INVOKE module_var_opt name const_list RPAR
+  | LPAR INVOKE module_var_opt name literal_list RPAR
     { Invoke ($3, $4, $5) @@ at () }
   | LPAR GET module_var_opt name RPAR
     { Get ($3, $4) @@ at() }
@@ -1046,20 +1120,44 @@ meta :
   | LPAR OUTPUT script_var_opt STRING RPAR { Output ($3, Some $4) @@ at () }
   | LPAR OUTPUT script_var_opt RPAR { Output ($3, None) @@ at () }
 
-const :
-  | LPAR CONST num RPAR { Values.Num (snd (num $2 $3)) @@ at () }
-  | LPAR REF_NULL ref_kind RPAR { Values.Ref (Values.NullRef $3) @@ at () }
-  | LPAR REF_EXTERN NAT RPAR { Values.Ref (ExternRef (nat32 $3 (ati 3))) @@ at () }
+literal_num :
+  | LPAR CONST num RPAR { snd (num $2 $3) }
 
-const_list :
+literal_vec :
+  | LPAR VEC_CONST VEC_SHAPE num_list RPAR { snd (vec $2 $3 $4 (at ())) }
+
+literal_ref :
+  | LPAR REF_NULL ref_kind RPAR { Values.NullRef $3 }
+  | LPAR REF_EXTERN NAT RPAR { ExternRef (nat32 $3 (ati 3)) }
+
+literal :
+  | literal_num { Values.Num $1 @@ at () }
+  | literal_vec { Values.Vec $1 @@ at () }
+  | literal_ref { Values.Ref $1 @@ at () }
+
+literal_list :
   | /* empty */ { [] }
-  | const const_list { $1 :: $2 }
+  | literal literal_list { $1 :: $2 }
+
+numpat :
+  | num { fun sh -> vec_lane_lit sh $1.it $1.at }
+  | NAN { fun sh -> vec_lane_nan sh $1 (ati 3) }
+
+numpat_list:
+  | /* empty */ { [] }
+  | numpat numpat_list { $1 :: $2 }
 
 result :
-  | const { LitResult $1 @@ at () }
-  | LPAR CONST NAN RPAR { NanResult (nanop $2 ($3 @@ ati 3)) @@ at () }
-  | LPAR REF_FUNC RPAR { RefResult FuncRefType @@ at () }
-  | LPAR REF_EXTERN RPAR { RefResult ExternRefType @@ at () }
+  | literal_num { NumResult (NumPat ($1 @@ at())) @@ at () }
+  | LPAR CONST NAN RPAR { NumResult (NanPat (nanop $2 ($3 @@ ati 3))) @@ at () }
+  | literal_ref { RefResult (RefPat ($1 @@ at ())) @@ at () }
+  | LPAR REF_FUNC RPAR { RefResult (RefTypePat FuncRefType) @@ at () }
+  | LPAR REF_EXTERN RPAR { RefResult (RefTypePat ExternRefType) @@ at () }
+  | LPAR VEC_CONST VEC_SHAPE numpat_list RPAR {
+    if V128.num_lanes $3 <> List.length $4 then
+      error (at ()) "wrong number of lane literals";
+    VecResult (VecPat (Values.V128 ($3, List.map (fun lit -> lit $3) $4))) @@ at ()
+  }
 
 result_list :
   | /* empty */ { [] }
diff --git a/interpreter/util/lib.ml b/interpreter/util/lib.ml
index adf101eb7..76757eb72 100644
--- a/interpreter/util/lib.ml
+++ b/interpreter/util/lib.ml
@@ -1,4 +1,4 @@
-type void
+type void = |
 
 module Fun =
 struct
@@ -108,6 +108,11 @@ struct
   let rec concat_map f = function
     | [] -> []
     | x::xs -> f x @ concat_map f xs
+
+  let rec pairwise f = function
+    | [] -> []
+    | x1::x2::xs -> f x1 x2 :: pairwise f xs
+    | _ -> failwith "pairwise"
 end
 
 module List32 =
diff --git a/interpreter/util/lib.mli b/interpreter/util/lib.mli
index 415a855e0..b66b8b0e8 100644
--- a/interpreter/util/lib.mli
+++ b/interpreter/util/lib.mli
@@ -1,6 +1,6 @@
 (* Things that should be in the OCaml library... *)
 
-type void
+type void = |
 
 module Fun :
 sig
@@ -25,6 +25,7 @@ sig
   val index_where : ('a -> bool) -> 'a list -> int option
   val map_filter : ('a -> 'b option) -> 'a list -> 'b list
   val concat_map : ('a -> 'b list) -> 'a list -> 'b list
+  val pairwise : ('a -> 'a -> 'b) -> 'a list -> 'b list
 end
 
 module List32 :
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index f6d2efce0..780404e50 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -111,10 +111,9 @@ let peek i (ell, ts) =
 (* Type Synthesis *)
 
 let type_num = Values.type_of_num
-let type_unop = Values.type_of_num
-let type_binop = Values.type_of_num
-let type_testop = Values.type_of_num
-let type_relop = Values.type_of_num
+let type_vec = Values.type_of_vec
+let type_vec_lane = function
+  | Values.V128 laneop -> V128.type_of_lane laneop
 
 let type_cvtop at = function
   | Values.I32 cvtop ->
@@ -152,25 +151,51 @@ let type_cvtop at = function
     | DemoteF64 -> error at "invalid conversion"
     ), F64Type
 
+let num_lanes = function
+  | Values.V128 laneop -> V128.num_lanes laneop
+
+let lane_extractop = function
+  | Values.V128 extractop ->
+    let open V128 in let open V128Op in
+    match extractop with
+    | I8x16 (Extract (i, _)) | I16x8 (Extract (i, _))
+    | I32x4 (Extract (i, _)) | I64x2 (Extract (i, _))
+    | F32x4 (Extract (i, _)) | F64x2 (Extract (i, _)) -> i
+
+let lane_replaceop = function
+  | Values.V128 replaceop ->
+    let open V128 in let open V128Op in
+    match replaceop with
+    | I8x16 (Replace i) | I16x8 (Replace i)
+    | I32x4 (Replace i) | I64x2 (Replace i)
+    | F32x4 (Replace i) | F64x2 (Replace i) -> i
+
 
 (* Expressions *)
 
-let check_pack sz t at =
-  require (packed_size sz < size t) at "invalid sign extension"
+let check_pack sz t_sz at =
+  require (packed_size sz < t_sz) at "invalid sign extension"
 
 let check_unop unop at =
   match unop with
   | Values.I32 (IntOp.ExtendS sz) | Values.I64 (IntOp.ExtendS sz) ->
-    check_pack sz (Values.type_of_num unop) at
+    check_pack sz (num_size (Values.type_of_num unop)) at
+  | _ -> ()
+
+let check_vec_binop binop at =
+  match binop with
+  | Values.(V128 (V128.I8x16 (V128Op.Shuffle is))) ->
+    if List.exists ((<=) 32) is then
+      error at "invalid lane index"
   | _ -> ()
 
-let check_memop (c : context) (memop : 'a memop) get_sz at =
+let check_memop (c : context) (memop : ('t, 's) memop) ty_size get_sz at =
   let _mt = memory c (0l @@ at) in
   let size =
-    match get_sz memop.sz with
-    | None -> size memop.ty
+    match get_sz memop.pack with
+    | None -> ty_size memop.ty
     | Some sz ->
-      check_pack sz memop.ty at;
+      check_pack sz (ty_size memop.ty) at;
       packed_size sz
   in
   require (1 lsl memop.align <= size) at
@@ -216,13 +241,14 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : op_type
 
   | Select None ->
     let t = peek 1 s in
-    require (match t with None -> true | Some t -> is_num_type t) e.at
-      ("type mismatch: instruction requires numeric type" ^
+    require (match t with None -> true | Some t -> is_num_type t || is_vec_type t) e.at
+      ("type mismatch: instruction requires numeric or vector type" ^
        " but stack has " ^ string_of_infer_type t);
     [t; t; Some (NumType I32Type)] -~> [t]
 
   | Select (Some ts) ->
-    require (List.length ts = 1) e.at "invalid result arity other than 1 is not (yet) allowed";
+    require (List.length ts = 1) e.at
+      "invalid result arity other than 1 is not (yet) allowed";
     (ts @ ts @ [NumType I32Type]) --> ts
 
   | Block (bt, es) ->
@@ -328,13 +354,33 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : op_type
     [] --> []
 
   | Load memop ->
-    check_memop c memop (Lib.Option.map fst) e.at;
+    check_memop c memop num_size (Lib.Option.map fst) e.at;
     [NumType I32Type] --> [NumType memop.ty]
 
   | Store memop ->
-    check_memop c memop (fun sz -> sz) e.at;
+    check_memop c memop num_size (fun sz -> sz) e.at;
     [NumType I32Type; NumType memop.ty] --> []
 
+  | VecLoad memop ->
+    check_memop c memop vec_size (Lib.Option.map fst) e.at;
+    [NumType I32Type] --> [VecType memop.ty]
+
+  | VecStore memop ->
+    check_memop c memop vec_size (fun _ -> None) e.at;
+    [NumType I32Type; VecType memop.ty] --> []
+
+  | VecLoadLane (memop, i) ->
+    check_memop c memop vec_size (fun sz -> Some sz) e.at;
+    require (i < vec_size memop.ty / packed_size memop.pack) e.at
+      "invalid lane index";
+    [NumType I32Type; VecType memop.ty] -->  [VecType memop.ty]
+
+  | VecStoreLane (memop, i) ->
+    check_memop c memop vec_size (fun sz -> Some sz) e.at;
+    require (i < vec_size memop.ty / packed_size memop.pack) e.at
+      "invalid lane index";
+    [NumType I32Type; VecType memop.ty] -->  []
+
   | MemorySize ->
     let _mt = memory c (0l @@ e.at) in
     [] --> [NumType I32Type]
@@ -380,26 +426,94 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : op_type
     [] --> [t]
 
   | Test testop ->
-    let t = NumType (type_testop testop) in
+    let t = NumType (type_num testop) in
     [t] --> [NumType I32Type]
 
   | Compare relop ->
-    let t = NumType (type_relop relop) in
+    let t = NumType (type_num relop) in
     [t; t] --> [NumType I32Type]
 
   | Unary unop ->
     check_unop unop e.at;
-    let t = NumType (type_unop unop) in
+    let t = NumType (type_num unop) in
     [t] --> [t]
 
   | Binary binop ->
-    let t = NumType (type_binop binop) in
+    let t = NumType (type_num binop) in
     [t; t] --> [t]
 
   | Convert cvtop ->
     let t1, t2 = type_cvtop e.at cvtop in
     [NumType t1] --> [NumType t2]
 
+  | VecConst v ->
+    let t = VecType (type_vec v.it) in
+    [] --> [t]
+
+  | VecTest testop ->
+    let t = VecType (type_vec testop) in
+    [t] --> [NumType I32Type]
+
+  | VecUnary unop ->
+    let t = VecType (type_vec unop) in
+    [t] --> [t]
+
+  | VecBinary binop ->
+    check_vec_binop binop e.at;
+    let t = VecType (type_vec binop) in
+    [t; t] --> [t]
+
+  | VecCompare relop ->
+    let t = VecType (type_vec relop) in
+    [t; t] --> [t]
+
+  | VecConvert cvtop ->
+    let t = VecType (type_vec cvtop) in
+    [t] --> [t]
+
+  | VecShift shiftop ->
+    let t = VecType (type_vec shiftop) in
+    [t; NumType I32Type] --> [VecType V128Type]
+
+  | VecBitmask bitmaskop ->
+    let t = VecType (type_vec bitmaskop) in
+    [t] --> [NumType I32Type]
+
+  | VecTestBits vtestop ->
+    let t = VecType (type_vec vtestop) in
+    [t] --> [NumType I32Type]
+
+  | VecUnaryBits vunop ->
+    let t = VecType (type_vec vunop) in
+    [t] --> [t]
+
+  | VecBinaryBits vbinop ->
+    let t = VecType (type_vec vbinop) in
+    [t; t] --> [t]
+
+  | VecTernaryBits vternop ->
+    let t = VecType (type_vec vternop) in
+    [t; t; t] --> [t]
+
+  | VecSplat splatop ->
+    let t1 = type_vec_lane splatop in
+    let t2 = VecType (type_vec splatop) in
+    [NumType t1] --> [t2]
+
+  | VecExtract extractop ->
+    let t = VecType (type_vec extractop) in
+    let t2 = type_vec_lane extractop in
+    require (lane_extractop extractop < num_lanes extractop) e.at
+      "invalid lane index";
+    [t] --> [NumType t2]
+
+  | VecReplace replaceop ->
+    let t = VecType (type_vec replaceop) in
+    let t2 = type_vec_lane replaceop in
+    require (lane_replaceop replaceop < num_lanes replaceop) e.at
+      "invalid lane index";
+    [t; NumType t2] --> [t]
+
 and check_seq (c : context) (s : infer_result_type) (es : instr list)
   : infer_result_type =
   match es with
@@ -435,12 +549,16 @@ let check_limits {min; max} range at msg =
 let check_num_type (t : num_type) at =
   ()
 
+let check_vec_type (t : vec_type) at =
+  ()
+
 let check_ref_type (t : ref_type) at =
   ()
 
 let check_value_type (t : value_type) at =
   match t with
   | NumType t' -> check_num_type t' at
+  | VecType t' -> check_vec_type t' at
   | RefType t' -> check_ref_type t' at
 
 let check_func_type (ft : func_type) at =
@@ -492,7 +610,8 @@ let is_const (c : context) (e : instr) =
   match e.it with
   | RefNull _
   | RefFunc _
-  | Const _ -> true
+  | Const _
+  | VecConst _ -> true
   | GlobalGet x -> let GlobalType (_, mut) = global c x in mut = Immutable
   | _ -> false
 
diff --git a/proposals/simd/BinarySIMD.md b/proposals/simd/BinarySIMD.md
new file mode 100644
index 000000000..d8c87cee9
--- /dev/null
+++ b/proposals/simd/BinarySIMD.md
@@ -0,0 +1,270 @@
+# Binary encoding of SIMD
+
+This document describes the binary encoding of the SIMD value type and
+instructions.
+
+## SIMD value type
+
+The `v128` value type is encoded as 0x7b:
+
+```
+valtype ::= ...
+          | 0x7B => v128
+```
+
+## SIMD instruction encodings
+
+All SIMD instructions are encoded as a 0xfd prefix byte followed by a
+SIMD-specific opcode in LEB128 format:
+
+```
+instr ::= ...
+        | 0xFD simdop:varuint32 ...
+```
+
+Some SIMD instructions have additional immediate operands following `simdop`.
+These immediate operands are encoded as individual bytes.
+For example, the `i8x16.shuffle` instruction has 16 bytes after `simdop`.
+
+In the description below, `ImmLaneIdx{I}` indicates the maximum value of the byte.
+For example, `ImmLaneIdx16` is a byte with values in the range 0-15 (inclusive).
+
+
+| Instruction                     | `simdop` | Immediate operands       |
+| --------------------------------|---------:|--------------------------|
+| `v128.load`                     |    `0x00`| m:memarg                 |
+| `v128.load8x8_s`                |    `0x01`| m:memarg                 |
+| `v128.load8x8_u`                |    `0x02`| m:memarg                 |
+| `v128.load16x4_s`               |    `0x03`| m:memarg                 |
+| `v128.load16x4_u`               |    `0x04`| m:memarg                 |
+| `v128.load32x2_s`               |    `0x05`| m:memarg                 |
+| `v128.load32x2_u`               |    `0x06`| m:memarg                 |
+| `v128.load8_splat`              |    `0x07`| m:memarg                 |
+| `v128.load16_splat`             |    `0x08`| m:memarg                 |
+| `v128.load32_splat`             |    `0x09`| m:memarg                 |
+| `v128.load64_splat`             |    `0x0a`| m:memarg                 |
+| `v128.store`                    |    `0x0b`| m:memarg                 |
+| `v128.const`                    |    `0x0c`| i:ImmByte[16]            |
+| `i8x16.shuffle`                 |    `0x0d`| s:ImmLaneIdx32[16]       |
+| `i8x16.swizzle`                 |    `0x0e`| -                        |
+| `i8x16.splat`                   |    `0x0f`| -                        |
+| `i16x8.splat`                   |    `0x10`| -                        |
+| `i32x4.splat`                   |    `0x11`| -                        |
+| `i64x2.splat`                   |    `0x12`| -                        |
+| `f32x4.splat`                   |    `0x13`| -                        |
+| `f64x2.splat`                   |    `0x14`| -                        |
+| `i8x16.extract_lane_s`          |    `0x15`| i:ImmLaneIdx16           |
+| `i8x16.extract_lane_u`          |    `0x16`| i:ImmLaneIdx16           |
+| `i8x16.replace_lane`            |    `0x17`| i:ImmLaneIdx16           |
+| `i16x8.extract_lane_s`          |    `0x18`| i:ImmLaneIdx8            |
+| `i16x8.extract_lane_u`          |    `0x19`| i:ImmLaneIdx8            |
+| `i16x8.replace_lane`            |    `0x1a`| i:ImmLaneIdx8            |
+| `i32x4.extract_lane`            |    `0x1b`| i:ImmLaneIdx4            |
+| `i32x4.replace_lane`            |    `0x1c`| i:ImmLaneIdx4            |
+| `i64x2.extract_lane`            |    `0x1d`| i:ImmLaneIdx2            |
+| `i64x2.replace_lane`            |    `0x1e`| i:ImmLaneIdx2            |
+| `f32x4.extract_lane`            |    `0x1f`| i:ImmLaneIdx4            |
+| `f32x4.replace_lane`            |    `0x20`| i:ImmLaneIdx4            |
+| `f64x2.extract_lane`            |    `0x21`| i:ImmLaneIdx2            |
+| `f64x2.replace_lane`            |    `0x22`| i:ImmLaneIdx2            |
+| `i8x16.eq`                      |    `0x23`| -                        |
+| `i8x16.ne`                      |    `0x24`| -                        |
+| `i8x16.lt_s`                    |    `0x25`| -                        |
+| `i8x16.lt_u`                    |    `0x26`| -                        |
+| `i8x16.gt_s`                    |    `0x27`| -                        |
+| `i8x16.gt_u`                    |    `0x28`| -                        |
+| `i8x16.le_s`                    |    `0x29`| -                        |
+| `i8x16.le_u`                    |    `0x2a`| -                        |
+| `i8x16.ge_s`                    |    `0x2b`| -                        |
+| `i8x16.ge_u`                    |    `0x2c`| -                        |
+| `i16x8.eq`                      |    `0x2d`| -                        |
+| `i16x8.ne`                      |    `0x2e`| -                        |
+| `i16x8.lt_s`                    |    `0x2f`| -                        |
+| `i16x8.lt_u`                    |    `0x30`| -                        |
+| `i16x8.gt_s`                    |    `0x31`| -                        |
+| `i16x8.gt_u`                    |    `0x32`| -                        |
+| `i16x8.le_s`                    |    `0x33`| -                        |
+| `i16x8.le_u`                    |    `0x34`| -                        |
+| `i16x8.ge_s`                    |    `0x35`| -                        |
+| `i16x8.ge_u`                    |    `0x36`| -                        |
+| `i32x4.eq`                      |    `0x37`| -                        |
+| `i32x4.ne`                      |    `0x38`| -                        |
+| `i32x4.lt_s`                    |    `0x39`| -                        |
+| `i32x4.lt_u`                    |    `0x3a`| -                        |
+| `i32x4.gt_s`                    |    `0x3b`| -                        |
+| `i32x4.gt_u`                    |    `0x3c`| -                        |
+| `i32x4.le_s`                    |    `0x3d`| -                        |
+| `i32x4.le_u`                    |    `0x3e`| -                        |
+| `i32x4.ge_s`                    |    `0x3f`| -                        |
+| `i32x4.ge_u`                    |    `0x40`| -                        |
+| `f32x4.eq`                      |    `0x41`| -                        |
+| `f32x4.ne`                      |    `0x42`| -                        |
+| `f32x4.lt`                      |    `0x43`| -                        |
+| `f32x4.gt`                      |    `0x44`| -                        |
+| `f32x4.le`                      |    `0x45`| -                        |
+| `f32x4.ge`                      |    `0x46`| -                        |
+| `f64x2.eq`                      |    `0x47`| -                        |
+| `f64x2.ne`                      |    `0x48`| -                        |
+| `f64x2.lt`                      |    `0x49`| -                        |
+| `f64x2.gt`                      |    `0x4a`| -                        |
+| `f64x2.le`                      |    `0x4b`| -                        |
+| `f64x2.ge`                      |    `0x4c`| -                        |
+| `v128.not`                      |    `0x4d`| -                        |
+| `v128.and`                      |    `0x4e`| -                        |
+| `v128.andnot`                   |    `0x4f`| -                        |
+| `v128.or`                       |    `0x50`| -                        |
+| `v128.xor`                      |    `0x51`| -                        |
+| `v128.bitselect`                |    `0x52`| -                        |
+| `i8x16.abs`                     |    `0x60`| -                        |
+| `i8x16.neg`                     |    `0x61`| -                        |
+| `i8x16.all_true`                |    `0x63`| -                        |
+| `i8x16.bitmask`                 |    `0x64`| -                        |
+| `i8x16.narrow_i16x8_s`          |    `0x65`| -                        |
+| `i8x16.narrow_i16x8_u`          |    `0x66`| -                        |
+| `i8x16.shl`                     |    `0x6b`| -                        |
+| `i8x16.shr_s`                   |    `0x6c`| -                        |
+| `i8x16.shr_u`                   |    `0x6d`| -                        |
+| `i8x16.add`                     |    `0x6e`| -                        |
+| `i8x16.add_sat_s`               |    `0x6f`| -                        |
+| `i8x16.add_sat_u`               |    `0x70`| -                        |
+| `i8x16.sub`                     |    `0x71`| -                        |
+| `i8x16.sub_sat_s`               |    `0x72`| -                        |
+| `i8x16.sub_sat_u`               |    `0x73`| -                        |
+| `i8x16.min_s`                   |    `0x76`| -                        |
+| `i8x16.min_u`                   |    `0x77`| -                        |
+| `i8x16.max_s`                   |    `0x78`| -                        |
+| `i8x16.max_u`                   |    `0x79`| -                        |
+| `i8x16.avgr_u`                  |    `0x7b`| -                        |
+| `i16x8.abs`                     |    `0x80`| -                        |
+| `i16x8.neg`                     |    `0x81`| -                        |
+| `i16x8.all_true`                |    `0x83`| -                        |
+| `i16x8.bitmask`                 |    `0x84`| -                        |
+| `i16x8.narrow_i32x4_s`          |    `0x85`| -                        |
+| `i16x8.narrow_i32x4_u`          |    `0x86`| -                        |
+| `i16x8.extend_low_i8x16_s`      |    `0x87`| -                        |
+| `i16x8.extend_high_i8x16_s`     |    `0x88`| -                        |
+| `i16x8.extend_low_i8x16_u`      |    `0x89`| -                        |
+| `i16x8.extend_high_i8x16_u`     |    `0x8a`| -                        |
+| `i16x8.shl`                     |    `0x8b`| -                        |
+| `i16x8.shr_s`                   |    `0x8c`| -                        |
+| `i16x8.shr_u`                   |    `0x8d`| -                        |
+| `i16x8.add`                     |    `0x8e`| -                        |
+| `i16x8.add_sat_s`               |    `0x8f`| -                        |
+| `i16x8.add_sat_u`               |    `0x90`| -                        |
+| `i16x8.sub`                     |    `0x91`| -                        |
+| `i16x8.sub_sat_s`               |    `0x92`| -                        |
+| `i16x8.sub_sat_u`               |    `0x93`| -                        |
+| `i16x8.mul`                     |    `0x95`| -                        |
+| `i16x8.min_s`                   |    `0x96`| -                        |
+| `i16x8.min_u`                   |    `0x97`| -                        |
+| `i16x8.max_s`                   |    `0x98`| -                        |
+| `i16x8.max_u`                   |    `0x99`| -                        |
+| `i16x8.avgr_u`                  |    `0x9b`| -                        |
+| `i32x4.abs`                     |    `0xa0`| -                        |
+| `i32x4.neg`                     |    `0xa1`| -                        |
+| `i32x4.all_true`                |    `0xa3`| -                        |
+| `i32x4.bitmask`                 |    `0xa4`| -                        |
+| `i32x4.extend_low_i16x8_s`      |    `0xa7`| -                        |
+| `i32x4.extend_high_i16x8_s`     |    `0xa8`| -                        |
+| `i32x4.extend_low_i16x8_u`      |    `0xa9`| -                        |
+| `i32x4.extend_high_i16x8_u`     |    `0xaa`| -                        |
+| `i32x4.shl`                     |    `0xab`| -                        |
+| `i32x4.shr_s`                   |    `0xac`| -                        |
+| `i32x4.shr_u`                   |    `0xad`| -                        |
+| `i32x4.add`                     |    `0xae`| -                        |
+| `i32x4.sub`                     |    `0xb1`| -                        |
+| `i32x4.mul`                     |    `0xb5`| -                        |
+| `i32x4.min_s`                   |    `0xb6`| -                        |
+| `i32x4.min_u`                   |    `0xb7`| -                        |
+| `i32x4.max_s`                   |    `0xb8`| -                        |
+| `i32x4.max_u`                   |    `0xb9`| -                        |
+| `i32x4.dot_i16x8_s`             |    `0xba`| -                        |
+| `i64x2.abs`                     |    `0xc0`| -                        |
+| `i64x2.neg`                     |    `0xc1`| -                        |
+| `i64x2.bitmask`                 |    `0xc4`| -                        |
+| `i64x2.extend_low_i32x4_s`      |    `0xc7`| -                        |
+| `i64x2.extend_high_i32x4_s`     |    `0xc8`| -                        |
+| `i64x2.extend_low_i32x4_u`      |    `0xc9`| -                        |
+| `i64x2.extend_high_i32x4_u`     |    `0xca`| -                        |
+| `i64x2.shl`                     |    `0xcb`| -                        |
+| `i64x2.shr_s`                   |    `0xcc`| -                        |
+| `i64x2.shr_u`                   |    `0xcd`| -                        |
+| `i64x2.add`                     |    `0xce`| -                        |
+| `i64x2.sub`                     |    `0xd1`| -                        |
+| `i64x2.mul`                     |    `0xd5`| -                        |
+| `f32x4.ceil`                    |    `0x67`| -                        |
+| `f32x4.floor`                   |    `0x68`| -                        |
+| `f32x4.trunc`                   |    `0x69`| -                        |
+| `f32x4.nearest`                 |    `0x6a`| -                        |
+| `f64x2.ceil`                    |    `0x74`| -                        |
+| `f64x2.floor`                   |    `0x75`| -                        |
+| `f64x2.trunc`                   |    `0x7a`| -                        |
+| `f64x2.nearest`                 |    `0x94`| -                        |
+| `f32x4.abs`                     |    `0xe0`| -                        |
+| `f32x4.neg`                     |    `0xe1`| -                        |
+| `f32x4.sqrt`                    |    `0xe3`| -                        |
+| `f32x4.add`                     |    `0xe4`| -                        |
+| `f32x4.sub`                     |    `0xe5`| -                        |
+| `f32x4.mul`                     |    `0xe6`| -                        |
+| `f32x4.div`                     |    `0xe7`| -                        |
+| `f32x4.min`                     |    `0xe8`| -                        |
+| `f32x4.max`                     |    `0xe9`| -                        |
+| `f32x4.pmin`                    |    `0xea`| -                        |
+| `f32x4.pmax`                    |    `0xeb`| -                        |
+| `f64x2.abs`                     |    `0xec`| -                        |
+| `f64x2.neg`                     |    `0xed`| -                        |
+| `f64x2.sqrt`                    |    `0xef`| -                        |
+| `f64x2.add`                     |    `0xf0`| -                        |
+| `f64x2.sub`                     |    `0xf1`| -                        |
+| `f64x2.mul`                     |    `0xf2`| -                        |
+| `f64x2.div`                     |    `0xf3`| -                        |
+| `f64x2.min`                     |    `0xf4`| -                        |
+| `f64x2.max`                     |    `0xf5`| -                        |
+| `f64x2.pmin`                    |    `0xf6`| -                        |
+| `f64x2.pmax`                    |    `0xf7`| -                        |
+| `i32x4.trunc_sat_f32x4_s`       |    `0xf8`| -                        |
+| `i32x4.trunc_sat_f32x4_u`       |    `0xf9`| -                        |
+| `f32x4.convert_i32x4_s`         |    `0xfa`| -                        |
+| `f32x4.convert_i32x4_u`         |    `0xfb`| -                        |
+| `v128.load32_zero`              |    `0x5c`| m:memarg                 |
+| `v128.load64_zero`              |    `0x5d`| m:memarg                 |
+| `i16x8.extmul_low_i8x16_s`      |    `0x9c`| -                        |
+| `i16x8.extmul_high_i8x16_s`     |    `0x9d`| -                        |
+| `i16x8.extmul_low_i8x16_u`      |    `0x9e`| -                        |
+| `i16x8.extmul_high_i8x16_u`     |    `0x9f`| -                        |
+| `i32x4.extmul_low_i16x8_s`      |    `0xbc`| -                        |
+| `i32x4.extmul_high_i16x8_s`     |    `0xbd`| -                        |
+| `i32x4.extmul_low_i16x8_u`      |    `0xbe`| -                        |
+| `i32x4.extmul_high_i16x8_u`     |    `0xbf`| -                        |
+| `i64x2.extmul_low_i32x4_s`      |    `0xdc`| -                        |
+| `i64x2.extmul_high_i32x4_s`     |    `0xdd`| -                        |
+| `i64x2.extmul_low_i32x4_u`      |    `0xde`| -                        |
+| `i64x2.extmul_high_i32x4_u`     |    `0xdf`| -                        |
+| `i16x8.q15mulr_sat_s`           |    `0x82`| -                        |
+| `v128.any_true`                 |    `0x53`| -                        |
+| `v128.load8_lane`               |    `0x54`| m:memarg, i:ImmLaneIdx16 |
+| `v128.load16_lane`              |    `0x55`| m:memarg, i:ImmLaneIdx8  |
+| `v128.load32_lane`              |    `0x56`| m:memarg, i:ImmLaneIdx4  |
+| `v128.load64_lane`              |    `0x57`| m:memarg, i:ImmLaneIdx2  |
+| `v128.store8_lane`              |    `0x58`| m:memarg, i:ImmLaneIdx16 |
+| `v128.store16_lane`             |    `0x59`| m:memarg, i:ImmLaneIdx8  |
+| `v128.store32_lane`             |    `0x5a`| m:memarg, i:ImmLaneIdx4  |
+| `v128.store64_lane`             |    `0x5b`| m:memarg, i:ImmLaneIdx2  |
+| `i64x2.eq`                      |    `0xd6`| -                        |
+| `i64x2.ne`                      |    `0xd7`| -                        |
+| `i64x2.lt_s`                    |    `0xd8`| -                        |
+| `i64x2.gt_s`                    |    `0xd9`| -                        |
+| `i64x2.le_s`                    |    `0xda`| -                        |
+| `i64x2.ge_s`                    |    `0xdb`| -                        |
+| `i64x2.all_true`                |    `0xc3`| -                        |
+| `f64x2.convert_low_i32x4_s`     |    `0xfe`| -                        |
+| `f64x2.convert_low_i32x4_u`     |    `0xff`| -                        |
+| `i32x4.trunc_sat_f64x2_s_zero`  |    `0xfc`| -                        |
+| `i32x4.trunc_sat_f64x2_u_zero`  |    `0xfd`| -                        |
+| `f32x4.demote_f64x2_zero`       |    `0x5e`| -                        |
+| `f64x2.promote_low_f32x4`       |    `0x5f`| -                        |
+| `i8x16.popcnt`                  |    `0x62`| -                        |
+| `i16x8.extadd_pairwise_i8x16_s` |    `0x7c`| -                        |
+| `i16x8.extadd_pairwise_i8x16_u` |    `0x7d`| -                        |
+| `i32x4.extadd_pairwise_i16x8_s` |    `0x7e`| -                        |
+| `i32x4.extadd_pairwise_i16x8_u` |    `0x7f`| -                        |
diff --git a/proposals/simd/ImplementationStatus.md b/proposals/simd/ImplementationStatus.md
new file mode 100644
index 000000000..24c67d7e6
--- /dev/null
+++ b/proposals/simd/ImplementationStatus.md
@@ -0,0 +1,248 @@
+| Instruction                     | LLVM[1]                   | V8[2]              | WAVM[3]            | ChakraCore[4]      | SpiderMonkey[5]    |
+| --------------------------------|---------------------------|--------------------|--------------------|--------------------|--------------------|
+| `v128.load`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `v128.load8x8_s`                |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load8x8_u`                |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load16x4_s`               |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load16x4_u`               |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load32x2_s`               |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load32x2_u`               |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load8_splat`              |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load16_splat`             |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load32_splat`             |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load64_splat`             |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.store`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `v128.const`                    | `-munimplemented-simd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.shuffle`                 |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.swizzle`                 |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i8x16.splat`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.splat`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.splat`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i64x2.splat`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.splat`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.splat`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.extract_lane_s`          |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.extract_lane_u`          |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.replace_lane`            |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.extract_lane_s`          |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.extract_lane_u`          |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.replace_lane`            |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.extract_lane`            |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.replace_lane`            |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i64x2.extract_lane`            |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i64x2.replace_lane`            |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.extract_lane`            |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.replace_lane`            |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.extract_lane`            |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.replace_lane`            |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.eq`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.ne`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.lt_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.lt_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.gt_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.gt_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.le_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.le_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.ge_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.ge_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.eq`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.ne`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.lt_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.lt_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.gt_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.gt_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.le_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.le_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.ge_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.ge_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.eq`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.ne`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.lt_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.lt_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.gt_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.gt_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.le_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.le_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.ge_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.ge_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.eq`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.ne`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.lt`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.gt`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.le`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.ge`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.eq`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.ne`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.lt`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.gt`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.le`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.ge`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `v128.not`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `v128.and`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `v128.andnot`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.or`                       |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `v128.xor`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `v128.bitselect`                |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.abs`                     |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i8x16.neg`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.all_true`                |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.bitmask`                 | `-munimplemented-simd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i8x16.narrow_i16x8_s`          |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i8x16.narrow_i16x8_u`          |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i8x16.shl`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.shr_s`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.shr_u`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.add`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.add_sat_s`               |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.add_sat_u`               |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.sub`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.sub_sat_s`               |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.sub_sat_u`               |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.min_s`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i8x16.min_u`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i8x16.max_s`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i8x16.max_u`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i8x16.avgr_u`                  |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.abs`                     |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.neg`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.all_true`                |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.bitmask`                 | `-munimplemented-simd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.narrow_i32x4_s`          |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.narrow_i32x4_u`          |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.extend_low_i8x16_s`      |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.extend_high_i8x16_s`     |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.extend_low_i8x16_u`      |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.extend_high_i8x16_u`     |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.shl`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.shr_s`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.shr_u`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.add`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.add_sat_s`               |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.add_sat_u`               |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.sub`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.sub_sat_s`               |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.sub_sat_u`               |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.mul`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.min_s`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.min_u`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.max_s`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.max_u`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.avgr_u`                  |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.q15mulr_sat_s`           |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.abs`                     |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.neg`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.all_true`                |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.bitmask`                 | `-munimplemented-simd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.extend_low_i16x8_s`      |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.extend_high_i16x8_s`     |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.extend_low_i16x8_u`      |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.extend_high_i16x8_u`     |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.shl`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.shr_s`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.shr_u`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.add`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.sub`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.mul`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.min_s`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.min_u`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.max_s`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.max_u`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.dot_i16x8_s`             |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.eq`                      |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.abs`                     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.neg`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i64x2.all_true`                |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.bitmask`                 |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.shl`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i64x2.shr_s`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i64x2.shr_u`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i64x2.add`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i64x2.sub`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i64x2.mul`                     |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.extend_low_i32x4_s`      |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.extend_high_i32x4_s`     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.extend_low_i32x4_u`      |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.extend_high_i32x4_u`     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f32x4.abs`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.neg`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.sqrt`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.add`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.sub`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.mul`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.div`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.min`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.max`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.pmin`                    |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f32x4.pmax`                    |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f32x4.ceil`                    |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f32x4.floor`                   |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f32x4.trunc`                   |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f32x4.nearest`                 |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f64x2.abs`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.neg`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.sqrt`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.add`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.sub`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.mul`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.div`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.min`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.max`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.pmin`                    |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f64x2.pmax`                    |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f64x2.ceil`                    |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f64x2.floor`                   |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f64x2.trunc`                   |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f64x2.nearest`                 |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.trunc_sat_f32x4_s`       |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.trunc_sat_f32x4_u`       |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.convert_i32x4_s`         |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.convert_i32x4_u`         |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load32_zero`              |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load64_zero`              |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.extmul_low_i8x16_s`      |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.extmul_high_i8x16_s`     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.extmul_low_i8x16_u`      |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.extmul_high_i8x16_u`     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.extmul_low_i16x8_s`      |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.extmul_high_i16x8_s`     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.extmul_low_i16x8_u`      |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.extmul_high_i16x8_u`     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.extmul_low_i32x4_s`      |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.extmul_high_i32x4_s`     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.extmul_low_i32x4_u`      |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.extmul_high_i32x4_u`     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.any_true`                 |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load8_lane`               |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load16_lane`              |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load32_lane`              |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load64_lane`              |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.store8_lane`              |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.store16_lane`             |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.store32_lane`             |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.store64_lane`             |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.ne`                      |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f64x2.convert_low_i32x4_s`     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f64x2.convert_low_i32x4_u`     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.trunc_sat_f64x2_s_zero`  |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.trunc_sat_f64x2_u_zero`  |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f32x4.demote_f64x2_zero`       |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f64x2.promote_low_f32x4`       |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i8x16.popcnt`                  |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.extadd_pairwise_i8x16_s` |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.extadd_pairwise_i8x16_u` |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.extadd_pairwise_i16x8_s` |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.extadd_pairwise_i16x8_u` |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.lt_s`                    |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.gt_s`                    |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.le_s`                    |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.ge_s`                    |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+
+[1] Tip of tree LLVM as of May 20, 2020
+
+[2] V8 9.1.0.
+
+[3] Not known to be updated after latest renumbering. Requires flag `--enable simd`
+
+[4] Only in 1.12.* (development branch). Requires (case-insensitive) flag `-wasmsimd`
+
+[5] Firefox x64/x86 (SSE4.1+ only) from FF89, ARM64 from FF90. Earlier versions control in about:config under `javascript.options.wasm_simd`
diff --git a/proposals/simd/NewOpcodes.md b/proposals/simd/NewOpcodes.md
new file mode 100644
index 000000000..49b1232a4
--- /dev/null
+++ b/proposals/simd/NewOpcodes.md
@@ -0,0 +1,157 @@
+| Memory instruction | opcode |
+| ------------------ | ------ |
+| v128.load          | 0x00   |
+| v128.load8x8_s     | 0x01   |
+| v128.load8x8_u     | 0x02   |
+| v128.load16x4_s    | 0x03   |
+| v128.load16x4_u    | 0x04   |
+| v128.load32x2_s    | 0x05   |
+| v128.load32x2_u    | 0x06   |
+| v128.load8_splat   | 0x07   |
+| v128.load16_splat  | 0x08   |
+| v128.load32_splat  | 0x09   |
+| v128.load64_splat  | 0x0a   |
+| v128.store         | 0x0b   |
+
+| Basic operation | opcode |
+| ----------------| ------ |
+| v128.const      | 0x0c   |
+| i8x16.shuffle   | 0x0d   |
+| i8x16.swizzle   | 0x0e   |
+
+| Splat operation | opcode |
+| --------------- | ------ |
+| i8x16.splat     | 0x0f   |
+| i16x8.splat     | 0x10   |
+| i32x4.splat     | 0x11   |
+| i64x2.splat     | 0x12   |
+| f32x4.splat     | 0x13   |
+| f64x2.splat     | 0x14   |
+
+| Lane operation       | opcode |
+| -------------------- | ------ |
+| i8x16.extract_lane_s | 0x15   |
+| i8x16.extract_lane_u | 0x16   |
+| i8x16.replace_lane   | 0x17   |
+| i16x8.extract_lane_s | 0x18   |
+| i16x8.extract_lane_u | 0x19   |
+| i16x8.replace_lane   | 0x1a   |
+| i32x4.extract_lane   | 0x1b   |
+| i32x4.replace_lane   | 0x1c   |
+| i64x2.extract_lane   | 0x1d   |
+| i64x2.replace_lane   | 0x1e   |
+| f32x4.extract_lane   | 0x1f   |
+| f32x4.replace_lane   | 0x20   |
+| f64x2.extract_lane   | 0x21   |
+| f64x2.replace_lane   | 0x22   |
+
+| i8x16 Cmp  | opcode | i16x8 Cmp  | opcode | i32x4 Cmp  | opcode |
+| ---------- | ------ | ---------- | ------ | ---------- | ------ |
+| i8x16.eq   | 0x23   | i16x8.eq   | 0x2d   | i32x4.eq   | 0x37   |
+| i8x16.ne   | 0x24   | i16x8.ne   | 0x2e   | i32x4.ne   | 0x38   |
+| i8x16.lt_s | 0x25   | i16x8.lt_s | 0x2f   | i32x4.lt_s | 0x39   |
+| i8x16.lt_u | 0x26   | i16x8.lt_u | 0x30   | i32x4.lt_u | 0x3a   |
+| i8x16.gt_s | 0x27   | i16x8.gt_s | 0x31   | i32x4.gt_s | 0x3b   |
+| i8x16.gt_u | 0x28   | i16x8.gt_u | 0x32   | i32x4.gt_u | 0x3c   |
+| i8x16.le_s | 0x29   | i16x8.le_s | 0x33   | i32x4.le_s | 0x3d   |
+| i8x16.le_u | 0x2a   | i16x8.le_u | 0x34   | i32x4.le_u | 0x3e   |
+| i8x16.ge_s | 0x2b   | i16x8.ge_s | 0x35   | i32x4.ge_s | 0x3f   |
+| i8x16.ge_u | 0x2c   | i16x8.ge_u | 0x36   | i32x4.ge_u | 0x40   |
+
+| f32x4 Cmp | opcode | f64x2 Cmp | opcode |
+| --------- | ------ | --------- | ------ |
+| f32x4.eq  | 0x41   | f64x2.eq  | 0x47   |
+| f32x4.ne  | 0x42   | f64x2.ne  | 0x48   |
+| f32x4.lt  | 0x43   | f64x2.lt  | 0x49   |
+| f32x4.gt  | 0x44   | f64x2.gt  | 0x4a   |
+| f32x4.le  | 0x45   | f64x2.le  | 0x4b   |
+| f32x4.ge  | 0x46   | f64x2.ge  | 0x4c   |
+
+| v128 Op        | opcode |
+| -------------- | ------ |
+| v128.not       | 0x4d   |
+| v128.and       | 0x4e   |
+| v128.andnot    | 0x4f   |
+| v128.or        | 0x50   |
+| v128.xor       | 0x51   |
+| v128.bitselect | 0x52   |
+| v128.any_true  | 0x53   |
+
+| Load Lane Op      | opcode |
+| ----------------- | ------ |
+| v128.load8_lane   | 0x54   |
+| v128.load16_lane  | 0x55   |
+| v128.load32_lane  | 0x56   |
+| v128.load64_lane  | 0x57   |
+| v128.store8_lane  | 0x58   |
+| v128.store16_lane | 0x59   |
+| v128.store32_lane | 0x5a   |
+| v128.store64_lane | 0x5b   |
+| v128.load32_zero  | 0x5c   |
+| v128.load64_zero  | 0x5d   |
+
+| Float conversion        | opcode |
+| ----------------------- | ------ |
+| f32x4.demote_f64x2_zero | 0x5e   |
+| f64x2.promote_low_f32x4 | 0x5f   |
+
+| i8x16 Op                      | opcode | i16x8 Op                  | opcode | i32x4 Op                  | opcode | i64x2 Op                  | opcode |
+| ----------------------------- | ------ | ------------------------- | ------ | ------------------------- | ------ | ------------------------- | ------ |
+| i8x16.abs                     | 0x60   | i16x8.abs                 | 0x80   | i32x4.abs                 | 0xa0   | i64x2.abs                 | 0xc0   |
+| i8x16.neg                     | 0x61   | i16x8.neg                 | 0x81   | i32x4.neg                 | 0xa1   | i64x2.neg                 | 0xc1   |
+| i8x16.popcnt                  | 0x62   | i16x8.q15mulr_sat_s       | 0x82   |                           | 0xa2   | -------------             | 0xc2   |
+| i8x16.all_true                | 0x63   | i16x8.all_true            | 0x83   | i32x4.all_true            | 0xa3   | i64x2.all_true            | 0xc3   |
+| i8x16.bitmask                 | 0x64   | i16x8.bitmask             | 0x84   | i32x4.bitmask             | 0xa4   | i64x2.bitmask             | 0xc4   |
+| i8x16.narrow_i16x8_s          | 0x65   | i16x8.narrow_i32x4_s      | 0x85   | ---- narrow ----          | 0xa5   | -------------             | 0xc5   |
+| i8x16.narrow_i16x8_u          | 0x66   | i16x8.narrow_i32x4_u      | 0x86   | ---- narrow ----          | 0xa6   | -------------             | 0xc6   |
+| f32x4.ceil                    | 0x67   | i16x8.extend_low_i8x16_s  | 0x87   | i32x4.extend_low_i16x8_s  | 0xa7   | i64x2.extend_low_i32x4_s  | 0xc7   |
+| f32x4.floor                   | 0x68   | i16x8.extend_high_i8x16_s | 0x88   | i32x4.extend_high_i16x8_s | 0xa8   | i64x2.extend_high_i32x4_s | 0xc8   |
+| f32x4.trunc                   | 0x69   | i16x8.extend_low_i8x16_u  | 0x89   | i32x4.extend_low_i16x8_u  | 0xa9   | i64x2.extend_low_i32x4_u  | 0xc9   |
+| f32x4.nearest                 | 0x6a   | i16x8.extend_high_i8x16_u | 0x8a   | i32x4.extend_high_i16x8_u | 0xaa   | i64x2.extend_high_i32x4_u | 0xca   |
+| i8x16.shl                     | 0x6b   | i16x8.shl                 | 0x8b   | i32x4.shl                 | 0xab   | i64x2.shl                 | 0xcb   |
+| i8x16.shr_s                   | 0x6c   | i16x8.shr_s               | 0x8c   | i32x4.shr_s               | 0xac   | i64x2.shr_s               | 0xcc   |
+| i8x16.shr_u                   | 0x6d   | i16x8.shr_u               | 0x8d   | i32x4.shr_u               | 0xad   | i64x2.shr_u               | 0xcd   |
+| i8x16.add                     | 0x6e   | i16x8.add                 | 0x8e   | i32x4.add                 | 0xae   | i64x2.add                 | 0xce   |
+| i8x16.add_sat_s               | 0x6f   | i16x8.add_sat_s           | 0x8f   | ---- add_sat ----         | 0xaf   | -------------             | 0xcf   |
+| i8x16.add_sat_u               | 0x70   | i16x8.add_sat_u           | 0x90   | ---- add_sat ----         | 0xb0   | -------------             | 0xd0   |
+| i8x16.sub                     | 0x71   | i16x8.sub                 | 0x91   | i32x4.sub                 | 0xb1   | i64x2.sub                 | 0xd1   |
+| i8x16.sub_sat_s               | 0x72   | i16x8.sub_sat_s           | 0x92   | ---- sub_sat ----         | 0xb2   | -------------             | 0xd2   |
+| i8x16.sub_sat_u               | 0x73   | i16x8.sub_sat_u           | 0x93   | ---- sub_sat ----         | 0xb3   | -------------             | 0xd3   |
+| f64x2.ceil                    | 0x74   | f64x2.nearest             | 0x94   | -------------             | 0xb4   | -------------             | 0xd4   |
+| f64x2.floor                   | 0x75   | i16x8.mul                 | 0x95   | i32x4.mul                 | 0xb5   | i64x2.mul                 | 0xd5   |
+| i8x16.min_s                   | 0x76   | i16x8.min_s               | 0x96   | i32x4.min_s               | 0xb6   | i64x2.eq                  | 0xd6   |
+| i8x16.min_u                   | 0x77   | i16x8.min_u               | 0x97   | i32x4.min_u               | 0xb7   | i64x2.ne                  | 0xd7   |
+| i8x16.max_s                   | 0x78   | i16x8.max_s               | 0x98   | i32x4.max_s               | 0xb8   | i64x2.lt_s                | 0xd8   |
+| i8x16.max_u                   | 0x79   | i16x8.max_u               | 0x99   | i32x4.max_u               | 0xb9   | i64x2.gt_s                | 0xd9   |
+| f64x2.trunc                   | 0x7a   |                           | 0x9a   | i32x4.dot_i16x8_s         | 0xba   | i64x2.le_s                | 0xda   |
+| i8x16.avgr_u                  | 0x7b   | i16x8.avgr_u              | 0x9b   | ---- avgr_u ----          | 0xbb   | i64x2.ge_s                | 0xdb   |
+| i16x8.extadd_pairwise_i8x16_s | 0x7c   | i16x8.extmul_low_i8x16_s  | 0x9c   | i32x4.extmul_low_i16x8_s  | 0xbc   | i64x2.extmul_low_i32x4_s  | 0xdc   |
+| i16x8.extadd_pairwise_i8x16_u | 0x7d   | i16x8.extmul_high_i8x16_s | 0x9d   | i32x4.extmul_high_i16x8_s | 0xbd   | i64x2.extmul_high_i32x4_s | 0xdd   |
+| i32x4.extadd_pairwise_i16x8_s | 0x7e   | i16x8.extmul_low_i8x16_u  | 0x9e   | i32x4.extmul_low_i16x8_u  | 0xbe   | i64x2.extmul_low_i32x4_u  | 0xde   |
+| i32x4.extadd_pairwise_i16x8_u | 0x7f   | i16x8.extmul_high_i8x16_u | 0x9f   | i32x4.extmul_high_i16x8_u | 0xbf   | i64x2.extmul_high_i32x4_u | 0xdf   |
+
+| f32x4 Op        | opcode | f64x2 Op        | opcode |
+| --------------- | ------ | --------------- | ------ |
+| f32x4.abs       | 0xe0   | f64x2.abs       | 0xec   |
+| f32x4.neg       | 0xe1   | f64x2.neg       | 0xed   |
+| ---- round ---- | 0xe2   | ---- round ---- | 0xee   |
+| f32x4.sqrt      | 0xe3   | f64x2.sqrt      | 0xef   |
+| f32x4.add       | 0xe4   | f64x2.add       | 0xf0   |
+| f32x4.sub       | 0xe5   | f64x2.sub       | 0xf1   |
+| f32x4.mul       | 0xe6   | f64x2.mul       | 0xf2   |
+| f32x4.div       | 0xe7   | f64x2.div       | 0xf3   |
+| f32x4.min       | 0xe8   | f64x2.min       | 0xf4   |
+| f32x4.max       | 0xe9   | f64x2.max       | 0xf5   |
+| f32x4.pmin      | 0xea   | f64x2.pmin      | 0xf6   |
+| f32x4.pmax      | 0xeb   | f64x2.pmax      | 0xf7   |
+
+| Conversion Op                | opcode |
+| ---------------------------- | ------ |
+| i32x4.trunc_sat_f32x4_s      | 0xf8   |
+| i32x4.trunc_sat_f32x4_u      | 0xf9   |
+| f32x4.convert_i32x4_s        | 0xfa   |
+| f32x4.convert_i32x4_u        | 0xfb   |
+| i32x4.trunc_sat_f64x2_s_zero | 0xfc   |
+| i32x4.trunc_sat_f64x2_u_zero | 0xfd   |
+| f64x2.convert_low_i32x4_s    | 0xfe   |
+| f64x2.convert_low_i32x4_u    | 0xff   |
diff --git a/proposals/simd/SIMD.md b/proposals/simd/SIMD.md
new file mode 100644
index 000000000..9f2c802a4
--- /dev/null
+++ b/proposals/simd/SIMD.md
@@ -0,0 +1,1178 @@
+# WebAssembly 128-bit packed SIMD Extension
+
+This specification describes a 128-bit packed *Single Instruction Multiple
+Data* (SIMD) extension to WebAssembly that can be implemented efficiently on
+current popular instruction set architectures.
+
+See also [The binary encoding of SIMD instructions](BinarySIMD.md).
+
+## Motivation
+
+WebAssembly aims to take advantage of [common hardware capabilities](https://github.com/WebAssembly/design/blob/master/Portability.md#assumptions-for-efficient-execution)
+for near native speed. The motivation for this proposal is to introduce
+WebAssembly operations that map to commonly available [SIMD](https://en.wikipedia.org/wiki/SIMD)
+instructions in hardware. 
+
+SIMD instructions in hardware work by performing simultaneous computations over
+packed data in one instruction. These are commonly used to improve performance
+for multimedia applications. The set of SIMD instructions in hardware is large, 
+and varies across different versions of hardware. This proposal is comprised
+of a portable subset of operations that in most cases map to commonly used
+instructions in mordern hardware. 
+
+
+# Types
+
+WebAssembly is extended with a new `v128` value type and a number of new kinds
+of immediate operands used by the SIMD instructions.
+
+## SIMD value type
+
+The `v128` value type is the _only_ type introduced in this extension. It has a
+concrete mapping to a 128-bit representation with bits numbered 0–127. The
+`v128` type corresponds to a vector register in a typical SIMD ISA. The
+interpretation of the 128 bits in the vector register is provided by the
+individual instructions. When a `v128` value is represented as 16 bytes, bits
+0-7 go in the first byte with bit 0 as the LSB, bits 8-15 go in the second byte,
+etc.
+
+## Immediate operands
+
+Some of the new SIMD instructions defined here have immediate operands that are
+encoded as individual bytes in the binary encoding. Many have a limited valid
+range, and it is a validation error if the immediate operands are out of range.
+
+* `ImmByte`: A single unconstrained byte (0-255).
+* `ImmLaneIdx2`: A byte with values in the range 0–1 identifying a lane.
+* `ImmLaneIdx4`: A byte with values in the range 0–3 identifying a lane.
+* `ImmLaneIdx8`: A byte with values in the range 0–7 identifying a lane.
+* `ImmLaneIdx16`: A byte with values in the range 0–15 identifying a lane.
+* `ImmLaneIdx32`: A byte with values in the range 0–31 identifying a lane.
+
+## Operations on the SIMD value type
+
+The _single_ `v128` SIMD type can be used to represent different types of packed
+data, e.g., it can represent four 32-bit floating point values, 8 16-bit signed
+or unsigned integer values, etc.
+
+The instructions introduced in this specification are named according to the
+following schema: `{interpretation}.{operation}`. Where the `{interpretation}`
+prefix denotes how the bytes of the `v128` type are interpreted by the `{operation}`. 
+
+For example, the instructions `f32x4.extract_lane` and `i64x2.extract_lane`
+perform the same semantic operation: extracting the scalar value of a vector
+lane. However, the `f32x4.extract_lane` instruction returns a 32-bit wide
+floating point value, while the `i64x2.extract_lane` instruction returns a
+64-bit wide integer value.
+
+The `v128` vector type interpretation interprets the vector as a bag of bits. 
+The `v{lane_width}x{n}` interpretations (e.g. `v32x4`) interpret the vector as
+`n` lanes of `lane_width` bits. The `{t}{lane_width}x{n}` interpretations (e.g.
+`i32x4` or `f32x4`) interpret the vector as `n` lanes of type `{t}{lane_width}`.
+
+### Lane division interpretation
+
+The first level of interpretations of the `v128` type imposes a lane structure on
+the bits:
+
+* `v8x16 : v128`: 8-bit lanes numbered 0–15. Lane n corresponds to bits 8n – 8n+7.
+* `v16x8 : v128`: 16-bit lanes numbered 0–7. Lane n corresponds to bits 16n – 16n+15.
+* `v32x4 : v128`: 32-bit lanes numbered 0–3. Lane n corresponds to bits 32n – 32n+31.
+* `v64x2 : v128`: 64-bit lanes numbered 0–1. Lane n corresponds to bits 64n – 64n+63.
+
+The lane dividing interpretations don't say anything about the semantics of the
+bits in each lane. The interpretations have *properties* used by the semantic
+specification pseudo-code below:
+
+|    S    | S.LaneBits | S.Lanes | S.MaskType |
+|---------|-----------:|--------:|:----------:|
+| `v8x16` |          8 |      16 | `i8x16`    |
+| `v16x8` |         16 |       8 | `i16x8`    |
+| `v32x4` |         32 |       4 | `i32x4`    |
+| `v64x2` |         64 |       2 | `i64x2`    |
+
+Since WebAssembly is little-endian, the least significant bit in each lane is
+the bit with the lowest number.
+
+### Modulo integer interpretations
+
+The bits in a lane can be interpreted as integers with modulo arithmetic
+semantics. Many arithmetic operations can be defined on these types which don't
+impose a signed or unsigned integer interpretation.
+
+* `i8x16 : v8x16`: Each lane is an `i8`.
+* `i16x8 : v16x8`: Each lane is an `i16`.
+* `i32x4 : v32x4`: Each lane is an `i32`.
+* `i64x2 : v64x2`: Each lane is an `i64`.
+
+Additional properties:
+
+|    S    |  S.Smin | S.Smax | S.Umax |
+|---------|--------:|-------:|-------:|
+| `i8x16` |    -2^7 |  2^7-1 |  2^8-1 |
+| `i16x8` |   -2^15 | 2^15-1 | 2^16-1 |
+| `i32x4` |   -2^31 | 2^31-1 | 2^32-1 |
+| `i64x2` |   -2^63 | 2^63-1 | 2^64-1 |
+
+Some operations interpret each lane specifically as a signed or unsigned
+integer. These operations have `_s` and `_u` suffixes as is the convention is
+WebAssembly.
+
+### Floating-point interpretations
+
+Each lane is interpreted as an IEEE floating-point number.
+
+* `f32x4 : v32x4`: Each lane is an `f32`.
+* `f64x2 : v64x2`: Each lane is an `f64`.
+
+The floating-point operations in this specification aim to be compatible with
+WebAssembly's scalar floating-point operations. In particular, the rules about
+NaN propagation and default NaN values are the same, and all operations use the
+default *roundTiesToEven* rounding mode.
+
+# JavaScript API and SIMD Values
+
+Accessing WebAssembly module imports or exports containing SIMD Type from JavaScript will throw.
+
+### Module Function Imports
+
+Calling an imported function from JavaScript when the function arguments or result is of type v128 will cause the host function to immidiately throw a [`TypeError`](https://tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror).
+
+### Exported Function Exotic Objects
+
+Invoking the [[Call]] method of an Exported Function Exotic Object when the function type of its [[Closure]] has an argument or result of type v128 will cause the host function to immidiately throw a [`TypeError`](https://tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror).
+
+
+## WebAssembly Module Instatiation
+
+Instantiating a WebAssembly Module from a Module moduleObject will throw a LinkError exception, when the global's valtype is v128 and the imported objects type is not WebAssembly.Global. 
+
+## Exported Functions
+
+### Exported Function Call
+
+Calling an Exported Function will throw a [`TypeError`](https://tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror), when parameters or results contains a v128. This error is thrown each time the [[Call]] method is invoked.
+
+### Creating a host function
+
+Creating a host function from JavaScript object will throw a [`TypeError`](https://tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror), when the host function signature contains a v128.
+
+### Global constructor
+
+If Global(descriptor, v) constructor will throw a [`TypeError`](https://tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror), when invoked with v of valuetype v128.
+
+## JavaScript coercion
+
+### ToJSValue
+
+The algorithm toJSValue(w) should have an assertion ensuring w is not of the form v128.const v128.
+
+### ToWebAssemblyValue
+
+The algorithm ToWebAssemblyValue(v, type)  should have an assertion ensuring type is not v128.
+
+## JavaScript API Global Object algorithms
+
+### ToValueType
+
+The algorithm ToValueType(s) will return 'v128' if s equals "v128".
+
+### DefaultValue 
+
+The algorithm DefaultValueType(valueType) will return v128.const 0.
+
+### GetGlobalValue
+
+The algorithm GetGlobalValue(Global global) will throw a [`TypeError`](https://tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror), when type_global(store, global.[[Global]]) is of the form mut v128.
+
+### Global value attribute Setter
+
+The setter of the value attribute of Global will throw a [`TypeError`](https://tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror), when invoked with a value v of valuetype v128.
+
+# Operations
+
+The SIMD operations described in this sections are generally named
+`S.Op`, where `S` is either a SIMD type or one of the interpretations
+of a SIMD type. Immediate mode operands are prefixed with `imm`.
+
+Many operations are simply the lane-wise application of a scalar operation:
+
+```python
+def S.lanewise_unary(func, a):
+    result = S.New()
+    for i in range(S.Lanes):
+        result[i] = func(a[i])
+    return result
+
+def S.lanewise_binary(func, a, b):
+    result = S.New()
+    for i in range(S.Lanes):
+        result[i] = func(a[i], b[i])
+    return result
+```
+
+Comparison operators produce a mask vector where the bits in each lane are 0
+for false and all ones for true:
+
+```python
+def S.lanewise_comparison(func, a, b):
+    all_ones = S.MaskType.Umax
+    result = S.MaskType.New()
+    for i in range(S.Lanes):
+        result[i] = all_ones if func(a[i], b[i]) else 0
+    return result
+```
+
+## Constructing SIMD values
+
+### Constant
+* `v128.const(imm: ImmByte[16]) -> v128`
+
+Materialize a constant `v128` SIMD value from the 16 immediate bytes in the
+immediate mode operand `imm` . The `v128.const` instruction is encoded with 16
+immediate bytes which provide the bits of the vector directly.
+
+### Create vector with identical lanes
+* `i8x16.splat(x: i32) -> v128`
+* `i16x8.splat(x: i32) -> v128`
+* `i32x4.splat(x: i32) -> v128`
+* `i64x2.splat(x: i64) -> v128`
+* `f32x4.splat(x: f32) -> v128`
+* `f64x2.splat(x: f64) -> v128`
+
+Construct a vector with `x` replicated to all lanes:
+
+```python
+def S.splat(x):
+    result = S.New()
+    for i in range(S.Lanes):
+        result[i] = S.Reduce(x)
+    return result
+```
+
+## Accessing lanes
+
+### Extract lane as a scalar
+* `i8x16.extract_lane_s(a: v128, imm: ImmLaneIdx16) -> i32`
+* `i8x16.extract_lane_u(a: v128, imm: ImmLaneIdx16) -> i32`
+* `i16x8.extract_lane_s(a: v128, imm: ImmLaneIdx8) -> i32`
+* `i16x8.extract_lane_u(a: v128, imm: ImmLaneIdx8) -> i32`
+* `i32x4.extract_lane(a: v128, imm: ImmLaneIdx4) -> i32`
+* `i64x2.extract_lane(a: v128, imm: ImmLaneIdx2) -> i64`
+* `f32x4.extract_lane(a: v128, imm: ImmLaneIdx4) -> f32`
+* `f64x2.extract_lane(a: v128, imm: ImmLaneIdx2) -> f64`
+
+Extract the scalar value of lane specified in the immediate mode operand `imm`
+in `a`. The `{interpretation}.extract_lane{_s}{_u}` instructions are encoded
+with one immediate byte providing the index of the lane to extract.
+
+```python
+def S.extract_lane(a, i):
+    return a[i]
+```
+
+The `_s` and `_u` variants will sign-extend or zero-extend the lane value to
+`i32` respectively.
+
+### Replace lane value
+* `i8x16.replace_lane(a: v128, imm: ImmLaneIdx16, x: i32) -> v128`
+* `i16x8.replace_lane(a: v128, imm: ImmLaneIdx8, x: i32) -> v128`
+* `i32x4.replace_lane(a: v128, imm: ImmLaneIdx4, x: i32) -> v128`
+* `i64x2.replace_lane(a: v128, imm: ImmLaneIdx2, x: i64) -> v128`
+* `f32x4.replace_lane(a: v128, imm: ImmLaneIdx4, x: f32) -> v128`
+* `f64x2.replace_lane(a: v128, imm: ImmLaneIdx2, x: f64) -> v128`
+
+Return a new vector with lanes identical to `a`, except for the lane specified
+in the immediate mode operand `imm` which has the value `x`. The
+`{interpretation}.replace_lane` instructions are encoded with an immediate byte 
+providing the index of the lane the value of which is to be replaced.
+
+```python
+def S.replace_lane(a, i, x):
+    result = S.New()
+    for j in range(S.Lanes):
+        result[j] = a[j]
+    result[i] = x
+    return result
+```
+
+The input lane value, `x`, is interpreted the same way as for the splat
+instructions. For the `i8` and `i16` lanes, the high bits of `x` are ignored.
+
+### Shuffling using immediate indices
+* `i8x16.shuffle(a: v128, b: v128, imm: ImmLaneIdx32[16]) -> v128`
+
+Returns a new vector with lanes selected from the lanes of the two input vectors
+`a` and `b` specified in the 16 byte wide immediate mode operand `imm`. This
+instruction is encoded with 16 bytes providing the indices of the elements to
+return. The indices `i` in range `[0, 15]` select the `i`-th element of `a`. The
+indices in range `[16, 31]` select the `i - 16`-th element of `b`.
+
+```python
+def S.shuffle(a, b, s):
+    result = S.New()
+    for i in range(S.Lanes):
+        if s[i] < S.lanes:
+            result[i] = a[s[i]]
+        else:
+            result[i] = b[s[i] - S.lanes]
+    return result
+```
+
+### Swizzling using variable indices
+* `i8x16.swizzle(a: v128, s: v128) -> v128`
+
+Returns a new vector with lanes selected from the lanes of the first input
+vector `a` specified in the second input vector `s`. The indices `i` in range
+`[0, 15]` select the `i`-th element of `a`. For indices outside of the range
+the resulting lane is initialized to 0.
+
+```python
+def S.swizzle(a, s):
+    result = S.New()
+    for i in range(S.Lanes):
+        if s[i] < S.lanes:
+            result[i] = a[s[i]]
+        else:
+            result[i] = 0
+    return result
+```
+
+## Integer arithmetic
+
+Wrapping integer arithmetic discards the high bits of the result.
+
+```python
+def S.Reduce(x):
+    bitmask = (1 << S.LaneBits) - 1
+    return x & bitmask
+```
+
+There is no integer division operation provided here. This operation is not
+commonly part of 128-bit SIMD ISAs.
+
+### Integer addition
+* `i8x16.add(a: v128, b: v128) -> v128`
+* `i16x8.add(a: v128, b: v128) -> v128`
+* `i32x4.add(a: v128, b: v128) -> v128`
+* `i64x2.add(a: v128, b: v128) -> v128`
+
+Lane-wise wrapping integer addition:
+
+```python
+def S.add(a, b):
+    def add(x, y):
+        return S.Reduce(x + y)
+    return S.lanewise_binary(add, a, b)
+```
+
+### Integer subtraction
+* `i8x16.sub(a: v128, b: v128) -> v128`
+* `i16x8.sub(a: v128, b: v128) -> v128`
+* `i32x4.sub(a: v128, b: v128) -> v128`
+* `i64x2.sub(a: v128, b: v128) -> v128`
+
+Lane-wise wrapping integer subtraction:
+
+```python
+def S.sub(a, b):
+    def sub(x, y):
+        return S.Reduce(x - y)
+    return S.lanewise_binary(sub, a, b)
+```
+
+### Integer multiplication
+* `i16x8.mul(a: v128, b: v128) -> v128`
+* `i32x4.mul(a: v128, b: v128) -> v128`
+* `i64x2.mul(a: v128, b: v128) -> v128`
+
+Lane-wise wrapping integer multiplication:
+
+```python
+def S.mul(a, b):
+    def mul(x, y):
+        return S.Reduce(x * y)
+    return S.lanewise_binary(mul, a, b)
+```
+
+### Integer dot product
+* `i32x4.dot_i16x8_s(a: v128, b: v128) -> v128`
+
+Lane-wise multiply signed 16-bit integers in the two input vectors and add adjacent pairs of the full 32-bit results.
+
+### Integer negation
+* `i8x16.neg(a: v128) -> v128`
+* `i16x8.neg(a: v128) -> v128`
+* `i32x4.neg(a: v128) -> v128`
+* `i64x2.neg(a: v128) -> v128`
+
+Lane-wise wrapping integer negation. In wrapping arithmetic, `y = -x` is the
+unique value such that `x + y == 0`.
+
+```python
+def S.neg(a):
+    def neg(x):
+        return S.Reduce(-x)
+    return S.lanewise_unary(neg, a)
+```
+
+## Extended integer arithmetic
+
+### Extended integer multiplication
+* `i16x8.extmul_low_i8x16_s(a: v128, b: v128) -> v128`
+* `i16x8.extmul_high_i8x16_s(a: v128, b: v128) -> v128`
+* `i16x8.extmul_low_i8x16_u(a: v128, b: v128) -> v128`
+* `i16x8.extmul_high_i8x16_u(a: v128, b: v128) -> v128`
+* `i32x4.extmul_low_i16x8_s(a: v128, b: v128) -> v128`
+* `i32x4.extmul_high_i16x8_s(a: v128, b: v128) -> v128`
+* `i32x4.extmul_low_i16x8_u(a: v128, b: v128) -> v128`
+* `i32x4.extmul_high_i16x8_u(a: v128, b: v128) -> v128`
+* `i64x2.extmul_low_i32x4_s(a: v128, b: v128) -> v128`
+* `i64x2.extmul_high_i32x4_s(a: v128, b: v128) -> v128`
+* `i64x2.extmul_low_i32x4_u(a: v128, b: v128) -> v128`
+* `i64x2.extmul_high_i32x4_u(a: v128, b: v128) -> v128`
+
+Lane-wise integer extended multiplication producing twice wider result than the inputs.
+
+These instructions provide a more performant equivalent to the following composite operations:
+- `i16x8.extmul_low_i8x16_s(a, b)` is equivalent to `i16x8.mul(i16x8.extend_low_i8x16_s(a), i16x8.extend_low_i8x16_s(b))`.
+- `i16x8.extmul_high_i8x16_s(a, b)` is equivalent to `i16x8.mul(i16x8.extend_high_i8x16_s(a), i16x8.extend_high_i8x16_s(b))`.
+- `i16x8.extmul_low_i8x16_u(a, b)` is equivalent to `i16x8.mul(i16x8.extend_low_i8x16_u(a), i16x8.extend_low_i8x16_u(b))`.
+- `i16x8.extmul_high_i8x16_u(a, b)` is equivalent to `i16x8.mul(i16x8.extend_high_i8x16_u(a), i16x8.extend_high_i8x16_u(b))`.
+- `i32x4.extmul_low_i16x8_s(a, b)` is equivalent to `i32x4.mul(i32x4.extend_low_i16x8_s(a), i32x4.extend_low_i16x8_s(b))`.
+- `i32x4.extmul_high_i16x8_s(a, b)` is equivalent to `i32x4.mul(i32x4.extend_high_i16x8_s(a), i32x4.extend_high_i16x8_s(b))`.
+- `i32x4.extmul_low_i16x8_u(a, b)` is equivalent to `i32x4.mul(i32x4.extend_low_i16x8_u(a), i32x4.extend_low_i16x8_u(b))`.
+- `i32x4.extmul_high_i16x8_u(a, b)` is equivalent to `i32x4.mul(i32x4.extend_high_i16x8_u(a), i32x4.extend_high_i16x8_u(b))`.
+- `i64x2.extmul_low_i32x4_s(a, b)` is equivalent to `i64x2.mul(i64x2.extend_low_i32x4_s(a), i64x2.extend_low_i32x4_s(b))`.
+- `i64x2.extmul_high_i32x4_s(a, b)` is equivalent to `i64x2.mul(i64x2.extend_high_i32x4_s(a), i64x2.extend_high_i32x4_s(b))`.
+- `i64x2.extmul_low_i32x4_u(a, b)` is equivalent to `i64x2.mul(i64x2.extend_low_i32x4_u(a), i64x2.extend_low_i32x4_u(b))`.
+- `i64x2.extmul_high_i32x4_u(a, b)` is equivalent to `i64x2.mul(i64x2.extend_high_i32x4_u(a), i64x2.extend_high_i32x4_u(b))`.
+
+### Extended pairwise integer addition
+* `i16x8.extadd_pairwise_i8x16_s(a: v128) -> v128`
+* `i16x8.extadd_pairwise_i8x16_u(a: v128) -> v128`
+* `i32x4.extadd_pairwise_i16x8_s(a: v128) -> v128`
+* `i32x4.extadd_pairwise_i16x8_u(a: v128) -> v128`
+
+Lane-wise integer extended pairwise addition producing extended results (twice wider results than the inputs).
+
+```python
+def S.extadd_pairwise_T(ext, a):
+    result = S.New()
+    for i in range(S.Lanes):
+        result[i] = ext(a[i*2]) + ext(a[i*2+1])
+
+def S.extadd_pairwise_T_s(a):
+    return S.extadd_pairwise_T(Sext, a)
+
+def S.extadd_pairwise_T_u(a):
+    return S.extadd_pairwise_T(Zext, a)
+```
+
+## Saturating integer arithmetic
+
+Saturating integer arithmetic behaves differently on signed and unsigned lanes.
+It is only defined here for 8-bit and 16-bit integer lanes.
+
+```python
+def S.SignedSaturate(x):
+    if x < S.Smin:
+        return S.Smin
+    if x > S.Smax:
+        return S.Smax
+    return x
+
+def S.UnsignedSaturate(x):
+    if x < 0:
+        return 0
+    if x > S.Umax:
+        return S.Umax
+    return x
+```
+
+### Saturating integer addition
+* `i8x16.add_sat_s(a: v128, b: v128) -> v128`
+* `i8x16.add_sat_u(a: v128, b: v128) -> v128`
+* `i16x8.add_sat_s(a: v128, b: v128) -> v128`
+* `i16x8.add_sat_u(a: v128, b: v128) -> v128`
+
+Lane-wise saturating addition:
+
+```python
+def S.add_sat_s(a, b):
+    def addsat(x, y):
+        return S.SignedSaturate(x + y)
+    return S.lanewise_binary(addsat, S.AsSigned(a), S.AsSigned(b))
+
+def S.add_sat_u(a, b):
+    def addsat(x, y):
+        return S.UnsignedSaturate(x + y)
+    return S.lanewise_binary(addsat, S.AsUnsigned(a), S.AsUnsigned(b))
+```
+
+### Saturating integer subtraction
+* `i8x16.sub_sat_s(a: v128, b: v128) -> v128`
+* `i8x16.sub_sat_u(a: v128, b: v128) -> v128`
+* `i16x8.sub_sat_s(a: v128, b: v128) -> v128`
+* `i16x8.sub_sat_u(a: v128, b: v128) -> v128`
+
+Lane-wise saturating subtraction:
+
+```python
+def S.sub_sat_s(a, b):
+    def subsat(x, y):
+        return S.SignedSaturate(x - y)
+    return S.lanewise_binary(subsat, S.AsSigned(a), S.AsSigned(b))
+
+def S.sub_sat_u(a, b):
+    def subsat(x, y):
+        return S.UnsignedSaturate(x - y)
+    return S.lanewise_binary(subsat, S.AsUnsigned(a), S.AsUnsigned(b))
+```
+
+### Saturating integer Q-format rounding multiplication
+
+* `i16x8.q15mulr_sat_s(a: v128, b: v128) -> v128`
+
+Lane-wise saturating rounding multiplication in Q15 format:
+
+```python
+def S.q15mulr_sat_s(a, b):
+    def subq15mulr(x, y):
+        return S.SignedSaturate((x * y + 0x4000) >> 15)
+    return S.lanewise_binary(subq15mulr, S.AsSigned(a), S.AsSigned(b))
+```
+
+### Lane-wise integer minimum
+* `i8x16.min_s(a: v128, b: v128) -> v128`
+* `i8x16.min_u(a: v128, b: v128) -> v128`
+* `i16x8.min_s(a: v128, b: v128) -> v128`
+* `i16x8.min_u(a: v128, b: v128) -> v128`
+* `i32x4.min_s(a: v128, b: v128) -> v128`
+* `i32x4.min_u(a: v128, b: v128) -> v128`
+
+Compares lane-wise signed/unsigned integers, and returns the minimum of
+each pair.
+
+```python
+def S.min(a, b):
+    return S.lanewise_binary(min, a, b)
+```
+
+### Lane-wise integer maximum
+* `i8x16.max_s(a: v128, b: v128) -> v128`
+* `i8x16.max_u(a: v128, b: v128) -> v128`
+* `i16x8.max_s(a: v128, b: v128) -> v128`
+* `i16x8.max_u(a: v128, b: v128) -> v128`
+* `i32x4.max_s(a: v128, b: v128) -> v128`
+* `i32x4.max_u(a: v128, b: v128) -> v128`
+
+Compares lane-wise signed/unsigned integers, and returns the maximum of
+each pair.
+
+```python
+def S.max(a, b):
+    return S.lanewise_binary(max, a, b)
+```
+
+### Lane-wise integer rounding average
+* `i8x16.avgr_u(a: v128, b: v128) -> v128`
+* `i16x8.avgr_u(a: v128, b: v128) -> v128`
+
+Lane-wise rounding average:
+
+```python
+def S.RoundingAverage(x, y):
+    return (x + y + 1) // 2
+
+def S.avgr_u(a, b):
+    return S.lanewise_binary(S.RoundingAverage, S.AsUnsigned(a), S.AsUnsigned(b))
+```
+
+### Lane-wise integer absolute value
+* `i8x16.abs(a: v128) -> v128`
+* `i16x8.abs(a: v128) -> v128`
+* `i32x4.abs(a: v128) -> v128`
+* `i64x2.abs(a: v128) -> v128`
+
+Lane-wise wrapping absolute value.
+
+```python
+def S.abs(a):
+    return S.lanewise_unary(abs, S.AsSigned(a))
+```
+
+## Bit shifts
+
+### Left shift by scalar
+* `i8x16.shl(a: v128, y: i32) -> v128`
+* `i16x8.shl(a: v128, y: i32) -> v128`
+* `i32x4.shl(a: v128, y: i32) -> v128`
+* `i64x2.shl(a: v128, y: i32) -> v128`
+
+Shift the bits in each lane to the left by the same amount. The shift count is
+taken modulo lane width:
+
+```python
+def S.shl(a, y):
+    # Number of bits to shift: 0 .. S.LaneBits - 1.
+    amount = y mod S.LaneBits
+    def shift(x):
+        return S.Reduce(x << amount)
+    return S.lanewise_unary(shift, a)
+```
+
+### Right shift by scalar
+* `i8x16.shr_s(a: v128, y: i32) -> v128`
+* `i8x16.shr_u(a: v128, y: i32) -> v128`
+* `i16x8.shr_s(a: v128, y: i32) -> v128`
+* `i16x8.shr_u(a: v128, y: i32) -> v128`
+* `i32x4.shr_s(a: v128, y: i32) -> v128`
+* `i32x4.shr_u(a: v128, y: i32) -> v128`
+* `i64x2.shr_s(a: v128, y: i32) -> v128`
+* `i64x2.shr_u(a: v128, y: i32) -> v128`
+
+Shift the bits in each lane to the right by the same amount. The shift count is
+taken modulo lane width.  This is an arithmetic right shift for the `_s`
+variants and a logical right shift for the `_u` variants.
+
+```python
+def S.shr_s(a, y):
+    # Number of bits to shift: 0 .. S.LaneBits - 1.
+    amount = y mod S.LaneBits
+    def shift(x):
+        return x >> amount
+    return S.lanewise_unary(shift, S.AsSigned(a))
+
+def S.shr_u(a, y):
+    # Number of bits to shift: 0 .. S.LaneBits - 1.
+    amount = y mod S.LaneBits
+    def shift(x):
+        return x >> amount
+    return S.lanewise_unary(shift, S.AsUnsigned(a))
+```
+
+
+## Bitwise operations
+
+Bitwise operations treat a `v128` value type as a vector of 128 independent bits.
+
+### Bitwise logic
+* `v128.and(a: v128, b: v128) -> v128`
+* `v128.or(a: v128, b: v128) -> v128`
+* `v128.xor(a: v128, b: v128) -> v128`
+* `v128.not(a: v128) -> v128`
+
+The logical operations defined on the scalar integer types are also available
+on the `v128` type where they operate bitwise the same way C's `&`, `|`, `^`,
+and `~` operators work on an `unsigned` type.
+
+### Bitwise AND-NOT
+
+* `v128.andnot(a: v128, b: v128) -> v128`
+
+Bitwise AND of bits of `a` and the logical inverse of bits of `b`. This operation is equivalent to `v128.and(a, v128.not(b))`.
+
+### Bitwise select
+* `v128.bitselect(v1: v128, v2: v128, c: v128) -> v128`
+
+Use the bits in the control mask `c` to select the corresponding bit from `v1`
+when 1 and `v2` when 0.
+This is the same as `v128.or(v128.and(v1, c), v128.and(v2, v128.not(c)))`.
+
+Note that the normal WebAssembly `select` instruction also works with vector
+types. It selects between two whole vectors controlled by a single scalar value,
+rather than selecting bits controlled by a control mask vector.
+
+### Lane-wise Population Count
+* `i8x16.popcnt(v: v128) -> v128`
+
+Count the number of bits set to one within each lane.
+
+```python
+def S.popcnt(v):
+    return S.lanewise_unary(popcnt, v)
+```
+
+## Boolean horizontal reductions
+
+These operations reduce all the lanes of an integer vector to a single scalar
+0 or 1 value. A lane is considered "true" if it is non-zero.
+
+### Any bit true
+* `v128.any_true(a: v128) -> i32`
+
+These functions return 1 if any bit in `a` is non-zero, 0 otherwise.
+
+### All lanes true
+* `i8x16.all_true(a: v128) -> i32`
+* `i16x8.all_true(a: v128) -> i32`
+* `i32x4.all_true(a: v128) -> i32`
+* `i64x2.all_true(a: v128) -> i32`
+
+These functions return 1 if all lanes in `a` are non-zero, 0 otherwise.
+
+```python
+def S.all_true(a):
+    for i in range(S.Lanes):
+        if a[i] == 0:
+            return 0
+    return 1
+```
+
+## Bitmask extraction
+
+* `i8x16.bitmask(a: v128) -> i32`
+* `i16x8.bitmask(a: v128) -> i32`
+* `i32x4.bitmask(a: v128) -> i32`
+* `i64x2.bitmask(a: v128) -> i32`
+
+These operations extract the high bit for each lane in `a` and produce a scalar
+mask with all bits concatenated.
+
+```python
+def S.bitmask(a):
+    result = 0
+    for i in range(S.Lanes):
+        if a[i] < 0:
+            result = result | (1 << i)
+    return result
+```
+
+## Comparisons
+
+The comparison operations all compare two vectors lane-wise, and produce a mask
+vector with the same number of lanes as the input interpretation where the bits
+in each lane are `0` for `false` and all ones for `true`.
+
+### Equality
+* `i8x16.eq(a: v128, b: v128) -> v128`
+* `i16x8.eq(a: v128, b: v128) -> v128`
+* `i32x4.eq(a: v128, b: v128) -> v128`
+* `i64x2.eq(a: v128, b: v128) -> v128`
+* `f32x4.eq(a: v128, b: v128) -> v128`
+* `f64x2.eq(a: v128, b: v128) -> v128`
+
+Integer equality is independent of the signed/unsigned interpretation. Floating
+point equality follows IEEE semantics, so a NaN lane compares not equal with
+anything, including itself, and +0.0 is equal to -0.0:
+
+```python
+def S.eq(a, b):
+    def eq(x, y):
+        return x == y
+    return S.lanewise_comparison(eq, a, b)
+```
+
+### Non-equality
+* `i8x16.ne(a: v128, b: v128) -> v128`
+* `i16x8.ne(a: v128, b: v128) -> v128`
+* `i32x4.ne(a: v128, b: v128) -> v128`
+* `i64x2.ne(a: v128, b: v128) -> v128`
+* `f32x4.ne(a: v128, b: v128) -> v128`
+* `f64x2.ne(a: v128, b: v128) -> v128`
+
+The `ne` operations produce the inverse of their `eq` counterparts:
+
+```python
+def S.ne(a, b):
+    def ne(x, y):
+        return x != y
+    return S.lanewise_comparison(ne, a, b)
+```
+
+### Less than
+* `i8x16.lt_s(a: v128, b: v128) -> v128`
+* `i8x16.lt_u(a: v128, b: v128) -> v128`
+* `i16x8.lt_s(a: v128, b: v128) -> v128`
+* `i16x8.lt_u(a: v128, b: v128) -> v128`
+* `i32x4.lt_s(a: v128, b: v128) -> v128`
+* `i32x4.lt_u(a: v128, b: v128) -> v128`
+* `i64x2.lt_s(a: v128, b: v128) -> v128`
+* `f32x4.lt(a: v128, b: v128) -> v128`
+* `f64x2.lt(a: v128, b: v128) -> v128`
+
+### Less than or equal
+* `i8x16.le_s(a: v128, b: v128) -> v128`
+* `i8x16.le_u(a: v128, b: v128) -> v128`
+* `i16x8.le_s(a: v128, b: v128) -> v128`
+* `i16x8.le_u(a: v128, b: v128) -> v128`
+* `i32x4.le_s(a: v128, b: v128) -> v128`
+* `i32x4.le_u(a: v128, b: v128) -> v128`
+* `i64x2.le_s(a: v128, b: v128) -> v128`
+* `f32x4.le(a: v128, b: v128) -> v128`
+* `f64x2.le(a: v128, b: v128) -> v128`
+
+### Greater than
+* `i8x16.gt_s(a: v128, b: v128) -> v128`
+* `i8x16.gt_u(a: v128, b: v128) -> v128`
+* `i16x8.gt_s(a: v128, b: v128) -> v128`
+* `i16x8.gt_u(a: v128, b: v128) -> v128`
+* `i32x4.gt_s(a: v128, b: v128) -> v128`
+* `i32x4.gt_u(a: v128, b: v128) -> v128`
+* `i64x2.gt_s(a: v128, b: v128) -> v128`
+* `f32x4.gt(a: v128, b: v128) -> v128`
+* `f64x2.gt(a: v128, b: v128) -> v128`
+
+### Greater than or equal
+* `i8x16.ge_s(a: v128, b: v128) -> v128`
+* `i8x16.ge_u(a: v128, b: v128) -> v128`
+* `i16x8.ge_s(a: v128, b: v128) -> v128`
+* `i16x8.ge_u(a: v128, b: v128) -> v128`
+* `i32x4.ge_s(a: v128, b: v128) -> v128`
+* `i32x4.ge_u(a: v128, b: v128) -> v128`
+* `i64x2.ge_s(a: v128, b: v128) -> v128`
+* `f32x4.ge(a: v128, b: v128) -> v128`
+* `f64x2.ge(a: v128, b: v128) -> v128`
+
+## Load and store
+
+Load and store operations are provided for the `v128` vectors. The memory
+operations take the same arguments and have the same semantics as the existing
+scalar WebAssembly load and store instructions (see
+[memarg](https://webassembly.github.io/spec/core/bikeshed/index.html#syntax-memarg).
+The difference is that the memory access size is 16 bytes which is also the
+natural alignment.
+
+### Load
+
+* `v128.load(m: memarg) -> v128`
+
+Load a `v128` vector from the given heap address.
+
+```python
+def S.load(m: memarg):
+    return S.from_bytes(memory[memarg.offset:memarg.offset + 16])
+```
+
+### Load and Zero-Pad
+
+* `v128.load32_zero(m: memarg) -> v128`
+* `v128.load64_zero(m: memarg) -> v128`
+
+Load a single 32-bit or 64-bit element into the lowest bits of a `v128` vector,
+and initialize all other bits of the `v128` vector to zero.
+
+```python
+def S.load32_zero(m: memarg):
+    return S.from_bytes(memory[memarg.offset:memarg.offset + 4])
+```
+
+```python
+def S.load64_zero(m: memarg):
+    return S.from_bytes(memory[memarg.offset:memarg.offset + 8])
+```
+
+### Load and Splat
+
+* `v128.load8_splat(m: memarg) -> v128`
+* `v128.load16_splat(m: memarg) -> v128`
+* `v128.load32_splat(m: memarg) -> v128`
+* `v128.load64_splat(m: memarg) -> v128`
+
+Load a single element and splat to all lanes of a `v128` vector. The natural
+alignment is the size of the element loaded.
+
+```python
+def S.load_splat(m: memarg):
+    val_bytes = memory[memarg.offset:memarg.offset + S.LaneBytes])
+    return S.splat(S.LaneType.from_bytes(val_bytes))
+```
+
+### Load Lane
+
+* `v128.load8_lane(m: memarg, x: v128, imm: ImmLaneIdx16) -> v128`
+* `v128.load16_lane(m: memarg, x: v128, imm: ImmLaneIdx8) -> v128`
+* `v128.load32_lane(m: memarg, x: v128, imm: ImmLaneIdx4) -> v128`
+* `v128.load64_lane(m: memarg, x: v128, imm: ImmLaneIdx2) -> v128`
+
+Load a single element from `m` into the lane of `x` specified in the immediate
+mode operand `imm`. The values of all other lanes of `x` are bypassed as is.
+
+### Load and Extend
+
+* `v128.load8x8_s(m: memarg) -> v128`: load eight 8-bit integers and sign extend each one to a 16-bit lane
+* `v128.load8x8_u(m: memarg) -> v128`: load eight 8-bit integers and zero extend each one to a 16-bit lane
+* `v128.load16x4_s(m: memarg) -> v128`: load four 16-bit integers and sign extend each one to a 32-bit lane
+* `v128.load16x4_u(m: memarg) -> v128`: load four 16-bit integers and zero extend each one to a 32-bit lane
+* `v128.load32x2_s(m: memarg) -> v128`: load two 32-bit integers and sign extend each one to a 64-bit lane
+* `v128.load32x2_u(m: memarg) -> v128`: load two 32-bit integers and zero extend each one to a 64-bit lane
+
+Fetch consecutive integers up to 32-bit wide and produce a vector with lanes up
+to 64 bits. The natural alignment is 8 bytes.
+
+```python
+def S.load_extend(ext, m: memarg):
+    result = S.New()
+    bytes = memory[memarg.offset:memarg.offset + 8])
+    for i in range(S.Lanes):
+        result[i] = ext(S.LaneType.from_bytes(bytes[(i * S.LaneBytes/2):((i+1) * S.LaneBytes/2)]))
+    return result
+
+def S.load_extend_s(m: memarg):
+    return S.load_extend(Sext, memarg)
+
+def S.load_extend_u(m: memarg):
+    return S.load_extend(Zext, memarg)
+```
+
+### Store
+
+* `v128.store(m: memarg, data: v128)`
+
+Store a `v128` vector to the given heap address.
+
+```python
+def S.store(m: memarg, a):
+    memory[memarg.offset:memarg.offset + 16] = bytes(a)
+```
+
+### Store Lane
+
+* `v128.store8_lane(m: memarg, data: v128, imm: ImmLaneIdx16)`
+* `v128.store16_lane(m: memarg, data: v128, imm: ImmLaneIdx8)`
+* `v128.store32_lane(m: memarg, data: v128, imm: ImmLaneIdx4)`
+* `v128.store64_lane(m: memarg, data: v128, imm: ImmLaneIdx2)`
+
+Store into `m` the lane of `data` specified in the immediate mode operand `imm`.
+
+## Floating-point sign bit operations
+
+These floating point operations are simple manipulations of the sign bit. No
+changes are made to the exponent or trailing significand bits, even for NaN
+inputs.
+
+### Negation
+* `f32x4.neg(a: v128) -> v128`
+* `f64x2.neg(a: v128) -> v128`
+
+Apply the IEEE `negate(x)` function to each lane. This simply inverts the sign
+bit, preserving all other bits.
+
+```python
+def S.neg(a):
+    return S.lanewise_unary(ieee.negate, a)
+```
+
+### Floating-point absolute value
+* `f32x4.abs(a: v128) -> v128`
+* `f64x2.abs(a: v128) -> v128`
+
+Apply the IEEE `abs(x)` function to each lane. This simply clears the sign bit,
+preserving all other bits.
+
+```python
+def S.abs(a):
+    return S.lanewise_unary(ieee.abs, a)
+```
+
+## Floating-point min and max
+
+These operations are not part of the IEEE 754-2008 standard. They are lane-wise
+versions of the existing scalar WebAssembly operations.
+
+### NaN-propagating minimum
+* `f32x4.min(a: v128, b: v128) -> v128`
+* `f64x2.min(a: v128, b: v128) -> v128`
+
+Lane-wise minimum value, propagating NaNs.
+
+### NaN-propagating maximum
+* `f32x4.max(a: v128, b: v128) -> v128`
+* `f64x2.max(a: v128, b: v128) -> v128`
+
+Lane-wise maximum value, propagating NaNs.
+
+### Pseudo-minimum
+* `f32x4.pmin(a: v128, b: v128) -> v128`
+* `f64x2.pmin(a: v128, b: v128) -> v128`
+
+Lane-wise minimum value, defined as `b < a ? b : a`.
+
+### Pseudo-maximum
+* `f32x4.pmax(a: v128, b: v128) -> v128`
+* `f64x2.pmax(a: v128, b: v128) -> v128`
+
+Lane-wise maximum value, defined as `a < b ? b : a`.
+
+## Floating-point arithmetic
+
+The floating-point arithmetic operations are all lane-wise versions of the
+existing scalar WebAssembly operations.
+
+### Addition
+* `f32x4.add(a: v128, b: v128) -> v128`
+* `f64x2.add(a: v128, b: v128) -> v128`
+
+Lane-wise IEEE `addition`.
+
+### Subtraction
+* `f32x4.sub(a: v128, b: v128) -> v128`
+* `f64x2.sub(a: v128, b: v128) -> v128`
+
+Lane-wise IEEE `subtraction`.
+
+### Division
+* `f32x4.div(a: v128, b: v128) -> v128`
+* `f64x2.div(a: v128, b: v128) -> v128`
+
+Lane-wise IEEE `division`.
+
+### Multiplication
+* `f32x4.mul(a: v128, b: v128) -> v128`
+* `f64x2.mul(a: v128, b: v128) -> v128`
+
+Lane-wise IEEE `multiplication`.
+
+### Square root
+* `f32x4.sqrt(a: v128) -> v128`
+* `f64x2.sqrt(a: v128) -> v128`
+
+Lane-wise IEEE `squareRoot`.
+
+### Round to integer above (ceiling)
+* `f32x4.ceil(a: v128) -> v128`
+* `f64x2.ceil(a: v128) -> v128`
+
+Lane-wise rounding to the nearest integral value not smaller than the input.
+
+### Round to integer below (floor)
+* `f32x4.floor(a: v128) -> v128`
+* `f64x2.floor(a: v128) -> v128`
+
+Lane-wise rounding to the nearest integral value not greater than the input.
+
+### Round to integer toward zero (truncate to integer)
+* `f32x4.trunc(a: v128) -> v128`
+* `f64x2.trunc(a: v128) -> v128`
+
+Lane-wise rounding to the nearest integral value with the magnitude not larger than the input.
+
+### Round to nearest integer, ties to even
+* `f32x4.nearest(a: v128) -> v128`
+* `f64x2.nearest(a: v128) -> v128`
+
+Lane-wise rounding to the nearest integral value; if two values are equally near, rounds to the even one.
+
+## Conversions
+### Integer to single-precision floating point
+* `f32x4.convert_i32x4_s(a: v128) -> v128`
+* `f32x4.convert_i32x4_u(a: v128) -> v128`
+
+Lane-wise conversion from integer to floating point. Integer values not
+representable as single-precision floating-point numbers will be rounded to the
+nearest-even representable number.
+
+### Integer to double-precision floating point
+* `f64x2.convert_low_i32x4_s(a: v128) -> v128`
+* `f64x2.convert_low_i32x4_u(a: v128) -> v128`
+
+Lane-wise conversion from integer to floating point.
+
+### Single-precision floating point to integer with saturation
+* `i32x4.trunc_sat_f32x4_s(a: v128) -> v128`
+* `i32x4.trunc_sat_f32x4_u(a: v128) -> v128`
+
+Lane-wise saturating conversion from single-precision floating point to integer
+using the IEEE `convertToIntegerTowardZero` function. If any input lane is a
+NaN, the resulting lane is 0. If the rounded integer value of a lane is outside
+the range of the destination type, the result is saturated to the nearest
+representable integer value.
+
+### Double-precision floating point to integer with saturation
+* `i32x4.trunc_sat_f64x2_s_zero(a: v128) -> v128`
+* `i32x4.trunc_sat_f64x2_u_zero(a: v128) -> v128`
+
+Saturating conversion of the two double-precision floating point lanes to two
+lower integer lanes using the IEEE `convertToIntegerTowardZero` function. The
+two higher lanes of the result are initialized to zero. If any input lane is a
+NaN, the resulting lane is 0. If the rounded integer value of a lane is outside
+the range of the destination type, the result is saturated to the nearest
+representable integer value.
+
+### Double-precision floating point to single-precision
+* `f32x4.demote_f64x2_zero(a: v128) -> v128`
+
+Conversion of the two double-precision floating point lanes to two lower
+single-precision lanes of the result. The two higher lanes of the result are
+initialized to zero. If the conversion result is not representable as a
+single-precision floating point number, it is rounded to the nearest-even
+representable number.
+
+### Single-precision floating point to double-precision
+* `f64x2.promote_low_f32x4(a: v128) -> v128`
+
+Conversion of the two lower single-precision floating point lanes to the two
+double-precision lanes of the result.
+
+### Integer to integer narrowing
+* `i8x16.narrow_i16x8_s(a: v128, b: v128) -> v128`
+* `i8x16.narrow_i16x8_u(a: v128, b: v128) -> v128`
+* `i16x8.narrow_i32x4_s(a: v128, b: v128) -> v128`
+* `i16x8.narrow_i32x4_u(a: v128, b: v128) -> v128`
+
+Converts two input vectors into a smaller lane vector by narrowing each lane,
+signed or unsigned. The signed narrowing operation will use signed saturation
+to handle overflow, 0x7f or 0x80 for i8x16, the unsigned narrowing operation
+will use unsigned saturation to handle overflow, 0x00 or 0xff for i8x16.
+Regardless of the whether the operation is signed or unsigned, the input lanes
+are interpreted as signed integers.
+
+```python
+def S.narrow_T_s(a, b):
+    result = S.New()
+    for i in range(T.Lanes):
+        result[i] = S.SignedSaturate(a[i])
+    for i in range(T.Lanes):
+        result[T.Lanes + i] = S.SignedSaturate(b[i])
+    return result
+
+def S.narrow_T_u(a, b):
+    result = S.New()
+    for i in range(T.Lanes):
+        result[i] = S.UnsignedSaturate(a[i])
+    for i in range(T.Lanes):
+        result[T.Lanes + i] = S.UnsignedSaturate(b[i])
+    return result
+```
+
+### Integer to integer extension
+* `i16x8.extend_low_i8x16_s(a: v128) -> v128`
+* `i16x8.extend_high_i8x16_s(a: v128) -> v128`
+* `i16x8.extend_low_i8x16_u(a: v128) -> v128`
+* `i16x8.extend_high_i8x16_u(a: v128) -> v128`
+* `i32x4.extend_low_i16x8_s(a: v128) -> v128`
+* `i32x4.extend_high_i16x8_s(a: v128) -> v128`
+* `i32x4.extend_low_i16x8_u(a: v128) -> v128`
+* `i32x4.extend_high_i16x8_u(a: v128) -> v128`
+* `i64x2.extend_low_i32x4_s(a: v128) -> v128`
+* `i64x2.extend_high_i32x4_s(a: v128) -> v128`
+* `i64x2.extend_low_i32x4_u(a: v128) -> v128`
+* `i64x2.extend_high_i32x4_u(a: v128) -> v128`
+
+Converts low or high half of the smaller lane vector to a larger lane vector,
+sign extended or zero (unsigned) extended.
+
+```python
+def S.extend_low_T(ext, a):
+    result = S.New()
+    for i in range(S.Lanes):
+        result[i] = ext(a[i])
+
+def S.extend_high_T(ext, a):
+    result = S.New()
+    for i in range(S.Lanes):
+        result[i] = ext(a[S.Lanes + i])
+
+def S.extend_low_T_s(a):
+    return S.extend_low_T(Sext, a)
+
+def S.extend_high_T_s(a):
+    return S.extend_high_T(Sext, a)
+
+def S.extend_low_T_u(a):
+    return S.extend_low_T(Zext, a)
+
+def S.extend_high_T_u(a):
+    return S.extend_high_T(Zext, a)
+```
diff --git a/proposals/simd/TextSIMD.md b/proposals/simd/TextSIMD.md
new file mode 100644
index 000000000..0f4fc6eb8
--- /dev/null
+++ b/proposals/simd/TextSIMD.md
@@ -0,0 +1,27 @@
+# Text format for SIMD
+
+### v128.const
+
+The `v128.const` instruction has multiple valid text formats corresponding to
+different lane interpretations. The valid text formats are
+
+```
+v128.const i8x16 i8 i8 i8 i8 i8 i8 i8 i8 i8 i8 i8 i8 i8 i8 i8 i8
+v128.const i16x8 i16 i16 i16 i16 i16 i16 i16 i16
+v128.const i32x4 i32 i32 i32 i32
+v128.const i64x2 i64 i64
+v128.const f32x4 f32 f32 f32 f32
+v128.const f64x2 f64 f64
+```
+
+The canonical text format used for printing `v128.const` instructions is
+
+```
+v128.const i32x4 0xNNNNNNNN 0xNNNNNNNN 0xNNNNNNNN 0xNNNNNNNN
+```
+
+### i8x16.shuffle
+
+```
+i8x16.shuffle i5 i5 i5 i5 i5 i5 i5 i5 i5 i5 i5 i5 i5 i5 i5 i5
+```
diff --git a/proposals/simd/W3CTAG-SIMDExplainer.md b/proposals/simd/W3CTAG-SIMDExplainer.md
new file mode 100644
index 000000000..b5d70633e
--- /dev/null
+++ b/proposals/simd/W3CTAG-SIMDExplainer.md
@@ -0,0 +1,72 @@
+# WASM SIMD Web Platform explainer
+
+## User benefits
+Modern processors support running multiple common computations in a single operation, so that instead of multiplying a number with a number, you can add (or multiply, subtract, etc.) the individual components of a fixed sized vector instead.
+
+##### Scalar operation #####
+
+```
+Ax + Bx = Cx
+Ay + By = Cy
+Az + Bz = Cz
+Aw + Bw = Cw
+```
+
+##### SIMD Operation of Vector Length 4 #####
+
+`Ax`|`Ay`|`Az`|`Aw`
+--|--|--|--
+
+<pre>
+            +
+</pre>
+
+`Bx`|`By`|`Bz`|`Bw`
+--|--|--|--
+
+<pre>
+            =
+</pre>
+
+`Cx`|`Cy`|`Cz`|`Cw`
+--|--|--|--
+
+
+
+
+
+
+This feature is called [Single Instruction Multiple Data (SIMD)](https://en.wikipedia.org/wiki/SIMD), and though hardware support exists for vector lengths up to 512 bits, 128-bit SIMD is the most common and is supported across common hardware architectures.
+
+SIMD has driven large speed ups in certain cases such as image manipulation, video encoding/decoding, machine learning, game engines and physics engines etc - with some of these use-cases not being usable without SIMD support, making SIMD support for the web platform essential for achieving near-native speed with certain native applications.
+
+This proposal outlines exposing a commonly available subset of 128-bit SIMD hardware instructions through WebAssembly.
+
+## Design principles
+This proposal consists of a portable set of widely used SIMD operations mapping closely to instructions available in modern hardware. The proposal draws heavily on inputs from application developers on the usefulness of the instructions and implementer feedback on performance. 
+
+JavaScript applications can access the SIMD values in WebAssembly module memory indirectly as scalar values through Arraybuffers, and manipulate them using function calls into WebAssembly. The 128-bit values are not currently exposed to JavaScript. There are no known accessibility, security or privacy implications specific to this feature. 
+
+## Prior work
+The current proposal builds on top of the [SIMD.js TC39 proposal](https://github.com/tc39/ecmascript_simd), which is no longer under active development. The SIMD.js proposal was abandoned for a few reasons:
+
+* Significant performance cliffs hidden within its high level abstractions making it challenging for real world applications to gain consistent benefits.
+* Gains only seen in carefully crafted asm.js code, which is not representative of the majority of JavaScript code in the wild.
+* High cost of implementation and optimization in engines that outweighed performance wins.
+
+Most of these were offset by the low level abstractions in WebAssembly, where we observed consistent performance across multiple architectures on real world applications.
+
+## References
+[1] GitHub repo: https://github.com/WebAssembly/simd
+
+[2] Proposal directory: https://github.com/WebAssembly/simd/tree/master/proposals/simd
+
+[3] Example usage and demos: https://v8.dev/features/simd
+
+[4] Tests: https://github.com/WebAssembly/simd/tree/master/test/core/simd
+
+[5] External status/issue trackers for this feature: https://www.chromestatus.com/feature/6533147810332672
+
+[6] SIMD.js: https://github.com/tc39/ecmascript_simd 
+
+[7] W3C Tag design reviews - WebAssembly SIMD : https://github.com/w3ctag/design-reviews/issues/487
diff --git a/proposals/simd/WebAssembly-SIMD-May-2017.pdf b/proposals/simd/WebAssembly-SIMD-May-2017.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..9b9fd29a55451545663df915779794afef1baadd
GIT binary patch
literal 128301
zcmbrlby!`?lP-*g;32pZ++BmayL)hF<GzvL?jGEOyKdawC3tXmw@c2PGxNLO%=gU9
zbN_(7o?ffFR#$b`daLSfG6fMaIwpD+II`ZI%bla5tL(|%emGVlMk0WrB^(bA5rd40
zt(lWK5!-u{5)p%#g|(B3!~3tbfs=`di4nlqgouw1&e6%i#J~p54IDVm3*XK7>B9!7
z<2QbKAGyW;z&>W~WDb_yCm8Kq%0exp;8)Lh4NP>$o~|9YQyaxx==wfNOo?~|*FZ!Z
z5#=5Q+)2e#y*S?`=9`7fE_w5B9a^oMbd0eA3h?GKq|6-oXXI?eR2k&Ri^MCRst|I1
z_V-ij>UxwV_eDT)52Ei*Q+Ty9ji3x1Z1k_R3O_j&sh79zUhh{o#dl^jxp1IK@yd;%
zKy`S1;dIM<yMoN(roH9mG@<h2=}=0NC)$)ThcmG?{(Cy_SAVqdXX<}`nYh^h-28LN
z{4WYpakn!eVo)$J`|H1hiLDb6%fBg0$;1)h>|kW#NW}hc4Z;9hr}z7gM1K_gu1#4J
zV+#WzfE$rE<9h=WBQq-z2Ro-O+`C5q7WAj%KbBB%02nEoI1y>TOA`?zVo))0b0X3u
zVh{#c100m?42(>O{uoTyk%@@oukrc#-VOCG@~>tU6(%CiKh5u>|1sI$0+{|t{zt;!
zwq|1bt2=|-`$QN7{}|l%-P%M9A|@^tMkY$)LjV0b$VhTkQC`9bo&a%xCO;DskzM0>
zz!FV!OQ1t3hD!P>Km-MlyNE!Gp`lQz8LM=Hiw6@MiK4;#e>Yr!z5Jxm-=!!by0aQ#
z1$$P`cD0uFGN8G>wAZ+>WOfEzXaQ4r{tngcqyg^Bnxlbsdeo)!8Fi%h4g%{FIFbf<
z=ccJCl=!^}#OyPOH#N0bqQCa`l-}34b(yw9f!uNa%_o+aLzwgf7@X)FJC8Rx<_<)H
za%~?r^BdIgbs`mW5EC;-4s322@m6o8^=;8EP3urfGWm86j^;Ra8*64ntHN3u*=Ak@
zRE|yx*@ju37mNu=MKTR+=Z<n_=KhBa7$aJ${^%Zgj&&%rC>r)@=p_W$$An(4HV35e
z2QKqWFt<Xp?J%fNNy9>vg%pdO{Xx^mi(2IeLnfMp9@)(hH<^j+I)o@jOy5dCk|;Qt
zrcJ7O>`6J^$%*FtuK7d9(mH{+@(b^v$CK&>`SC=iU__?oy7h4x0|*1`mQ*VpzqUP5
z6|BzYgTT&anfw_M*d;Vr-P(^Uf*@<XxZd9g6!784$JUPESyuEk`y5YM-vPrNL0osK
zBd1Sl+=ZC@ek79UEGD8mg++zZBBP@SNXZk%FL$5bwmP{i#)f)me`IxHUIgx|D()x1
z285co2J-l6#LyeV1^CQu`e3nBz+ii4SfQCa>w^IUxfGftVFm%bV8SGjq_+GX5Wpkt
zPfT!w?QQ1ev6YU|%pR|MkA(0#VYZtxg2c+Zw+PY34rIBs*m>&#)?E;vV_=-J;aL6X
z86jxDA>#S6*g>ulfd%+Ve1c4Zq?drO5P+%?<XZ%T6J%Nhck#Eh1Do~pn1qu1&TjWX
z2THvY(GDKLS6l!ts7sm=e9h0|<M;DV=(&PFV=(fOQ-$U~;c9(!7Zz0DM1$-T4vqN~
zC-5*yUW`TU|1(Eef%lrk38&?wuK!~;%p?)(hZk^Q07?qPi~-^zScC6U6*t~T@$Qig
z5jXT7Fqoaon^H{}d`OMmn47rgV6=hy-SHm<20ubhiD`Vqy$}(K(I5p!`C=7IoDWeV
znihkUkJ}t65o^B<`5`#RAO#DfAA2iUGh)+F&0yY8ig7N*C`C;MbC=!p6N}%&_X5MY
z>Ou{QGJY3Wc9ir;x?Z(!(ciSIlB*#X4UW0-kOn%jf8*JCH(}{8+p<+aH6kxWwE7<P
zAa0UhxV2HQp`Cq4?s7ag^!m~c=Y!`%upUj=-$4-rs|98C9r;TV5vet)$|szUdmmo{
zP`X(a{fgzCh=V@4_v#o@RYxrfwn^fV%f+Kf29aVaky54B`Kd@+66=!ll7qg)4}CQj
zcfisV(37tq%_7n#LyqHDNT4J~lb6C16<U(xl4=%k7jPFYP(m!Woz?i6(vqPi4-x@N
z0U5;OS(2}kw}#5&OJl7PkCHvf<P#Q>U6b|cvncex_(;7LJ~u%qb_sMT`{h-s<%n(8
zb@K*Fil*fz8ip9A8HO7A|7Pn`Bx{TFi);KWUm|c&HBDCV1xIM6z<s)@PPXprFOy%4
z_~IP-Pc!iceb<EhpletYG863`${oBNoSoWXr4QYV-|ktIunQvMBU&S(uUL1RC$=V*
z*()vd-rA@VAE<4qy%LENO%uTrqkqb%0_M=>GJe|pl%Hj^B)2rMT(W$cqc4q|D4KB1
zoXF5;ecOHxKCEg9^=Nvuyy-dQJ&eam!)eFC#!<ydX6<LgPP0uLO4~`>V;!h7*MhHy
z(%RA5tJh;pOg$Y{F(s=F=gKLsI4Po=;>%wx<t;ZVuGKKhldBy^)s3Uq<`8VuX;gL<
zl9y)CV9>8rJj>xz%qq{y?-1|M_8IP+B>MF&Trj<>I43Np!ywZjZ_|k6XKd*db)Hrp
zcR#05gMHWq-<CFcRcMA}oMhyXtn%XQn##A9iMj~{t6g())>5|Cf!wMUP0cc~`E0Hp
zo<XlX_w)xEc;0Z0@C=Mq41L-YT4lN;T0%`KO=u09y2Gl+o?pFbR=P&OfgsB*quTMp
z)!q8?61sJljuRkvnr_u9Myp)w#4XY-@e}zI6AW*#TQCUeZqdnwvNZrWhjO&P*))C;
zu?0inNl`r`S+t&^IZic>IGzWOfO(ENONZq!Wxv^k=MYP8Odp}|W|uRox}3PBb@VtY
zyAZkO(reSZy2!iq()2`wER7s19zKvz6u*Zv0k0R5T&W(bUfCFTXLx3LR>b#}FO)Bm
z54GK;y%flBZ}0-~;_|q9wQ#=oxbP$o#R*jgyAPKSB?hGi!w1g{`x)99s;3LQtMxk}
z!?ZrB&MXFm(6g{hAP+1Xf-d@_BNja^YZ>{mdy}f0x0@>zouR0RaBr(b^x*WMcz7g+
zG={6#ka(ZyoVcv0r)aXMbg~AmX6?3EgjNJmAuk3YF1jbFi$lrX^s035*70w+ty6jy
zouu01Uk>#<B_k6RG5TGa_S6Kpg!t>9-a=8kOLk-`uJxN;cc2#HTZ5nC_WEh|A}@6B
zO`c<+k^^c2rbLo^bwiCLD<sh+w;<#N>o=Th^e_FkOA=xd@~Bu!rb@;v0_yJTW`xKL
z!m4O=S$HWx3_YxQjKVF$7IUYnsJQ}Du`-m7nx?HOQLi#L5)q{7Wd54)wU#w&X5uDU
z!-}IQyVu)k+qNV4Lsvsj-fX69uFhudF0Vn)U2LaTNaca^6*|k!a;~~vEt@y(N6|J!
zHWEwcBVr?wCb;XiVQaIB*@{)|-^^>zcKd~zg%meIbmQ7c)_vCK)+ei`wdIz}$;5h7
zH-;m>!+y(?t;8LzYXa3DR!46GPCx~>1y8OUE+1W2Ru5XPG*S&U^_C_pHgwB(MlW+O
z8(Y<n+tm!T?Y|*gL>oufF&Ec>q$(}N=ZX&V5B+eW({@3Jo{c9NzXp~UI@WD`X22sM
z`(XG8(D2%P2JaNC$^~uu3|2PFdM1u?4_i9SeDr-pP9!d3C&UBA3kJHQo#(h`7dVPJ
z64<*V<NB+&><0iZ8#lt9sHF!AEP2iMP@G@5E`AT(6P{%v@GQB90e>D)yky-rOlpN`
z<;<_lhc@K1TX@QNt{?c$WZ;kE)A6Ujd0j``rl!>nn@LZ^j-&rb=gM;Rz7*;Yya*4)
z4F0O_#Me@{J)KceRk1eWmt3iL(d<yN40?K2O)fR7;L_y=W&lAaK`)W>1g)7#`p4cD
z2lZz*paZ+wm!z%osCH=J-lOgl!`f{Na3|_50~a#<!{aG^yXTwU3hx1M?PUt41X+)N
z)PwWI{Ke>aE0+RJo;vd<fBDPY{eo!;==wN&;oC%Qh*@+{lQ6?u;zOl;5A;OI1dUjo
z*r9m2_(a4*#HvU2b>I0&MDom5U<cJ}!(HN3X_mL^6UfYPsQ27z>L`_8YOT1P>v8_p
zX3uzkd&bq`tgt9-t+bv0*6$_f$>@3@_TX6lUOq7^lHb(}_W9C{+{Scw{Vw3@=|AJ{
zzhLNJXq%mh`5(Oc2ig8<dk4Xi!oorZjwZ(M!1*t{s{79~On>nA{}<E#4Y~ij0H$1B
z7O=wp33R1Cs^}RqDj&*o+Y^koNO}S%>6aTk8;OG10KOpT`})-Wr9f9Iq3#za4VJW{
zq~+RZTj~JCV`8SnZ$%|-OI-Ok?_A_-33Yy6nih9*O_*0!L@J&Mj=tZ^oFvfR9^GMX
z7#1eQikY?q`vXxt^23{@p4p`pTQe=%kN!V<j$S6Nd!nk^9v?4GU$^vK?_Bj?mqYnW
zo&qblQwGJTsfIM=k<q?UMW1d_p8NVl_)jc-4T=>;g=Q^DV7D$RleM!sN6MSW2560G
zJZK#8l=RPMemCA*iHmyMx$<IuR*>G)Ug}h@X`pAV*}O`y#UtRGI8@+Zp)fQ9glbgv
zLTfLlW|YI%XQn3C&;R1Ywaa#_QDpB#V*t&KBTgc8^9HGja2t$aB59;={0KvWSAqu6
zjt9e=*fGg|p7k<v(7XMBf=O<?(;ZOugP(ZoPBzva!(q}%oA`>LA3G{CxOwgBBTG&q
z9XIKhF%BdN-H&{A5fjV(L`qniq}lAdXtQ2hzIARS-(x{cUl=&Zw|AZq9Pl_pOD@SS
zVf|63hlIKwTB!=-BbhD+0H0trn;E~*?3u+>H!3$EF+q0}4QX*=wKBs{WG}Uc6Q`ZD
zQfBwH2ehQnhovoQ%|6zsw61;O`^HIc`@`a1V%<S@w;G@r6uVbMTuy7L$Ow#`-+;_~
zr9rpA53du5eXSzVhxvKx!YQkK<NEfpa~0LFU{S46q+G0^ydXeE1gip}@tv7y2Nn&k
zG$HM4;T>_?&uZ?&S9gn2E{r=AD7ogEtcw1=+^JE4Pa~g-m3{#Rs_=r0(y<Lvw&#-=
zS@)S)u+)08b!+i^97g1w(hH|Kdb^HBwl)&hq71l@M&omCu+uhO3H(`2sUt*Feq#|m
z#edWuA~=6?p4c1kTgY<xt!n)ELI$ND66Pkdp=&d45Qc_7M+s@);42srU|hfc*1md$
z%5Ag*4B^Q*OwwFWcG0R^H7@eq$hdN5a4YTE^eD|R6kU`vnQ6(0(Ncs}-cle?cl=E{
znlqH+@$>H7O6_-Fqtr$3$d^*!=;8Oo0<&c>U~8A*sgiiOz9@mIn!bzQ;N=(f_`(hd
z9gPX}!w^L=>&-8pNPoSsBi!l-D{>=Lxa@nIcMs?*Jaxd#_f84Ajpx#B8D$6iA*t@_
z>~=JJKka(vd*|+d+qGlBg)U&7X*iYn^x?ZLyRyJ^Ib#BgSxif9I}cSI8B-n}R4QNP
z<UI~Zo=ivO42fYd=rwF?T*j8*Q&l=g)!c8fCR=-l+TvT7?Z**S^-9VI(@r^h86K{O
zS#k<ytT4q*Ku{(yT#`8@<N4HPoiHbu1iG?oMs}7vo_1&{p1a#iiqMMd?gw;_#R~2^
z;pN&r|61TE?SJ8&{z;NBF|u;~yXX1eCI*=P&a3=;X5cU1^)IObxc@sf@UM~kKY58i
zLI3}2Zh)DH>8~6G9K*lo3EoBht2D0v>{FTl&F}uVNul}-{b<qw``-0E<?B4?ki6G*
zUhi6qt}1ZsIJbtZ9X43S_F4h_FT(3<v2)lc%`+qZrrGFUKH-)P4OLX=o0zD&OdziU
zS_oSR-Vk0mU6)&2eI6U0CQf}?^}Sx)_x1Q(Uv4nov=?kU`Lp!pB0H?4e7bxd!RgY<
zZBzPf@o!Iel<%SmTX=gj-yY9Pp8A534NiJoSJx4@Ugvy(Z$@`V>!9a}#<x}A6+_2k
zQI;;>bI#LF@NOEysWb<YHqMWEQ^vQOUmG1S7Xuw<uMZ1vuMc~x{Li=Qs~m3^BU!Hc
zZwIbE4~JLLJ`eXccY6SR@8_*7z9;Tn$bRR;ew%~c<tRW2kWrK{pz`F`fOCf&YK4v7
z(^11p!>MxP^^^1Q!VU3>Q6s{OGhWcpNs>X+>C9KxD~DF3tGb-Xgp;qdFDoF4*3lU!
z-DHD<Zj5DF$T}eHe9`N#36g~Cob-~mjWi^E0~&2$K!aWpiY}Fn&fd|y{CW6%cpP6q
zdET6f-t<CMpZsN*bp}Y7a0QuR^(@@X`mW@u0=M-|nBtA*^(`37OZo1G<AnTfl|z33
z3uL?HkZvDuNC`yuL3(1|Y9G6D#!7B>M*DE?)|D-MCwujEy`{XP;)r#{F0atJ#df((
z>*=Enh#pJKl09c3N^I+99(mcLx+cE_(~DLcaq6O{Ws^^{XRO2KiD(P!V>yaU0gQ^>
z$W94s%3<Y5`?WTOO)toLfhGSU9KFSNxmOKWx6dXn3DfwfZ9m*A8=}J-Fp=+l*bbi1
z#D!Iwf^Eot-yNCiay{nJ>U`Cvv*#W1^nD0yMyA#O{!YEeV-;Z4m}j)tJ`gZj7zArX
zR2XzN|6qn+^qrk_&`^dwd+TfE(MI)6$#N33*BWCxR}G)g@}#Syfs6L-kqt<2DAtoI
zOry>eBRq-rmxs~^?Q6dkRs9m^1=MH4?>tIg@{a{o3>f99eYqAcIXB0!i!EoBO+#jE
z8qeLjK-|U?0=kuO@BTJUj0QV~M|56(<XxL1z*1P7<|dK1;FYziTdmldamJ#~He@1L
zRJ#<U-Ll<DFl?<?u1De0m9H1&l>oThRVVp|c?Oa0`!kT79^^Mn8}n40xOc7)<MCWD
zW&T+(_K4ordz+z4=3-TJke)h~A6=TfIS!}nQ9npV0(p05o7bnPNsgRaza)%3iB?C$
zSr4gNklji;LP;Mb=jJ0v0rBww74wtH3;qmk@MVn70s40`h(NWh?#L<Go_Y}uizwST
zR`%c&gd`K{JdZ&MH8D0dvX4P8_tY(PsKmQfUt0{?!^Oy23O-j2DO<9&C@M$bOuL2J
zI^~Eo`c)+D_rp6lZHaQXC~|#^HxqefTEtrodT2SFxpZ+mVlwq1ZUerl2XQE=^x)Rx
ztQB)f#5Ux{uuB(~n@gtW;-=a=<xLNc4HB2XzewO&k4GxhzHkP#NIJj7FS(prD306i
zqYbees$ZORR?i6=<mFHt7Gxr1wxTGu^PKZN7?1?^j&>vfB-`!c4;+?kO^R2n0&8J$
zg9{d&ZOyuJM0=A58-?EHr9&JZ7qN5s{>xA2g%4Vg7><WXb=3|h`8gbS=)c;uXJi;x
z*|(LRPL$9_BYSH4Wd`TY1DwH?KUjrWl5}U6lX#WAu=ij9C7>IQY5q)uDn(X9KEOGc
z<3XVtH)$-mlC1qA3~zlAH432etITqOnTO=e!;q__IhEvAnPcUX>%8~D2TQ^n(OFRk
z3Y(@A>w0~ryHiY>>Q7PMZof}dqesY*#9dU8*??}Jm@$s-<)`2p_JyhK^>^OIZ5DHN
zckNW^5#s@iQKH)CKL(ePRTPUf9fyA2T;z!4bQinn`iRML9<}1~i=yn;0>$Shi)SGS
zj@7DazYMZ?mHBuaRW11_+hi2*rkJMO5Kb%d3Uf&vdP;+gUUxysIJ@L`DJihF=RQ*~
zG{0e2uphsoU~x8%z}MK*JDz|KS>9=QD*}TWtM{62C5Av@>TUR~WYU{-TY_~`Yh`u_
zTX9nsiz<RNQO?(y_1k0fL+L;w@oysSN{}QP9e_sMX%0(@v=JTw!b2Vb{UaWMHS3JF
zC74_FmGIg}EC5TlPjtbJ=S5OUJJaK=ff)h^Ip^0ns!@L$@;aMkxI}DsCghlg+z@uF
zzt&7Sg*axjKvkW#Vb!5S+?X7xBUfl?4vdyuKRR{GLwtbjk>oApLi}k;Qy0K#1GV}@
z0|vc<@hE2kz};YiK48~3<FRUboGGbIZmo@99>+$5*U@BH|C<w8``K75%P^yC35FTU
zc87+|Ze$Fh+J!h((qt1f4t`xf4sQHDwKQOHS;pLehPIu_(Wm&kr``tV7TqU{0AO6f
zu}wqaad{bIVnFC$uZwqNK-0+9ytXxOb}X`I$;?5q3CZOFesP_sH43p@Psl;bUYw!v
zq1mPt_6h>{QG0e&dn)S2zB&^G`R<5b&^t5c%yMy&U<VN&8Pt4-*Y!}6v6K8pNNI7%
z?9@0z>Nzw&v`#lpGB*uzx{n;wrQwxImyw-Nu~l&+YqSB#8Zyk=(a08Roe8o_oe78l
z4RUM8!aFBreErK|B^U#2jd#Dt++hZ+#@34a(ju2|*%&}ofx&FON;Mom>{e|#2TQ`)
zSCB@BZKP$Ea6g<)H-_gqZ`2yuXxB8Vd>d(3Dt+%_2Cx7b1FmyS0oV1W0C!O`&yiC4
zCETZ+@^9zj+-qnz6X!1DA(pqhu_wooX=*mr+gkJXmp|z+)ajIIN*hq($J%Y|8J;Br
zTAY8`JN2*F{dk%mUcyaG14;H^Z62hvngEQnTyMz<rEbafrEmLbYMdSPYdCI&SHc_L
zH}p%K<Pz?!Ta|n}UpxPUx+wrpkj*nMh-+`L%GJ9s(z|R(;)l91UZ3+${}e&PFGWs1
z$=}u)y<DColG*B-pWoL!vuECRsBfoc4!kpQcBuh1@>h33_RJT%YMA3xm*^eLIWsrM
zwXTc28Q;&k8{{pXsl=W}t(|Q<CU_Zo%@zpBiRt|wi@zy`(#zs;GGVf9Nnj(IqnFa_
z;y{wzQ#!lg%=&xa<A}}#gV@_YaP_wRA9Kcl*D{AjDC0|iT+w!q@J_<lx#P&Ownt(c
zQAMxX{v3jarX&)Z@imEb9U@V1dcGisoKPjZ^x&y!Inw0gNP=0e&Z>v_2-}9th2!JM
zj87czo6{?ZZ4ckL*c32pSkU*b>3MU*a>_89dCu`3HB&$YUxS=s6~rhTePW2s=vuy?
zwkhDxU|ha@?}L>+#2d@b4}F?|80MMX<@M-y(TL^$y!-<MLbe*`=206@RUTVg9OuHa
zpb0at?XT9W<(N(i1`NKxAdpD=UEgZ8@B2GR`c{n4^44_iS@P0l81da!-XX2eY7Bhs
z`oBm0N#Ccam9JA?*V`rAoaRdt=3Cp}rB}lNF20o?6i8NSn9gHDQzo6L|E{&;W7&&(
zV?bEXpG8|E7e#;R2e%6@1042U(vQB_Jw5@tahr)~bVY1A>#G?@;Ps?{`X5><i^CF<
zN>@VIkDMd6YK)d}A%>$}W+x3U<AUlb;jUa(u&gMvmT&R7iJ8|()J3bmSWgA27=rtw
zc;`#ZT3(8c4QXpJ4B-Nc-~Y;omhA<}Tt~bqn{hqKPpk3s9#y;`vC794w$Ph#D-8O(
zr;a$wYO6jI!py4w)Wy3sEj<XcMEKFBImCl##cqKcAx9bYQTutDPbV06Sknf-)p6?3
zkWeXfnOeVOvw_+*Z+C^RJb5LOZ*~Q-J}g!FF}{<cqFBRB&VsP5pRPIGV~=S~%sP{<
znky7M1kz7!%A?}Pvy#P7mG{90B8U~CSQJCdxi+8&CZlBRv*ox`NV*aslEDh51>T`S
z7*(8Iy!~cjysaVHT}p)#ypwAaau|grEQ<?qXgd01wgp)EzSZJyY_s2{Tkc~L69*8U
zIdlechb&E^WHVNE!)l=)<n!6wC+X;R?_BWsb~k9LJ_p;$#&XVDg^{ip>o#p3Z&b-e
zK<GY7(M^g*?%Lofn0Wbm1U1V*UgyX`Uf0V(_KwYmrUQ$c-W{b~dajV$a&`H+TpQKc
z-p9v)&$0+@Y8QehB&^qr!yJJHj>Em>AH&|i=CcNp;-S5=4U*~jM506@QA+R*j#&ZI
zusbydQpks-3g2c(1s2V<%Z9*jrHoGU`Fhf(y_v3IC%i;#2r{W+FtlA3H}R#7!>cnQ
znQPERW5;lU-BW&3gr-GMFkpHLd_N?IWlQN!tHiet9>d_|g=DPyv+F-l=C4lR_kES*
zzEjgSwu={exxuoy^1Zxn@bx5|W=zh-K;@ACI43I^MMYb{q_BL&WtqGThk_a%Xp9n&
z#)fpwm>9jsc#F1WJmwh}un!$Ft!n8<mq~4oic$}S-C7i3t+p?`XqgCUZn79QPhX5h
zVdLV*i+Xoo#wUua0mE84G+k&s#RwuQjexOZ&2~`#l8|3cnfw0o9x0ZdardMa@%Gb&
zFm@t}v@iQqLvVJOJTJ9TksD&#xz<}6V(d*hlYv#DV|D0s$*~RezqW-Vt!^U@{p(H?
z&2bCD&V;p3i{1SpmN^F(?H0oZ_C+v0brsH>1YHtZH2ZDUm47Te;mi{!iMnPCMC!Mc
z;6dBUm8Fj%wvp;qwG^Z`oo2^Y<gOmom6U<M7Ho}UQq8Y)#u%J5-O4{%(H30R1O_#%
z9KxGN_0X?`hTK0z2>~s*y6Vh!YcxAEBjf(<EBL-7vq)`hZsE4_#|UC*%iyERJ2oh{
zusV6!$>41$5}K(V!q^*`ZA7JiS!dL};{r8plR=iB(NhhhB$<+4{EH2U18$9+PhZEA
z?86=JKw!nFzJm@mx~Ch^apLAQ-@n!N`&B@KdBv0t@_>bi(A-HJLwtcCa!AzjZS8zn
z%HqlMVp_TWVvTYSkzP+yx77449{xD+!?GmsLj!gnYGv0nb|=l^FKhu#t=)0`I?4Gk
z;`y>vHY?-EhET23H_S3aRRR9UUu|V>8W?1Z-DkZ_nHOYB*Bct;+iXQe&L6&Yn;wab
z@qPMf6e>7T%op@4OdOs`-3WBW=SSySLBf+-FA<8#LqU(|+slWTDUj%7o$$5n0pLGR
zZJ-CuR{z<wPTG6^`4Yal=QcURn8xPW=tY{Y8HwzUt3*diA}@$WQG(`|pyugQavz&+
zCxPUx@`~=y(<C#>5#FP*P53MP>EPF(0V*j8ZSk^>>h7urLlO>cGBZ&Wvw6<pDc~b1
zSFLlLDWL>9ITe`iu*|&_A}T?YszRfxgmhTmT=m3Ih7aX6ctg}ody{RfS{;IAgWU8n
zWU3`gCQsfYk%dNPw9UaSU%rim)m=mVFiQT{A)zd}U&K8_u}Nm;U0Wz~VML2%Ou75n
zh=iml-otbyo65F!et4o8gt`S7s9@wZ>?n%TNk%#D=PuPkgq^2Mu)U)OYh`2r=FEi%
zWr~(gy%0|?wX97Wd|Yj&QwN)3$A;X4ALZvs;^tG-?lfU;@86sXe|E39wjIHA4m9^^
z3>$~8kkk0e+3&j6v2rF4l4&+CabChX$Offj7?bZHDvm>&0`Q)Rp4;VnhsI26RlaSv
zlpQ{mgS*PaNE+7P4Lna8=)rrdi+fT>Lwx<!NfQKeSwabz09{9Nw7q&vYoXt-IVR}r
zPF+skF)E`Io{32G9h3CTd6NO8lco??JAt-AN#`f|rTnhXg}Jw<pDn(c#M|R(4~)pf
zq!&RNQ0pr**Mn&8u?zF@F^#qkAzKuLZFx<M^m%*I<Rdw~QI-Xy+RO&F@Ql8?kO#q@
z<r{GG3=ODVxCAUi@#SxaYRRaU$db5#-MWy31;Ox~6JTnKXLwjS$0Dm7Ql+z!TJxC1
z7uGV*nzJAAnZzSk^LEdO9=mQI=ubtx10=nA8q$)^N{`|GHTQ^mEK<&Hk$|Wd6Q?U&
z^f))#59!MGxNC0wLw8T|cr}}Sl%0_B=eeiTDswD0Q3TgJFV!pwF68K46pA!q8u5kI
z1Pzz*P(uAf5fgPKtkyHC7F~4HV<^$>QmrJK&qq&VKB9CFd-aP|k|UWdBqx!to^2jb
zniMXVynN$(gZAgWwbl(Z6w{KLiXy43k>?H}qDa;mW%sn{aJGV1%048_#HTWzcw7|e
zU99g;CEN$!NgwCJJ|p*MeH5@ig~VEx_o7Ar7j^FK><&{L`SmwKz#ft0Lt4e-&#VPf
zUA>NjJ!w*d$X-YdCCIp#JX@B`l;4ys->wHB;o-^MEEU|Ul1WwjNUPDs9cmM^&?H&u
z3AVqZ9otT+S{lHy=x|pQipfNqNI>;%v#U{uX-|JtW|_N>l1+%vW<Iqlgjb4czN|pD
z4<^i`vMoW@l7wUZp?Uo>-_YYI72W8zA*xf`)kAVV^-(BF0=}PWIfh(^LEB<+q^4@H
zQXG?j34wM<+R`8tW^Ok78yB`J9lI@Ao+)p!Ttiy<bADyed|$Fx%xBlle7<39hhf}`
zjSNohExC3ijXN@IrjKXv9G3Pl!DJq#pvQ23%tq0@e!T55wFXpER$Gnz?`SDf@>GFj
zZNsI}cZ-TFhc&<ncTUmBD0byNO_IoPDi5L@L6-%;38wi7DC*SHCgN>$qdPX-@^dCD
z_K&IK?$}sf1QCJ0NkLyZ*x~AIbqrys^*V^48<5lusF&ak?S-om_e}weUZc<sU_q?B
zc(vfR-^uh4=t_+)k5-itt6NV!6Bv1ho1)$BW}ifu(V02p#!|Qywss=zb)I>w?J2`h
z$s4Y^xXfO2DdQw*LNrGZWco$JbYdVF_o?f_NJiKw(er0+LobGbqN7*-rV&rfs9&@B
z%tKa7<(YPWe-LIj#I?X8c9uD<`p~bo(!MzsH_gbL8@rVP-Nz(_x4zFQo$4`EGdWbr
z!J#2ryZAk_`}2rEG4>M#ASr0dKP2={8QdD34m;jipAq=3Wx-5EU`!3R+JzRLjDtNl
zNf&Pi&gH`mv0g}+5_X%HDoIh2Hko46>r)&hUP>Kv*kbF5q9&SfzZyETMF6dIb3oW|
zdH#k%;5#fSVx$9b6J+HC4G~$HVhzx`)l-%WsIlrHMV6Xve@|%Ypt#{0R`~rvgE9Ft
z6{ZfT8zJ4Nd?Rcu_eIgJZ^uw^RI}k{tjq}%Bz#4$^tB-iJ#>CS5nEiJ>2BS|O`>Ho
z+JHj_7U7H_r501od+4f*{x*e58aY45aoq))lgKlB564Z}jeM{xW4m+OBwJS!KX;Iy
zoZ^@1kB<J%XB;m7(d^IqqgqZecVaS-3A9P`p^aAaS43?1a6;Umf*)0UzZxl`wyX6*
zgB^)$oIRwYo5CIHL2=1<G7Rkpf7-my7E~L0)C`Wg==g}rHorqg<MXGQ7#?QTBkNRF
z*`jw%sx5Yez7V5%%G$rGY=q0OMwJi)ztu`GM~e+KL4l$5Vv|K)Fgn$J{#Zk+ad{-G
za{OwNlZfMo05%0zo=?`@g-^vTFp!=CZ&JdR_e;`xM(j8{j#+B~dIn~KKa$y_&;?m3
zC{nrYD;_ta<kGqmg}vB^y58k@)+9^CJSIm)l6s{Hr-%`yiQcJjRB<&%%Y<YP@?4^=
z{Jt~Yg6}3lI*Ay)zrO@=O2s507`5()Bw@k_)<V8Yh&u{>dd`Vu!7*F!oCgBf#@`|D
z4_P<e&vsM_bGc$d(0m%R5<{wzT&&W(s68V2^_rc<eguX2WJs)XhW9_5Lsb|><(J@;
z&5qGGBNtMfQY*;@qRhA7R7I3aKTm}vl?{Ex?yh(N0{SvIOOb0ZN)8Z1_gkxW9e9}0
z>Ur&%!|qNUBXStFp7A?U6vhWsUK52;qko(5VhsRhVeyopBbDg!Of>4wkF0p&(=E{l
ziS0uj#4J9f_s3u3Ow1PBsnu=E^v}UKbyf49(yQLhDgP)ziv}~$_1oiS>WA}8K|W7X
zX#><k)nTirlr!g|i++*S0xvg*O)HB}eow7_KA;08ewfynq&x|zrT}|TAorERp#T$Q
z)8w$Y_Jezdu%NhMnodFy7x1M0vPSZgPGiaNuACOm>Vom0r%LUDku4btj!nlx4ch9W
zSPh-ML0Kiwp4n0Hg&Ezc;9cjaod|aqHGCG|x&6~#U1ai96lZ7!r_C4hP2^W&Z^hnt
z8}bOl6R<lv&(nSmCTeDgKN<#xQ=nSf2ZlpoPlXvyR<+rf_~UFFNZ|-dZ{_b0BNz8h
zf6tWir;>4}6s1Ht5xFR!9G=QY9}i1Hk)4-Bw_bfm?AkwOVYqt6cdPoS-dgPn)6_5h
zwfu`ogq9M`EM{>w@K?AADjIgFr5)7J?8(dROz9w_BjS_7b+SMIm{PUy^O;AKW?6)i
zRl%GtR-G-2Wy7Jcq7*buWb-T)t&e|{QE{ZBZHBOF+POkgWt?UF3Ah);McdX$uihO}
zi?CEfz^#W%XX_R_+TJH7EQYcv!%xE4Fg>ZNLmjTbPeL{bzv<OEOp+8(l$~Eft#al^
zX8R@gj?E2FTlI~U?|99%6>m7cZGH>0OynCtGZ%*aG~6b2J>sCf$L=L8KIEIb-w2AQ
zp#JV4PHe46V#6wD`t2uZuU>>ECAZW%(Bvdcblx{OA8+nd@k5iQCmnJ(+EI1$JfiY+
z96L6qje{SY7{OuiLCUO|x%Q)Hjb&oHMQdrk*-N=Aiber$n1-@wdp}p<&pe05W1W1P
z%kIYOw&B@r3hh2}OqZht#7eT{LTukw;%xRkD0i^w;-Q%;XAalJ7KwOdm0v*4(&$)>
z#OcPGp*N0IH2YYt90>CxtUxVjY6Rhg$D9v^cm?I+l8%%Eoo#4+29f2gqdgc6pemao
zAUrOG5Mv^}f}s4css&>pgkGC|y>(deN@hASMo7zf^Z^+!qB7#!<VT!HRHF857|3YQ
zoIrRlMrzw!k$`gOA3>Bmy@q$H8rp`KP0`}KOSWD8J`KZFYG`@=YB>7>V_HFMniR|*
zcMc%YSK!cxq{9=vtd+AB^wWk<ptTk2LK4)z(P+^Vn`Eeusb43czBcr_<zW)Klg)?G
z?c)R7y^5+ZqE({q5!oUMCzB@fHF`97_?teT0V7ew=I`&}VHiI+OC_>OMVMQtLtTs<
z6@Fyo|DjSU;L^JG+g;HD*4{cE4}A#ju<#?>z0Ek%qtTSixVa8U2ve`fQe{<H-acp=
zYf_1TvWs^TlF1k@xeUgzIB`HLt~NJ>#Uijam&~k2PU}7EA!R3~UjSXpSS=1jX(WvQ
zO>|b}O%=w)tr2}Br{Cvez8x_?h7HVifO=o4-xT~gaK|gxgIV~8yWDY*4YCEWV5?z}
ze+uV~H)hDzq-Nm~nTska#H%UPCh-h%#x_qv!tG0NQPXWq1RLZZFk$x9`5%SAe^pS<
z8^&2q{j(8v46s~;M)MpZPR>(~x0Z>$oBR>_4v8BCa&>-a$uKl=2<sbajp8kZm1#0r
z%~D&<58{-^W6?59!%#P&U#e=2f-e?_ybn$`RGlyLC#uRvpa08EdO{%2_hPu0-7Iq0
z0PU3sjcjnMQo`14fypX1;XgihR2f$t=9%Fs`_f54ZQTj8<vy#VeiK#-8!*Y;?yXXs
z(LmN-is}-72c?9(d7tavH!>5<$_8I1N3x4NbJJLG=r*{FVtkQ77&1On%@Akh12JZC
z-O}}+h}*?LKVFrPcPr$3*7J=*Bs0HCzwY3BZrLKRA(zaiM$YtkA3HHSvRx`%lZc)A
z_rPbYC06(p_8FUB#j3x`V%fF!RQ2C0H7*R}fA%qS%LaPFdyLH^7kEPzC$IAwroZs@
zTMq;07K~j9G?7~yYGrX!0O3-9v_ejZd4Ky@zyYSO1b7NOj**IV4+HI%#kcKAQK3le
zOS<KLWa0=)Ws72bq<jeJ%lOZhXm--)2<XrG?7!OxJNWSV&wz{l+}H(pNC9M0o{xWG
z3w7lPGm5$e?)Jly6saAI)<f)Z1^C&mDbOO1(A;X&y7X7hRz#)&CHV1%Meh&}cjMOV
zg8FWe**pvb7+e)Q(3l!6oRV<xCWj!SNf4c7v0?hTkxK(ooK|VSX006bonX6EPc_cx
zdR*_o`gjcRLS2-k*RijeQn^Beb`-@1`p4(!u0mRRvE^4k8Qz!c*7198dFgv`5WfEN
zBdbeRH3fS|HN*Gw)vYl){)?5Rtl(-M_uKS0n9$KI%>P_z|EtXWht9*n!OZdRmG(be
z_J24&{}T#6^WUWQ|ERS8sc8R?D(!!D{YTdSy3+nm$Y&*D{`*LPup<i*^B<DHUo`xG
zW#_-Q|4mW)|Ea(;|La+RznS{X|3>tGXX-Qk7fgL|2Lt#2o~j?Hs%ws?ipJOKXa@Ni
zhOiEiuFjv|2KInCR1Gz}ep$9f61DNjR5_h`*vW;Rd(7DMN9rnhj(ovJItJ81X*OT~
z_m2(K><qUB1$}W+Y{+mZ?`%g(pwc-v%d)YHAahT~!)fzgrsufpX>)S%5n%P|xK4_7
zFTgwJM>-!DQ0k;b)<UT`{d`|+V@Ik0wm<49<r&~ZuvUO3eR^!BePX12yZsXzYqBM1
zR}IoAin0L3#4>0vSVT9Oh>!=@BLV=)&!tVZ=eOXSIIkn%@$=i)LIAd9*8=8j+}S)W
z_ra0cmbKA{*|=?0<@2%F5t1pzz{OeM1g4Cc<!3j-^SGR7##6}l<vKYuqaSjfo3RdM
zS>x=cMGkZiLuo!vKgl{201?dNp9_*PjuJV1v%vJ6<uIcguNTZ#?Hgu<NpG+OU(wEM
zJGEBvws=Z9(bwr}`9^wva`8YsGoO>u;FW^)v|kHP{xIgM%I@>XeCgF9_7vk+gIN3E
zHCPAVhH)GchMBauOLX35gy~M#OHZFJh{j-u$sc$#Y+lAtB;3*Mm_;6UH(Qox)VU!-
zQ2vxh8_e&pzcjVxf#Nm<NZ`8V?X+s)R{{$f8#Ph|rnq~9yZOrHJ24Lx%-rK_Pj-ZG
z5QV3qTn-LsAOh3jChaD@t`W@9eVw$xsLASNt~Dq!^OVqe6HRk91p^j`Uy1<=-U~&u
zzIAd(G4p<UdHTddJTFp?`+Hw(zF8Oc*b?Y*)_p`?L~VG;Hkm<R4kXVM=cXj@r7=`M
zh^5v;5AOTIgm4hUi8U4ql7Afc=3A_~rk|I6Y)3#6Dl_Y0fhn_N1?RbkIT{yBgKeNc
zH9x*;i(cbD>oCG@<h!qp1c5y=QFL_W!dsD(?dtL0$;x*NJBxbV%x9b)?d`iUODnGZ
z%+QQm*nYZ%Yror`%SU`Lb4Nb|HR$jT!@tEhk9`s2jvEsk=Sf$rv+u|4{L)k+>Ui6z
zDN}RMU|9EUNGKtrwCQaG_Ns@cv0BNI{`9=9k>7}Y>@EyB+^Jo@wXEDK%befR$DHQZ
zfIx>dp_IPVx|Di;=`^BJfz@=)b;dR5y7`*TLtmhUR`+00(*78?6~?>YbKd-f(KM(Q
z?bB8FuTeN@!VA|AM(GbMIdgiD8Ld7>bUPt6%I;#=YA!SrRH#yw4gy?d*6JT79}^W#
z7{pv`tBj3!$9)5R;>^MeNh*HxRI58z?e$3GpB3us^vnmbElTntWiI_HM5;tl??6{I
zYU9@Z@!_lN7sK#zVh6&nKL{y)zK$>H#B;JK0e&Y`_0mr<^lP!Dpu#8wZrR*$4yvYM
z4<VR2<ePf12&cY|GW9E#O+Cadg-?C)692r$GQ#wh&em&&b%wuN3~QYitWCqZXTOfJ
zqYLP2G(F7unr*>Q!lhGL_;nX+iBGlBh7AW!WgS7L!$PgL*Og;}<niccUrx@Z)qwTc
zlr~T0kbKIgF*=_0zi{RM&^MWwnEvB1)jxF2f8})k<?WP+{+-jw{ICB0AMf|K2mgOK
zrxd8F9fGTh^%~DL1lKw~^J|VSUl`;>)hgY9zFJV1rX62rg;TRMhap%SA8$N*Ogb(z
z4G*OL{yV(1T~e?OMECLgv`5!G%#%`yf|~0QF(qG}n;_-2XyXNUyfL|^WxC0P*VW7V
z17I%;JJ+vX2vqTeo=eul?l@F@xiV!m-1+t4;0sQ^A`We_8gJa#_-Ah+nu?bWZT=W}
zMs<o)>oavgGcK)zG}+}UOuJg$EZGLCh+nPcYF+4upe}jB#v_PuydYW9kI%WCJM2M`
zL72<;Y~t|~ec4>_w55qcC~nYhUe&=2cN;E93Z3$CxGS?NqSwS$^HOQ!_`;se!Oi0C
z98LKg3bj|ue$InG$MO4}5$ZdXXnUbEq4X5tL%BA@eJk1O17%>=E0(A5&W%J~Ga?VY
zpxij@ei{?}fC(b((6q>JxzA8ee6HPS^n2^q7{xm{)>SUY@{r{2TCX^-+XsY5D6w*9
zygz&3t2qM8>kuO)N+1sw4cVbrj*r3BS#+H`_XD+U(CkEojQkSqc_$ezxTZ6&v%`Ux
z>N<q%MZ2*!15aacl7*Pwu$r^+hsS1c;IR}RG=Y7pZTiEwUW3jwQX%)FJhiFRx#3xT
z%jqbk1N{A%nA~iXhTqWlR0)V4Goq15_bGY5^tuh2PenL%hN?r^vPzWVl3~BKC{U9=
zTjcw1Ryi=@x$2Gu)K275yG5o&jdiCvC!A#HmJ69web9BSqwW(TRD{f=zJ^&0J5tWU
zI>p%-e%mU_7>SI^!of8#Xuy1XTBKc`C|p9II;Og1<?j6b&1{ix!4<=^1wGWumPl%O
zVkBe`e-*;ABLv5W`r8Y17>;H|aC-%9G<!eK2=*1UEa<X-ofkA+ReMNH{`l2nTaOp{
z8Ka3nqpyWv(GE!Imj!`)uPqK})3VG2&6wCL;mFm^7cF~W=&C{`9*&QbISC4nwH57#
z>JcW(`8;G}+9YOpz8+2%%#azm&l-th-j}9oV}E5it==T;@d;AzISb@Rc%ui=0jYsx
z8OeOf^zp>HG4xXU((6)$()vx0tz$8sx1`LNj%1e@GjrutjSDFnT-1PM!lbQBqz6U!
zc~z>*5FWCkZQUws*NL%oKtZF!^$umO^ONJA#&69j9eGa3^_LW|vG7F>$g4q(ysdMK
z+;zh>gs-qRXYmUqA%Tl%(ty-c3#KdG^)3-cf{2*UEBHTP<)D#aSAa?Wt>4nS()Py?
zuQsV4sdw1<zqC`JmCnhhX*C<tcy@16B!1)r>PX@qZZ|1SI`=VYh7Hl#vb)>I^|~q_
zleDBdwg<P{sPl|_2bsU=yWIiL><4f}XfUP*w+J|bTz4SPK4*9e*`$m$@LxW(lhjCg
z-f`Zw=TNTc^EYa7ToB;8g_~cEsU2nAX_t>7Z}|A{e}5&+&hk?IFZ|j+>_{d?j(;bE
z{)O}Yz{dZ}ul;of^FRC=%O6<!54QZ<ud)0E5dVARRuDTO)yw#){|p#*wn*U8XkqoM
zoA}-g8Ls=C{v?t=e~eQNE2~A-9(`u<OBOl&h}hZzD`nK{YJ>w3j`iaSnLz?k0XFLZ
zBq@e^P&V_&y$3r==;{TPjxY`*^6O(|BN{O}5hidl?4LNv2um>tMV*$kSh%x`AEM9C
z0H+nz^WfH?%7&IQ*$rO5Rl`29Hc8g8*qA{Jv4i4+?##kBd|yzjE#Q!xRPeK$1QY(U
z?xIzrM5$hi+8|xTA)ZDb;#ZdKB%oNJb$!fLqa$TxPhC%2N+#FJ)>TqL1~cxfKEHH@
z*k;eqd4Ec2xeKD2<;C(H&KWIP8Jma8F2xe{Q@s0aRjaqLrzB~T1Xdr7Zw8W?S??i|
z57xfEQ+e7+b}!~afB8C%!ZTQhTKVOFw%T8M{-b*q#=pK*|91H=_V}N~6)gWC`+v^%
z{$<hsQC#s?*MDsPzm6;ZC#QQ^{)?D_<?oo`zdH#Lu`26$GUC3r$HfO7bW5b&2{8{b
z&+0;*81W-O6+53NMqV-LXD=o3j@PSBM=LmituIovGTfc}<m%h$-b=aX%hA@`?R{mm
z{A<Tv(a6!(^2y6ZbcfF~KjGWiK*tlZkB9g3j(oH{|LIG|^2x>0+g*`<JK}5b`#t%N
zw=IT_H=oy&j+YmH{^yG<g11v2_N$K9p%#Y5WWu|><wBh`0DopBL*qbl@*bglW%9tt
z%u)2y&Mt|M+jHyN4)R3w+l9XM?%C_z`rFm|+cN)4N5>oT+vUXD<$%v)&)M5a^xL&`
zDc?&|d;3b}8RnaZkEaKSZ|NpFx$)^}=1KbLa!EQ11ZsP6^J#A9X>VWiZfn!aB78f)
zzrDWQ+S$3hym#n$cJpY~A@C05S=vemzPPXL+`MkNczXCe?_79za-6-~Ts(N!&o94R
z+<4rGn>_~bv^iBRA1!a`k9xYdW8d7q-d{F9R>nl*^Sr)mnvc-?!P&X!$-cGyt;J8i
zGt2dXYlQyoVgckMMEH7sk1YJ8T>PM(fE!83klZ-1T$}f@dExWCy5-qfH1YO;|MmIQ
zRq?^~{S|$9Ut8a<8GN4aqThP1o_ac-8av(?-kzTZ-nKeklKEd=*I!?@e7v7m-yZMz
zUy!OZKTR{y+XbREE-c&?4PH5QtbN-5RkW_~^m_gLc<<5i=GFlMEiEm>8}fDN6LQb)
zoa{W_ySTsEdv>hAG_T|H48B;zj6^S|Lzg)>zqxrgv!2}yjNBZY<jiGdW~I5lT;QRv
z>*+;wp+q+0%(Nw2Wi|Wd-0Xx+=<E5k8ODMoFP}hfyl(xbL|!P`BLv9HHx`1lo-LNW
zUN5}d8^#tW-rQW1?g%-nozDkOATNW8ZtK;b?X0Ns^!YpH)w{bKkGw>O3xR^OcZ%Gn
z@`J2rgd9j}jPRs9AW-j_!Di4r41DsQpl#!V<Mz=@DioHHn$ciyEikA=x(2l{uKe!&
z;d!eea-G5TEfgxDYX`y22gD9rqIU|o!@qyoIkAapgeOHxpP;;TX?|_$(5{RI@qw&y
zAo`;Hlz1YWwLbbrfcW|O+jMRD*YwsOaV~oF)5X57>yb1+92DGMKfZdWY<T!I17`RQ
zwv%&CDHLFy-eB-n+O=_YNtzMc`Chw}Tts6LXp*0_2Z2xap3NC~I(iqv&(|2s!G1LL
zbK@5?t#2@5fgnCz!nJ9IWGkA@H{2j6El#@@qGS#q%S?GxYsNH0eu#I~Q}lr&1?x^d
zy}Ul3do*%zvK@sXuAiy<du=bNtyP?n64QG<TzI(GoZyl<RyV4DJvd2qVL1_738_xB
z>mxH%`aRK@14g6s<MKqz!|-;2`^e67jU2E*2msvEEbc_%02(>M*YpYX*3bAeEAEKS
zRPMro9a~tx+Ri{zm<)jH9&S9n(}suJ=dF4mq(J=y$UrIyB0x>lA#A$HTj%`rh&$80
zRr4t_qGK9LQ1AIoz?O*p`qh%K@nReoN>6h5=;?hOy}VvdX75o@xB)4)IGt$LKS4t!
zG1O`3lTc4AR=Ue$N>%Xk@^9@CRR*j`g?OwdSx3sjCu^`_Tgb~N?=cckWi6w*H!Z4Y
zcr-Hy<DZi8xx4ufKcz=Q2_+TQuilw`(h(HOo!((4ozkuZ^pINSn(GLjt(0_r^zP6D
zn1{+OX#YTsL-YX&GykrWju48Np2QTw*fnfAlCF~>UIuHZL#=}{NJi4m4FcKDE_0s>
zzNYX=c%`<ufu5V%XD9@JFsG+sWlOetJlXqHZ_XY*B~W%IlF638(mEFc{ek{5qi0vI
zvF?r)u0Nh}<}=qT(6+hz_>sIoikBP^cXA3@j^cX3^}((}kG<RJfjK4E+C=ep3+IN@
zH~7_Sc;I&_BBaF%P3d*^U%zXxcm&l_EV_v<E~vvjA{GjB+PbmZzL!<tgfcRs1!quY
zAHu@*GKa2lxw<z+;sau6vnYtqoVG~tLj?;}FJ$2FWlU#2Ib2*HV?mLoKZ)UGW>q=+
z-W~1GS#%$=s`*bk<wrb7f=OherUIn})-HY5jvpUVT3n0W;cCB~odH<Wd>HFf&c{rF
zKk~D^JfH+aX$eQ~yb3$WoaFCRlnocjC&c627kk_jU~0_|#yoO53>nge1%i)c7RKWy
zI|l49JemOo>Jt3l4PY9RlS}LM&NYo|r3thzMH+eg>>J=&N|1Skgl~Cq+pm^8Q{W=F
zctAW%CmB0rGe)m-vEvr*G-H>W@GqEhZed^?DH3PzM?M29Lao)QVYmAOs{3SF(h9<<
zE6Zh!^$lsA@(nlnvD<+PNuJ!$!eKUFp5tp<Bip7<)cG#l-U${r0ON_f?5wIgq!0Z;
z%f$07Iu1U}xC|EZhx@O+$GuBxfm$&~S4&3h2dRdzAJE>41}n#oVrXA+G54gl{J*s&
zTZD-WscVG~dAER2=|_Q*IaAhkZ#R`64;Xx)Z)Fq8uT`5^mIb4C$x6=DS6oG2iNXaO
z`2k`EgiOOCudoanbb**cR8ros7ps)k-zpchwa~yUtMEIm$47|nE>LwJFGtVb`jnhv
zIr}KZ+u|>gCE#@_??<2m%;niD&J7H+JjL#x<}d=j#5ntGz+xvhO^z_!#Xw&^A}sqe
zLZuIU)sN@N%e?xwp4F_CiuQF6hS#(9^A(%fb7E+-w^#IZdtXl_XW!*6)3+a=KKZmT
zdI~Paw2NP!V+A4JCY|^cObkIFJ|bjHU?&Tn3w#nA{XYOSK+C_0Y512XCarl>JNB8&
z{cNpw!P14-1VRR!*cejGdVvs`r|FDf*B3rFzX6Q0dVj`+P&LRi8L^Us-d}w$kDsT!
z?-dTFZTY)*9+7!;%QcrHFZqgEJ72EwtGIyrNFakT7Vu&%5yb#6vu*&!w1HP<-9Orr
zZ8r(VUK3jzCq76F^2&TXbT}e&AW(rUAiR-7bn?p~2SapHWgZ1Q#{@DjoDUF0XG<O;
z!s}(;TFgRgMPll{Q^ry>cx-@`{nyxzt8>`k2}9Z@-V~415_skHGM@I2>{ncOd%Hgy
zgDSVU0JmQFZ<}Y$D;9~TpN30LIH`VnF!>-g%gX79%MHF+sqY!i1cKduAQIG308iIJ
zIESw<$pR(e|2<@HpZF){rA#j3c4`6=atfQrp|FFzQu+|&tEl(A1GCnL_<usS(iFmX
z$P~wg6P2+l;7C&F4Ip0U{Xy6wf~Ck~vuoC}qYASIpgx^B{lTy4%m&fB_D)?;nvH_>
zTYep?i4ZUN733)w3T>YxGB)qSDF}9FUC&Bm4x&Tx#|qYtgOZ#gAL<5(=|Ok@kX~t*
z?}VKt<L6~1HtR|^KVs0l$n!OuW6{7!_A_#~&<hklyk5vcAzKiUfFY#0K%&E8_)d<s
z54#P*Q2<FhVz(d+1wcIZl-C}J8VJTaxDdg#0lk;NK>Rx{8)P0#ktcrN=jPKlDmi&g
z(n}s?W<c(n#<biDl8EqfS$)nw^XaD!$_4Bw?>TiOcCKI$!jpXR(eDc}gS}%)qcXl>
z04k^7`&$0&D0ddZVdj2N?ke=L6pp#a<>vW6yL4U}m{g$!O+2JLrQzCTMxb57W$yYo
zj&wE3xnC|6Hy-4SHpY&MN6iaHX@KGO3ndWb5)Gld4bUP%X6bzdGfi=WSu>`~oeg&&
zSE0f9X#rXgau4C?bHCZ#`5vx`pNRVN>o!%6>XoW`=U;7|JE0upDa1F6+emeRF%#F=
z$=baA*71*P<|W9>J7<sby3oHLUwdbgh)=rejLG)B(n|sjs5I**Q9WDyOVGCXmw>-E
ziMP;73+QRH_i~g+>S?;ZPtm-`aq?F$={1V#dL)Hhy+Gtksjb+<4vdnbyASqE&kmA5
z$pt7rjKOodE-w#E*I%;EJ-3hb`oU#uS}rPd1rZ7#mV3Sp!ds7-`W#Kf$+Q-NA>ANE
z;8}VRb+ea;!-;JW5_s$suFv!Y^W7sE(0!B6e9JbZu51_+zwoX3uxDCsIvXazmbN*A
zo=p$H+m6AFE^6lbrQ43!L+b^jy>OfP8b`>VxR`^mU+psag<i<ZCpub&eJxoe6SY7I
z5vX7+C&^R-u<vuONCpUP^Q$qP3FJaRihv<wDqylHVTIge$h5ob{o$oB>FGo2%hb>f
zFP!P8;_uAl`;`OLDF2&LEY-9z^iP;T12BorcWXKNafEQl6W_T_&6k^<me>FZyK))P
zjuyT~sZJ*<4R9@(3~(3oJ1+mes5zwEKUFWYAdfoKQTUOL{FONg<-C}XSz6P<rLJM{
z`S@#2T0SUx+FkQ_IG7cL(_iQtL~znddGSXO)6lsM<dPsf<&QemGxfM+dcJ-Tc>;Wa
zr2&pwV;PEiV|+=QXvNlaJVAr((E(r;R48bWll|ami3mC*58=+BG;NXGE9tcFh*vg(
zm}YJz$v!1PPAwfmKXj^TmG_)M5Y+R%Z*q<b-(a5*D}88#Pl%O1AWIFx$4%1uk+eZ5
zPgveHF^n7eyBMHon<<f(YmB62VRY=x8<2e<d2?->^;Tw1D1{S9e_@>Xv4!x4q#H=y
z`4yLO(B?<x9;Gbevnz+<&rw^h2`_=2DMbL;d{it{nkTojc@lwa?ZXQf?d>@WK&RcG
z6D-LO#E<uF_$m;5DgBYl7N;{b0K_AvWFpItugXIq7d?@#ydRDzm+5$@k*LoL5Sg@Q
z`DWoz5WI%K=p$qRz=maw3ZA$e+%z!ulILeouDt`jh-2@h1H{SjJ_r;1%x<<rtTmdH
z5Mgl_hRJZHL&$`DhcPHXRe;zoZM=EpD+`bezaPa$Wn9GQjk@tvu|1C*owrh9#}Q$M
zvrYM1j%pGsUa@hTD*do<F8`pDP^);{o*0Rgy=>17&u-hZprJrQw@o@+7L<K~u8+e}
z+6-UVRhS9`SY7qwA(G6H!tJfFN1+VS=;csi{}RneYXej4EE=5|WG-sRUH&KX!@Gn=
zz8V<C8gt$HN4w-z<n+ltu)O##{~TIciC>hjdYB87HxF5)Fyz0=ATS`YF8{NnM90jO
zVQ(^Uk`fLxT#8n2E3Qx+;yk-5eif5giTufhfjH=mlX--IDe*n=>n+@sUAw1WUIa?_
zcbd-JpGDRAzQKMIWP(qGX`jBBn!Q)iBEhKMR>xC)5(DzEwuzfKXv;Hfh(j0fG?(PF
z)ZI1}MHv<h_)xa!<%RKinTJ}=iMp0-0U$}s5Q8~t>7EzPF6l_E^tm)QuUSBs=E*T7
zl~%L#Nw$MAs3^f7Mar^s{JR1`8SgCXN9L_08Q-CJGZYgY<&p<_E7!U)9X#bw)F9CU
zQtlYP2YC{rG^=<u1}fa(V#``*#i+LzN>^|zX`XmLNlH0amU1{D6;E=BV3;ETFGr5-
zK`=t`4l~Q(bdW5MoO1*%;Z!oqNUE#PWz8Ikv7$1}FOQyK9mHw2O|rviBTGh8`p>3v
zP`4>uwj5?EPnz8rM$Mi&UIFNPQk;Fd?0B4$#JP>1^I}&P`k~WZi1Vf`{n5@LBNwQ%
zyiaIhML>?2&MPh9b1=t&IrSB8FkOuZWZlWDH(b=v4MH8h$U*p1Mg!$!`X-I&!uUFI
z!CSFow3B_0EClZITF%xs3%zhB!TC(k@>LxU^IQ~I#$Z&t!<7z6dzAYW%N<UYjfE84
zTR!vycE7<z>`UvQIS$VSi^0_)6O7^)>I5!XNgnKhNk2LZ2nM^%aB>ij;rvUf+q9nr
z(X77#z$WUYD91V-zIZCPN`O)LQd~v5kjQe&)TL5IghB+Ce-I8(^xavRN|R$I?j9r?
zfRd?rh6f@OF9!A=C4wlO4YwKM;-(iSt*YTe6&MN01F=vmwTn1D-{nJ|7<oxX8=~bI
z37kWpzWXnbqCyF<AlSF>p|VgWEKTdCq`~+GR;P6dNAu!+N2tDICqc5MO0Uh!Pn09%
z{TbCX->r}q;HgkfRgy}=RH9F~IO0p`-YUS0gfY0RV?`jI=YibB59XD{Ax7d!Auso!
z&*6Uc=fUL3;2X!hSIm?RDCEPbGG^rXKnOz9>h|zGgD~2S7aWA&+n^$PflmcnUTI51
zbjq=Mus<FcZpinn9)4vm_PIJuKnR9JEeLzX$=&zpgi`LoxZ(GegRklfgAjMD(+-l~
zP{8k)nkoHv-yY(PtuDGq8HGHSLNU^Taa4RT1Rv^&*2k=1Zz`n_#n+fYKr31GAPjn?
zf#}K9Tt_`RpmgJ?u2g9h!AsM}KC9B_TZ$e*_-4lw#VfZeaPj6d1i!^}3jPlRbZ(W5
zJS%L^i^1PJ90pd)FfCEYrAibezN}4pcmv6k73J0`L+MNG7cz;E6rBUpy*xieNcS$<
zpv2dhaWZ($u^40N%c<UHnmW~soGEtHEI*R&f4(QI--O)fzQH~rR^rRHlTV11J|I&W
zbF5HCvfk$D04jrHrKXGdMR{byE)u6_`d)Gt-8X`wq*n|i5q1!!3l-Epd@l_FixMG0
zYK%ZI9$mSj1L2guMon1MWpg)bfdO=8(;$pXi(-rw+fdv?rYKkr(S#$M6=MXG|KdTh
zI@sb0f_-Tp-4nt(PA&+3lz45MWt7xIz!)iX1er5n14TFrOL{Z%OA>waiT9?_f0Y*T
z-O&`J_xN`~UY&A{KC;mpqR0&?R>DYhAQ%bMghPN}r|^CvoHtZsN{;Cu{Kz9x3{bYI
zQO<H&T7;=VO7G<;5aDaplpu89rwH5T(LQ9=>B`pgrM42ch$7AVlI#U>aM}Ehm*wO0
zfw8#wZ>uLb0iFwq+UDKh9k*mpil)df(m@o%+bjfTLIOOM?Fs?Xi|H_&!d?uQ1&+=c
z2`EjR!d{d1%R_|1Kg}zoi@{Pwhru`l3fKe5VKj#IDzX_{#FV@Y0cEpbjq^D6@{On1
z8%#PF-jXcJ6NDkj<58~!amFCm%YyEBjt_E1iPx}Kp@mo>{<h)R5-V|p2T^LB>jWmh
z32!7LixzvcxvfoqT=FLikx+7?gsY3T<h(*Vd4sNdY?6}dXeChYtk>H&F>RJ(ilnUc
zA-bQCUxoQQ<WuPRh$vUmMm=Rh@9@>&6MBgSd#9JFuC~R)%3;u0LJSge5Slk$4YsPg
z%ocCWqVzSy!V7=wDo~}i4^strDuK}~+{=U-1dEP2$aA^BK~%dz$XW~X4jD%rM;H@B
z0J=M6E`Q5Dq#8h&o&&)HCgqYBxcC?@B9TUc+082mnUNa5@W}6_<TQuiy!Zs92E0wP
z-O2>q8@ivYiob<<$rlKrbynO!^}kq&s?0X~94az+&4WptGQb!NV7UuCO*c9S?XE>5
zv0!nbR4fuqE=kDYXe^Ij8Y_o=NXP30r!YCGYF0IYloc2kr+MVWDL|Mr35o~B_uPh1
zQgAayy}=jF-bvt}>^;I6A*M3=K4+@$;a!eh#}FJl+Loek+ITV(1$<61yw3$e_O^5>
zdlE!H>)9rLK?X1kCwXWk{$oklAY78Gd1w-GQD9!c!Aa%<WI`Mw`5~QlF1JbWFGayH
zwSC<WqZ?KA^uZ?535U8bsb(j_bde3R-;-0gVfE7S@zPyS69J&}()$t)7AJj;;=H0{
z`f(nSLvkMWxk7hp!>ADx26Cz-H782fd}CtjOk9+Ni|#w~ViP+~2+@MP$yH>MQUhvK
zG*fw~dJobb{xO4@)Jx3_CJfFPTeH+}+Jbp)9!~j5zK^!}38qo_>!|OLv;~Q+Rs&gl
zcTJ+TVe-y6i|I_c5ZHWBPyJA|x%@F16O2nYEr%43!ZBY_A4t<;G7NFc=MyY}lzY`~
zCWP`8SO9>#tiAroJS^N=7DpBj#6k!K;vZ_(AUu<4S`c1S7D{#t9vCJG@zMiyN<LoR
zTaa53J16U8vK26o%jSD|bS3Gej!9KAWVm!<+{x<Hm!OZDRAp^IIM=Cv^$LnAwo0nX
zimQc+Ix=?sLp#<3lVK}^#AcYPc_=}58kGf#(a4S}V7yQIYi<$Eh}5Tz3ToAqnpaeq
z!L<O9YggGjAyE)zWxS8))%M#t<x@e@ytw{Fo@PS(`b--0Qe~Z{G=wG_@+><uNX)!x
zxv=fY>Fn-&tt3wn#DibEM3z_b2o-fQwaWxsm&b7TF8<khOTmV7g+XlK;Bu$!2o<Uw
zG;gv=OGCauIczebh0IZ1_~N|%qZ(3>Rh7&`Jz@)+U^v2I&{)ErZSyB*jp{h6by&{R
z9vWxZFBE{)=WPssg8vS}Wui*QV~S|@4I(}H9u0~$>M)C?*E}Kq?7Xc`NuWgliS34P
zxp)yB4ogd^#nK{N1|+t3n$}LGw`;Ma6iL(Om*n9|s<NdAWZwoAILhl9#5VC#K#sUN
z?1#9T_DzI;3*-ntB`*F>&Sjbk4-$2X8a?aniSuCzTC+JIwvL`WL8F7<ndGxg$c<^t
zvKGWfMn(mO?VapOO`Db{n0FZj*H15V$5$N;#@}linRt={2vP^$1L9aH=K(||W}o8@
zQY@`rI>X{iUgeF;38<{&9*`x=f=CKc%MV6kt#}NKkB3|NhtgRGB0T}cyu(Us7lEga
zlw3IdLiUs)22)?Q%X~rp?L!c85L$5t^*tgnh+O)ZoIAL<KM+(XEZKEJhH0>>ZI?`m
zn*iv}LSV`sW1lhnQ7cpB(}JA2>=MJsbg;AS2L!d-qcq8y3J04NW^$B4THJ67NMZ}C
zZ;K^Bh=Z#lJUm!#P^{{bLN4Eg&Zh5Ww{BcTnt>YxX)OAbT6LC#G`gm9z)-cVGbSOl
zAE5_sHcN$e3~t}H9oFKFRCWfhlzI>y3Z1QZKZ~2}ou=?%X(}blP*@%&g$}L6AmqJ4
zzbZpp%FSL136Ejecp0n;O{6Vb7LV$>_A&fmlLN>MWrDdYJpa5PgVtxD*F4>ts>o+%
z^x{#~ycQzG+`;gVyIG-RK6R<7R68Z1W&491=UK#by>mzsdJfhRoSdA(Gq4pQ6G4E~
z-l9Mnd`b13&Xmq+D^13=RJ0cMxUx%W3qe|=Xbb;2;r3r2!flTS^sBso8}kj2njmL!
znS;pm@Q}(pN*xvRAwb!mA~g|vjSWVXIIA<ec_Px-G($<+x|)Q%ktdiNGj4Y9R`o9O
z@`6<AqUnw<h$ktPM35Kjlo>HFNe-75cw6s6utD;=q?=GTC6C{US=1DU*g~!h*mEg6
zT9^_^%{NM%0OB9DK?PaK*E}JE3P<y@E_zuM8E6q_XcS-C#!K7IU}XZ%T_4mvrJm;5
zv)diQWr@Sk0>Umoxa)zR#`BnezPC{%asj_l$}-KPSgJ~<PjI-M^E_G0WCaeHo?k3Q
z$I+Gp@yD9RWbi8naRPd<NUv)^iJ0WV3>5Lj$Q?Q1OzLtPXm5w}-w9YupSJ_z>cF3M
z#n?Ap(N6aL`hTMe9T9}qs3$du#-`C+j3@~bGGp-_C66G>4k7}0Hcuvd-Y|$d?fD*L
zYP}w3)M*3dwKfzt;T0ukyn-xBh7ld4RLdbAX83?188)k$+cf9qtD|O#^Nd<{xP)WV
zq=ba9gROxy?#VrC5L7xH7F)_Yh{RA~Q+z1r*w?^nanKV`W+;qjD8ouIhIGpy7(Qhf
zjI(-1X~%RC3EwXiZyu$b1g-Sg+ND^|HhEz>tOj~6T$xA>Qs#L#iarE(!a0HUxo<-J
zTOgm}ua*&WB*tVg@u%&cN?9eel<**&L;GqMdDE@Gj*Y1eN#zcmcgcO-&d}Tu`Ee3*
zR%%{#94;d?WTZiq+J>wGh`dZ7_QL1Vmf{PL7+&(2eF$lA1wv9Yz#2M>M9wHpTjpW-
zr`dp3svlR(&jsPPwKk)e->33U)Jl$nF@5C9IVWfUIu2S0Pt>K;5V6KShf2bL5169-
zgZ2^*M<#cRbAGs(QcPKsApGODDd19bZ0ihF;SEKB<3a%r%o^z-uCUMd?!1DkO(Ubr
zp|pi8z2agC*N^kYK;`I`Y-?H(ysvT0aQs;biw^+bM^E!%eBLw>k#(GsyS!=ER&R>r
zU{5?OLEDNLV~kZLpp2kRMPcsBZ5<99#Fd+u$KG)<e&4I0!Z8X>8tk2JYtzNeOSet>
z$Z99PLNEPwcBRxxAD{}Sa|>aVaTtB22{LZA_^xZFQkM?^;bVU=0Z(T0B#$Tkxto7h
zBwhY<L!*Sy*_756tP&TNUG!NY$8;2CrNodNjFV+g;ur~vb_tRz9fT)!=INg3?h2f;
zsWVn--lqBAX~e82|1<GP?6%Itu32AT58oi)$G{~U&KcoW9geE(N`|YXW`4#}3WpEW
zXI}Bx5H9E~uJ_XQ7>s<4>3}F)hY1#1H7WgQ5v(g1@Sg-)c6B0tW3ZwnKa1%*qr?(c
z=67>t!xD5=6Q=|ULOO5W*=8ltN^#SN`Q+DnFKcfMLO$>kh<xG)q{4DvWASPuIV+i#
zAAZb@kLl)i=aVAO``AJ&9-qsalL8S;4r^C6*`~8cZZ1mZ)SmwqjE~(IPCjOP<XkJ{
z8$&AQ(x?1wsC$#p9QhfT(>8*zGLbuerbWLdyG=hGgS1o$+us)BENojg!$oV>6_cD%
zDv$tN2)7Z=Ag!?c2wJTz+J#i%Cb6i5(H3WMw7&8{ILx7%cauxdI?CfM%)5~S|M=J{
z<-xcxeGSKOcdbM{m5^+cZ#51D;jN!}SgqEUU_?>N?1Bt`%-rjOIyjk%ZwT)qiGVjs
zFf@U6-mty<B2BCF3nc$Hy$m8rI%_XrAUth>XNVOLH*(J+Q%5!9$#qzAJ`h}Ra>pgC
z83kjWf7DQ{9))7%O+!?by7<=dj+uk3=_UNl!#UcLqwg>RgwKVZ6b2_YE5$|y5u0t2
zts?)-OtAQ!8rFS#)}}Dh!<n)Lx+w?33M;fO18|rp*JTiTPt;C9s@wOuFS2dgSJ2-C
zpuj)6W)L?oLM+e5m-)l49tb1bxb5vm7=5Nv8WrSj>MiT?!&2=h`e)zqDh(%#f(;m9
zmp`!GR*&fmNlHftG0#dM%<FiZj>DX1o+~77FqB2EHKx@UY<J;M<Q~oK0J&n<e5JWl
z)Dafg9W?$&+ic_Zi@l@-$^sWP78#mWwPUIYj2mv7Wm>yfKIiyOC=`2mw{x@UvF<XP
zS8;%ZS&IcI9k^S01!wu^92iaCA`87tNdm)hZXE9l?YLatsbZz*m(tDn6Gm3%#WlTR
z;YogJg0);xtqDqez*i{w((Tyw`~?}4N)qs87uraBs^CNgel<d-5QvW0H`&)SaXzOG
zoKz>?(}jj~pRsA2+5-EgN%PxOg`T>Dr;d*9fz5?6N8vSV(iO(zBfQ;~^o*rfm<<}U
zUCRef7YU9t4joOJ|5Fet-XVZLU{-0=4hu;d_>YjU-rT$>r@yXIg60njtdJQ*>w_`)
z>d#80rikXT9sDV)^Gsj_y{YGRoi^+a2{)e$F@UCqP2%PA)?x}?K|OpilO2T+bSqug
zrAO-hliZZ~FP4Idr4z7#jt}(4r&<eIozqh+5ag*_uY>ebgH4ue)$0VtP_puq0$xbl
zZg-BtMzJU5GeCA>qj`{`SOJEM>nrTa5g+Wx@1CFdF6GVpD*3+w@}V>Gv*xD|vsx_Z
zj56vqr6->vC`itkD(old%f5H>s#d8%kSSi})AQ==G;NSk_gso>L2+u%{cvSLXlWYO
zD5f*d@i~9K2Bxm#G8TxUUK)cf!R%ct(@fY9G){b)X3eE1O8Azc@4lb(M$<|{VLJe#
zAYtOai`ANykDtW@TSaI0|H^JGxtt3rdBdVi_1W2cb?!sCBhDn$s8C}~zA`!NBq0mQ
zx)gMBBOs^T#WVD^vH)q={KefkV&Vs(8?=sd*0BPT)41rrUDE$+z=kTeuszM|&zS+?
z>tMw4vDI6u3kdNGe0FtbIunecZd9h;;i%=qt(-({HE5EeE(B}Z)ORpsCQCNOKyx}k
zN}==AT1dVo2qn4@xUca*LEx(-YFpxHAVBeD1=6-H!$HVfxogyYO=K`R1A9uOU_j?1
zebJU?Y6^r3(}FM?(=%}CyOk4b4xm;e0ql1;m><I-ll<br<;PXisEJdfK`tInryJ}=
zzeQA8@?Y5A?tBmF*sLLi64GE7&)aWTCAzDM<E$=fV94wMJFhN|E%~)|Fvs)kdwelm
zPAnLYI1Uf-r9iBs=W-Bf@Z6H_D0<Q+-c7+@@kM63TMZ{8nO=?bRevX71uN!3hNCwR
z_f)`{!st>==9XUWZlfhn&Y@xrxjyq$GE!qsT=ROXW7VU2;J)vDQ4JmME9^Hx=A2+4
z8Qf??0kXY1nByQmMzl#nlVPK%mBZB-KM4Qsl=?G)OAN%YGV_OFWgVQ6tLMf<yuc60
z2kM%lR)@YvKq0?V%OD$lVEEG+mt-ytDUYf3rj?5OQhw!gN-;DKCVGz`7?%mpY76NQ
zAgLxxcH!e)2mwMc2@2~WJ$_n6_!u=u>?+4xq3X&a=iTnC)>?g7R%Ra)lgI%gDZgb#
zOI{ko&=u91mF;OCK?&MIQx>voIKQ~z!ZIyVuN9)YQ+Hl4y5oW<t!X0V@aK71iGrwL
z*gUw8bLztp0%@q@ENGoP5QzyLngtl^31P`OIVs@oh*3M70S=E!K;QGnZeY|tv}?e9
z4-|T({uspsxn23ccGVx*xOR?z0ie(wABf9SOtsjOD$Y0^Oo}xaK1lq-$}D4NDc35c
zN7N%Zh)X52;Kh6e<io+a8jE6_4iGEusfB7b3+M6_m67aHvH!S7B@q*gD9#nD2LbKK
z4oH4wK|hEGDYi?Tf>{q=te+u1<o^W0JGr6p>PjmB5*kHM-HJS!7ckC2Y|nPB{D6Ih
z5YAhif(s5q!&$p5oFAfcsaXM<JCAXy6Y)zXB~m{L-sXLUeH*o_xL@b}<EXAhEbJw+
zl+Yi*GTcI`D5_msw{ZPIwFK8(h5_6lDv>_%01-5V<6ubDD555TyDMNqb11c>_dc|8
z<~gfKf)rOW!REzG<3_O4=^SKEFh-^8@S?471X~+Z8Qu46nSN+>wDeK;4zax3Lm+H+
zTor_XGzN7u+09Gye00caKN~<3dhMtLvX=g?A`*9<@_3Mzn_wk}dA)VRCQc+U{oAx6
z8PXR7=4zPr+0)k=Od``t5G?&^P|icM0ICTD*xj-<bCaaD$gjx+*7L2g+ClKL@<dBh
zBlhR2AWx(1NU*H+!ZaYgbhWT9|A7K2qRdASZG;Y+gPqG#4=tf`G)pbA_PK)YI@jBP
zI(faf9EDu%&asx1#`MBZyF}*-uxohls_zbaujSt2oUa4X=GivWzsm}C$FO=WST5dh
zBHy+vULevV&0{B&g5k}XrnV!B-Pd65P?cVTxW^cTU*7*Bt^bZjoSC#zyTn6$fT%>K
z&@@(`qC#9XI-}#RJlk5=`7&iB;!0C!ADko4*{GyCw;8`_>w4XdSz^JE;7S>Q&BOfb
z*RG?KA7D|^qmbH4Fjv7O3468x$WnUw+v#6f-qu1XVHgNKw#EfQqi}=<^e@etMovEv
zwdUo2P2J8A!@YSr)skr^&!ubapQZeK?`PPzQC9jskIq2$J+3fr=_)>*5i8U<65*8z
zuy>j^zb?W<1195p_JGy6rGl?bU_4n}qp=x%?~lywxtdzGr#_V+%K!?Z9h$Xk9@OLn
zkgSjlS!E8Cnq5F4gDJ8u-MLSOJLynK;SmQ+kG}8mi1pfZ;norP6uY>hwbYUzKGm4m
zjPKF+s;Fh#xUw$kbv%#~u0irk0w^<Ck!PFAKeJHD+F}X48fVZEE3Pe5-0ASdu87p<
zg)Kkl36Lx$s$t5Ef>jz>X%+{yM|?9*;`}Ode12_LI=U3Y);PFP`qq4(L+p-4Is>HE
z7fO|-L8f*I=J^3ICn%p8E_dxa2*V#P^R(Kod9rMW28{VGQv2Qt@KL23N?p^zTKGJG
zMkNqxtak<u>7Kgpv9o03TD*i%r%gjQOP(QQ^SO`401~j;NcD>@oi(UJZm1QgoLQ_3
zp@e@Wz(a0qQi;5~YGU%p<{LHAL|kV2EF>#vKcxUq=_s~D9r)tWQVfkE`}K);?W~@=
z09wymx-9m`(YU6&6&hETXh|Wf+?a-&%|BXuNaIIHpbjH+t^BXi{MmJ&rG0z1AONS@
z^lu_ZX@7(L7D&GPC_XkS=vEWuy9eXW*o3f19zGsp19Lmed6eD@py==H1@vy~eXy#S
zEf@sBE@~Q8k*f>EJf(1suXfW=P@}l?$*kQ8*{x3u8A5%Rf!{UIve^M(n&K!qk)4it
z#F%w0b)i&e9v%VFm<NEKG4udRv4gNlv-nM;Oe|HFHi-<PLhY6-@_E!^5Lp7}T}<?6
zw$mxxD2LkJX8dC~DKC`m0>Butw#shVavRU-P`heF_merb8{`gz?*d3BgiKzeErD>d
z)<GYLmS|8R&Un+`3W<YAhId@Y%(3VSGv9W85GJFA+X~IYu%UtEPj(qm>EhUz(@+g5
zS}55b(zWK~4GLZU#AOYi+){3JW(9HVqc{+A^YGodF*b)+tQ6m|etnN+$RNbPioW4F
z-ag;UrO@{Wbu9XB|9~)79oVUQM5}p3*OIW(jT9sY;u1SuxZGnBJ4}`Z4Rl+7oR`%B
z$#45O9&1tFFnaD9;bb^FE-SF4;SjE73o;ror%*==#10sYMhJBj4Rs2VFvbjnWb5R?
zW-^XeGs<vWucM}u;}jmh+lRGDv=ALS$FB@o{`KK!r4&mMGAH>MWy>Ha)m^R4>mF6Q
z7d}f%1Y>-lAl+NFcrsnzOb`Ou2I%#_l=6M=3(R@HK>q5yj6Q=A|1d<=l#j`m+HcFb
zfqT57lTP9(WmQstq6mwO6K1cY9k(4z=<^1n?q;%EyIW8V@9GHMmSW0}i~8d5F#-)0
zOX9I<V$PogrGw@L<|pO-Nwf!H=65UKN|Z-(k{h@_$DBRhqpxwRWaFBb?ucewudIAr
z*WZFbkH>@u(0rM9#S10*{)BtGeUX=>rZr}@z%D`+VGDeG!~${+PQrInx`4tK(9vTh
z{zbOL=W_n)wkmcm*BO96EW5-bRkUa!>{lMLu$ZDcpUXd}C?g~}x0`)M*1S<<Ba{MY
zttrKUWl}1AE&W0gii#zs&R1sp8s%xEB6h)0VKUsFhg&u)7HtE^Y0D2T!_X$BVnY|h
z+10rg;3^jk=Z<Pb#|%Cz%nAbtKecE97Z}22xr!vw;4(-DCGN$95?;Ww3()z>#XImP
zZf-q-y`a)xD7Q0<Jd`PoI!dQe2L}lUMnM8?LA0gJSp#$zm5u<hz!Z?JLGmI=JH>wd
z7W*oWq=Ckwk|}2ng^#HRlZJ|I$!rzzgx@u_=EW@^%npx7034*}LK6Uq);`nGW@5R)
zT($|oUy2)id=bFE_1`B+7wUS+k=uk(>J==js|1BaHGZVw%HS@wRt8oJ3g+PoL3v~F
zTBVzE6XoT#PnQMf%9PVEyhkL<_?`lE$vxQs5S&pC_~bNHgv$#f_VW07=)yNCiIOtg
z0b=zGO&^*3l`km_ETt%oS7wi}gwZk^>I1$CqB7aS`K>4KQf98=kBtZ(%@<eD!VTh$
z)Dv4m&@Mh!tZ%M-%?y}Pys{n)Eym7oEW_yk5|Atu714s)3zNR2M;7Q~$x1&Z4OdCE
z9tvA;;v{70ovNiOn^y4wuk{so{mmz2ilsrsJY9BL>PwQj1?BaIe=??4mu!kPQ#X@3
z*Qfo%F7t|#I&NnoYL_Q9oYYCizzMPC=cilf2s*hz7=bSXz!_^A6O|{B_;DeYu<exG
z1`ylLvV{wY%68{ac@>?6@mtNpHc$Pn*uJ+3I-RsoDcqb1<Q)c97?4WfUJsWY!C>fR
z6C}Qza(8Y<l5G3=Y?=(=Y3Vds9~Qy4c3F|Q4C>3XExlGS(pN=FWB^Yr%^$rXyoU&4
z9XVmR$n`$#C1w`)gV;cK0>=16wa>+JGCt#6>5Z7Mz#^oO0YvG;G+!-rL9|mH87M~V
zc!EU@NPRdV;#lpSx2fQw)ICl{zL<iO4}`kzrtHnSGfHrJDo>cc>+4C#&oXYGA29Pi
z<o>rnJ~al<5B_NfzD=!3iK#44yQc#73Z$def48SKYZvMi3LDTb(DS~*gbK{#F2o#6
ze>s%WCbI2L&qt9KfFl~mTz|@I`AC@CGl#5EI9{-A6kEovR7p$*;ygRyeHl_*%ztub
zUy+_fZ~+VnZFhKLZyr`}Ji99{+vl(wkzt-1#o??bc?yVjLb3pg6#JHs;=dNA6{~-n
zRA4-iC@|g#VE>)~tR%WF4BNo<{RtnGS8f{pP*ZDVCG94i+d*n?3c{i5NNjRh4h=2{
zJK?AqqWq!?G6HNGZmX&hMB)C-2e9u-vECBvb5;<=(r1-oYsc7{-DIn1<zNlRc2!z}
z=!;ACSNbKEm5G=8>mNe+reR1P*q-W?((1c)+D&Ebk13tLqH=NmNW}UF9G?B6Ae}P^
z)zQ;#J333<|7ua|m^?)Cxqp!1(1dW+>h=$x2$xXrw#xYjp9AVC%VZJ;1t^gaO>5Wb
zFK$sB5^&ZIp6R;DX+dz8`eGc0t>N&-j9Jlf%f9+tY|_<?Sk6nc_Vg>mp$b0}BpwQ>
z24}RIwj`9L5`yXmu{`bTb8<NnGqHCisuWx4o|D^Nsksu>*4*=+%%>xyG4NhLw31w^
z-86<ttEB0B8PJ**S^%@cMkP2D0x4rv!IF0PS;m`pVEf+W{<lD;G4PGVCNakennLGe
z#Dg<2(Y?G+3?O#!zl3`a;KsN%g|qTR?VxqKa8>P;F>OI~Ec)F)oXkHUQFd_uAjrdT
z(OlNd|H{W0B;HeZKmSlYhXS=wI6?$}5@k)MM2gtn&I%7}ysfe6FzbRyRIlyBodll~
zXwE>}rhpbr>`u7f<GcZ+o*NB?t4N8F_7J&%b!NF)zBa?|BhnT2#P`GFZI1EfkZ4YE
z?(Q}B*~Nm*v!_b%>q?2NB72?Q&8Kne)vp~&6k!Mmd&6$*!E>%rFlaBtS?f*ZgSEhv
zA(sTePm#uU#ns~;!4gJp9=+TXF17V2J75~CuN$K_Dq<JD=(Uf=h}NnPB$$eyMN1M)
z6go`l-x_^fXA0rSdSt3Vei#FiR6oblxQLn{y!Lk2J&DnP@d<Oa@nnbE0p{TcZ@c@A
z1ay)#3_H_GVV9Y#`QuP-ol-#3i+!UwKrSc#sOl5q`Iv1n)$8kKm30`Ka7epC(%*PL
zzK%V08AKa~?t^iu%hPU0gAr$g5VbsIqtz~A-3;sb%c}P=zV_;UtkLTN0~7lb_Nm}_
zkw|e?eLp!Vr}Jldv&nC;Z;)y1uk&;w^LtRh*+s>w)VobouCj1=onLv;>mr^lTo|OO
zGe4QPY6v^B$I1<2@Ji{`dZ(&gTXBhj+yne^D^goCaJ}(CMCEJm&v{JQV;Q&g>)B<T
zdz&KGX56)U^Hg<U#vjIJKI%}->z^bLeDYIguiBrlk&$&d<-(Sk8xL6zqIkONM2Us8
z;#*O4NobliV*voaJt19ihJ`na=Ug;Xml=i9tdvI1VR?=Hsd#e{3(@)T-YVM|U@0n}
z-EhSG$Be*IXFD|Zrke)g&CdL)PkFp7-WU7N!A}ayZBGh&NhG}EnHXFakDJvt;awWg
zQNYw@ED%b&IX$VbUKHMI#to2?%={+MYne<*EqM1iky_h?<FbBr{K?!N49I4jZIa`C
z1rAty>eYdHZhekVIzI(gh(@GL4&XZ)guA>zFy4vPMf3}QQf}-H0Ocra;k+cW#=E8!
znr#c{Jy#ul4T=bGFhUDaID8#5e>ADz@8pPEr+>sVu@^L@P#~uycFd)5FTRz|6S;2|
z7A!RrOjfE<q<v5K!m_iy;5QDZh`^XMqLup^mg~8UU<BlJyZf6nfl#2Q{kbf9s&(we
zUSsOvFAG9hB}zIlTAC9YuD;8ukA0KfPl&^QNb@JeN*|DH_UZR8PP8fC;N&+DKZFII
zY@}`zB0Q2{6MK!ZX~*fa7$ew$>5AiPEtet&t^b;v5ekw^)a>4ZCW^R-^vcg+x-K`U
zJ@>h?&?2xdKxhran)n0VA&P$^ZnhFg5r5Mv$`&b?@^S0Kot{!BIeQ?|krrCalc9;N
z7_sK@tbDS?9m+LGkea@dX%G~k(|BkoW=kNvznl_|6NjV7dTIh4xQ3KJ(E#u+XV+Jf
zx=3Exm1oF6X$Q*=wG<bC;CHP_Ph5M-Xh59?AUt~jt3Uc!ZvG-bj4dq<0|gURDY+3;
ziF5lkGP}*7r`)iWX?ft4rEBab3NXM{e6;#Ib}9a@UP-&3O}YtG!MVj{;lcpYa|N~m
ztuU=b_Z8`MLCe|)Z+ot&c^qd1GRi46DeSoY-qV33(IEvRCCO-@#jkzlILCA4@phkX
z$jyL)&~-L|1U=j6yvUnRZW_{kER{>q@fHrIMe#*pQ5T(b-n4W%huQ6}Ls4dNZ;m@I
z!it?G!J~zX9J&Rt0&l`0qqWb)nDf-Y!jw_8uy0Nd;!3LJ7`5;)Q&jSy+S$CN>K_?Q
z?Ue~w{w=5MtH?zF;-r_RK}QPzHekYw1y=iw-i+%XcG-@j93newCX^!)Z!(G66L6dV
zX3P8og!huU=w_b+!$7v_AN5c6qGp#r1bL3Z*O668XBM{2%5*hKBPG0m>0WCdcB=y`
zh-;wD%XaE|6sJ(+R`NL>9XGd4%~`Z4Gu2@FnB{97Xw2IP&~?%#;ZZLK52l;ItxRUN
zJLhR_c=eYo8Fyz8f;W+1k#;ksQSJ;_n?({LbrM{_Z{AJOT1Vz>oGg4dOew1mSdS|N
zk-Kcu#9bH(LSK=85AYC?SjP2LSgPGA805OU>eOYL16Ts}DOKFqIVkk%C(efIDV_uC
zDo6L6A=yR6<=i?p)hqvP0TAx=4j22@YaMJix?$By9EOg&AhUTac|WH&KVe*Ibr)Jf
z0o3*5F73c2ul8w_AOeK)?~$G$S~5q2T!y+~qstht^C`)NC;mavNGJelZTaq+2|6F<
zYfT`1G;qk3XIa`fgRtG@6?BI%h!p##p&fcQDnDVg^N%9tAlhd90~aU}H>Mnudmph%
zx?_A$0*7VoT5L}i%mpaqk9Cz=Q=aM7Arpu57*cS>dagI)ZP=+x9fZi3ChFWT5&+cy
z<y*vwW1GUk)b(ji<>u#5_=Mj_Y22QNp~{$r+Nn(|69gSb;l|8Z5dV8VW(vp`>F#4k
z-mNrw|NL*O{MG+XNAyYuMA=5Z1(x)d2xTW$f;=F7XBST*AU_8Of~bv*O4BfR<Y!8X
ze0xd(X?w&vSS<{Dr-29!K#lg?2QGD&4u?QuiJx9>z{@z)D5_Ay2T1WLa~z~c-Q_b2
z7-A!gaoR$~26UoYVzBozr9Dc4HTzr;zH5(Jtg|S{e)YoVQa!zjkbv>S9RYTvpA!L!
zT(~D+C(g*1N(OtZ3T_ccQl`b{pTY&w@a&T%kS?b&$!L65R;0{j?$H2A^A2ZpX)p?r
zR-9g<`bv5A_yE%%|ECP|3y1{1%LWGPx(eMPtCO=u-WVXG^V2qhO@N5a5}6#%CX{K=
z85J3`j<&lJ$vX@9w!_L}osU8Dt}h$KtlO>6@9DLnvKYKgdI7IZHW*Pm9POnaYt-ad
z*sbHL>&6zLkTnlW)as$7eNU9&(u2Ys4h?&UBaG92t%Siy$6h}uX&peMk{Rl;13PFb
zu(W0ms)zzWY6h$uARfStRs^9k_cRFl5Feid6B72w33<p20l0zTbB!+O7^E^me2GxC
zc?E-g@1rRO_}}JHFC9v9fa2KF2CFx2UQSYhfKgaHF~A^YPJ`$I^v1}kNVO$ny0F*x
z;Ji##Vz*-75vY_Nh^$mEn0%2|Z{vIg{cXUJdv-<x;nrTc><^a0Ydy`;_t<Oa%Zm;{
zK}v3rszuEGHyY(J2NEBLyCTJQ$<yXu;#mmm)k62Dte15QP{3|l`OfkQ2NvxlMFoZD
zxcgz49!rt;Y#w!^y@W*R$)P#&ID=IjWs<W4K`Nm-Q;@x%Fi8HQd7MfN5%D+;r6HBw
zd`}D*q+FIoFjzbupeIS1Msw8Q5=?o}={Vn9-nJ?BlC}lGPQ6ms7%Ptp=;9JhfhZWe
zq~<w%2V#)V<&Kw!+~@W&?zo<_mbL+6<BhXSf9_aIE6kcTAN)X63lb=L#ok6Z3sh(8
zy)8W3*-AU`Zh2Hu=X0gSlY1|%r~J1%OB#T-X`1b)pPMGreMC&?OfoFRmd%(OC3rWl
z4V0~kpNUw<rHaa04w5Nro1~@Y-vbk^^uQNNci<!{!vZPvY&(Fj)NAtyN!=ptiWfrg
zi%5EoW}{#VF`3+6E!&ucG}>ii2N6Lwt0V=x&=|}f<?>9&azPjar;EWH`;6NAPlAoL
zR&U>3XpVW0p0m=L(tNGhqTE8Oqb~*%S?tk@L23x<xh+G&N~%bRVqVqmgQ-+jhK#u-
zBzBNC<f@QNtXfSvh^TbaXdG5{AjZ<-RSLxt7ROjIcGG?q^7O@5*l&SMWl-+2q(_bQ
zw2fv!l})kFp)y-RwJs!%qFI277QN3XRI@D*eXH%ga11gB!ez+EnCZp{BGoG7_4H!~
zHxdUajcFcp#_2d`=0y5jd8?W_8|7DjDCrt8CJRA~HH{~(uj(wdIEp7GS}#J36J#`u
zfpa%_24Qq_*L#wW8yiAVG^r}hR#RXAnjNWx9qy@|Y1$08OaA5BM;e9SEH0v9rx@Ml
zP1W!?dDaJ)Ys0ZkIcfEQKIb!RNe}RG%|3Qnk5A9<d93U}Bn9g5N@g{QwS{B|Qv+~o
zkGRwsPk`82g_X1Kk0;y+aZ38Yn7oNKUj`smV;!^D<fHluEzY+lKSn5B`BWL0qK*_+
zJxlGd@MpS^zmlKO!L<0DQQRr4S_PzLq2>uLY!QlBn)7wH=RXlC#Ne12wLI^hNUhiv
zM2!oJqmc~ES&8B~^tPGuD~+nRFmj(PMK&W>FUScQf}9)dJpjx73QNo%10E~M52l^6
zhfou{2@B2;5v0>$IDf2#tx<ei<i@7V-hoW)7f=-d8zO=oQt-EHDjj%L6|-PK+q=^i
z6sA>qVF`AC=n0d&u>H<gw5Fu&ktpe{KKgR~eaYL;V%oefu-^pv6nfNf;-puL!Gzv7
zGl@V<BTnH6?w1qWmd!wv4-)Ld-*ofHQY_Q`_(lo-y}P;SO0jAJR`k*P#>!9!;^Jm(
zph5s?IqIYbVmy4!@6#6=W@-<3@uLR0&N1!A%sUN)#34B6klw;e*ml7nx2E>ho`P19
zvn5BVh~x$BIFcS8NQuSQGNH#8E&8C_<ZE)(!axr5a`B>D`Yu%nrWWMQa!#H*BlgV!
zm96dNY1+G;1leU#r;{b3?^2i_UZOMx4QAf}vhDUwWp_1+cbwM9ds6u#Hy?2Yd(j|C
z;ysn*+?EJpNA(^QL-<EdZ7-thFeuhZaYLB6m$LbYtVJ!(Yb7CJ`^K3cKjP$jZb}}Q
z@Ai^A*(yKSs3k#r$6d#Br}L*;3(x5!KMxEan72Nd#gb_S4pn#(lb6gWJ&qdY$rkUT
z)L>%KP%hyZR%pq(lp>TJ#hH$${IzK;pT_zfk9QgIDERWS;ZB|+=3!6jlN>g4@O=)=
z4h8h$^y+UE$S(pX?%sOGmlc6V@Oq4zgRRhcFb)YdQ_A)vBv=5N5Tqmy%Q60P-6?%R
z3?LyRRx&2X7X(>9xDbw#o}Yxy=f1-}Ar5;)^RJBgt0FAM|A$ALXRqkHyMOA;;l@2Z
zU`02+60tuyAk`{|sh^A46A@PN!;e_0Mn-?@I(<J3Bga&WA}Q&2Y#Jh()Gv%IwIrRD
z_Kr*4jw;U$GP<1N`XBXSfY1)*>zb#PB8@>m@{rF>0j*lpgZUaD`Wh*%rH|^*1qE=R
z6Od5GEnsbixP@uaEK6<S#K6xISauyW^^Oz&aX`tWEZN%Sb)uOkxZL%GQj0xz^$j7c
z?>E?Qf<%_qSIX9I>QK&dqgg`&)~|UK5-L~^QehzcdflY+l)A&e(V&Ny+Qh6V2yciL
zb;4Q20T|(yK@@hgIhs-@E4eOR!yn}+yhtfq-^WX=QCzP0z<)paWs3@dqa~c39a3|&
z6k!k`QHr%>3yVTiN||b@jh=@wJ>a{t^xdMu0rg3?MIJ-PM+C<58$NchFF5)>YCkCS
z6CTYAyCl~$G^j3EiBrQaX=J?P3wg>=X@lpo#5^v)D8wyi&<$B0qWo0sq>5*wrunrX
z)5?a{W7M?*4-YwVj%h(o*9sKqDqO)N7llhJp;)G~Q8Z7_H+GdoQV?0#b5E?Gi(I0#
z<~R{dn~Bv==*5sw2WyDve#;7F@Fq^<{&cZ`eVa*0*VMJMiv?vT_+y<DAq1mb;#R`>
z`OOO1Y47ntxtBF3FR&#y{m`16upJ1XSXIAnNY}A4&2w}L!1)BoqKsBAtm+a8R|z`z
z-yT=#=aX~WB5@IVY2fn%agt@NL|}2c%W?wLu4ah4^mF+=Nf0S23sq+;glL+>RSWIv
zmoh=W<HrZ3V!QffpXY0k6T}d;`|UATilf?61$^5y-T=tA;+O1bbjmgaBYkbZG?#VV
z#-*zv&gS&Rf?(TH%p4yMtEBTeJ~?h4eU%~)P3tF%P$Zz0h>h!9R&w6BsM{VZxi>Gv
z$G?nFHWdkyjz~~;IDElyF0*+^&g^utE{4)p+o*H`+Q*18{Z12$l`n`{rAK4UvZ`mF
zCGUHWi~TOaVpoUB4+E>&#pDIA>0?Z8J4X}}4~hYvvTNxTa#A045Gi|@`X+ex`3?3P
zAkOE<a(N37g2{4*GDdzZ7ff{Pn;6AIA^ierf*rOv2k6lc+VYfo6RdeW_sW>mPO1l%
zS#=rAegoA4`;94Hf-4XGwkT}P4CEPx+UD`KcEN`q&N{yBhhedr)qMshwG!5^7})ha
zfqI%Um`begfpJD!-J-j?#_7{l>{pF_SdSH|a-MqJC{{1G(KJ4nOD`Y416y%OQSvCB
z{qkf#awRL6^pOAkisfE4=)xi^c7DauF`-3@Zr5hyi*kYzBRcxX|3s@QQP&~$EM2Wc
zyKLhUc@$T&1udB)7h2hmPeEP_R2MBpiAi!28Sf>M^+^O#-r@@oNwy(Nkdkm&qR-`9
zZIlJz6(s#Aqt^y_p*Eh_F16h*W$n5&>%<kYJIk71`kbmyqRf(T|4btewWahq$k?4#
zJC~qM1>_HO-O72_h8IM=0LEcOPGt%QVPqP@FwGn?qun$BluH@Jb&PDY_}S1keG?nZ
zI-;FeCq|^Z_rsPExVN=}?3JPJAM41?(TT<6CR=N1b~MP}%@*ez*VhpM)58gFQdZh5
zQn)LPaeHZnBMA8q7IfXGO`>@14_(2gM@9lL8UdbcR|zBbWz0ii5cA*?1c#z{4s=cV
z?GiOSh`F2gLZ?Pa5yb6Xv{$|jO<x7Jd0%0lkiB&<vHpZiU<dgWe-3%;J7JGu9Pt<R
zrV@&Q*oo#kxeL9k?eOP<RHHM7VV`;IXLVV*mO|O`uR$0!?`lxx{@3rI2C1)NKfy-g
z(i%~O57Wi{T}lt2tk?q+xU^=1O{-6^Yx}YbqiECiY!baqmtOojxUF<U1`1J<l^7(|
z97IQJRy>&ZNjyW5ZtrGD5IJ_=QvvE_%B>`N43ZD#!)IQtLA%P&ck3|bm4e0@WR~p;
zLcW{@#4E^CieTP1?4bbsnG4e>mkwG9FQnT56svnBz&~n}Kc5r3HI2nm{5;3o&(|>t
zxin#A#n?S@Lv}X}g1MJ_IYmf;QjIE<?)4nO2o4H!qCpzh{3DD&l%%8ZOlA5G!*=1j
zLGoFLU-zqCd8+45cPy->?L6Ef{p4sd@ZKF^kmM;^CtWGU*Cr)^MglO6alz=L+8Y}s
z&E-L{{6jkTK(Zy_L@V79M{9M?U<h^Qi423}!A;N#)%<u^Bv4^K_JxS=eQqA3Om0fU
z_b^rzS51qb14ysMDIC_LGlH=p=NX6;X>z7oZWJ}dG1xra#NN)qy|m`pW|B=2#N-0C
zgF7teT`XRXcG-hoUPtDW)O3pk$<q-vNhMQqJRMKqB8UX31i2lgh*-!>vs}ZOhmIt}
zC_y&bY*(C>=Gn?oZVc2<a^Ck2Y&v4H{|PbgLmPaD9Ib)N_PU;EwtFc@!Mpv~t9*6^
zF}}>FM`L~&8+jlSNYGL>=iJ-Ncu>vQm0zYgAcRsLDgfStlbcOi06YW(!<915D~y>6
zRu<WF%Mt}zRhEKCNxFIt{6Kh+P0I^ZT<pM>to5VE$Y!(VdF=7gnh$DS38K(qM*<B<
zKBkICS?5%brZH&!k~@@RVGv5Idkv9_nERe^XsNTl2N^Yw2?&TjuOP@#HNqbm2}%pZ
z^LNG+=bsB-F~WZCjs|hg9F#_hkorv~I19iL&V{Egm>PzKe*z}EeS}y(?~D>aAQiF3
zBB8~Y=^kRN^XijdaSOB%T6X3})zBIJH1vMCsRoYejGAN92d>$CYTyX~NkF#0&y+^x
z?MCVOZWM7$y$8{Gk{;o!k(|SJyxKk|zNw==CZk$y99Guw7-YZ12XQ6nnuSwzrg>T}
z+X@y$m!WmabywF7;wo4)h%Js)a$v=cD3yC+<Ka@Zs+EXYmt=zIZfPaFMrnPJuA6<a
z3Z>iUlm*NB#ZU;{v;wQ}jp<|vkAK1~sD#rih_KhDV%q?D&ihZx*$;M>7(He`&w<*f
zNz%+`RBeZ(0NQ$3H4ZO4Q`M1Yz%T8Q7VO2aghw+@JA%<lGi(qpHazM1RZ=Gde+l^V
z_pkr?DeK~$#Fj+6iuWPz0?A$g#|=F}p18B6P$*UvF*tY1sQhves@i@jl`gx0<ccqT
z&A`)wa=ip3aiG>54|=$&GN8v_hdHWUx<=GY3g!owdI%zxaLfYZJ&ekEl`O&5mLfcr
zKvWEDDfXmm`Pf0M*iS1DQiV9kGK6gtHe=5`af(e~C<L3C%UfSi#-GuA(FUjuO4jL?
z3n&I5{KasEn1sE=hzcP$5`z|+_Iz9bZF);$h)l)3mJ(EWOix@00v8a@4;IFi#7LSF
zK8`RYev%RMc3UgAsbAA&lh!w)ZLX|9^I)Jvw^9wc8WBo}NCv<r7(-h`n{yYSWJ3GS
z4T8}Jz4x5Y^Er-?YE4TyaXFr4WJ<cUkbOIyF|yj7x7^xPXE6VVk-?Pz&gulD1E+yl
zzBV9EZU;ipJe#mdZ*VZdB513F<Ud%6ia*&G-clurP{*T9mvv+X?AD@Fdi^@&xt{@o
zE?86=E|e2X4@Emmuj)0AbXPaRa!6Ea$6*Q*;|$1%4GNWFU$K_r?AfNTWUR2=Xdd&>
z!L5_t$+N(kZnGpmcs$b>ixG($xj4o7gd{fuPv7j#-YmHP=7LiRq^GBrn?zW;c9PIx
z(D<1|_Qyn1X6-<Pk&U4)^~)sjC9lPCM@^(UQWLlv35?PYlHwp4KMA>cUttW)*HPag
zsSJ)BHIxu{&bkPs2B|-_B1bMfRR!@g+5VXSt)dY@kxEO$u2M?fAp+zf4Baa60PC~|
zDxnM|Eo<CL5yUk-{8%ay9&#rZm3nH6fsX1z&s|T`RUJWn&gnJa5)Tl0Kxjy}Vm?Zv
zge==I5E}RzyTxa47LI|yv+OGkR~k+F!_qSsC6QNZK~xG6-<E%oM<+yC>Mm@S3uSSg
zgqc#B9@}w%)yeuEf1vXG5~MSIAd+;66>4Q1Gp@dgq}&8JWXqC9wg^x2fB7Sgl0sSf
zjQ=ZifhKZIH4d4QSITqEGn`qImZBS(T##}hIB{9k9N~0EhO^H>RNYDmvGBBA(iuH^
z)k6Na4Uj>C(C5!@j7;<^m$ymg>tpFIHU!ZHmog~8ZeeHBKDUqAx2!J22@cLr%sW7Z
zr4YxRk*b3dG874@r5wRFNxbvXGVhURWr;<f=p^r_hKVLBtiF$yTGWP;{2*Q{7<Hd7
zS(+S9TijXl?W4FHUSrC3>aO&;_+n?lPP`yz;k-Z|5)hMJLW!B=?qI2mQ<+@zau0P{
z4Tfi>jJYo^n)x1amP&;u?n@U|0tkI(U3f2fSV;lb&go+CI&}u=S)Zg}dETUlDV~+!
zy~rlD6fGvCB~Ni-ek$42SmC_iq}47zU=M$m;7`crO{Tv?j_miLmQP#RR-$juQfL+{
z#f0$_YQamQUx^VR6MbHPXi5Jbi<-kv<OfS$<Z|SLFcRr$nnDu==6243K*CTZ1mW-B
z9z~=$BKnm-@4h0fX+;R;fba+|1C;bi@>9jtMjJ#EBWPK+-X+6?L?P46B~V#B5Sn==
zfWa`j&!Ji^mOfQ3uGND`5O5LF6laX5*~hO86eIFxlw*o!Rw$M}ejY@f$nhA&lIjhi
z<HtWlPz3uv*pQMPubBmg<ukIUWRM*kfIT|1(jhL9Hi&!HAl69AYNO<F>6zrMf`K1g
z$6E0!>5|#*AO^4W2*QY;E!OA08a!<fN}^W2b4&AXI~mWQdUXZ&g}p&UOE6-O3McoC
zQ2>S!r^Vw%is5^g&MU(25zs-Z>sLBwLt8u75xM#vuc!=x&hVUXuF!BhT5`d(k&gmp
zgc`yp9G^tEQi2iOo$tux2)QOf2(Hgz0e$*6cq_57aGS?X*K-KsFGPtijZ&e<m;CP<
zQthl0e6sFHz(#Xk<p6MaJ!g2Ho|v&F1@62goWm1+NL<}z+&mEgRy$^rW1YaFuWRI1
zf}SouWL$p|x+M4u=x+ijHKrRA@Kj?9p-@~&ezRbC3Be>ua4P-DlZpu)VXh|aDJ+at
z%L4kP@7RalW<U%;GsvVDJwOG$01N{Ny{O66Iv^i?5KOp2C<sH$bulIpC+i#2GZ-9w
zgroEuLk~`xQY3Y91@rmVhPSfFsvBYHK-BbF38W_!?GeRr7$yLN%0}5`zj6^|569L-
zgFl=fL|C1bs_#GrueEYZXqzCCM_3F*dau4b`lDax8ANJx^N>1})Sf~!)MBs;HbMC1
z8mGANm^%z`GmBqNR}ur<N;FX-vOXmydJyUqBoyW-H%9E!MT|P0xIBF?^-605Q3yK_
zHliM=3?O%?F?c<m<1LhqJF9p1JOB?V0P|5eOHg@Hcp(U9?@WV>F3FAv#dUqIcD?|d
zvj91xuJ~=*3DMg*H|&g(W3bCH+6RS|^6Zk{5;2}JSm$7c7o^4JaK>qqqHv0q$6@Kh
zXdvPXEBS%Y8aCtS^b8mYZ*@UF-;9{^LrN~h7bxL-AX2)`V{u^RF#S?QbxG~VQX9lD
z#hRUSVqm}3pPI(UJJzQh6ER2yQ#Z)XG0O|$R&XKGvv{_Ab;85l%v}v8kN}{15yc*{
zP-&C3_3)q!p|@z<rqR8!I>~DD(=s6MJvx!<=XfQ(N5*&B$#|dpD)+wylE&x<gSqAJ
zs9;}ZHZ-kfsH^P^R@+w)WKYsRQkt9B12PA4q>5(K27?ZbibVB2FYy_K_lu%@2bsdw
z_9wqa6h$lK_h#5&J*2!YNxFF}agI-~Cm-?bz^NyV<%uf!HcxrybV<q@#~XG~)?p2(
zRj4;+9Y$+YUG_GOuu42KMwIw7_mkAt?@Ao|Ugm|Y+b3tUzF})&L52y$0`(nlCAB6H
z3apd(!|YVewbM+SRBn7tl2uv~qF&lvi=;GBl2=SKc2!eCkNf~Iace4qRjF9NdG)*`
z#pWF;mO|cb4kzHG9hinYTWT+|D&{SINQ{Y9vFwyaW%Q#omemQSXr{N`4%mdFS~MfI
zb1YwyqcL8aO9j^is_(b8L>w99PHa^3GGcUpXwoO#JXk$NwvZ`;Kcl*D6vjzUNWlBV
z5ac5o34(cS(^70KgSt^oS5S>&5z3&og%%jrgf&Q6db^b96>@yQO8wS!3n`fZXx-^b
zF~auQz_}7!1MgZI8>K-i21ZX^Y(@#~W2p53i*T%ze@V;v9ya%T2xpW|V8;VdRg0cR
z6=-w?V9CKjx-Z?lc6C2%8ITA;LZ#tGEui`o*#k*rn|H+cSJ)?HyP9BsLVg|dsQ{?6
zxGILrW9Y5`?=VCFMNu9Ss!?75^#_BLqMdop)j<z?;HL{x4gozm(mXn=>}&HJ8Rym2
zB2#l#qNbb2Bjdjv+ORS(3Sv)ZC7D(BO44T6OrnD{*Up^3r$}L~^Z?JKi!}n%aNMYN
zz?o-S4o%searzwmeCN?LgT=vT1XEnG9%rXZ2ORFOf*^|&6u=Ydvnkg*8q`&jv$n(}
zhUM_e2OU|c@{<vtJJ0o;%=B}KL8QRX_tijg0tcJ3b7X-GO(|08d8`vhzOy?~#42UH
zg=)egQDs2d5&Ael$Si{~6Dl+hh1~T#u_NoX#_vv+2OS+2|5cW47GH115sbx$I1n}a
zhyoK6D+{UUwIl2y7xVEo>Ms(YSk0z=UpB}fd!vd0%D2xY<hC(neXWxWad~o)2}I}d
zhqB|*xrTwEQFjZeC(QCgT=zd)TdW@ekc+Q0h}$AjKwQChJdhqXqcUV1OKCUFt!UFq
z@fO$&(zEVkoKpBf*xiYu%puS9!1Mu9q=gfB-D%TZG%8f_WruF|ri*z_hsE^_#TKHM
zxWB7aUS>!cWDX<B(t@IiK}z#9&(=$C1d~<5maMKzU124w%RD8*L?NnVVVOSjC<uo1
zSUB{tItbE-gj7c2YTi#m-n1{EuK@QQzKlp+NaQ$O-WR9IqwrmbwGp0C$}S(prGi~h
zu0bw0Mt<Ed4rUXInsRnDWrnD(HCGUyM^t)y_qfaS&uPlibw3j)G;IN=^SbEiYZY*U
zt&OHDqr1G>_Y1Ag&CAkoL9~~J-|k-8Q{Pj-haW#Pol}y+au&gZR%LObzIpf!A{Y(7
zA_{fw=7IU&?pexnMg*o{x;@vD?nKT-MAI@dDC+<S=6dC>Ub^UZrpY#=?`kYlkFZmV
zP+ucla5#xVa?})e?RsVl$$kPjQw7+Bj&HbWCA*FmN1r&F{0jBsLh`FMoBqh7;c!iU
zdym1_NUIzy{2H~cqtt~gb&Jy}-7jk%dlxs+7hG8qW$`ZX4#c^k!R*PS=VzL`B@SoX
zJh46}5GsS;;heL(XTf~;?I9HC#rk0Jc}FFW=kP}7Q<C33)=x3>nUJ{@Y9gFr*FqJU
zM7c+(Wja$B9B(wBsS|5PMW1;IghM-OX?J=HF+_jHaQ@Mk&fZ1kUbPIihIOo_6mxXn
z0@d-{@rZrn#QNO|)=t>xkX*(EuR5Nx=OE-sGrs-mp%0s}1qGWRRK56MC<#)n@2rlf
z^sIz<E`$^1;^=W<cZHe;=lw2Qj44{tpiiQ9%Ol9S{_ss)3D7s#Z-E@)PlYe`k*uTv
zwPf@286o7ISk+6^I}%cpHlNT^djXi`1E3zWI3h+Ss}mZ8fNoq=EY7@<Q#}QQksl}7
zmZ~9Mz0qx2_rhxG4tDONt+A3XzL2RF!(P$o0e%4zzo2XJ&GR{Klu@}d_LLh}0X+a~
zW*P{3w1FTLjA>xXN=26Q)i6-G&lJiTB_Qbu15P|f$6KQOovz&HcAjQL|MRK=xoi;q
z>{>o0&0sc7fKfQm=h8Yh9L$x#HdTfu)&P-_vVlrN^<k9L>Zk1ESIH@t0%MN&mA>pz
z98!En*`bw~7e03oXTp7bj~6$K5v<?w@&Jt_UTvL0s1`g`wYOU`LF9i%1t!k+N@~%K
z-Ze2QUc{cIgo|#^yEWCA%a@%jPoJZBOSF+*L7Y*PWTAhlH+B58aX31V#l#)XceE)P
zqaZ*!N*mLR0i=)nSaQzZv>(~b300V@g1>BY*^DsGt34<2K&SgcBU5M_GaQPi<f0R0
zTb8OfD{3AIwR|;SSHM!ziUoylc@GdNoiDnewUJ5hv1yo)qZ=YoqGtNo*)I)dxA5?J
zpe&v*<vExtkMrvzL2srcMwObHq;S^`U)sP3R}o7bX&$8>bwyZAU~E|w6rYgtj7);k
zlMt~9^*~u4;X#r_m6I9bQW$F8$8!H9;+@XoKf$PwFOctJ%;PPT{mblEwWFQOE_AJk
zISH1V!n2jOW{0cCGd{9Cj>Ay!t8hxjrz)deFer3#C8C6j&(z&*iXJ0aNgUKgNDD|X
zg5bxlDm5>a!OsXr1)v1q62tbrv2T#io<1K|-kDJGHu(av8R6KSJI<vvT1@U((`;Nz
zJBZ29ol)+4ve#>4oOSQ%9`5FfB{Fq-Ts*Rb4@-BfP8zS9RB0l$5=@E#BXB>b!h=w&
z&8sFeL7>;l&^M2}UDs~OWFsAgOG=$43qdCNtb*bj2(CG9M!z|)yrW<ZCcSYam}~kW
z!5n}jxcg70Nm!q>)=?PIB?+!myHQePM~1wcL8vGUe>x&Wrau*iI!#;1_1^JllWbOy
zdW(CpO7p<U!b@7h3d|)k&C276a!{ZTw@tz!jtOrtcmTZkp@hPzDSAh1-w}Wtyt7h2
zaEnBe`3Gx@{UcjCbXX!%R0tMjyNOf;;BVkc;f6~kmGRiT9`b3Lq=EPitO%8O$6ZuV
zqsXM@>p}XZ@<Ak?h7n;=>E2jL%Qhjvrpk!zX$l_S;sj{uzxOVik0lNLI#(<?xe7uO
z#-i221(CMXkD_C3zR{EgzCSffFxsmdc{qA4y8dKR?EI6I`qWq0ZqfZb>f0FDKQgZ*
z4I}m@V=|fdWf2sbv|p}()#%sN#oJvi(rE$us8aoW$;mE6OARFR#mqSc2#<dnwV=OC
zpB4}ar9AlelZv<u30LCZ3x(9ODqA{$jaKH{^FsV&=pEj(7<)@dLm1r6N$gP~R;lV(
z#cW!=cfrU~Pis~3#yL6BoCZd$&w)|qUM1r8>1?P42QO4cC3RsOrD&So@Mv0|h#;q;
zyQs3~)P!s0Gb_uJ61%MFxR5u93@3)u`f?)eD*OxId!o_7Aqj*B>utJpe{Gai{F$ho
zj>^_O(kOZeYj_eej_W8CB!8JgBV2up)3PQkpgzlr)wRRx-x%?yEfzyFGw10^zbU_t
zotju|(dWw&uCb>itbS`MA^R+?VuKwlkxX$~xW{16!A=VVp{Id6J5ENS_E#As{3x0?
zDfycM42!4P5{%{T={N_iJ#FaVuvjTmi0{LqC}-G@kUj$j#W737?haNIsx2BI&s5M5
zgxs6v<){#vQi#^M9$2k|NyP|ClO>Mkde1@D=$I_w*;NX`tQr?%UiyBlhIi;FoUX~a
zm9Tutx8@;Gjp^g#La=0H9?u{MoCy9TY^kKLu-^npbmIU*7Uh@~Z7TfxSb$>?qS*Wp
zwC9l(UO>1_u~`rpz{<E{&ut>7ehO|8q=U(D^ky_;nLe&@YfrD{%=0z@xKD|G)3V@M
zc`)H0mIJXVpQGz{m6q+K<Z3r(BXM&2lq56{H!~6Q=ecN=hnkmz4vj(N%vw7U@DKCA
zY)Um2jK=o88bm9=2N7=&Cmy~Ucn~Uz^4~lWTB*i0F=9reY^KLsPorbgge|@QSu-Td
zy5sRdX)c>$fLWPFVYfQX)?ijqp-0<2^#U!NYANnLgUrLl6<C3F^;u6gR+35Hg2?~a
z0JpdVUp;4vz{5&`LB2yUT@@aWE-+AN1SxUrP*6+Uw=||)EgvjTJuloJnNPB3o}xe-
zm)PTdSSf?qLd@K`yR;n?OVvltWpcWrl^U^HNaP;`5%!<DEe|H~2g9Owj^VBOD3nN`
zp%VxnILbM77g0OMM}Z`m8b)iCs$?6YfYYD=lvq6E`s&#bwR@hiFaXme=#c<!VgaJ&
zB<MuPfYggqf-+JPidusi3(9%iONjHZV?*(mLFrH7Z7*EQWyJDMvWPC8*Mk|0mkIN*
zKysmE6I;p(Ci+Q_YHiZv6Fq_KYeHrTl3=uw5-UjVNIpxNm!h2h)_0ticYyPrK&p37
zR89AuN1bgdW+Kv(wr8QAggmwORq*$@pGSQkGnK(I=F!x}osd%)Wp{Uf0w}H7Z+$G8
zQMbL6t`lcYJ8%(x4xR%8$!S5kkVyZQ=SFE={RfQ#DP0>RRBYOOz5O~(*B@Kjg*YE$
z1~5c}aJ>2qh=cdS(^|;u74tQ)vgG|hx;_p_fkK7q7UHRh>^$F}F;5YtM|yh6G{o?v
zoTbtlMIH<)4ozdy5$Bg*5L&aYwL!Y9(lmN}KO~JE5tN9hNGki+MlLw>Bq~mmDkmr)
z+6>R<!ik{5r`WA@6PD$YIvo)y{i{VV4ED7$GOPx<G&qr`M)IeVW%-nJKnn2y^pM&!
z;pDgMQ^XU22ik?;<XvYtXK2B;(oOO{6esW+BeGD5x3s_gB=BA7nSNR0ZIY@CnR=lL
z8j@cvd}$g%&8_NhC5HIYaWM4v**dy9h0r_2!Q|EK-84cxFAhwbC#=B-gryg_)7?x%
z`lF3HtwjH9J>1qA6-E*O<UrUkl<S$xP-36iT))0L>W((sVn^sfxwNt!jkBm3v8<zE
zhg}?l7N|ZL0jrDJQhbzh9I+OoWRFz<^V5Vm`FU-~#_*b><p!;p6=x}|Hpu)14dole
zcm#rorHkWH&eNGkt)zs3ydE95qxPD{=`iXqsi7xJo5bt_r~<2Cv1l5MqiW1l5R|Bj
z_H0Dr_!nZ`4!=M?{+m=y@W1{2Q#pv#9Ni!(xH^gL1TRPY+<{U?{ZbJp6UydBw4I`a
z`C?^52;aV65>TMpy_5Yqh6tVoOgzelboOGN#W5A{VKG({XRsx3O~vu%d@lE>%UJX)
zdzo|2tAa$QPkYvn*gWdCy9r%sBd*XdQbshRc;FJ1C<_AB2oi)PXc}(mF|RHMYH@6F
zn!J{*AZ0GuYWm3i^sczcZ}v56jw_zSUYt<oSq2=F#UtEVS%?E+XM?06!-;NF^i#>`
zG9-QG4w>8%Bh~joc9ojPO32}x$17+}+NBr?i9n%?a9uzKu@@C6SKM$*7oYoaI7KV_
zF4HPiuz60`l`+P()49rQI1jN=C@gIaLMWiYN{(_aSL`R`<cp26^$MM>jyu~GM#~@B
z4q|RYM0@9RR4J#yQV3LgSQ}4+xAuN(CjbV)6@9-Va;Hld6-k%>Eg~GAb_b<Haq{*<
zU0Qp?fc(dKd^(hK_u2xIadpjOt8-(*oyCcK#M{*oM35dW1rUX&4<nUi6_MlKlU6$@
zI!Or@$LdA{py*PIO^g52o#pX)%{Z+2`44!`1-C?_Zim8+MQ_k!UdgT{Hsjy?#KeU{
zLv(zPMeu5Quz4axgNmCL6x9lxeUAWfQ>Z;s&%!444#U3($uo~ogp-FoWldL56jo<r
z*FN4T4RwvmfhXTVkU9uwvaQ%>I^~$uG=$>;9Py-Nc;@g#r~IrRI^I{<H;ChX9h0`%
zFFp1PP_YmfuJ?Gx>0?ilLgxaM9ZDNx7+DIOK%Fe^#5RJNBaURA$!nn!t}<5`NhnIg
zo=7mra%u|lmhsVkMmTRqN}%hW_{TpA@$*BwkSTr9N_htoVXy_$@)-CvJy8E=m&DiR
zD=mOEx}|Qjr5AM<kW+lny>*N=A;vZ}UhpT<@1_HAaeHF{W9)g3qHF=D%k6R2kq$6F
z4PkR-p!Q~g=$u&sL7>ISd~RHhu3f=boQZw*SPc)=FFDg=Lk6Cdm4g*wwSd{~K-MBb
z*4QkP(7X@(-7^3JI-e=;AlGdrI4Gqa1cx|F`GNBzD82AQ<a;e4F6DT)12)NU5V<oS
zZl4sdl}a!yFbgKUHp=Sm;DmDvRFDty#NG`ei{T&ksR3ci#wbBvyDITYVK#4n?0gKr
zt-!GKra!@fnD$UFag3tLK)<mPv6uiWVN-fKYGMi4TuNZcj$l$OhgRajX8A0}Hj38r
z1RO|6ObtnRQ#Jdk@XCi>ta1-}q&14{mZgZtJj2#5VPHy~);YZeDPZAF3{3R&q8_&2
z>qgn9_&>>z5NQl0&?T%?DVJeekme8zTReSPnzWnG5-+V(*6A<Bu6bW!zX3v(_KVt1
zLBq!ht|#R&#0j$6HiqsTNQVaz^!P{acQ3aE;dVI%x2@Y<7UP%0428GnE~+vGQTc*w
zE+EgLd4|U$9CC_&az$k-0oX#Bbo}N`CWF#sL2$m|#?TZp(Qt6M9Etk9At|=x+H6Di
z$P-_8ce)1PP5K$*bikq>nwf=*$$7$uKp+r}`aEIQ!k>cla9vO2$jhBQ=E{iyZAKiB
z3>Gk!cj}28K_N_l_>?W>=Bmz47%7yfD4@W8$)Z7!H;CUL=&+>|(huC+bIoa>J}jF;
zi>45pRzqKqrVYaOwGc6{si|Lp_LYn!=ZfixlUsaSBImuy89)ugiu_(ya$XJCYG`|r
zrzYj7E74?g++6b42JpmwE!{l4I=dgNJOE1_3R*qOGo&zQ725|f-0znci`qeaf_Dm^
zJIs2HHi{e$A^<r%@Q=n&*5!T9JQ;t_Y6ua~ER_3Rb~}{23KCgZfUaEaiK+8UNHA`?
zMG>z*`ER#>;vIV;U=RnZ)lA10Wt7j?V9cR#m@}mhtzBf&n@b-L(a{b?VKFLGRxd*W
z<*uI3h=P2zdDP&xO9~u3Jki^=GWS#rq5jm{+OqtSj435M=JaoaXv&^!p8D-KiBi9N
zxU0{hW7(0Z--_>TKxBR(((4C8#%bCQ89%%HN$kJrfp37LEii_t83`Bw(b=cEkm-eT
z-aP-`4&pj4_!vV_JIGRd&0|2$fw5h`fPk^#bxOs_YvAgMC*2z%irTJ?gNKaQV63gv
z1=XAOeqKL~vr!R0x5{Xk%Y{z;cFF9+ZcOuRFL*i^c2q}(v*OHe%CJ-QCuxej&G4YQ
z)~NDseRl|+m@vq7BL`9aYzzk`$GLg4&4+5d#*x#L2L`cfB9za;{+qLLJd^AzM+t~B
zlc(Mo)qJZkSFGS!P8z^^%#|2=z5>fhn>iA5rTM7gv{H>#IY~l(N6OyTvz-B>VP|ga
zgyTj4ie4%m^%;>0%o!!5KU)!V^^Y<x6rHnWajohfE0H=22w#DMv_P4Y9jYFij>0z^
zN;2o&lQ{FUI+^@}(;!j?2;DZjUDQ9ga@EoMCtDGE#RpyT>>rAlR)TQ7&j&5e8-!3N
zZIOW1V}bp{HYt(OKmwrQx$tvx7@{&7@yvb-=a5d@Oy5JP=>UtaY8%hFFM3`e+#QBE
zQ#5fnlOI@rL@;vNK8GJGiTo+|!*sfz;6-+T&sht3qj;<SSPr3b>*h^&P{8(Ucw@>}
z{aNxp=KUqi`M!?&4w)Q>+<CmnTy~q)M;yK75YKnP=9GVaR0XrV5<XevCXUsWg1E<Y
zc#qkt)p#MM%)U|ddySk00}4;AWLrJ_T&PIrO`BsU+7xjLs!QC&U>aTqporrRX{VkO
zT5z6JjZtM*%LVXF3TR{9Zk`k=>WDf2UC(D>qBQ0h!I3m|NpuuC%12qzbhKKQA%s_q
zO0^bB>XMnKnd`-fVmSZ1jR_NK3k{-mG|V`BnV~{SPR_V>fsWml_~02q8;Bg~fiNX~
zjsu>NC|x4UGK9c`%%Y=Jyp?TV&@A&(eg?U^-4Y^*$_Z3I-gz%*mZd5zjia)w#rP{0
za%9~Z@04_&^s+IfP-gZ+7}<9|4zP~?w#Tm0el1i_W7y(72va$~^2dz6l?1cPbK6t5
zyjq&a+R{+U?-|6o`v-ANbzs%DRIMXex4i-ocxh)?lJ~*<1%F-m4wqK`Ot|bRwqS}x
z5sq~e78z9-w$svs?p9f;EEF;7b7dm9Svyi4vT-MdKYU_%5NbE=&<TVN=X-^8xfpG)
zw-u%t^M&nBXy_lQPsIw5WR3aoxfpc<vhPj?Y_o)3Um<B$#NDj%$9GSDJGo$#4?C`p
zYWkO7xzCjON#x{t`bW8^q6ABkzWN@U-xahJB+Rv2MrWq<tAMx3FEalLu-;Jup8!J-
zAXO0)X!wXt@QbnvU2#}v6qmng`#B+%9C6M`S-|NY&WX8tCb|3zc}%M=S>m7|^g~K<
zIm#7X2-Y0B{Ze`tlA6cvlo<@RXB(DLObwL=krrzu>{X2^$R4&Tv4Q8y1DAXim-;Qb
zBE2r{m$Y58m}pJ9CN373*2mF4MU5;GP7y%oy!Ty7%U1yQZh!fZ9@s03Y-icFWncQu
z^pee#W&hxfyG!jK2`EnOH``SnodiVWy6ln<E9I(3Od<8v><R8)wtLd&D}|#cBOdGZ
zIcvtB6+}1>PH6#JfUJXPt2_%(J2oIjTbH7F{%9*c!}DZ<T7V_YQ&_%T@VS35*a}{9
z>njO25A(!w`$t){ouNBTLD-8<MMSd2{Yi=cpe0XN?x8>Gw`x>Qe^epvl{_PcJZ=Ag
z&EqMADd|;<L-|fuu)ku8>1q<B9SwNghnOll%g#rs9ED}&yOb4yJ$)7t9Gs>F@%`E=
zqYoXvq&2N5ZVJZJ(58T)+U}HN{?oLQwY$yGlDch2yfjs}?}Jga$cUvm??K9Hlq9E>
zT+py~A6cL_7+(d>!GtvaVH8e|$+N68Okd>=6~4*hZ-5XXQp`18A9fWaDZpz|T>8Ic
ze=x~bgv;M4{ZJ7p-`u=%8xeN_^YW9GSj%fxRr20|&F8L%Q2>Mtkd@hxoWHf{1(SSk
znm_LM#dts}+>i}Y(zTx>-VLvcQSbe%fg=kTrsjijdu>T@E7{iP1bs7L6?*7o<tZwP
zgS2@`wmeTT8Q<n*9$BM`Sj>oR3f<*SkyQ95K;1mJP(Npvgl}`WJGp!l6qK`&{I)<b
zsem$w-0=j`_FTJjyo!&fJ-}u}f>tWqmU8ODRj?Dj5SCn()^2w|GS3FJW<PL{sJcei
zpD@?TxF8&taV)9T+h{LfF7NdZa@>=dlVev|_K)4vn<n85?|aFS;4qkqL_$t)tVPI5
zi>vz6^o|vE>5U3%aWbYYPF;;w{#ZpLfUNWW7Z0U=N`@Xy>L|SKgA;@e(b#YuEdJyP
ziMS!Jq2i7|`Et%eq$Y&)YZ;+_NN=2_pm|VO3Mi@wMqtMRp2|J*a0dK=6;W0TL}9Db
z7M4`+i3{?2`V)w@+PsB0!$q?er6l$nrAxDvvPWuNAO3;Iv`)5Cf!N2qPILI4mt~v$
zcadGw5V&6i3o=u^`tI>7*V&*O$x;l=_@TOBFYyF{`sSf;&TEj5H>_&R(I?Z9Q>xh!
zq9~<Wmx+^?+5Il(j`vOW|N9UtedvdyH8^V}nSv6Ao+n9bKvt(_j@_~ZnZb#cIZat=
z(UoUrFawB2o)JfAqIPjcQRV(2LKY?%e&jGnPF9F4sdnUFq$j=Qh(L<^aGSH!JNO$^
z!K=<Stn44g;QR@eIFua<#z%l3qi{^MlQ=*=XTOR{6ZU<OcnPi+m1GIPdJzhw!a<a%
zDWKS1JEIj_83#3lS1f!$cz*+1J#ejzr@aYnYc%7Q(IZn}xuOi7&+!+HY+hnqg&joq
zf2&Ju_Uk*fz%8H+qK<mzaR$5R5KKAHsYDO#PK=tF5sB}2A?MZyDbZZ3T24ZdNU&Hh
zh)~`+OSEa>1&L)dVIXztF(Cbd#wy^!e6PMcAFg^c<P~qP>#jU*5Im7KZ7oVa<dH}$
zp?fs1EI$Bb$pCf&VN(Uo!|%fjizJpg^9marPb6^$(b>K$5KvyzZHVaZx=wkAs=Vi5
zd&W@i-tl<dLB^V>Fnsy%)Ad)2DUw+lvl`2YbALZf74{VxjxCmcis?P}Hl2vWaHgdb
zgn4ZF>U8i{LSYh)SK-?N1eEdHJWQ_2ngBV|SVVTgI~vZEV6R_=un57=ygi|zWvE<w
zLZ8-Hc*a^gLJ-=<T@#XCz?A_8QU94cOZwH-g3ZsG(vaWIT4qT5i)lZLc}n9e?7t70
z(wKTkX~YM*x@;>7_xgNy5C~ycCC3Lv&hf$8(=e1QU7eK(!!<?Elt;lP*tBm;QHM1)
z)N3hO9)<ZFS!KLifDwfYV`%~Nxc*Ei8KB42!7+7i)%xnv?8T&lLYy3DQVZwjJ!<aO
zMI6_$xJm~GWq@J;qxK^@>o%7Y8brBZQkAEll`>65tHyPP`v2?gUV1fcuCtEM`&0A~
zMz)DfoFOM621tM`F-DdHL3RRm;PdnQU+aE$@8117?l?Az6!*J!RozwVe5!hI&>*sD
zwWPQ7lm=&@E;!xxdBUgv@>LL`9|@OExRoZ~b<XpoL!5bq6;8)u!`5w+4R+g;#kR{f
zm9@Ym_37iJ0mMu(0u6xN)0-Gb%NGbPE6uuT9F%T1;0UbII-Ju@qm#$N!Fs!_n*&Ql
zof2WTnrC>*fVh=~>2tAQO93&7eO@1NAEU;&#~?Wslg&JxWimSnF%1J?y<gX9Md=+S
z#pYeC-6puhO(9Ovh#mM7;l#m(s&L8P2<r!7@EjLa=<nNQRh3A<1+6Nv&y{D3zC4Hf
z9F>ijcz|Y(<t$wpGzKHF<wB?L-QjedfLRm)4AMog0DfckhRlUF4X?@#9&BB6uwN#r
z&*h!UM%0*0C_|jR)sNjgq+2LTr1l;_5FFD=Vl<(QF(1XQc?YxBBZ@D`=1n-ig-nR0
z@XzhW_^joGIICW%Z^BR#UlV3YxH~kb8M3M`)ot1CwUdosc?{y|5J*nqw_VNZ=QBfT
zwpFbh-_FPaTuUa?6*C^*mDt_%s2cTRGYK8@L<c?L+dBJg)oza|CLjMW=Dy_srC3rA
zvgJ12HzR+ORAYu<_?g=g)5WYz!8tHyDYiNoC9ml#L8ONnT-Z$!_sUNT(e1uP?K0Wn
z!=T+Kq;#3eo5q1Hp+WbO>9H6hmIffPjMB5EM6~NdHhp|apmU&j8W=jCvOP(g5PO2i
zkG%~@a2ivRXnMA@fi%yisuS$I69f<j^Aw0M%kKc@sT*hvNj}eO7li!bU}gK;!2*j0
zP0!i)9gg1EuSf1Sk`Vt^^3s_-L4j|aGAyJHOA?09kP1|XOR14IIa`RdIg`b~9B(&3
ztixind$*svRL~7W_W4#)D}YJ3+4alTnHorOuay&^`xp_xKXp`xU5d9(w)lv?y*)y*
zui-WF_}GGyROWH!v2L4$Qp4P#Mfu|jW+jC%u3hHQ+OCm}yK>x#$G%s_Q7J6K-$M0A
zfncw?JzAQfn%pqK(oSv4eD6__E*5|NKSAh?$=la*YMYPjZmr4g3$m4d59Cei=OPnc
zRLpYwB!RS6@$DoW5^8(jt|VFvNoJ>e%fu4?_8^>{_YM6e4GA2kpK0S~s*Si|O|h%P
zSZJQ-FjYZ{l^Bd$05SRTJ+;~>fg2L@<4+0r%Ur5GQJ~g%LM{hN`_HKx%EflwzLiBP
zThSP*tqhc1a<&Dp4@|7=i2_z@4Vj%cea^-7k9nSy>1hkOV4+}p!hiMAbQ#{>QajW!
z>i`08f>DTbBy9vf*CqM|Oh7{RreU8Y4MB2&_mkn{i?EKdn^fT0x45agYFxZmX1!|?
zOb&iD1f!%N8&eBU4-LdALvHqrf!VVL>!RfL$q|^vZKbv52Qnd>=3}(4m8iRZ;;{|w
zH$V?yAGkfmz7e~4(-sSH7Vf2xsF6<UTM$c%1=LL=y}Y+U^c~Di<N0f8!{B+<HH3z2
zJyNh{o(_ZviIH{_Du-Q<-N?qzUNRD_P7S_~qfAvnK+T`g{|Q(^$)sK&=U!j@29uH?
zIEgilIin*Lbr4<MLHwz*ASNl^JdM^@v`2Ouw{%L=gx`3C11}e!q~Z~}xoIRo>iS?j
z%cOS>>Om9|n}-!^y*F+0*0h1P(m;P0kmSY!67aDbJjbq{6~Y5<d>&gUcJ^w79Y}DD
z2)Z?c5ZPE}ggTE;B9x|NoTExEHu{xoIj)f1#5=qs*^q||x>kw{q-dAkAM2n&0C(XC
z1&*t?cE9zj6Ta_b>gS0+8D8;VJE&yB=JgiPtF=AT+kZ=c)0Rd^5fCLS;k0V^gVk#!
zwLq3KbFEVnrniVZ7t$s%@il?=qsS~?qjFE(_2HFMZ2NCA;OiO3ve1o?F)kbxs2Ci@
z*)ommL=FVQHi|fKwD+iz)G4ench}a~%QRDFWjre`a(nq8sYMVb5F%xvl*Pgk87hD1
zYxxI3XbY~ppOUuX0&);7Ely@@3}`3AI9aJ?<%2KzmF$I)j$IE;X|!^STS*GTJP;=5
z=5d{RMj{xeuGM{birM}t0~E0D-Fzw8rmZnAro*X9B)rs6*TZ|9XD!sF-}YcjNa1iq
zZyHYo`{2^*?L7^tiZYDPkMiNMX+)Zt1K_nJ^Su~^V-GE)5bIWDsLe3c?KS|*W=r1I
z3&IOZ$H=?d)btM0bsq=bPqjo~+1nUyG81`ojO^DuUVrVXfzsXy1=DtHIuo^rp5zzI
z$`3r!5imS+Oh|T~*JPGsPVK6W(BB*z5xIHgG`=YLIe-a|4W#wedD9hGriAB9!a*Jh
zCk2nxe}R1uWcs4SL>&qxd$sue)J3BGb~O(PjLpDZJvAo@iOC^WEQB@6U36Ek>J9ro
zt5#pk)FGJSUq5Ed`CLV(g^F-_4hT}n3ZjfN#^YH?+BsrdDEy@o$@gkm6f0-pQ_sjP
z{6>A2b804Ms+%|ExvN$5cHxqKD|40o=m)2Hyu64)-ipOgB{0z8;w<Fb^E6PLW10U@
z#+o#t@w}?676`GL`Q>)d{vjnFS1Ot3n6+(GY1nup^HG!^MEo$m%g8V;U@+BV3wG9K
z`W_mKEQuo`iw*`+EFLy76OqF~32jO@!N$M`*_#z91V#MjJ$2W_alz?8d(OE*y{L}O
zXpJg%=>zCZXA!GhxTf{F1eDT1i2ZK8)JYIBkF5>yk;{(}>vNoXs!Al>QlqEE&+_#-
z=2GB3JnceFyIkjy&%rQMM|0vOgae^kO&-M6B-BHxH4KF(h5TwxQB+;$Fif0}>MU~*
zdQXnc7>cYOrctkklIG>CZ1vJEOl>^oGDn;U8@15}kuYsueWGW}%6=`ES=OQ(JG7>i
z@=PfwE@O`@!eXx%50WzXJ)Ex=c(C2YpDZkeZeE=tGAOC_4or8)7?`sJAdhA+O$rH2
z4VzC9SF5)Jf0Woh_Yvj|$q#b<?HKd;3&!n&Py#6i?q^D9Y6>~a2j*><UZf-|tL|iO
zdvqy?@+9d4!9wF9Idgx+GGKe=p(kqH0E8@xLj{TD=Z`4_Kn!#5?Xu0|wTT-b9!#wR
z6M?8K+5xSt7KQobZ*#g=B+kQ!EFNLca)41YMa#WV%j~v+MyKOJ)bsirh&)HgDnqV@
zaxf2lTM3oLn1kpY?)Bu@IT@80(mItyQZ`ut98(RtJZ~@Cit-Oqf0&<RUOJ{7SfDnv
z=5>ZL>r9CTDeqO+-5|^y<aw<betPV=F|<tmLp_S?I;yp}T^tb)-cs{p!gV4zhxcbu
zXm#<L6%yCpq$Qry)?oTgJ>W0t>3Dq)Bs2!m!{>a=8TT?x)zi7_VyrUG1F_FW&DP10
z@{7H!Zf!n0+<`FY!;3wb+xc>esLgieZV%Q5(d`{RF+v^5tqq@*E<2xI^41DLQgxE&
zPP~0WP)&znY6`f0`cw1^pHe5`1q<oTj0~sJ9Zw=L!f+A_2tw4J&Tm>I&A)_V8C0?*
zeDnK1k#GB@h=m=lp~o)sWqggPFfC@uO63IOL}v>EJKdm)r;`>e#*9pPD;y}o)a`&D
z^a79<vT<Dw)J;tsNsz}glOV_MC70xwt{!8M1a&IvhJ4zBS_BD_Xi6hsf}XRSlre6m
zvAh`MK)7yN;}Q)_YNelV#5`U4jp%<5B&E?012{s>P*9m0=(TfZW}W7c>d_O#G>G?J
z7uvD`z4zW`q!sGj5*KIusen#g>riJ<bm0|Xau{#%67>4z3#t&M;5zm&Ev3Em-oi=d
z6=}<jKxe^qY!yVQfa_LRT9K@I)K8c4f^7>rM+j<eD7I2n!}aLFy5TR(rxP>`Yj$L>
zD$8NfJt@P6P=F0e|0Pl}NFnE1M!Lz|v>g9f75{Sz2m<Dlz#<wTTKN*rShRVhhMk?t
zz{o6dqQPITEkM7B1DD}U0xN(eu8c~MJYuaizL!*DA}|H)uGR;kdlLOh+SoJ^#<qzf
z6u?yb^yw=$TC{@21YH`t)g3tB<W|bmCyJ%*nkV&=R-MYYUA50g&{@uY=>V|_q%k-o
z54L#(bv0mn*!9`)a`~3_NtcH@(O^<e1E-w(r32ZKr7oO78a$*E{S-ccJ2(LZYfH&E
zQvE(YmQ~rE?UYbXD-q#Rb+Z>W*H0Nlm>=<oS<l!vujZ^220mCxRnihi!2nkAo>?q5
zmudixUv2-aM$r>($P~yJ`x;(l!JEcmto9Q}n;);HS10<hy+F1dq*h#;529BhR$0i?
z=T;$YULn(IZ31M2!5HxJVTl<6BOQnfT>ad~2YKyu-@v{D;(SRzMnCDt2!cc|Lt-qG
zT_Y^%r5QnNy0m9v+`ZI&Q9kGzJT-caVY#C2PzB2<qaRmzAzxa9<w$GfE_2=L<<x;O
zzAG!#d*#8ZMD*JZYc;LCGnd5=ImAb_e2tg<%CR{ZoA$I`(w|1LFNHsKI&#IaYnK;F
zK?On5aYC0Bctl`AoNlW2V@kWvK&`_YB1;JiMw&M5QK%72SXav?Z?^^m4kTg;9_!|m
z)^8yP=#pm;x1^^vL^jn>YVXv!&>)DW?$+>WH0fA`gkS5{_AK{Jo2#fHm4#s2(V)a}
z8K<?$mzVNHFR9Sg6hx(Y{z92uZh}#8U)M|Xbkf+teAE^yc9DgvslNMr_{W}j5Zz9}
zxZQUT!i=>}DCAM=KFB+{9Z5G$b9Z3%K%?+QmzzS0G+h@NaBx?*v;%kEJKdCP-^)qd
zd2y35XyQGjdR|RWQ$@MEEW(P`kef7$D!8O}khQI|G>U6K34-)p4C*&@xGjCHqRIUJ
zxCa~eJ?fpOwV%w{t%tP>ccCH1)OnTZDoVAvq^gXd_;g%XHbs0!R7w9>m9DZ<+p~c@
ziwcWP!wzG*xW0UA5WS`?M4=Xed@FYM<2zrA;<ux|h5VopGvR;znaZU!lsx>4ALQ15
z{}Lt1lRN0|N=wE7aFl1|pnGI2E_r!YBtscVhEr0Fi^6=>d{+`Q2N{Gk(n${8Qfw+c
z#klsUDG1-8p42?4OjN}JmnJn^<%ZWnZyJu5r)bn77Sr&JqSHY{*NP1JQB&txukmZu
z0)%A2^KPrh_OdHq;Ebi};FAYlM+H-*IpET_sh{FROOfU_h0h$uN@d!rhkb*TA41f(
zqh1gzJ;;nSt?z(gkAd#-+o~@RG3yW_l+zA^v5bP_*S=iZw=alMOG;6ep~iukamVPI
zU*8m(AB2Suf;Nj)o0pT`ynI<H?yY{b!L_-{wL@`wOGk6Hqh3n&p{UGn&Ri6QzHsFT
ztQCm-g3QKP1GIV6MJ2Dp)!sfB;d|=6eNW-E(qD-lKt5oFbbkZ;F350Pr&!gsoRUTH
zaEy&u=3FH^>-QJL`3077NKS3IstU!?*ce79y(=0`^#`Nwq`Q=%7?X0*xg|78EE*#Z
z>pa5e?b4N|a`N~kbe~a-ms$h-@j_TJD`np%Bl)7e*5`X*vLSg29P1U^8Ba}_c^FlK
z_{@UmB0f6JKe*dV)cPa52IGBoi=$eMO87y{7nE=;1mE-?7hMz1f*I}y^>_-afJeF!
z$#)Zy=F>`7QW9SBzq&s|RmVe>j4(s<@-EA?ImE7#0k{G!DsoQIZmOT{%1LM%yIZ{^
z1ufCmHc1Bq6W}SAIh0@l#3$OWY5YBjBv-q#2erPmIPWB5TW+25==+G4wa@#Xi{38p
zMzXauEw(9(@-wW&l=tdIrz3P(19Z8!_QHW+zFpb+(%v9mr)w0`RDG}NSHBwM7D<{F
z3OgQ_K<f}CCymKaNFMuq8SzIot3{87JT;kUUPh(guSPpRO4*=%NQ!vZWy)SxA+u0R
zi!tsIfH+F%6tDPPOcN)fw9qu%XaC|>{T1<HUinEf*siG+%*d!HT7`^a%emUU9Th~;
zUX~q~Q#{i*<b(5zgL&=3`9|TDCt)C=oo@ahdXVyhS?a{`4Pv3+3rUcLlj04Uy1T%u
zWXWHF)idjIs*QDxt|Y!DnMNfbtAfH&uN$$ktTD33LgIsZ!xY=0riv4}r>r<R{D{<O
z0Ld;K#My9pU}c&N169(6JZc-+3y^Z<y4okaz(61hqgaElBlEf+nW8QH6qX&7o2*Dt
zAwku`;=DVY+voBQg=j2SdC1facZO}nUG585OUqFZQ4ukwlNo^a%}PYcE;AxpPHa`c
z=dv<Juh%q4uWA`(E0AR+OQx@K>Iy2Fwurew+?}pWCXR}SHqI#dh?HbZvWv-7C|}Sv
zSDn^Hni$gvOBqfc(?4-QugWHma{-e_+@5v|=2h=x8{svTY$b`AAmqOr6csn*`I2l$
zsrq;OlwoR=Bjd9>OL+3R6G!KzW5{*U)8R5+Y>&CcxHQD|9%6@Ghex=TE4M6+knU{}
zRhHNYZ3^$u#<wW=ncIW#0Z3H%FF<@sLU!NXf-aM;Zomn=Y}}|Td@+yv$dz#w8hceI
z>0nHFrYf%3b;y`d&fUrKuX6^19K$J6l-X|@3n0~Hsp3gT%et2q>@GiF0{TJLlN3Y+
zZ)gNttv7BiW!NC4T1Ub0q66&41;|Jx6O6!=FOb4qgB&sgo(#sXi4vC(&At&-Jn{|f
zdmt~dR}X>$;_GVa%2rmx0Kur(IyouR+(299s%!Q=2#st^HMe`1rBTpfuWBH;_^D3E
zUe#B6!MY*3Nw6-rysN433*=`w8ic*Nt{H@^VU<GPLjnkU?6nA(t_|YmDYRgNsv3}L
z9wG0dM~`FdGVUN%NA_GszsS@)niYCJ1!MK42Ipj9TB}e_Pel_}TFK@Lt8bo~zO65L
zkyY9}p|1Qk%T+QTgfBzJrN=mSQ-)ylqdiE2aPRJW#0NG@mT-wSPwYw2N}}msI96z0
z=8S(wb=~To1F)+SYnjoZv)+Ut>I2iFu*aWtJ|8Xxx<T_6{Dn{-g2f(9tKxEI-ybRF
zHYEVBsV#=pBZM#@f}`k}R^opMJLSNP2`x0;UIqY@L~fh3;g5O0Z6FmtKJU5vcIm1y
zs*m^O&F*xnYDCX8_Y2@R4_Be?=H1eGtdwz|OJ<@m+;P47ot+GFkzz%blI(+|jLO+E
z**6PqaBF#{dY1OJf|qE{_}<s1G0G{?htD*P4^6{j+1$iR9<sIboJNAV>c_p8v$i3L
zFKmIwRhsT&9&m(!YTqo4btr>5LPW)wm&PcJNX7*3DI>-<7ce>G$f>n~@H{O<TG`{B
z4NM!eEiv3obNpqKRa4R#Yo!4AO2|imkFchFJ?dM?R0d5>Y<g3Sys^erx@RYSyO+nr
zD~Q0f==$ghDqK+NHajA-)fk>)^;3jlNf?A)I->)1;++kyH$(Ci+t2>s%x*~aV2>{M
z3BNs<1`#Fj<ZY~kj&)*)`eAg)BF(+@Ea@q&aK0`4vxPv6qeV^YyUjx33{3zcfiWC_
zaN+}dVmWFhQC#!KSd5*JNj54wS5{({qpR$_b)<pt<p<$=yKHmPrz0Rw+y+2I|A>Wr
z0!zE(+Awv;t}INwQoXl?qn}YzNQU#|P8La-d05Fm#;(LOA0^Q8WfS3ga1vpPDc)#I
z3K+F{y%=v|tx9R@MA$RKjdBJd{UH4iT>w2M&Kqx?T?D$^Qv9B9HHhvKIrs=g731TE
z`dS(Ft4<_~`H8LVaQmsmmYgdH16B2s&FT)}2tU<ob|O7Y*19tt=0r=$p+MQiPR5Xh
zZ2IS30S-o6_<qFngzHIARy=}ptInmRvSSmJFA)}7as&Diu=s?d?`$9xUQCF+U|>wK
za()k})#JZ;91*TfudES*rtx6+K0yIxb;%&>e7fhS>@EIc?AvBMFS<Ey*65Y=FdF@G
za~|w2?k6d#0O!#p->e1cz;lXQd086Ff@I3%V}pDpt=r~D*f*oL(#LtC1jv>>N?v`a
zrlXU6#or#JLy0Jmq-#pM7aL_dNj3a;wYWzemjr@ipgr6aOl2C^AqfReL5L2~2W=ur
zZ;9gJq7z(hsq`~};UVxB(sv+~fA0`h(1iaY&;5)LX|N>cqVFx7ZIo?lzOoV#VBtY<
zFdxtuyjk}~5NVC`qp8J=bZ;7}`8Xb(qxsG8^4qm!St;KRO(d?%g{ImHN4<31D6y_E
zZm}odytfcLjq??aF3H~8p4tG*v@Ra4&=gFDq<A!gNYrH(Y!4cXQ2no+3ri$cQZ{8X
z<RBWAv)0dcfY6WaDiLw4qFDGrKCbilq<K;8f%S8p0Vsi<S<C^T<XDBGb+2@ao^V$p
zQuw<Y6g|BtJ6uY~VY*D;;tpM65S+aQP@GNkFN%9`*Tvo4HMo0l4ek&eg1c*QC%C)2
z1$TE3?z)HMegEHg>zt}v=ic6`nSOeDdivKr1zWYx^n~f-RU1i{3Mfkv3JzvTFgCOd
z?r4!T+EqNg;0OQCRn>a0{Wt;OciIm*h=?IZ0b3SeE;`Grw@?i4V<;cZQyKzZM1kM!
zZd7;FN$29+qkRS<;Uda(a+j`FSwmOHI%lXOYlJ-gTT8#3_y_jt{-<db=0x-hHi3oI
zYocALQNvHQ!68wjh($UU$fk$baOp86J+*2X*gX-u`=1RhwF;F=7|z9d0n2e2hW(xv
zba7YNhyh|Jwrmq*XEkkEEu;tq4i6!-ur6x_3dfQJ8uDm%0|^!&Ma(}6U2Y^hlkN_@
zV|_h#!1q>}hXFXWCk|Zwaok&~XJ!vHxOeiB3It_fk572yfmiK;@@dE#u+hzvm)#wP
zq$+i7I>`C+((3V*!{ss(rAUdaF;<H(j}nB;42DdQQ=h>!l+uDX*c)I-+%5CKTCq;!
zTYTCjtrr)s>oG^pprhEtwtakmvp3aVztV1&C8Nekzm1mvFr)p|_bsdo0`iDlL)dJG
z_*p~`>|%AaGB25?fj|?>kEJUC86jA3T9qJl)g~J|vXUQWJ*6DQ1T-kgeE1nJK{8^&
zKSRtB3oi*j5DQw(hQ_RaeQ(bA4)TO@q}{5NG8VIkMLVfV1Wfp=WC;YHq)h?pQLx(s
z#23c#9?eFvej;}44e5EEcpG7R?OMM>D63Z;oK_neQ4z{4EH3<luLm5}wf4m_ODYj(
z?VjO=kgSEeOed!{U(?!Vuk>5t@O&WWR3hw$DtKrV(R_#zd^+3$Pt5m&Aa16DI9+eO
zzDZ$(Vr5o(6d<$;>kLZc)Idp0a-i_9*AC5jb09gDqa;)zPS2o=T!@^V{noP%&qP1o
zCY#6#3qwl60#{OIKZ+C7%KtJVigW7*N+WzENOng}7m(~t$8K?3ISQkJq<rNTPyANn
z+T-xM@kq=HT6VA%b!{B~4bz+OD|S5*vU;{B#FBChNEhJXO>a0%fPnQy$C4RZEvnmc
zrT}wnKN6~XG|kxGKeHO1-?N}<o}0g}WU6M=1x_@^ca~+nk-<D%uTsX4ajn{H@kuKE
zAjYkGB_1QqS}IW}QXq&I2tdLtJ)>x13oUTbs`WH2C|7zcfp^tCrQx8ib&9t2w|G7^
zW}6yFd-q*N6QlA}N<|Y(j#`4o84SveRK59mrYpfgW5|mv9t`pXW>M6c#eYXh*zOSy
zA%slflfoo6hMKpeY#BIo<OCR-scU9RePf_k`a}}?=&95F#Z1%yF)|Z?^=hBhM(|xS
z0M#>^OBc#+N8crBe0StjuL+td2`c~ktc`c6k}Z69!$0zhHI#~zvvhua%HrbgKH1F<
zI-V(@+k}@<H)ESq-12Y&dO#lOtJ`tH#E>*^l#&GyHzqs>*Dvax`Q>a>C~(#0hoMHY
zLDzJRed4ZcAE}XX^8*_7cuDOY=j1v-OlbRcs9D5l(qi}fxdFu0`~8*FJ42}8yht_C
zYunANHAYh^RPm4yvn}V8(Z_|pb)j8PA<+tipGeStY7>FN)hWPn3PTi9f|0ir;a1Bt
z3OkD`bgAy(fjS|T#6j53u=~k)3BqkZ2vKzYJeB|}58lzOr|6J8ACfgna<rQuo$LPn
z)Cjo8*9PdI*v8)NEC&Lhcr~StG|;L+5tB8LwZ@P=IGb<rQNJ5Z#TCvy?b(O%BP@65
z%jxjVh$jgc4N56*USyc8FLJ4Q-T<((tdW;9{KXcOFF|7qt3V|u$?hQG;Mo0C*{;6-
z6w+c+>VarG<o6ZS2Jy!;y3`9nCTT(!4B)MOAQ}FKP4%^4)6*GrETjn#fwPZ>+V(9v
z+EaxQseBS5PQw{8*ev4JoAIKl@9q&&<4{O8-UAg&F~3K+-`H}1JDe4_==hfz5`RuC
zTyvF_6n6h}-e+X#iWOlbXCXs)zYLWbRzk3q09_TXP+4EH@9Q7$H6E}b#7>zCX{~wR
zkVg2!pg(p7z7E=F*(K<tsZaD?%s5D(kZnq9K_#u@YZN%&JPv$=rPQ*J>*L0-ySR$s
znFfc&M4xkOY762W*7Fbs9k$GL45zc24X?3F<D;!CAJk|hU)XOO0#j|Ca%Rb4VwLLG
z(`hrdANP+M^*R)##B9qAcDe|;IZ~~;Vl(V)(p=UWz^ozPTy4Ono!)ljxrG!~a+Kya
zd~0J(3RU`!tcKcNe!<3=FI6&)WayG|_E8EeRZy_rSz4;>wlLBW*Gb;8dF;Yv>cE?P
zw|@)tj4AAm2&#a-)txc|r)WmJJO<0woT~~WNTE6}3h<C92)a|eyK$iQEiE=vOv(Ck
z%$CAc(g1m1*^yyb=Sr{6Lls<#Zay$e&Cs$f%lTYh&^Ok1p~$NeB)8btIb%~gUIC3-
z0CN_Z6g^6+!}u2LT+-Sl@r0jIug7ZTB&K5_KaK`U-f)S$D>iG=dc}3V&&L??N#y&a
zxMSO%;k6U$C;2G8JZPy}Om1iT`k@e-;-D8{`Leqk_i$TIyDIH#kCKS{JzDFe!AzE3
zA2{$FWgq>qFFp{`$n!bMFcWXTq){Y;7W_GdRdYA%NsNM04Cq)8_R6u$i|`*u72S<C
z`A$eGFPwe}N1646wnxKlmSq@{$LeVLHVP#Z^owvJ1$<mhZJnXKP$=UpY%a^o7+#xH
z(eJ=*GV@MhJExl{1mR<F!=x?;?0CrQW(R3&+ogx@3FaKGLTlt&E}gZF4UU11?}o0m
zfzyTYq~f$27j-LE&#mZZx6T3=<m*~-kAxN8kK>IP9>{_NI0<TpZsmg=nA-Qkl?9l}
zjj=OOB1^I$qX-dp42CVQ({I$Kjj&e0RJqSiH90Y)mz6UyRV|9}WKM6zEzt8@*sMrh
zVl8pTu2;#8c1606bhZM$W3{XG$3{E_hd?agyV?qeOa!Ua$y~{iv*kw(Zq7wrWMTsx
zi8L=Hu}ZmMpyTcXN}bo-i3fnkjxxgf?Y!t?iJNyNEAB%=o-i~adu!XNPU9@PdOJRZ
z>Bqe@)j{Gqk))XV_%%YUV6!6DgV;TS?7v-%nEY1=$oQi;Wsqd*3iPQeLav^06*EZn
zp>1bxF;Ge5%WwB#!3Rt>*K~RgSr5)@=leg$^qY#|Yv2VHs6A;Nr~ROMctaL44iw*o
zpb%=FUHD{Hdt!a+F|lyf8R>(<r%vgDyx>;1*S?O^@@4Mltkm+XS!QJ@n7ic_3&jTA
z-hDuX{E*vpz?s(%ZtFp;L@qmY?)5(DgOcYg0(C)r7Fw9OGxk+$&cz8=mUP>AE30hO
zQBH+u`__s+XZ-?qF=#XAjY5&1^n!^W$6K4oMO(K~P_{Y|YvsyH%&{bES!chGc$uK!
zH;^Bew+9ZC?&_%~wh)DVSz@?hla5;AQ0hwvC#L!A)=FQY$AuYbCbRt#qRT<^Q8cu_
zQ#q_g_;omTm2xnpFnkE2;$eo+X@Qnr*nCP4pK6wMAIkBYAh-7Ow=$<{mR6p6TZjE0
z027ufYj}Fa^!RQL2miunTT5^S&e2P`XRXn*X%YQCy;$o0vm?kBQ`;CHhJ1u21!+=l
z9{lrt>)_a=&(Nq7=}Io3SI?t)oK?^?zf#2wN%eBwxFa@p3k3#E4g7P(mFO@soV>rr
zSn{cSr$wyaC7(Fu6*Y#wXNOu|l%`+A!xV$kdoxFLbAStFG2QWFv>`sEy%6UwGx0$p
z*jJ+_M8Pr?c~C|o2|;0pL{lX4kjXJK2p5h%sBirhAI<VxsFYLO(N3ObGhQZbn4w4v
z69tLc%0*nu2e+Wx+keQeVIG$B^<I=X%7`BAi)#5I6AT+=R{c_Yf)QtN{W$&<Jb~9|
zmQ1=@vzgyTafV0(xS|vuwrs<rMC19(CznW#;UD#UaF*)*=$xYZEE<o8(FbrYN&22K
zi&?8jIU10u1?Jqdey0fhh#UHmW|qBcp~P#ed&Np7sYjTy`Gy}FZ_ZEbqt|{!16P=#
zXoxZ<%EO?+fE_q2j*a;kcY>hNFT*F%F5;a>H2tF_bc<9i-;!>wKeH3b=|<8D%=Cn4
z4dWs@x78C1rGP7mh<QCyA6Y6ZKIM)>OE-;9Lbnl2;zeSS)PLCCK<+oKu{T0tRk`=z
zzE`2~z?-~Q{8k|qs>wzJ@+GRnIx|j#J*pV_w;#k=6lUQi?c@CTcw(t5h#!R|9?+IL
zACyA7pyS7?7dU^n%<mnYOjnA^ejb@XZR~KIbRlIugTFXufh*S5V{Jf*JD)S~h-a8=
zT&kQ9XbDvx-4+?+>6c`a{yqiX$6_Zh^ew-hHb3{aEIx5b-FDd1UYP2F!JJ-Om4B$D
z#fe`UCYY#=TR7CZNR#8CFi#74gEoSIEOV6)PBhvxzW`#&o^XS{{(V=g*Ey<*yfH5^
z)gnGS9E3n2T(s2fjR5RE5pWW3glzs}r#Cx^CJo9|mxhX;9I-qz5UzD=hM8Zalr{nK
zESZhqhlkY)OSxC6P<eFKQwXZIXKxO-*qu)aPvEaY8gKboc=c=!@Eeru)4dQq0r3Y`
zE9g~tf$>>NL7VXC^8ER;fdC|qAQ8gQ98`RoyE&0l8;0qI#Luf_ontcJrP4Qw93Sxd
zhv2qk%h#?g9o<F4kpk}6(M1g<d#?720=91KTiEc6PKnr430U4(9Newa0B7SpdAn%C
zm^pSrQx@v$68AfLH#D<!->S$)Ir<^^xCi2^mrw4nq#wSzSZj)OT^QErYJ|G2D3<GC
zlvVSj8Q&i;!?68&6p7_c9()X+oR-F(3vgst97QDzj1QV9EgJ(6OUM-qP@2=wG|s*9
z;?pmomh?k$gZ>by%|e2k@dC|pr>l|=+CwWjFYa<P*qfEU6<0qYKOQt_B<r~N_*Od$
zfB!<Pef&ehE>W|j&h2wXsI(nb@X1Dikfw@ZZ>_Z-Tv!LHzI#_Ox7cKHFAm;nKJmAn
z*W<yah@^e%Vm*8mBjk*Q&#7r@(qYiC8OympcqkK8L3T-Zuq&JPP<zC62y{5QKW?IA
zgxPedA2IEcbAhUEeZM5CAG0g(E721^8I=Ygjj0ng!y&65k(aX9IaDBwa#t7!hb6g2
z<NVMxq=WwwknZ&bjCdzI$mm+N&HyqnJqUwEZ5F0^nLLCV<m+${3KvKncSrqPP2*=t
z5R_mFt-@q5gW0rh?`ZtRYqs19h!pJIwFSS3TOmg}xAW#f)MvT6;sNjxhachM4!5&X
zsRcVSmf(UR=%H;Ha@h%L-DU<%nQ5pP3*;Oq1RlmcdW15uKbE~?aCFe@n4lQeh`|OL
zbfszo^<`D^FU}Hv28~1H%UTyND_l8*7qXmtl}pg}s4VwQk(uG3OsN2^wYPrhoEA=Y
zNERlGMnig?YG`99eqT9smW{ta6g`w-KCOT=69wZy2E!AzV@evF!s|d-;X5fI_m@+v
z1yR?JijxhcKBvS;u{HA6jN=Bu&gMk3DkvKu3iF?H&l57FHuL9FzlZ2XTI(q)M14tQ
za0-#a6MLs#5Wc0SR3Rc?;1KLBzjc^vihcUDFqB{eAAFR(*JaduO_t=V%UP`jSw5q9
zKd%Nv_b*o1V&#_iT@p(IuLpC2QwJqGOo_L3z@!Wnba*Y|I44i^Xy?j3PFCJ6$!rMa
zL)PV{QkFBIXU2zn48K|E8c5PU-XL!i-#00Ew6MXF1a)+-qXt>aqG~0wAD1bkQt-%Z
z7vW*X4IKUwM@yBAxZ{jvIB(J``%$?>>2qvr!R;c+$6MEM^<)~zhaABQl9~>54@!!0
z4`URej&Baqosgq;-$JURsbV6bs7EsmDkv?l@EN0ptf0OJw0yb~of}o(9mg$s4ngeR
ziBjKM6$;*-)U$3sEVOLi_Cb+dFe)tUq>V^J-4GNF?h1paw`EgX5_#k!cU9W1yY?sq
z&~RF4=jy@FIt5p`{1gNKb(7M-7j$lPd#D}h#{a#iwb>kf<cl$SA~L^z*=}w+@~H}s
z=v6GM>I{xDoVbIHC3uvgIS$fP7>^@9s`j0zS{#0_`VZl2c6(!Pi;Ty3CWQ#qlvF6F
z?N#{(f``E}l7L!l7iLR<j3yjO9oIngG6V>rx=3t_hCi3Bo}i_Jsw*+n)w5{tZNo5m
zH<95cXpb(iZ-ih1@eLgI1p7V8H+f*#8xl=ff>n0)F7T*b@2KY6C}QTou<^VH-2w#0
zSrsYS+584dHq^Q1jgfXJS@!3OwgLp>Uw{TyKW91GWMZK5?AQI#s4|$Ij>oLzSTb`P
zP2El7`!2-aCUV#~2Pz{DH#47P*({ZX+o({=(=K)V&5|p%XODHVtUP5cX6L(1B2m+h
z1EoP7;A8+~Y(!;B1i~=Rpiikt7f;x;yC|r>WwwoQU@%At(-kV^X23}i4JnR6>L#fL
zjUY5-dn%$rISl^;tf4v=@QKRn*ouBkIIIVLOWx0l%&bVnz*fo*uu##AFcr@>4ETu2
z;@ReEi|RMNd&?E5vn_p9>bk5x8{*38$+!Hz?I1(s-$M{a>3qKQadEa;DEbS_i!je}
z#@s<4mHH~Smg=2#Zq8=L1+fFki!NPaGqh#6XWMxWO)&t_uzS;plvcvyzh=rXX;{Ae
z7Jy$drtWFxwU0wlesx_duj?`(=Z7s>pz$j+9CR%8x=&=O8XzBbv5RzY+=i^tTmsWn
zyperV`T>V;b~yKfo1cL09NJ^05iy%kMDDC|9*#;}H^tK^EmsOq6e`F=oxinR{vow%
zq%YFUds_5FscV}~t@k+>FDYUj46`+<6Z1;oLFsoFxFcLZdS5>bS@X_0@1oE!zpPER
zXC>~*E<jltD()e3jIDPQnV~@?ke12jj^6ZUO#Nz>Swl~H2==XT<uf*C6|duXKBDwv
zV{3$Xw*7QHhfo?VZh$$Q1+jBGUgcv6n7j5CH@&AS-C*oqO~xsOzSqM%m1>%|K5c&2
zOSxAbu1?Ai9t~!jb+s7N%w#Xw+!WTDF~`sCcZu&agKL{<bgrL_Aa;n+Bs@*1A(q@<
z3YF$Mu489{OBj4Sn_QulScN7<x^;SVh%9=S^{dB4LXCP%Nv^3|Q-vM<a~?ll!N}63
z;M1LY354*=>J<1ntY(P>QJ0>?&nQH>+neGYu{Nf!8J{@jSpUsE<hQ0}(ZWJ<a-fYY
z3i4q`of_tFCTonAtqV`+?WY~T40&z8CN~!T0I(XVLtXevIVnto@VqEp92ZRDptGLB
z+B>I>+OBa@ibA(OztHi@@ItbW8l%lj3iUm22w<D4{V<%YQS{S=606Bi<)oxqS#UJ3
zih8&%y3s8bJC|ButS7%ycVUGRSJNew%<TvR1397eWOkQ}deNb!B>lRETk4GUT5N9Y
zb2*Q<Busc#l03W}Sji5~2ixJw8>#J4gxTdpev#kq^=s_fi5J7nFAgU})BJ`g8a7Tb
zk$0@L*eQ20@<zXsQ18NgDR@8<J}^{-T)AB}|N6wJtKxWp-eqlUp@>-KseFWWUEYcn
z=nvy1DWc_XXnV5{u1Um%tBv}SuvRsIxA#*Q2SF$irT)JD9GjhfJR3$hf9`Ykn3@!x
zFuO+&*q#c{&#60h8TJ^rF=T8t>ylMO2rK8NPaMl9j?sW1KhOo8Wj4?PaS$29H8^Bj
z(F3w&5E!%tk@v)rwX-2xJ@!crHz5O)ieIc@sr>b*y0t|`{q9{lSsdFxZS)W&%Tk~W
zJe;Wp4xsJ1w~7Op$oE0&VZIjQCw<(JJY$Lm1cQLp%qfJlv_k4`@8Mv+8&;@Q@T;*r
zR_tAaJXcs-QnigJel`yP5Pq`Ba$1@@;ARA;05_}CU9ut%>Br>5vj#F&n1Eww;`QO~
z(OIY8p{GFW-f@Pau2(S3+QAUg2+u(E9|@RI!&N-cue6r4CB+pDx2+l`Zv>1IQR)z+
za-`7(+eeug$OcL=t8}%=ZkK~nw-y$QG@vf#3U&n+MN4M+hpj<U-FNATd+#{J*9&K;
za(w2()aVu4kSQlM#L);ZcKo@+2@{&W3s9OwRhn*ew`r=|)-6rUK*NAql)B^_IH|`O
zG_4;QC?qi*?z7Dk*;q^#ttQL!SL7>1S4PySQjN>0h!7DlgG|5Sw$eM8q3Si*^)4h5
zFwfel`?LhB%W}4A=6E=!Gq;=4Ikmee;${x{ij-!k|DyFJ^^X0!@(ZrP46qxVsnaaH
zI$E!ghtLSUKf3dm_&6wYQGqb>YC*#l?AU60Vbqrf_T+RGagXx58x~CxA`d?K?PN<3
zdG-F@F&+o$!VdX7gPLB1D%HbdeXl{~8sAyPE=s3>OG-oe(3-i9$t#NebLI%XXw1v5
zN0YLN?@h_Zl|xB%DIRso4m(N2COjo?wPYeR8dpBHs`5_1;PcMji`9DtQo+cgV$HFG
z7{Z<6J2jhm0>`L7Z+8wc&hN_?z%9nYlBKv*{es>lh3dN?NBvyLW;&wd&>ULt-K%Nw
zLs|k|oCHJGs?j@{qr32%nk_6N^tSO+mTx3V`s5FDT;%Z!rcT=Q+mzMBVMx>rA>vN(
zI)si0H5XZ8R<!A>BTDURbvR0phHsm$S@)S%<oqh^=^e83A=I_~y0nwAsNkvfTou7@
z`8_M9y|Db8XZ7gvCE}^ZSAF>K^8^Xir(X5AFrW77B?1T#$1PA&MX62S?)#HYT$S>w
zi?j2j<%KG%n*-|7Dfi&9EzrN(T<7c=Q^%pp#38Ywem5nZBT=`gU{l4f;KhOKK52D(
z^eLB`RHK&RFb_WH(YUoFbZ>FzKH*D9<N!7#DHfXCHpMTt$ILtuAP<oa{p_45r;;`%
z9~45|O880tDH7F`Jp81k4icvtIxhgN5|HkY%H<!2lj^7C^}w1h&2(TVN*V$hCk*j@
z0TZ?qKFY7#t@|L(f#=dJo5OMx4?<;A+FH*TP`1cOu);_1=?H&8QU%1y81e}D1r$K9
z?_{@OuoDL*+wdF8MXgeJCB7Q{u3<49s)wq~<L2tVB6>MOR|iU>t>McqZL-XM2zm4a
zk2empY4{@FzFh}2J}Mp7L1eG%sY?#^B>@bD>f>Zo$^G*3E35E!r!b97ol?u)gU*rt
z4|OaxjmJZk&dwq23e)dQ_hkL*rM_G+`%b(^ptt<3Di&`7DZqTuT(W6Nd0~4pOa7%k
zEn{@|06Ee~V~q?FW=AU-l3<MXy3MZJ2Hh~+0vU<b{koA?=#P6mz~?VIgp;&fb(#*L
zx4p!{Z)rv*hpM^I@Zo4I4HwcE9d1xdrJ;z6gi*(mT5R=ZO`Jz#p|&{P*uoc;&G|wP
zI9C8EKZ6TmmC3#iu`^Qz40gz;&@m9j`|qLN|5nd9{j@oY9XV?B8Nc#(tbj?8$5?Z4
z5QeP3<U}z`{<%?uGj9lc$qoBC4uA0cJ)I&h2L>nYwtNP&`>YIav9`->qk7zz0P9lm
zn#7K@0~=nP>;?J33v2zbH^tiY_ZY%QsLLYyYI1>X5#_96dd;TYW=M!32Y&zL1hhEK
z#n#!yL6MjaY<W%Ou9j0V!Fb(9hGDNQsxLX_KCyW}zMbiRhGSnfALETn;jH7Jggijl
zCf>g8co_PcIXpY(@_G-Ilf{+46{=uI{GL9%O3}B`iusu?5jYmhlZKdcjqMH|welGf
z1kwC^J%x>49VwdYJz=_9m5z)FqNwwYO~|g>HHEm=@12*RhV~zbA+grEy4RYEl1ww0
z&WjAi98&U;$GB{#ItyP#daR3BJ)rcTJDAH&VFLk?QV5a{Kc%WhDvPCGu#;M{nRd*q
z0+B#_ef@y!@%Kk7uLS}#A|y9;D{QoKh=cL2`?*Rw96a4wjq=iwX%@2rvjg#+6nrEb
z(FcNQ1BC*Ssw$r49Z`YoHO}W&HxPF0B7st73KZ9C4-F)kS@y_ZAkc--4sP2aHdI|T
z7j4s;a3I}oqx?tf1-`#r-AP>ET0R~-6_jFF#_H72dEC6J*!S7uJ*+Da*5pj>9?)mU
zs@nHni_YS|H%&0_BIcx-nr;vHSPw2DXle1`qzblLIA0`ILoA^a&J*nQpZ&NatT%lZ
z2I&dnoEWSuMHf$cB56S%PwPFYOGH4VUJ4)WredDI4F2`DA?KZJ?P)m2Whw{-PQixM
zwwKT1m6@W6&6$)JVjP>{U#RQPJZs*42hI3S#%~o4iISdRHi3?I;c2AmH}6*Y>Nybg
zOl2zbGx+*K1c1CzyZG%uZ+{f2m!FsN7x6VM?tX2a#YAjC5jPuBLr^Ht<2(?VPfeB+
z2xn~2kI%<5MnyxM!WgPW#jr)Am@S;aC(Q68R=%bUcbVD4kB46AE7@?kZE)m_OBdD?
zXIZ_CRawRn3w3hgec9R^+r@G@;2jh++yAna(M2g|dZztgPR+q_Km@t?7gY-Qwl!yP
z^`XUWOZz^L{f&nPItG=KvEhVt^bDWBPEo<61)RJ-U7s>sgAGd=<dQv=YAx#d2+#tW
z??fH7!-8&|uMO7#t{@@Q8i`bXhGjyXn@2XBT^Y*|<XfIf)=#v+LT>Oii{LKn35W!7
z;pUCh-sI)$SX`H&pfyQn74+yIUX72t%7E?0ukc*!e9(qZyIiodp;nXpW3`RjJZ=X&
zK$BKx(CyQQ7B*>yh`<m;U2#ZGQmNNZSK#)L2=ZykW0K!WU2j(p$bZn<E2KTni(^C$
z78NL_;FC?aanx7&#U(m3`$eYAL<RYOGO~g56bS#QmJ9QOIK1PZD#Z3x`$}h`oXqH#
z=w>7=mwVw@vo3qm5Z?xMqEk2K%fJElue16}2Q~!-DAjp{DcvDcqgL)Y0yIl};T!pe
z{NIGq=L)|P7EbfbT~z=T?J|L~6;xLyjov!X0hIH)WK}ycLo$ob^i7_Ojx4p(^_(5n
z;6^e*eafWR(zV0$`3NhpOc&qhnL^3MFauJP-z<&d<OD}FS4^waoH0VaW}BM`nGoE=
zkF(&Co0$uj2w-``JzD9;a*>cULXa3^ZYBkZi=qFTJmt>;wDY*4F0pMym7}&DMrEk`
zAG!A!7*8HZ(RH0$ou3J}j&l<fZG8N;?KXR*qQHz;^l@yvgavD&#BrL(jT7XCTn}tJ
zT-M79;)F%o^OiCw`?|!7I98-CHeG?$7~ZIlvx*9q_qJ?)F)+?Ik$f!gycN>vtckW?
zSTU@O<5ODTU|fpBcut~Wic=IMO*a1zMjs<%>6IKT)o8_0<$Sx8;ylI%I0v`x1VrKM
zUe+~JO%HEgsGE-X<r=gDVMhdtkf>Db+2H{DORp;YNq4uxCikKmemkcQ%%zl8Ni(?7
z*C0!J42((9T-m9;?`T&?#>XdYHZm(FGb$Oc6?4mb5>l_XpFZ9xK-4G(eXk-a^UPvu
z=p}~z?vMzoVxe(IH}l)eI=3KMF13geZ9>?M&|MWnu_DlKSuuX=J97Ps6tZ4Y5<oQO
zF^c%P&;A(m80TgueYC;~M&ukI%YmSvVhz3D$rk&fhg~vVI96#JVrcPo@S`j+)U>QG
zvW)@3WOi0O@@(HEj->EmD~!1<2!c|-suJGYvq11L=PmoapI9o#T?RWnn!9y0lB&}D
z;%ok>@dHTBf|#Idal0f7hHDj!<~IWk@CRj7ZNR4OYOp=tH4_a}sT3K3>7F}%(xP>#
z(l^%_E=7WU7XM~R-gE_n&m9%fBIq|BD+$eLhVgADTHe}W)w3CUDyw{VCXa+z#Pg{g
zyXwqXgN2N(@E*^3tM9SOk<;U;-&(S<Tc1z9QQy?k4r9EkE=2l$PfH!A&C5YASKIYB
zK5rM5j+cih;}$VJiJh+6t+p8OMxn`<s;lh(ktfWpo8dwzI`SGJYuA;4x*yxwFUr>)
z74A6akixx-#(8J2)46`-<fegSrME5fj>eFPm1F53kC9_+rp_B2(C9W2zCO$GNjv^Q
zjC4S<XRtl(EPW`~gZa_14sN5`*#mv{rsf&HKySz<sWOsJ5-Z!vSjdbf-HsY{`FH^m
z>!90Qel0z(6q@^rJa+trYOnFByZjF39lq9G1#(kFk0wBL5wym$Qe#|-uBBj89SxWC
zQ&Poln+C*EHT!J<_D(RnWT9Mo&auUmFqN<@A@B|gT22Q2glMp!dYaDY)N!yV?)4g{
zr!o^fMg7$cDi`6a3P0iZp;KdZn$$c!k6I8M3ubFl;09rCIed}u5%ojM4PydKI)pZ<
zFO#Jb5J5aIzU_eluE7eS)}9S!2J4He(a@JOKnS01V0fB~KLEN8!m((37Vwax%<kh#
zZJVW`yGkC%@MV_D6yG8vR)rh@(~(BC@C}*Lh8|KdY^h}&dEw`eU($zQC*QK3G4I)8
zuEWxLn&slNbZSn3>O1)iHd#&jgsd>O(av}MO38+3C&nj$wodFUY*;Cco9Be28Qt0Z
zib@T-l_a&T?s{<f-szz11?k3=>lSykGI>(EOP_FePpoC2Q71>ING!e%@JQS<wql7R
z%sObqfGg0*@1xQH^!5g`Gz=;BiPNV}1E{Cpoaz`iC^TszF1rAGVPivhUmoV1B@{!t
zL0A5<7Rt<ppZ)M_(*Bs63f>o;=6J_f$$NmZ<QSbP&C>RFl80&39Y>g7YPDb;$7#of
ztSu%@(P3=;TAzn=!_8;{L^{oOs2tl?osgW5`=bjnN9*MZ&Qoq?aLNbrS=$d--!2;x
zS1B@4td#{ue1*$zkNoY3k0TpY!#i_8DNVfF;tZ<RexlqiMfS?-M_pYm7nNuRx#&Ev
z(QUDpj1pLP4Yy9fC7UA1e62xG$@W^4{+Xs%87EQ*#7?dp{HnvNR>DQ~MVFmD{&p2^
zS6SOa59OIEdsV$6DrC||rrOc@=bCi;E)iwkW7>e68fo;M429Y<_;%%B=KkKNDz9>t
zN&*~}w++5^YOmK-G%3<(FS9%s+B0#ZH#m`Kd9y<J&X1~A0OF-DEF5=CbSTrij1`(6
zg#)ct`<Fj+a8y#}x2W`_7Wtq%u-|@^=}gQS=3re&Vu42a*)YDAaGe6}Gys4J=Fe0m
zuC-`aB;7e1|1lqJ4+vGU$WoaiQ9n($K>-)if*RXH?q%_ev#hK1>rwj5luOSuwM!f*
z8C2ic@WtJq)C7~TVgQq?@eErTj?`nAWS!-thWc!sy+qYR+xb9C(<GZG**&AM17DYz
z`}=#bp{OdA+L|&%8ADX*acs(90jK)+Rz7_<Q+ApzXV&kda=DaX=vWXiX0T5qBP;3w
zOS*WI&*d|!3NsUv2sIM@fu{MQTTv*Xter`mA)<=$-c|}wzJeySHopoqev+fwQs`D8
zksO<jn|>kLu=ejT+hh$n6TyTWO3Grq!!%jP{zlxaxB{1JeLf-kaA_U=iHsw(ilu_A
z2PI-1+v1V?J~p;bpPwVi;PYCDF~zTv7CrppfMFBcthK<lDI{xM$fR3S(TYGM^4B>z
zv~ej=5|#KGu$ZaBE_1ZZFgb6iEaVffM}{#SHFeC1HcP;-OE*7gn)w_1Cm(DRi_!E3
zC@>{|-7J&2rz2yQoKpEASLZYaavV}S^NmI&{+|B(j-M?yDNq)Ka#ISR(6f~W39tux
zp{Mp<tEcgC&K>USgEoZP$_pk|XCXcQiMSa;i$ZCyBC=w|Fv>#XV=ynbJw^E8%PR*u
zfgG`rJOheBxl*5nSjU`YU0+X6V=1yG{OYxMzQr(pH`tmArKS-;P>*pv3b~t@E}mgp
zb5na#%q+b*3X2(ek8A2g@{6mjL~Pv#*rV^F&!64iYvuiFzm5|r7>_8piZ6JeXHd&2
zkKAOcK(Tn^-n@gP$_@n1L8z$<`u!}ZN>U^*)U8W82z6*dk4df?19!Zzay3mEQ@+u?
z3GcAdv)8EpG;n|(EmzxRw6q6X9@{bq14cwF3~>!0GHq}tGGrW9PZR3`Xj{al?5(On
z)6MuTl4Z|RkA50Fe~>eeC0w!es=p7)RRKMdfpq%CW9GZJqj4WECD<u!^UeI1<$wqD
zXx(|&h#LgP7n*d!veJ`BEl{`P7xA#h>R>l}{;%na<PtZ{W~Ee=AuF_sY$@^r4y)&t
zz5}n)>fo1|<16_PB)0+cLHPX^`QR1m*;eF6Qo)alf|}Rk`H9iqZb4W2cZXifP~3D_
z^ufPJn!H9`lJ8m~vg!9BEOK<GvaN(6?}MLd3QS=+3e0#tBtUk`QlMuo`zR9={14=5
zUDaQ{sF5vndc)(|SlnECx|FxGb9bwUTw+iILO4$q)Z;hn5_&NT@z{<$SEjGAT2Nbr
zFw%z&ChS1z_SXj++KI%nRnYbEM34jyYoFZ}<jq?Ptm(Tq91!H@Za!^Cf4!!igU@s{
z3aV$9{Iri%J$CP@g(rqEk~WTUCw~>E<2X`rz*}oxDZ(Gdo45<PLrqb|$?)-Cixqi4
zTyuL`2sg`z>eKANsk!UCw=5NjC9%%@-5fS6Sj?w^5M9DbtfID5^&O;woYB37NT!Vz
zK4o&ZacZ0RV3l+DYTg;V{*J6mFLLKFP`_umd)-(uE^&jTzOP~E5O)Wf>%MR;0q#i?
zL^qCQ%aJTILU0-NCRm#Ov2)C^iN{$lh{?*Txa2LmETJgRpn^B?k6c({#P0`6IIxh4
zkZm;Onk{Z22g6~daN5achHw$ghI{ZAog=lhGRGPZXM<+Q{EF{!u6(xRJlBvlNU;-f
zwPXhD05xSy7EB($-=;b3qx)&XN1KsGYVjMN*ux9I$k~pty{V3Y$bqDe+)+THwA&Dh
za<?gSP>Ytx_Nmc6V2FX)%xCJF!c?zz2xu%+1=JcOx|`w_B{ZR>HH-6as#K`zZVhhz
z{ADq(48;*C8e>w&qa^hlj1^x=_W8zH3nw8%KVh%?XDbDFH=+6nZHre?z0R{CxrW|g
zyko4J8EuJJYRdF0?1l0Es)yp}n9}sS;p$|7wKNrb!TL73WC?M8BI^jJ2BbGBfseib
zlbKN$A7bwX-dXS3j@flf22)^LM2b(f{;~Q67_rKmp77k2IJflA_fsL<M*<bG?h5XH
z?gVhEghV8E3VqMI(aq%AQ47Y$$~7hty6qvB{;^ZJs5KVcU1|InTJ2B+m&J<Yxbi1#
z`P&U?j<SyN)b{n+j;Z;~8cjXvnav|TKdrXlZW;wLwf?!$+vF<#(iH2gqswZ7D1Y%$
z6-#_%-)E|Af^$-9sBK#Q%a1d{NAMnUy&$?zH@auJ3_k^N_%@4zRKt|!7f$EPQfot&
z#>gY0(~@?1vP(^Bn||3;_sV)pjBoDlyovsdNqZ-|nx475F<3&is)wW431TG%yBE8O
z2NYsGEEr^ovr~ZHWG(DioI$BGG2$=DreMFND8;JNw<yC;*PD!75O(;}68rm?d4Gek
z^trR#W6cOrcD0&+O7Nsi5g9Yp*>CyjLVc~(UiwCR4mmPErm+=m^lVa!-uHFC-f_<V
zcgY3KB!k#PO-s#$>R{_&yYhkN>%o4G<(wQUdHz{4gi5e?6vP9Xh!m6IC%NO$-L|>U
z+;LJ&&~?IjLiw-}99Sz+K>9XU<R8&ZlP<+ZaQQ@Q7U|KbZOQdfWA1weu-{;~SD7{Z
z6ehA<vFpp8ao}Pr`*PgT0}A=`k-L9Ts$R-a)~kMF7>w0oyjs|v>#~MOx|gH|dCHb0
zrcfnhu!w+~r%PGOpN%I-+JwPohDP}<H)cQ6@?)IVz?ut6+Zg4$`X_kM@(2Sj<yOR=
zmQ6kn&%UMNF~=ZJFCG~FbrE@5X+B8-n;UCCe{AchtT3f4@yOD{obi2(0(7Ix{xvpV
zGLxw5A;*|i8BBH<r>SfK7%RIaACNc0ZkgXMyg5$(OA<cD)Q-H&)rO4o&w8V6CtgN+
zT{}z0Fbd~5D;&`^5T#U~zKwEPeHln>ow8Zr37u9@g;qMi_b3sLTwZ~!n|%r_qQw*L
zFW^XFB<Zh5wQb)_8c9Ke+^P?CL)q~kQup8dCDe(*z9J2HK(%D*p$G$872OX)8ry}~
zM&Ii=Wa>Y4hKDZQ#qhm;@v3@eEVw+dE)@p(ErAHYXYlyBvAnN4OJ<|PVu2f7IZr(7
zlSmm_%PJU`e`XtR<1fi{5oP!6<LXa?cj1bq#%ImiQ&o-b<4=`b&vC~=cv!&Vv`UUJ
z8=O5CXn&RuekT_ec$+s;va8iong6w=FvucFRbQ*-zD+!?DUcSeoTxHs#_`<~X@WC?
zY(ki_aYsM3j$95eH7D;kK{Uvs_tI!#e_AsAX_x@O5<J)7`w$ufcXCTyhr8T3e|qAR
zyM0UagE(wADHGznka6MhBH&ic&`49HO3ZRk)>_2w+?Y?XPF)LZR=@e1-Y2d2J2*e?
ziRw9}qZUh^nr$B@fcWt<1Pol_YdGv8@=QDabURA*I%AqihR0Pg&#wd`EXU~MdFP@m
z<-~ag;}>^=u<E0Y!7z9cCw3|tZ>4ckQe9_h!#xi9pQEv|T~D&Q5U>qSMfyy)p3E0s
zA3rcdN?F+VP@6&jf(#VQ4eDo8I+J<Tj#&^c5pJG$;PPrq^T(?($wDet9NX;AS6w*S
zJFqamy4hGk{-V}j1M<{cMP9PN2JYV?qR!OXFfV0zUHGVG5Ujt<Zdl?B3)COzPL;l&
z|MF{>c%~<c<a7+%rK@bx<hXz>G{4~LvjiQ%sp_CkT?RQ-dHLo>R4i!ZU54gptYwYD
zwp_{snElk?al81F4!Q}Vnm|E-P@p1o95G6wrPB1pyh!Q~i8YR=<c;XSz~{C58?+r3
z_fYkrWU>G*^`6Y1@b5#1G<eT8s7lzh*V3UuFp9_p#i*!88edSMXyU4Nj0-fiyc#t?
z68%FfpWq6lo1Mn$MIALnwVWI&DYD!?O;{^POdKQGnNDG57<x^SB-+2<5k!nR@bqJa
zayw6@HVLB;gEGYS?;a%WPn9pWH}g+c_N8!(AbQUWK%1q6?+!#@^cmTr@LOqRe(qpG
z|I9_>@7@2ks?P^E0pwm3T{(T6HkW^lAi<#TAdE8kv0q0o6tUO09HnfN4;gX@Ir*3O
zh3B^<Ry-#QBd!JSHDc`&Kbrfj>K!SEMhmX2^VH>GQYYRX02S?V_Ts%pW?lBq6eFV3
zW9A?ZN6&rq7beFckT@n_wOo9yYB127vBc(@^ymQ;B9(H3g8U}2Yn3{A0>N-RPyi2&
zqeoH=kF)SZ8ZTB_NZu1oXlClnX0pUT*T^+j1ye`(2B5^MIOGXKMq*|?!`xrTfWRy9
z$@>MLnM-v!Sk`&}m#ZF0de7u(hOo3C9}QH*mZUzKh~ui{=iX}dU}y3E{=8cWQESPL
z+$z(s3|nDxTvP&N^)e+zMH;=C1Q_wlYn1D6SC$K3aIt>nq2v=)_WTx3jdJ_Ge5Hdz
zXQ-%9dS>sAf$;z@QFv<s*C{cnLTGa5`PJ+~Jc;8f?23yt|M=6VBU1VF$t019O#Rl+
z0qIGhHg6Wfw+pU3m_bAMp)%@%8$~v<N|Gctrrgi!Uwg)QjnsINlSR2&)-Q+~WKLLN
z=I-)9hNz2ApR{7w1JNnvi)@tLckJ_!Iw?HoO46y@M<jB%hAZni=s)SDAuHeRal)O*
z)Sjt-h7B{9AbfOMzwC-87Qd`nI@+NDgA#Qd&<FwDwit3$o4huQzqh)H@kY1WkG=GR
zvqSj2vG_=IbD6iJDw?MY3Dx?GBaGLVu20<5g`N&Eg;$2<If3UD!NjGCxt>hurdD@W
z+@Yha3_zzd;4e;({3L#ERAXmy<p~g^8jyX^_kF*5zi{n(eeDtingHie5)$Gip3*0Q
z&sd{);DW%Lh)u8eX-1!1yr&z+_vahI7bM@8hpy*4LEviy@acH-ZRf_<r%CKC;6i&x
z|1Aah=nJeR7uZD2)@!30Bbt7{WYF3<)K7k#_I;kW^L;7<-aP;hyWXB>?SKb2G4F2|
zKG#oOz=;DRQ@3@8+BQ!Cb6Wt3)M#{DAbIp7k<SgI0C2U-sQ^*!sPL1*Fh#b$NcpW~
zG<eNXX)51{f&dUV5^tRmlR%b=uw096sDO?w=u#tqS+K@e?bEB*?m61vK)rQY3z^1B
zGucgwgN|T}C+w-~DS1lG^2<f|#`(y1#uwVj8?XH_;rG+SF8<QRV&&OmJKwvfE}!Ss
z$&1)W98_SF^0k9BFdcpkOHhSLbU61nBciF`Gvh}Td|zI=p1Qi8Iei~ayI#&VUk@~V
zKm2{#r@FFJ+)3#=^*qjgb5u!IqLW;y-ilDQJMGHk)1a7n+Kf9(uz9}=ovpmB^IC2P
z_g;FnTHYK2B~uasf!_P&zI--Ia9Di7^&M*2`^NE_ht<+^vLTMAAI##Q_CQknO^Q8f
zlIVAFwto$|u^%g>;3`*ZGcCkC;APLC%1+U%)pd~O6;&Mxo^MwxCTqq)Mb4?n^i)a2
zHSn;lB1NJ_gS7KE61*25Ecs;s-z7b+;AQt|LP#9g$fg$wClDE}UrO*<o+38SBl9>Y
zKSmb0$_ESWHGd9-wIm_{i;4ZR&Q<nO89eD+t*vtbyoLOWX{hfkICMH)*D+}2?#d<Z
z!wh%}lsC(g3=)$_8gmie#%*_-gPq6Ly2p{%N9($I+nw^(F$;bne;puuxgNgNGi*Ib
zWZ*BTjMhH!9tZoLm<FI!5%;G+mX!kSVC(66?S*isA<GVAeQ4|G#hB<(@@_3En1y)K
z%%j_N!`9NBf#8;C^VBgzy&xSKpGGa3fuK{)M!3I^vW?83NL|%(8n#+nFs8ll?`^wt
z^#2nE?HG8fR_`-%xq%Yjmr<v9L3OlW7v~906WMxb?cQ51_rJO|4z?6ZVAc5!;U&0g
z#$`}m_jw6J%dH_5Zp;b=3p$!@7U%qvkH3rTFp$iD)L=Jf)aRgq@lvIbuz;?S&QRG7
zB3*4xjX3=BHt)+)qt$=9-$oo@*zDt+3zfU5?2){HaP3u-R6w>*guttbC;H&pW;W=f
zc;2P{F7<nHv<s?4;2yB;+5cYnBIq3heyIgK`z0uOslaUpbbbMT{L$+;QI2^6K0*6y
z<eZ%qK0s6*sPvKQbiw%KkTPI=-)hrm{GHm|g~Iny&-6EOvq>fhcRDa=>moSu<oAyB
z8Dv$V9)$110H?q2@{;H!V;fNN65YHSNq!ay?KSyF=ph+Ubnu<1@Ng66o##fvA4oml
zUPgV`>7#h#dl$6B@*M0{anJ$0e0(j|B5fN)-tAPs(Q|e4dS|r!vc#JWl=J3%IK$JQ
zYc~Pz-UuFi#~$P77XY^1iPhe8>mQh&PP02bcK)7Zoa^%5&;EIUA$5`9%fJr2_X9Fo
zW-WLl>@PZOD)_uc!<!JY++TnRemk$Z(+4Yqac=afhV*$(Ak+quD>})TG`@RpQC@CR
zZb19gs?;*+L;F0he2m%h^H6F71uhddysh6--VFU0HQvMgvcm^E9}nSPHx__E)W;5V
z-$kC=p`Y#J`zhF-@NZ^xYUS!izEw|Fmb|V&xf`ORj*<r&@*i>P3Kd;!zD<G8D+V9O
zZ;SA9^?y7+h;Fa}+Y0s4fa_SBY`~N#{xsm&IZ!GM_~pP;_Km3UX>;QBaPHNkpn&9J
zV$n0aOXmI-p48}+QB!;JX|0X%=h={GBFv(G%%>^kn`)N64^dz#tLCI|Q|E^HdpR)Z
zq=9jhc61Uz)Ah|Xs*114H3C+C#gpLmVcZl_)erZ6Fq&b*%f(-Cp{(kmb+RM>C7Z3?
zw*nZP7UK+5dA?;IpX8pXdf%C)#ch}JK;o`gf64GLO-oUU2|k=FGv=3n6OyveJa}?@
z-?lrPODW?n)>D1uy3_998REX<-aDKV6m3L@cKX1L-n5<Z{9;s2O#Q}nXNM<x<Jtx^
z&U{Y0e@VSni5q{Ad=?xn@vYFGF%)|g4hM#1JjWMTI_c-!Gn5SN`jEPhYuIYw-7u6D
zBQy3f8orQQHBKa*Bwo~c#Pgk?m|k|8Y*)6?ETxohta5Ic-jTVha*l4TbD7ZRwx=j;
zR2A18O<XdRaoT;JKU#m6KJwxkA)>vzV>wIkZ7kn71+S_Dx*NN1q`_<dl-f!*^Ok*W
ztItwLHGX}UlztmIQ(v2N6R*izNm#9T%m*bqLFCAnH<_b~jxV!dy&V;_ZG(A{-Vnga
zJjA=t6~8obc8ePQjQ;%M0B4D-I*3zs=XR6n7v%n+ODHpbd~rXt_OV^Zqy$!8FGepk
zz=>9DGX+JPAD+8cmjzG!1x?$V8Y3M1<nvuE_#qcLbrqq*7Q8Zytg71eeBPRc)RYnJ
z90Vp5VTT~0we=Lfe%1Bl>u74v@+$iZ9o#db=ibp|cZ)C*0pIMq>u-jyTP+^s(9?GJ
zc*lUbx_Ps{CZT;Nj?3^^E2wjMpL9s(Th8!vWM6<g@)hUW!;Z*p`-l{aPoNtJ4*uM_
z4rgj>;^gdTYH0I^voo@UW90-e0sb)TOsq`Y|B<r)E9K(@Fsi!Sn*taW4bA?xj;6NG
z0M?ITWdNhHsgs?Hqp_(IfR*bXiKv~e^M}HRfa4#5oT-V0p@^LuoHo;kfSHMf4Zz94
zr3(-c_|IB@rvCBZ&svI(cE&2E&H(KXR!sb3ZBsXA0Hc)6$KoRY_M-pxQUF~5qo|#=
zoui7qp|L68&va2IX22gn%5VY#0LIU5&JrrlhR*+tN&FdO`Nt~>Cl&zbKOp`nihp?h
zcfP7BGvFU2f5e&!MwX_=&VL<~vSDTdu>ZCFXMI)x+rKgR7+?W#F#ls$%7z2L#{EA$
zGY5d<zYoj+_P-BsAJbU?Z2y_T%nsoAk6lgx`+o-jtpAzK24MS>l8=~6*>C~a|GPFT
z9LIkj*Z>^=(P9U%{l_Xdfc+o&2de)D{x6#U3B0VSt(mhqfc@V*{*&{60{~!DaWQiK
zy9@qi0>G$YVe+B;kxNENQwuY5X8;T9hi4zDceJ;&{s=gnv!lz$Zux&?=U-n`<P4px
z0Gw?9U=gu!c2YET6t%Olx3m4Tued&PVPXAY=A-{(N6ggN&cyU1nQ;H^S~pN*18m5A
zVkTU$e;c7LWDpQ2HxSVOb8r6z^9LXc=l^WBzghd=Fth#Z&Hoi<RwkzZfd0$>-=O}Z
z^MQ`>1FNyAy|as<HGuK|4ZE1A>i>ZpxCGn+L6#Pm5(fbV1p$fu_<#VnLB4->v-k=E
zA}0qz0|Ej90|Ehx3j+DUeW-v4fa3j!7YC&R0skup0|5!K0D<^dNB*P#Lm$@u&iSVY
z&jI~c`@>ES*#BsQ(&d2vm;W;jcm~3yXm00h=VWeY4`5|r0^t&ol7skT{e%AU<bPS@
zIfBUL7?4_s<L|JkzaK?>fZZS{Frajxbl{*QAYdq<;3%NLeh{J$FCanx(%)$x4Ja5m
z1SAwR3@jY{he87~2pA|hI2Z&tB;=oEK)pZ4K_E~dQHhy_q0p2Jp-CLjS^VO1VMs-4
zdN7oyFUeSq9Q|S8FtM<4aLFkssi<k#*f}`4xOqgyK8s68N=d7zs;O&ee$g^EG5u<0
zZei)<?DEak&D|p)Feo@AG%P$mAu%aACG|&IUVcGgQSr}`(%QQEhQ_Amme$_B{(-@v
z;gQjq*}3_J#iiwy?Va7d{e#1!<CClFo7=nlhsUSqKe#^P`46m*_8(;b8!nU&Two9o
z;1JM%aDjrk{sE2x0ZGgZg(|EBZRmhT!r}*mE)thp(*sM&s(guI<Twq7NyfHKe)R|1
zUu6Gx!2JJzA^Q)o|KeH&5e0$zOK?z7aENelaEPdgAB2j9`iHRavHlYNzeMtvDE|=M
ze+c+t1QZ$?8XgWF4Gs>Cfe4p~;r}xM*FUx;8gS*~_HfXT%><4DA_#JTT`VtjdZtvO
zvf2sFcGdhsnBn2Wj)TCvyEX-uJR#6=<S5DKd_O_Wv1LZ!Fu;d0i$kFB#0D}zBQDOw
zeOE;Nb(as}+pDFKJ;)Z)B6`?OLS2T(w;ZU_AT9zRNG4Z?V-DJoptPD%F*G!3_GN)R
zMi01PHadt{PhEHS#k*T^EHr~7bg_rwYAm`9VP=<>M>6UDF8-EN_TYE4%t*}}C6x7O
zBzY)HBW#mhGFJ>lL~-WZ$p#RJ3{O`e2;WplOrr6L;G0N>!b0pWsUYW}&?opN%50tc
zA{)w&yFO0Gp&hs>3Fq45{1$I>pb=BwoioL`{}+329uIZ@_6>i>$RHU?A!DggmNr|=
zV9ZF_vW0d@Q7Bo9jF^!SCu5g1jIs>Mk`$3_F_su1$`Tn2#%^rW;QpT7zw7l}zw>%t
z&+EGG`}v)J{r>Y3n)iH<&-*xz_vd&Y1LJb6Y-3N5IU~=?JbV)7I;;TwU!US(o#_Hd
zKftHmmFlwoI*LuZWaSeD>FVbrLY5p8+KvZLb}2v+L5QxF!VaKzc?(#!;t8vnByAY2
zuVid9D22q(gRMOT%V+w<YOcmxN>>q-RrvS_!im7N(5xW5GwP61t@Qe8j=F4xAr@hy
zbuCOiJ-r*EXIqpv>MZtDP<x4#miLn8QGgP!mAb!@0plr`BVmj@vSmWOjk=1)jJ=Jv
zfD3r*Fr<WIdMOZD=nc>`#-%KJVf}rHC6Iv)K4mpq5nIQF3|^fr;1Q3`hSFz4h?T|t
zR!8uIQH|vf)YJ=cwtxf!glG(1qLyRDlef(`7J?-y0*WkdUgbwSne@6RQ9_J9q8K7p
zJ8sT8-SfoCTx5u=5KMx)2TAmaS(<QxZgq?eDRUpxESSsMs}6ONweBKi&AL24%>p4f
zK`|vD$~jw?U6-3n(t>-8-_lf=bJk__i$V4;s`h^KG3;(UAG0)L_3pDz6O-DpnkSNE
zcaVT!XFvri$xt$z4w}-1;rdhjId>RP>hlfP`>;77j&BC<_4<$wcJ>LlLfpU-r$bnR
zIh#HbT<V>s&Cb|{QYgwD$!wCO`&hIKLx!zBK|*UWmf3(2{paTWISYouArQ8*Jse6c
zDo`%8;HSxSL!|Cpqp^Boi)p|Hy1{sO*QyC-Er%z|D{hmID30;sSUZ&=2fSS%{&c-0
zQ7OGMAryOpDG<BuNUViX^`xmUbF3X3my>b88%?{)wA={^J+(@EV8t{4O3#s2Evb=F
z#QQKHZVTwmNr$z?WXx<R!G18(Q5gb&O-poj%vx77LThRFUY_&P`YRi*)hYnIm4(}}
z9?@<wWRW<3T2Yo_*^)L%yV{!SiW=|-f+(gy5au0)mMyDgMle0)jcT9kA$tq!t!R5~
z`r!DjoMDt+PUk^w2WxTy(GcJHs2<we?UU{T>Bq}j1|^B;GIC*s%K8rnH>n!0$|uTY
zhSC6BWkfATwSOUR_X&jX7Le>BsqmcfJP)cOAtyv~fjnZwLUeuDFAnZV=YtWJ8c^HX
zNAxHgw{8aA$*=V4Bg)_q@7t9Cg=7W2Zq=HWV%ob~Dwm~w<|2WuFXNYkV=a5vyCenV
z64*6cz+QLBFsbTA@C#2?w@}bs;3<mU3hu80f8qiOwFT&vj$ka**Q~{9(z!fp8PV@i
z%WbCRbF}phC2Fg#LvYVCA`XCrEN2K@Jn<l7f#eFsVvoT(GjBpS5?F1@@%VYHG7$UF
z2pbOVB&w<RB6gY8)~+t=E=?Nqbr@aEQN_XKmnCTy+q4uELP+Ub0K??%*^f4Ke1c4f
z9)r?O6d`5P);I4)^1K5ik$Dq3n~AEt!#>N;D}0(|He4X<I~G@SRf~5svF%9_$gy@|
z^z*0l+M)v+m<dQmGDo&RNxqOT5XKW**0v;s&0uZ#7+=^kNb#U;0bg;#1FFeQGzS&^
z=Vi`$fD?mz3MdS^IV#*ea=w_+N!)um_#wtZ$zWmCnEqDVu(<}sh>N^A9ApKzAde8m
z#)!4dp{@csd7qG;=qeRqd<>p%9^@rfbH+A=vn#Ub49Dgv-h)A2>I;ef7PJw=G!T-(
zgZ!{bMKiM1-Hn@9m$Rk3g6RcH11iGk31i6&m@^dH5yLe0w0(X3)27&-!1ubG1yHqx
z%BNR{!G7ZS;S0Oc6U7J9vY4DM<C9I+>LHx2-MzDpF;gx)*4t$=7^zpjNu!rna`@!q
z(_m&>fVQ=u19_N3&<4D@LjfSac0C5TX_jW5SW}0ZQ7;R+y)o@AaOkK}S1zK{i3I7N
z*>KGw@3ep*&Lq?9HiQ+STb-l2gKeb@zpHk?NVm+CAe9?<f~lUhPgxR^)Lpqgp-E{W
zij`xpn%zvj>`6Psnxq)ud}|T0dMR9`$cwl>7^8`s3;C{;JU2O|RINE@7KF`~l8X07
z(=^EOYF=yiG9d5Bv(1u|oBo-%M&kqSPI3gVKAQ_lnXzyzbpVX2vjGi9onljtPfUT3
zngH+8#C?rQixDGt6&>pxdCOcE9vsBZ+lbJTVgOH!<zdg5|Dutq$~O}q#j6BS(g0(f
zaCs&LZ~h6M;@5EM?fX7&BgcNO>$gK(yI&01b|Rnb^o(Tl7J&U}9b6eTugxKtI!k#A
z&<VH1$FEDo)Dd^&8X5wVbL-vmFN9`j7*AC?(*})NzpqD*yaomZ&3+5$A&Lm`h(q<r
z8?L`LuN6nZ?Fk$AL~hF8ndu7d|B;rkgm+%#DniB}Gc<cR{?;%9hN+@4EVdH^ga>mG
zlqFgZQCz_nm|U~+q~2PZX;(5~Bt-cQ2PN$p{>1&xC8Pl+A9gn(Vy<php-U{W;qG5$
z%~Vi&<uHvAHFfevz-k683^BSaZMg+pBKj<jdU5kIAwFHuIAdc4FZYjC4S<sMXRlb;
zu<Q3euWr(NmT~xDPc`hmm<5i_J9jjgu+ulYA-i7gS}iszqE^YFnxJu$q{I=c8*erP
zwQY*2ynv@7BoeX8z^F$irsL#xEyE(OQzfRfmrgGY<MDnO+Z4!mCN~3Yl0Mo{x@3D2
zVCBR3t}|kkE#NGmWS0kv>;Fhl4wa5|Kscux6<F9p%7rPR2gf!MlzJ|hy1GW2TW^?P
zEnNBd{Dkq2IRx$9DUR6Z%!M4Z!=pk=LQytgQVRuNsNgk&FDZ_N@U`(IpLA^woQn67
z5CfhE507@nGRkGhH=ow(a;$&erx{H4E@y0OG(zzT+8vvJy<-T<WiDl{d(m`lBGWS^
z+Oc~9_YVCX5AmFxn95E~Phf@BrsC`&Ke|AA5j$_Ny9Q(zh?_`#`eq8(_48%O<$1|T
z3mvZ{NstuTUutXZgq()QiK4bU!DN4iWz^!2(?<}<-N90*c7a(-*|dZ3K@?3|7|US;
z13Qg!htt{PC<zG;Q*0z_rxZq8H1#oAMar1owQdFY3@LPM0gtIpv071-rAXZx?Lbsc
zp-)Iu%q_sj@H7I-TFzmjU}A{SZ6>SCs6a)VC}?m0TR`z_qcIB89vE<@3xZ~6OQIE)
zur0B1QEJ1!U_kNF2c-$vmf*efVgY1MXEGfcGS?u7ZbAeP4J~Kz-t2FQwFum{j}=E=
zrmscDJ_o$|vki?g>h!BL7LH#i1X>uV9Ry2_-Gd-I_jcIWdXZzbN$hZvPo>^_Fkb+P
zAvJQE*rIH--i^^~M%N;voKXnU_bq^B6Vd0H*_%5;L>Trkkg!6fY|n21;~iM~P_mEC
zV)Q;-PnDQC5*OT0Vc~WPQ9fu>8ebgRH>R&ZrJ6oL+mzm&Aka0s%0rsRiMv(HJbo}z
z&z)*Q*XDNh&LJ2dl^T4SB$lPCF9A59+2Q_Nyi$J>4v=k6Es&fLz@Fi(=FAMWkU-w*
z9(^X~(@40Qz0cZ6A$<qRSZoG!x$B!1z*LZFB<@AEPg{#bhpgtGz%}od{QM{(nAWjb
z3PCzCbBva$c_?{LqX(&v!FJR0&lk=#HGsyVFdT5ngZe!>V`wRBK$Y|<pc}n1EJN;0
zf)mja6L_zV4xUi!_vmF-q}D;r;hnAx#h5o|W*M$cY=&&O7(`A8&ATa)6Z5QEhQct!
z$*M3ja_eJ#XLw`WLHgEm{^(_XAPivWedr9E>yrLub0PW8%VkCZpd*iv&1g^#J@k;E
zPiaquD$UW$EE^x1Ae<usul2-|QN~-Oqh~E+Ig|Q>iHXq-bU7y}IfWNZSA^iMXRUxm
zpy9=j)|Ne4vRd-<O7E>a)ziOcz$!u|uTkt(tzO%4sj|V@GF;g+eW{<~$T9)xiNMU~
z?-IkS8kM&5!d?Sj=1}FD)zwCq!E`DWu@|sX;R*?FCX%BV)kTX9I{4!HQOJ)}&1ELV
z{uFSu^L%g;hY$^H0X1IjJCuvJFOmawg2a~Pxc#I+3v3dg{_ZkqVDI%Lg~EVzFOUUw
zIG*rMvN*~e;JN^F?fyBkvyiwUu?3>~WLHnhWz<k_4^e(_$rlVQE8k)AFR;GP%l{@P
z41Ydp;kNt0n;1tNpPs{o7@X24*$PX`x;Wf*Vg8Y{r8~n5IHATM`wfCD$U;&?Mu_n@
zWIX;lS@IW1``E3o4AL}vCYV$TpxjnCOqNBX1)lUxHXC)vCP}t;ezJ!s8Uv`(%JjJt
zlGXrS7rq5t(enE&fF95Kabc8=@aiP)H}CgN2e4)V<5@>Vz2VZen|I&O*6;+q-DANB
z0gpDMJb{kv4YBr#BKm9wDn$zVtXBLAvdvJ@DTZ}#KFxrs^gZ>UcV<E;vutT>W7b%>
z0#)9IzugEaJps|19MC3dFBrj+S$!!d=KY%|H}7Z3L%JO}_c$HA?+1h>5@w9+qlkgO
z_MTF{U!$;?JxFs1RD^gn8nZfM-<hyNSU-aIZ6^vF1tl_)b$w{2fV(koQ21ND<M)~y
z^(QB--Z(7OuF&<C<!U9t<($L=?nZj)LrD^X5QJb<p<yQue8=&f45X0ua&sGS)P#`?
za$ol+dIobLTS^}_>`O1eR%0;L?Jkfi7#dd0IwN-dyM)|Qq$l0VQ=4Pc!j!OwUjiI-
zA7pYj#g>nrcd6CeWIyv3INNxizCLH#T1sT-)%W)hB~Bl^<hwnJlCsLIE_4BQQGUv>
z=lOL-DK-=)PN;qsB}XY*q81ZIFnXmt`pt5(7K!CoEn9mhaiU{?+zFyCWP5rGI!ni}
zGs+Gas;}?$RY9?ELh_n?0<ug_=N*T&Yov|5M%|@KSX{8FSpKj#hQ8JT)%2F|G{^2E
z4zF;{CBcRZkPV;2S>xQCF%T4^zX%%&Z1Yp3+vB$YOO~0uQmx16Ewg*{W%`s-<*+?`
zIRn1cGio4$uAzV2A#t@r7@Lymq7;jo2q0X#ru>7*3Bd_pdyTVr%1K!7iqT!_D&SQ?
zqOqh?r<&blbO>ZC==T(%cq6^;pY3+37T&;5m-R#d#=^n*z4?r@JPpyDoj#ic<x_6y
zI-UVt%?91VIt0!H503y67TjCSNVOAkF3Zbtia(8jk1P3<J8cAl`3jgpkk)caUjL#Z
zI13g{?J5?56#-sGLSA%x9k3gzY&;R=_@1?K3uiefA-!2D+PGcBHIsLE(@`EQ6#*M?
zUI9n9&*0c3NqCW9miDgInkLP>D`4Pwv=}R(H&^Yfi6JDa9+T3UD2#Ii6NjT^s}^GS
zGMF$_Ko=-RfXTa(36+at6xm}<PuayhA#(`niPOUl&I%p(xD$|1FerPn!O*~2o=fYJ
z>-6c~i7nX2J5P85Y5>but+n@hB>Nxr#ArLNck;ILyOBm02{PStu{+BLEFX06<XI1?
zHqC%RNyRf{pKd1BNs*ZnH0)-@sjF0GClT>S^MvXTa-gx~tN_&!p^3`b3FwAmes%Ed
z%piqNS`4UQ;HJ2msPut_Ms*AM&?b<JRG7NUGT{r{$vWMK76f{g>SH-?ZHI@(4cMa3
zmipfuCD>r9JlCfNmXiWP;b;V2=z8o<oIn#Rp&1(u?zt8+>ZaIlRCBrkMmgn495*jp
z;;6XXJ=7$Joh=o#q!m;}5R~+9YF^n-6q#XoaXeLVLtHrs8{7FTuB&@RdeWk{(f5}R
zPIjwz6ru}Y{57W4g;fYxR_8Oi8DcYq8vku&634HW30>02KHIPJ<eMKiFT-IZDKV*C
zTXv}pkedwK7R(`Bl5+V~5A9#KQbQpaMffYveJVq^f9fz$0os5bqlc)a$W-W<C(wUd
z$0g99)ZMa!^3a5J1jy5dQyT#UN?khNdD6hr>9|t9L7J`*b3O}oB$2C*+tDJ#K+O>e
zm%N}*X}z>9pfN4}NBAUdNuyfrp`{oQMcwyQfXyf?Du61);?u#FQ4r4ikRYg!+$~Rn
ze<XnA&#;LEs!eML*<IRy_<C$Cj*bm;t#Kkp#a!dAWo#Q>ibYRGs=V?Jt(Kh!fBPz(
z8+rTX9li2402PXwu$<aqSlfQWk(4$;yFo9{5Gh!K(6a%p1R{!)&Zhdvd<t$xV?&Mg
zC-PN$`$Bo6L`j}#MkL_UIQUsBARv<9R@9=s)Jc4bh=o6AVl6M>gnxF#b%_C$de(+U
zx=9*6Lc&JfOj&w?oMRa%Nk!gQu2%+?1Tdn#*C5phf~nZ9SpS)HbWT(<5Eq5Fc?=zw
zuEclngf!PSV*K}Kwp)JY+jdACV`LBZlm+GwAmm{`P<2v(xzB#sIAwT&N5wmE9X#dZ
z2qwvkzP?$SpIs#;2;iJ_XJjd2^V+L4#Bw&Ef}We9bXy4q*GlMp>;?veO_?CEa=HgU
zA++@SlG^>DluPcr9}oC1!%~5>Hx31_L-ZB#v3ga6ON2T8rcn;w8m{%6Cc}nob&S4F
z9u9EiDh=Ak_4g`7Mwj_9hH|NF^t3<SY||E?3e`ioN_;=kHYx-m4qokWB)Jp0PwIZ{
zB<&KQ$%H{UU1fIxA-_4Z9|AN<X*I<g?j|TuD!{k^2V$hL$TKn+^&ix8eHrm8m|Lo4
zh^Pf_HTaZ;5Px?0Eb|)swV5?*KBgSAzl-Zy8!-%>n^|Ln`iixdYCC3q)AoZi30~;>
z{B=^hx;dPCD2C8TJfIL`jiwd)=Mvq79Az&_6t8>h(|TEJ<LO>y040bG3|4>Q*Xte`
zQbbng_;76Cg_aDnQ72)eF7OYR;9C7?FpZvT(bU4g_1r{akjK(`cd-AF$!{dE&H)|)
z2*Pq+e~2fa3VvzBRWe2zl*@Xnw0tcC>%qbT>7pC2R|W5iw1V0FS)r;vi@K|qlPJ!H
z4L~*&AwRuQqoAUQ%9bC^Lk&A>JbSo6$;}ZEkavg+>Ef<r0MzFSu(w+AeBNF|6jLz~
zZ&Wt#Zg8jHTfn#+nI1SHMVty;I`eYZVmhYcZU+2WTn&37089<{kg@*Lm|KVAg2^0G
z3U|uzP?^UhnV=m7@FRn1Re)|D?ehS|f|4yK7a;Qu<h-uIj}}!N+fxZdwepz;z}VPM
z#1f+&W#gTR!UV|p=Pt4uz2+>}Hz#T~%RyDnWOym{B(JxjKYe}DP`z1ff!10Bc8Re(
zzZeN~X0>{6)n4n70|?r#&aezgFqM5_w7RuVJCaFT0CUnPg}={Ry{R^16d?p9DW0>Z
z0;_)p0Hh{wG+w<g&bU_B=i92ra05*`FpuacXb$Wkk1|=N8N%L1tTWAVHOzD}DC~(4
z1C80>OTS4xK$o<C%g2a|S7mi(^X?*<ut=`2a5}y*OCa$-v3pRjAi0tuTBZQp<K|AF
zVIh5Sv3GRB5gpJn9td(lT3PqdU4@vgrR;0pUNh3Mbd7B`z2IgoT`OoWl5#ajsbJNI
zlo<TJT@99v4qF!DN9MKxDuw(=6!ytdHX7@PmPvF3-g)joX&Q>dD2pzTtRy?id=B4W
z-2$m<!Fso>JrmrhC^)ctm`%e22HlPbzsb~~F|5kmw=cxYz+JAAPZWN+9i;(Oda8X&
z;G7{ly4FaWXoxW;yToQbTeht);C39qDO+NylydVSc22Se^v<+mavY7F4I}!nSTThz
zkXJQvZ{$etr?ARCD#*hh@SHAFqPNc7nq_X@bK9b;^`It+;}?`MTC;sxQ^VAwFe6X!
z*A54|K6}h88cPMv%ZUhZm3)Ekb`GSkQkug0$CYyd;XqFvE2wYsI<bFk3osSvj~Y&}
z)Jb7<<$+A<Vg)nU6axmc$fE0aGqIXF3!8zi7jZRmjzc}sFG10w0g$u$-l&&2Q8U*F
zD?lc6%wzJ_C0fW<yy3I+Uen4v)55^!+5OR<6lXRA)vX;7qLg|K$W|vKQV2o%5Qx?G
z<R$yW4Ri{N@2Hv3?idRO{}#X<m8LGvn9DimGO6gz(lJ>@x`rDwR$z68ox$g=cXoeT
z*r6KPR(7VdG+LL*U3orlsUWd=7pRT(M_~fDp}l`(VmCjQPT!N0y^hv!V2m}w-Sz_4
zY8Wx}EuhF;E^3C^myT}tilJVeOf}CCijvKk#0lF4H`9I^d#}@x*fcp58ac`3*tVQ4
zho*x^e1FTXMJ8rKR&~IVW$Im!P&;ihY(v7A&$IzrSWQFt+FtW~f$Jt%(<feorC!Su
zO7I`ewe<B7BJ!|>5hCWZjhJJuoFm!CnvFtIvyqLkR`8Akyh$kmzop3QFsd?RE(pl6
zX$3l?J3_G(R0hnLiVz}k**V^N%f=FS8r4aL!f@84c?<e5A4Xs~1E8dkNr6lHP0;rW
z^BKcqCXISwDKv@6^ieDDJL&KT0bMYR&M!F2(wpnx(0y?bOstu@H;K}3RY_HxZU@Ma
z>kL?@>x4>*F*>|rI*CXjHE*mQp)Oq*=D<I#eB97Zw0U`E^SD;~hgFdAJ1l0u&7><y
zsLDq<Rujg0vi5~x|ESs@U6at^%SYUH7OD%c=eqLOOn?_h+`R8fu>(vhmC>s~-nlyr
zD+3C+z)(CN{5d+CE(x1&K<=#ar`<|Yr?&=ovss)D;Jjb4bi+Qz+8fFxUtu58pciHH
zt;(ED2&EHjvbsi7H1RtvbCiC1mrFE{GGltkw)c?BnUIP?f=~yPU-28POy9VLGRW#h
zabM%M1*IvUI)}nw*1-S<92$Q-m0;*~&(NeiRZs|cZ%^W)Y8;)q1=v4?NIm9kU@rkt
z+77`RMjAc!4kE6QItKYB`Rwa*XC%1;%ClSQJZegZpl)h=SCVFLZjv^zr_VJrgiLmP
z-v%74jTfkyN!0_5yG9n+OFoW>xES}ZB2cun4xq?$qg9Bh$L@-fQSXLs0aKaY%vfV8
z4;qPBZ5|<tZ2VANr}QL3%a9V2k-Pmdu<8P(RVZdXgO3ciEOdQu7ppo+DNu4yeW(|b
z>U$pGY#I^)m_>Shh_Qa(g#?<l>u9WDfVC4e6qzu$;R3*NEYD2FnY$H&g5^&OH1D0!
zrRJ=|qv<edy4f!)sQz^{fG0tyLUEOVFAcBS;Z83ed6p1GQtzz-G@OyQ;%Ms)O4}@a
zXeW#}ZAW;xw2+xL#cO0#V^AqX29T6QPwV`;9-E$GEij&a9VNkh2g%8W>FD#~N#?-u
z6Ty}8N^Ff3S$}_e?iR2=n}1X~Gq|^GDFd1w>IGiusX!}9=^IM4F{~o(eWQ}6YH}l{
z1b$pZ`7*SqS~dxkCgY++0>NUX?lM_ehvLDq7<kW|XJ%`72ie4HJ61Dsf?2P@^~_ES
z>$V>#BN8+>8&Bh!Yjk&Z%GC;OX7!(%rMx8e?q+5-FW$#k3{dl;L$guIoBJxe(udLj
z!dCaV7*W{2-CJ3;EDQm+BD5>sY=$ae!%fAc-`|AFgb~G(uBB(NHC{&T9tCrFf!tZ$
z+~#Esk?1fO#oz}~L`B-$BEUE6D2|ap0(tcsEEmgMpw82dgv2bZMFO5p_L&$|&JAMY
zeGCrGoNQB4a79ul*SgRWk`f+u!~@dWGHI_*H%Y%?nT-l5v1oRC?*k92pMpK+r+~*`
zdBMpei-yFpnPTI}{PB=>2u(H`P_+w*@|oE*Kb_o!So$Uy>L>?<>n;Xt+HRg-tERtG
zgwzy2U`kF>#`Jl|>b?G~)vZ^gESVjhasvX_;ThvZ>3%QzPugM@*r;TU!CTw$qJ0Tz
z-yBph)%2e@!4FK7HQvhNXRByTN4J|P8Ja*+{gJk`EGO$hXtIJ(QXFC3Bs4YcyY38w
zyJU_&ln|2M9Vu{~hq1Vs2+SpU>!fcOf*#OD7!@YgxhARm@IEvWnn1+ChM?<K&<jM|
zAZLj(W>JHXZA`McuM4Lyu4c(8uC9RjyaSR9j4ptgeXo@ObAge1vbNnqy*HN{pQhS1
zumvD-JFc}`;8V?t-HzG6AGOV3JZI6mj*G$w5)vRAg+{>0P8{o*0WCxTDCIO~pPg<n
z@~B_V0`heHnUi40L4rcool|`^ixE4j(Aj!KugTses!tU7)09O;NcGX-%eot0oKEJL
zR5hd@EV?a@(hjr-66!l+)$T&$x{zW3fQRQ`Tn%-Y^BRLK-o^ug<ynKIm*551*D(p9
zJMLkrmz{xo%j3j>D1>ZF*pV`?Ns4_bP}mPv6-7VIbykKM$meLV>f5x<N()C1J9ZTq
z=3D--#|I2s@#M#QqcETdMX94ue#&=hs=w9W7N~PGF$diww*`<pc#7A9&d_q_aD%16
zEx+F`xRfois=D3P<P0kW$0z0#*F3xha3*XLLJ?LcVtv`j-t6NlXslTWV2R6ASo3EY
zdw&uVS{={wxK@c-n=wXj^D2vl=?2{eI>ZV`)G!!TL!BH$bCY5+iBD%&?;;q77ogqF
zQh_c!DtdS7qd>vp);ZmU;90oF^u0kkhCkP5$sx**$z8y~4>QNEak_*VT~yYZO$ZO(
zS#MA;u|rFQ&!=CPpbUVY$>WZvEV^1~&kmAk`^h+6ce(UNA~3w;{RBP)w}VN<iuQwd
z+x|3#MXHDi2CFNhy#Kr}gw>S*w)dwIq9h-RM|&caLiVDesSaK<+zD&3hXcPxi1PBe
zO~Bqi{Mx#z9VuOJ%`_RFlACusy=hQs%PK(2%TCLSUWL??^1JGj>Uph6Rz<pUBfv&7
z0hy}-OuxQD8wU%}*C&Jmm*_>7+52-RY2!-6%y0N5oDfpihhC+e{xY3FFF0<iX(TCj
z7vgDge>G#<;pgp^qo~ch^L{eIUi9M<=U}jfwxfmvNBJ;YKoWqOK{~$!1$wW3u<>Md
zCLM-~g7?v(THjTdGx#3z`GP{7lM|@hO-iKo;~4W9uccv^08sQHLZ!Uc?oxS-P{Upp
zc0xkV+$Gb`7i3d{Y=K6{S_NNi8?kWf`!ckmVV$mCi77tJ{Tz2IZ<Jm)5ZQ7WNSLH_
zv#GmePRl%<x-TXp7CNmY05Hk({uvP5gGZcuFs|ZI?|a1FKgN|7;b!cqTewJLNy$bR
zo|_4477)GeM!5$mP*|Z)@49u8wRe!6-$bCI6~f60ysxMcf!q0s&6G<;Fc!0L>S3_s
z$TA&I2nQdy12}OW^QL)!s^6YIVH7ORCa^2r5Wjg`lDEuW$BOqx2|t>PQN}^6zE1=Q
z5hAjzU_vxfmLO2u5>yIwo|nEXYY^!rf$X@;ShtQhVaPVYd!EFiX9@I6fU7mtXCH@=
zeUK46KzRVRTHhN_BN)A07l%(fGD%gSEVVt}Vj2oI78|!bPqe1%l{PfFd-e8WvvuP$
zV`!0JZ6|wd9LrhHjyhJ|#g`(WFosxa`m^I%y#pSoV+OdL?zO{kDs}^J2r!_%y;Ubo
ztbL=LKPp|8_i88T1$6MtG#WRdC$MQMfO;*h8aYqR6-2X0RFY+9f}ja)*k@A=vJYa^
z`cTPgwgvt~8b91+yV4GxZ)BCar;rJ~+flXvz&h)gOn77Im(*aN;e@3~NV{jyd%e<E
ztSB~&-2kY(bf4rbn0{pRLVLoF#D#P_OZ#U_o!5EYi}1?;-k})MQ<^rbf#uQ`uESA6
z!c{H~X>eI4SbgV<OE&6sZ~J;*Vd>?Cx?uBG8AGEEkcoQ7nx?rirZGqfdsk26U+=lD
zEq*ep-0}?mcZIM;8A`Ompj=GRy2c7P6%_T0pzN2dBEZmv)?`3EWHr%~XRxp_R?JdQ
z7BYBoQ`ctYwbgm<>T-tQsOG#s$f`H9`h$a;Hz~|cvMniuw5~CH(FjHw0N)6SWAX2~
z@LRDm!?Ja;@o4uSL(KI~(RkxgzZsnHVVsb9gT^~y+j}cw6qVtiK-ae5uY|pT$NVUQ
z614VQ+~W+zr+H=4RJB8tvxL+6=>FrwO(If9pthEiiYGfct&FFXyXDc|;R8B{iDE)4
z8IWg8`G<iVM>h2kv?U(XoWm=(lHH7y^I}B;{tkTbU)7=e6d=Jh*qF{tIpK@NI$cjg
zNKaQ`3mMx6&J=H^r%+*5T8g}TA0rkzlY~*AzQnSEmN}z`;ildnZD-b>tOqQaLlue{
z*$_h%EPXH(I3DR<D?vR9qaqk!R#nDT8p(x9S1jnGQ5HsBkpRKU(h?t~+!X#?@8egw
z^>DdDB>=tc4b5Of5dggk+M9{n4y{&Svhu2-k6`IyUub6%W;%)DXxg=|E^efOR5;BJ
zp9(>Qtl!&E#?=TR7Utq`0uQwrMXS}c?EO*mc)z(h<F?viXiutixT2a~Ico+dco_yb
zOX%JmCufxpWO&s`j3+=IOG>h$x+0u-k6F}b1H8}OE%_4fAi->A#_O=65Mqj8!`3@s
z;7ren=qd}PA*EpwCKoJu?`GFv)WOjj1luic%|<PY`)LDBTeDfcv;HQE%tUF_41J<K
z=k5ShR0hKs>FJcTL#TH6RXaA7s2=|wv$Ua<71EmrRsboyGL{F^TG&#rJFL~-p_%}{
zP21fEPHUl-H^2eR*l+F122q{@$0d*m66Ml;BuRZ1AEW^U`!l*yZzc1FO04FYmU+cZ
zV+h%xn)|$F5+~HWxf1AQXd-cq{!XdZLglNBFdkkAj^^-0_g|*k2iTN|%aa4TaIrhu
zQax|98&Ccq?w>vFu(TdzyL|nF3?WT!J=kfOP`Pd;>U+n2$le7~;`Pwtd^w^sf2U`3
zLa!`%k=OLoGjN`u>;Z*<F^<g!%*&v1K~-37l!A|M4hfEoX?(KHTLQeNx%w8+xfSyP
z&(1cBYu2?9_SO=Nbq5}TO}MuwHP|FpCEGjj)FJ61#gRCDs7DtI>;%zrqEUCnHa^8X
zk>K22$%$Pb><$3mK4{?>Y+iz~ZpB-Jmc&$s#4NhL%J**%^v{yk(qeS+g`w@sIX*an
zRbwP;)7+$t<TYcI4Dc?bLx!zoLdIn66?wFVxm8}9_)d}jU?w<ra!&JqpVge*$PC6u
zbKu~Bkgz2y67nEPA;zFDT{6-0{tW%6u?g%*KN!E@q|kj#1V=C;SfR?;U!G(%X1x8F
z1pOm;XZ~euh$tY*u~wCT&_)E=G_YfE;SBnlw+>-B7h>W@&_21n*~-F|MoOf~Gr+l%
z6<HM&av|$ml;La@3A=H(4lnz_I<)?!)1rDa-3KR(a&wxcJxJI*wLSDqX~?v?!A=X4
zW-)TSp;w0$Gy+uShWb+Bm?|%0yHH+ySHI+r8OqXn2Q)&;Cw&kUA0mpq5<nSQ@4Cs<
z4vnZ`kW!I|MYut#+0LK`fmmVotA_JPumU-dxa->p5g3{dp6h!SCjE}$XdZ89jpNwp
z9}u7$1mm{H0|*3}QP%VDQ~d6#weduvBkyvCgPM>qfdlGse$cl73W<&0ci=+QJyt@S
zkXJ(Yf__UneBn9~p;jLpCX+a;v%JcaNc;e3%lt@e|3TTn1J-9_TC`W%jeeSDIgSm-
zSP-<&K|S?8>^*g+Qs(>Sb)wiPo4q`e0DEYNVx>lmDxZi7oT(1GRaf{k-XGdWlq6|6
zW5V#A(dB&@!X<wz3(OlcnBWCrJXn&c>_}i)D>4p|@he$w`R=?+-M%@Qss~E+SsX#Y
zE)T1UwIFQRcGzmd5lqCwdUr&!)o41E)XhG7(=KWjr0Ndd!wgXQ@ac?l5>05%R!}Nm
z)`;iH0CzO#B>l?t)fU7VyE%(>wamKXHxs8BPy{H?P=SOqvD=JM)`MQGGydQ#C&(1v
z|LX|(@7eG_=fzc3HPux9V~YIuxc^_K$Tk0AE%<Luk^i4h&i}(!@&7eF{{O?|{BJOS
znVkRAi|`lB$N%(nfS!bZG3I}G68^=Qe}nmF%)i|mf5EKvw_ry7<A3=VWBv{1pE3V7
zsr&`A=HG+)A1CNvjQKa1f5!aVjPn=F8h^`qM*TfbnBQRj8S`(?(O)oY{w?kw)ZfHm
ze}egE%)h-=f5CkG?|IID6Nmi?=ASYD_K^Jrv&R4AJgaN|Cz}`e?EVKnFZBNfi_LVX
z{%Mq{%UHI&BP9D6cddp9f$|ASs5t!li+{ff|Bi%zpMrm%g8!RSFpO3Cr1Agen*E&|
z{!AFE>Zs%Y(eeCtAOAIr{3DP5YpZ|s-%}N8{0ZitGv{xY^<OX_|DSk;|Bt&o^xsnz
z{s!~Un17qe|AHCJ|9?Z5hyI(Y!au?M1@oWY_`hQQdt&?VsR}j!Yi$4C4e%Gt8h=am
zuL>IIe}~h*xXt^G=AR$*?<EL-0e$>$dC=hAi@yc*Z#4f58ucG-(4YG;{;}l&^^d(0
z|0m4-|Lk-SJa+PiudCw?Bkybe|I`)8{qOA$|IG*d=SGVEwB3OSH8e!+il}Y++|m-I
zRNvInK&LlE?yLQL<oS#JwQW&OJSoiw^H~$Qhg!mv+nYWWj3$$(b3V24sz<~{JWYyD
zvl-CHD>%|@OHN3OPLh;w{?u|reqVuu$Ux}>f1B9ghoz51v<~fpLbsPa3VWaFXVzAd
zY4qglr~5jow~amDsHl`I9{T=htlQkqXKHi9=A}Z<*rV@?3(&#VI_hZbHw^-_fhvpD
zt19*hvUw4*Q+9jD0}Fu=;^H<VnIO(GtE(Qly#*>Hj|v`FFPS%%G`c&BpC4PDI|lc?
zXDD%cp_qthZK^wP=W;2hj};?(_3Gs-PKVmI?cp=wf9iBp+iPa(>q~__H&XfaLxU}L
ztI|{7UmJ`+z|#EuSxp>rNsuqfZD)^bf%I-k$=%XNTzhu9b!0d=JyF?i5_wlu(>KCQ
zP&L6JJmO76?&S-U%>vt7Cof*i{iEjVoB78r#sXfii#-KQnjfFA6DSFeNDBEQBq<_J
zw1s$K`&~uku3hp2wL-ZIDi>|{0&yL7LH|_^{T(-dhL<`T^&gdi)_;)8e~K@ye{B2s
zcYOUjzWyii^*e6<5?{YHgujqB`X4)T{#)_&U-XNAErZRZ`PrFo$<hdA6{|gW=BmOI
zOSKM&T@+X_=O4TMAi~2?v)O|Gz@d{)r_V)%y)ZGT)X;Dbn5zhy^YN+f%<wuE?Xx*S
z4sf6Sy7WP|XqC0G`JkQ2og)}LsCSr{n3$B5kSM-zSor(=kmllclz_*VuC6cFR1COq
z$%-w^BbDKXpOONf55Jm5knQXSbU%D}@PNB@=fQ&yA9M%o$Yg}utHYnoqV6MzRHNss
z8!xVlG@^8O1&2n5{1I-6Gd^i&YG`49jT~PRnOYGRmXn;E{O(<Ha!yWISVd}NN&Jh4
zAIMQz<&Qz54_q83wLMrM!yqfuYjf9xQ_KB>H_r(lwTE0&ReJy0RC%fo&zE3s=KS>O
zu?tSFZ@cm9kx81G?~1>_vU`7hy(Ifw@^<l*XKiZ7)7>(t*@bHEuU;jlh+yI3I)~Je
z>4-7xdfk`xJr5;m#tvh{<KlasB+F9sv$4%iIqP)|J@0O7ax3rA(l;!^W6%`c!0~Cc
z*6NZ>ahji>j^E1X$%J+zIC^HN%8^yg>iu@%*t-;+E~ohP<f(Gi&g&;03?N?d8Y1=|
z%1pRbR=qbwUq$_m*P>vgNo!1RhgPcl&DTz2ebN2CvZyKVac=fYt-x6fdpTfsYwDhr
z@kD>|{JdXrXn1JVjvd1Ijj1so>`?fs`%pQ)dGPC4Q}C6`T7?%~Z>Tz_#-%sj_jgs*
zx3^H6KXZ&B(tbhrq<Tz7O4N(|*{sQ%f4u5->-)IXWKz~@uLtMa^YMinog_TAG_x>i
zZQ_s<o~<6hR%c|0ynFbN%RT1*9!+_p)@dETlYu>H^k^IG<Nd|qmF3e+JJPhzxAH!G
z+;<HF>9gA;RrO_r_Z-xPZn!Kf521V(B8;QYetGJo?a{2P6TU%fw_{hZevK^mKmN9s
zRr-1Q!^0ONoh6Gc`BPJ=eH9!|SXfx2hZLfxxA$w0?fJ9k5}zcAiSHi0;hb}@f%X9&
zxG}Pj#uB%SneqGPaQnDN#q)P19}-n$6<E2W(a#-gR9|~9Mi?K;w^Vsr`K`x2ysLSs
zcXo{ftBx@@ZvNbSO!?@`-2A+k9&WeX-Cgh8xpVurhlfI3S<z?#L&D<S+qduDm1<~d
z9q;b_YI`<uw|G!<yRpe*e{ptaFEh3BkFJ#+n#ngCIa7k2`}sW(^%Gw_<TE6nqVI=h
zi+xqFcvj{%)3eb&+dIqI7IsP@>*m;=<iztm-N!W`*M?8;zZW~xYPnP3=a0^TZ&v4R
zE}pZCefD&xtn{7<KW2XaLg3||!^gFrX5`2n_}tnaMI(Wqecd6_VaGG#XuE7ae&ljl
z+hlk4<&O}L%w3%&OMkTH-<pyVZQ8g#u&gcjS#)$6M^4#7AK9nez4dyvAp!QT@X9Us
zS5!5_C`v-8fKJJbfTV_0Ol;zdoG;T2FUw?5_nK*Q%fDijDAgjZFXfUiU(#2ocp)`$
zTWujHtS?_}<jJeim^mKGK*jw|uce{nH$un7<U`B#%?*`jJu*UXG_v;6FT0oZuh$hQ
z6b;d`Z;B_M>){!%ZSeLG=Z#oMKKOV({^7Lk@C<9l>p?Hy?WH_z)6Tj9H>9Xmip$|$
zhqQ=2&)#+TE<t)<!nyU>{p6QZd!Jo~9gwWLwizT7F+U#G*V6fLIuU;D*jzxmZ)w>@
zhZis9cYJB%?;C7m!-sYaYfD@#f0UI3u=DSP54v+cMsO0JUbVh>I-p%_L}b|M$APPA
zyO8$Sk6yFGdoFL^C4E3i|L7jBvDd-Jz9Oi#17dH@51+e(nGRxIba6AaIOA^)ZDTyG
zds;F#e8t8-B@MA_ggN8u@<$st?~>rigXu?ca)T1uhmnV3nk4Qamy({rEBvwBH)4~|
z+g<E^JfR+1J2!yj3|_db|Jgix$3mrldvnnGfXOZIx{L$$y5*|I#@mgfdnxZfxo<s{
z3fc!$WaWR1=;7H|`on1d+qaru&+dWF4lCFf2J{}&{Av?F>Z~Aib&M~m@r`Fh)R&Z!
z;W=pqUD>J#leR;%z=qGBYQ_~S54G9EiC*|oS-%U%2_+R|74fC{#GUf8C5w@VrrIu4
zG&c{@up>5_uS<j@CWeAbjtzYYewLE9HrsHd4C;F>M_cf^?yLG^mJiL;UoV|jl4^hZ
zJ!mA~!^O@}-+#u6$NZy2>>>Ti*2OL?FLp)u<DD^bgz3%)ZuO_jYt43{cyD~A9=0o6
zoxZcxG&&GJ6_)&NldZ|wnbN%`-7z~JmOnzydMy5<u<|@z%Q|U~gL9qmlUcEN5p?LN
z2KC5~`}1`nTC!?_hr$wl?^d03I-+#UIL1G)chGC&Mc$O!Lqx|BNxp5uu{XzeCiiMy
zsaQ{8CX@+$Zy1f8<-mmVdPN3~>^S?0zOXOmsPvE0ZzpXm9y?Av+j$aGezI}ubLo$%
z2OHmijeh7%-AC=j*x%%zZA^_Hu)G$OZZz}6taoonhfIqpk7Qhp(%~YV+o2(?(c*D=
z>tpxY2)Ry^q7#;u`>m}nuN+w4cypUpc3Ayu{4OWwy(MEiMi#$q8!L4#{1(*GkJYX!
zE|FRMX}R_B`SQVd1(x!n4Kh6-?OTOgMOajg)v~+<pRQDOR3rOFzXcxl$w};-W~q?$
zvBBOy1naI`JrlcUxvus5kCqGOkukfm?0EUClY8t<zUKX*r86`i)2x`kmy{KE=wV0U
zVY5FT1kFq|o-$-KynmjIuukR`y>;|Vw#oJxl3jpIlD+L$l#pZU&R<r;8n%0~KCV_y
zv+3Lj!8(M2={wcORxw|mRgTvjs9w#hx4|f8HNPGdHeEb`o{ppaIQ!=9jrDL+Z0wkU
z>EPXlqh;Y92_J2{;f$0V5u*|(fBWn6SI&oLH|Fmg_-s(O75vL#L`>S5{iLdOMr+~y
zjp4<xgw>3inRl?hx7puiuMVQ#eW?Q;J&OAo^HP)d_@U}oh2Q%^(vMv)F}-EP?}~#9
z7w3hgh_16cH_yH)&GNtKNhmMXe|X94`!_tbKXbmjZmMx#x7y5}ybV3bS960KLDmzP
z-aF?Kl1^^Axg>;KvhYYB^qT7x@JF7=C47)`Fqvxc*5k9oerPwlJZ>2VdWLW9P8h2^
zwsz_UNq&7z_=ACQ=MdJn|Klh;OfyWFR;Tb%hu*&K>uIfj){$l9W=WuGb|6n0D}R*#
z@X^a@5Mecgy>6_+zV9oVo!3)&OgDPd?vfVI1ACA2P%rrgNl}r$bB2*8+^VZxsE%@;
zr(K_J_)MP@+1ZV(XD*+Rnk+jPWWvwZF2(1hqQtxA?hzgb@i$3b&@RVBwCw$&KNw8u
zCOumD6<+x42zzWT=p~65<oQ_H@(solqoPW91UtS>^O3LpKx=D20hP3CGg|whKHH#w
zpnc5#K7PUY+*Eri&+{ubi97MXzEynRyVI^ZFY-~k%=RsbkOm#y^oH?s8l|Mikss8*
z+LQF(vRd_w*3$<|tga@D^EJ6(pX|;`1vBBN#%7ke^)>UZ#}<)Sat*%NC&|is-Y8mj
z+6Fn-_hkC9?H_q<o6JvDev$_=Phk~5KaYBKASdjHc1fS@#Ybs9<8TA|rvuq<9G1}4
z-^h`1Gi*ho&Rkqw&a}^Hy^R#})?**F&bu{yCHrHhKQ&Yyg~{)+jUgx7JCmzXhIi%X
z7;l#P_e`1ksDBaBlumw1m>wM?+1Dy%HWKdMh*^uPvkXoTcqKG?UqIu~?HVFKN&Vuz
zPYSwk+}LX|v&EOEOgm4w%Un?PKa5R0uJIaq7j^F1m?X<i=H!i-6M3_b$h<GomS@|)
zoIS|kz2E|oTEOqW<)c}l7t!`|@7Z%jyT&}iv)(mEl5=4SJx@vE*R%E9aBWBP-QDLv
zip$9HUo$V66n0Z_Zjw~%S!IV^RIYO<%{zpY(AKRiALkZ`bFsU>l7=^3uO0)Onx?qr
zRHo+Byolm6;+h%bBE2P^<zgvjk9cy5wlYPz0mc_?Qs(Odm+bDH$*(iCI_+|7z-!Fh
z)MO*qmB`(1?VwmPkx)(B<Fn&d-NDSBi=|!aiUoJs_$v2_{>!Y#CPhcx(~Qi&#qMc%
zD?U@PS18xWrYKKp@Th`u!E!@$cW87*&!zIETb_8yNDgcOsFX*~kDT+lCpvWjt9|%c
zZcc-+rPwl@+<Z)X|F62__qXc0iRR%qcAuflc^*(KaAPkoS9HyIhY9J_)CZ9wMYj7E
z@7h!mI(#DEr_3Iob}913EYDv5h#HGUzab496QX}?w4xC7P0iZ(E&K;lCH=P*ux_Vs
zpDd5H7g7qFj3jLT*ll1rY@_j3XH`vd`70*=ppoyDGj&}yx1+}V`MT&~XC!3&8TSh5
zJ0n~Kx};b|^0{(YJ>Pf7<Hz={6-#uh*p(Q*v{-B0-ShnG^`ckR@5;JIX#>~~4_=7D
zf-(XXwGrW?Cs|1N^`+aF4O>4y`Vp}?nzoWWHDD}DYtSBXgK8ip4!=x!mz`<pWWS@&
zog?7d6f@J7^!=xO<(}N_Z-knnh}%T1pH+7qI$W7AIWxVHc)Z3vze(uhha2tpH-l3|
zoBnvfxY>7As3q5B?~DNy3yc1+9eMml9>kqRZC+C8Tn(527GDe`zIC=gn0fqj(HUg1
zROBwM#kaktK5X#cLT)6a6mwHNbYIKdnOPR_y?sT08l!ON&Y7MdQ_aV3iyL1A>U~*%
zo7>OYe(SND3Ucm)Z^}!4woS>T#Cl`fkEwOdO2M~sfd(7Phel~pS~619R-e_@8(lw9
zH>j^LQnBZLJh~M7u_TOpA)fuYp$8XVC3{q=zD7B}a=MAJcD?jx_xaBGfUKU1x^I;v
zf~%nVYSs2r^iM^)9#8y6#cf~x3Qj%z9ewS5S-bV<jp^G3!h-vqOKOpdFY_gjwEfyv
zS(T@IWcc%5q^qyp5T7tk{}Ve|2fJb0_c-!iwH5N{Gl|vtj_U;<^ZBJ;$W?k6iFZG5
zuOQ@#HW#)9_yzX6ol4is<L9I8)7dRH>a)9VfOYJaN>JPGNr>|~DbwYKKO82Wo+^DJ
z6R?;k_BLR{Xz=-dIC;}rT%KET>_j;84EfE*O((s4IVdhV*Vx=Wg}QOqzwl~~kr4D*
z*3YRo!IDY24}~5dPmCE;qF*^T5mCZzaWc4Wdu3uxu25oG4r;JN+4`!4Pe8BTfge{B
zrz8%CzglQ)_3*jfk=zAbG}x7|%!=;sGl_S@daQlf^{6x%5s+#ZCfpz-cKm)^<H#Be
zwkLm4ed87W(=ckx*=;!zw~J9@;+I7$domq$BWUVZ&D>-mYF$m*JSybcj>*@Do97-U
zg$-NsNQE%0|NP8Jvop|3WH_H@UcqeZua_%bqbR&bVW;{ZQ~l*1TTUKotc?vLoW50P
z92oQ<FInWdRzu@(`R?&)_B!t5#t(;!WnaZl+7De<rhUKcU~qx;Jzd~)zTw6Xxr-rl
zFO36cKfLO#Ir#GU-ky+#frU98o&dZ@q`8sEmn)NzVaLxp7&wGnKlWw%d!$1#c~QM=
zDDu?TRORCSsU>9L#_j#}KWr9^Y4W)@W=1GyLi3LwcL>>SvY>N4uW_h80}>W|<!0Z_
zqTCbRmu;ZSy+y;X>yO<@Io#Y=6%$>%ly^}kFgY?gs#|}DOyzVJlD2NDJNWAx`|wUf
zsiW1cMMkF$r)mzq{W{KDxq;D7e1F@)Kw8~BosnsIV?txwREFU=c{hRm9ew)aWsHH5
zNY5LLc%n_eVL{Q}Ws1SAg7$g8i}^|&Z=nq}M{iGgvJAX-Y5xklrQi9(O2q44mssA>
z@1km%QzMSYI?vP_9q;T2zNKV|e~@w6H_LgCI+wXKRWi?bubyBtiRrfdh%m9D--hyS
zPyZF+ax+WW%^IoN6VQM6qHmZ*SqHejS0g#?LDJcfn}#6ezO~K4=qx@FJod56%=D98
z|CMOmZNppfVf0%?tpTjpHy^q<i`IH8r_2Pb<ss4t23Nji<;0^XGwP$-5&V4gqSs)9
z<J@g$BYxZr_0p6OBzAH%AkBhySkE=Y`Q$a^t-?H^$|}9Nnf2=BQy-tG3r#!ToZ}OJ
zXv&{-hH&8cZo>QzZF5ewH(v<j>}%aw%Ejmkk^DFA1!n#u8U%#+$}?8IiU6x%g}>EE
zr?=a1heej=ueQmtRGz3IJ6X)j#DzU`@B=P?#Bg4jM2E(uOC5|*B|KBCtI1R8{i5~0
zB#CqN_!L&uP-y4uESJ8#52<$Au4dtRCa(tn4$nZk@MT3WM$^L`-UZd16ZeClQ)@0Y
z6;($SCO&%?csw+x?ML5RGPf;s1@`Lg<kcBz!5e%LuI2N?IM3B*34-6(f7Wfcm-*&S
zg@%-Ww`eOS=*#OTPhDbS_T*LvZ3~}axfIq!u+Ki1eDQw7&GV=>(L$={&T$HqEN*a`
z_gb60n%CfsQppoiomOq#1c7^RzU(=fFX?@Yy?LS2?By}3G0N#%ha=f`9&)BY4}04C
zjV~5wgKRtT;ys&DP;k)tl@(geQ@I_xc3Aq3?iWGd+ow9~F>h$aA)>X5xrg;cQ=-pB
zmtG${m$o_G!E@@U%KpbY(BhnInS#Bpyi%6}i!2VG`&qjIuUE_}8}AIbYZhjh_1yav
zeLK4HM1pKgt;nZ?-><|dxxe`C7rg=xQ{EU1{fa*kB~kpK@v?hE(z_^M`O;s%o;^Nu
z{yFkQO~;$&l-UnYE|5xcB&WyY;aW3P<Km8eY1F_Nn~q?f)aRRh)_dj{#HhKtjL*7M
zYHn4I^i<K2-IUq6RHatKm@(^1_jzX)zla>~oDBFtH%kwJv=+Ecas{P<%ze}E@-?tj
z|BkZ_3;9RU%Ll2#(r#IjGw-INnBhkpNc^PpflqIH%3RXy6k6_mm-^}nZBH~4WHXIq
zg9wuFbSLRvz>%mu7nFS*pG%i?VqO6^%nf?(eGfirY`{w|y5XbuAtTQB&q$HXIr2g8
z{mG=yeLajT`&v?c_kFQ{@@u?%=UID%Jx=O|xlVhNLc)~K5ZOLItR&~i%|$A~xvl6%
zfXr8sOZ#C}h8kH&tqKG8li@d9!k&?(3PgGyq#hdh@nV;Pt6{3{5Jp6jH{_DxAjggW
zQfo)-y~}sb)htxUR>YmZGdU@DH%#)##a^e6x)oLt+y5}T=qd2oFu<}j#5}!J<!an6
ze7?%*uh{KrGADF;3X<|H!F3#C4!9hQG(I`lBH+co+by3I_(-pBl0N30oiOuDt#wyA
z{h_knHY_?l-Q4}4_PzL<<T$wDK}&blWT)quj!A0Y$9G)~YrmKwIhQk%!jg)+jQIJH
zkZG=U{mW#phC%c|+Fkz{-fIVi2F|Hm8%#3ZuT6_OS8TH5>W_+km-;Jy#oX9;Gydh0
z(sv$r@N2$bF13w@yQk<28r_vkGbG2w+%ae|baD|Nuc&t-XHGaF`f3f`EBa#+)jZ*_
z@DGyO&trUZuW4VcOPhII6&8?iA)AWM$cedGe9e`d!g?0<DehU;B>(j=-`*Dy6Q=p4
zwdS`J`NQ*O9oC2Ktqt|1FZ<m+i|C6rG!%5;b$hBU>;J#ldkdgCwryQF!5tDLNN{%+
z?hxEvgS$g;cMa~rJ;B}Gf;++89fG_3i)82QefHV+-E+@hx9U~BU8}l#_3Y8p`WthM
zF=b3HfrK$5e=1y`l1l;P1&cDTUVPXcO+wh9HaPP$Q0dVlWJwXvhdH@4sLIk->OiPI
z>xRx$C%eV>No^!duke|q0ytPB>%I^MVHRD5Qt<_jo4mxbeDHMjh$}&g#*7lA24nn`
z4&5&p*lyg8Ndk7qK^p*Vs6X}8X+x>{Hh^P%Y!zg$Gr&lZm}|~Rs01^r?Tb+i)1o!Y
zOH}i{>;OUTj{uf~T(Jr_*JEhx%DmNE${kZ`MqYTz>J9&f(s9%;RGJ}Fedg|aObrtt
z@Y<cW(wcAgo5&dA<;NDrSU!We?_pM(5DrK!&9j*eUUhXxfh)2shYI4-@LNo1t-fOT
zu4CWw6fX}RI7F0VwvXl`#hA@*rt<Y*vd;kXKGwjeU1!~?o0jvQ5#Bu-F;1uRn;SRR
zg3*^YQPoFGbzIQo!E=ip<bpg2OcytJ|0rb^KJUk&6MTeZ1SPDec`imoYV7>rWU$w-
zo%%7AFrR8}nL3iF2m<d%Ar0hEnNI5lze2ihQ+#+hj<s`PHi@BT(F-zu`j}MJN2BjM
zhWMJ#fq<Ra$fsiLB`8HjK<<G4b-K#<tiN3l6lc8M6XAKEsDc1|b7XV`H-}-L?L8j;
zsHbjJg1O_S`^#G@go3dENMMIbiq_(TcO$xxhkfDtPA7f7P||(gp#HKi+B$i$nE+2O
zR)9CZWk6@KiY{S;F>IWZBPWPM0gBpoE=#n|w^sso7Q;=C>b}fCr*%maa&eCx^?|}z
zglNfX)<<csC&ZG*+VbEIuKcotLlz9(c0-{e`rj&pFp8`ZhlN0sDe~Hn4Ion9XHrV+
zD5S@rf_Z2kbBdi^@`#WLf+k~@&9AC9);bR23|u^ng`teMC3!1$d^o&8a(c_fe&{}0
zB}zS+=v~6>k~PTX$21Y{v~&Xd7MCQ;o6C4yBrxK--DvwQ_)%I%17R6y@fp-mzF={$
zwh5srwo|uK>!&gj$QpVu=7Jet;xIpZ*`kpWw%}$zCblwSQg7XCCH=Cpb~U3W8{$Cw
z9=qJ{CQ&v5J-r+rk1cm6#KtGAtaEfY$hKy}rKVxW5R?R#Wpjs;N=(4Wyy1}t#x>K_
zGf6unmeo`UgNGO_k1W$?vLNi%?%H%>=76eGQ_XPf_c1kj0kF<Cf-hFK?0C(u-7k;Y
zRBKt{h<Uhb6dHS?qkJ$yuzHvrwwOzU?%As{Fv!g1%p{NI2a+Z9UHAOlgdcd|xZbIl
z^#NLQ=&R&#$@VXQDx3MxbQdc09=T!dHochh8gN5Ep-Or2atx@K7`AZN8b+h2eabBT
z9!V~2Cvi`Kc6a1X#GFAvk2IB2({NAr9oul-i9;GDbM(PFqAG)AF6~m9(n<(x7SwBT
zNg?U{yso;043_`9M}$ub!bmZl?Lf6-y)mKdi@eO%E4GcS)Q@kCMkGmLHp96B(o{t{
zPggow6$EcbFi~>wx{bbr#A%UqTa}d`$i+;hK#LUeD(19S&0~qjq}3Ot;63htoq35h
zM-W_Ds|h<I*et@M%0EI*dA;^!_f-8_s*>1qA`Dl{I~dCBJ^SL5ib8}-)Z-{g_0*Q|
z;!-8AqStYZkjR^v41xg9bdM;xshRMG1MY7m)l4X)+-xoCS}7NwrfxYtunXb%V_bgX
zt0<7^J7U-?J(NV<^*-7U+q^BpgR&-@1fN7Zs7Jj4$41;|Fe`IqTb+J8*nP%uq57`3
ztlWIfWl9*g=ap<9aEnhl%9-XyNUCaqTe&W`X{4N(A#x6b!^BVIpTmqj4qz=RRPIvC
z0Fi5L7h}FMPI^0uPN+t6S}?;vFE<|U+LESbRO0TNHSGdvchl}jF#7#Coo!S(HQLi*
zj%<_E#(EpdRicNIajN)fYTKdT0~fP10`7whkiS*iG+?D_h14i}b~Rw1uDO2af@Qj;
zp2BY1{g5&qz}(}$9=tc2xs={XQa$1EvEI=*zXi-y>%G)6Xp)UzrqKqDUenaYO|I@l
z=zT1cN@NGCmeIT@eTsYW5P2lI>xWsOwQA1(MDZB~oAnwRh&ry5Z?@C+-KU(P4>nUM
zqrEt%*%`sJQv>gI4f4+RQJL$Sqc>h$g)#J;Ts6awW7zfpAO<M1%C)zvWj=W14IL#i
zXV6Hxx?6`N2IJY{2Iw~Me@V&gEdOZsRDC5hv)xZp1wV;w{#C^Y%+)fzlx93V92xw>
zHWzj{zuZXw$yB2`iUV!l00V#Ncg;NF?x|&$at5OfbkMGb^REU{+^^V1&-k&5G@N4Q
zk|-)VEDx$D;&vQOmQb0-PxUt9nbbXYEQw$mVU6oFP~Kr5H7|>4!7MD5_6#+yKb*kX
z3Ds?q6m!}jYG)@sfLe~4f>p1NLyxP2I=ZG>gPNxSgqVf#Dkx=H#-V|w7=bzCE;G-9
zi<2Rw@A%4Lc-r6Txa3*F>wf83)_xFY(A2zJH^>{1%q|-yz#8yU8>^VriG#E7t^Wf&
zb3Uq@eb96ZF|tA39ShPoRmKKfP;(qMezTtBObi2fV?vnB#ijRJDW_X|M_tG{`RJ1y
zy%0n3sm9e;E+5{Da>3kD<~M&1Pe5^U?jg`1FEC*u?ry)e7TtfS-tXVn*ImrR<$N*0
z<o}VD)?6)vx?Pm3_y{anUaqHOHOo_1XNauSROE1I@&-4(em2=G$aV#CVJ<u4u%%~o
zo$V{r5KALh$ekQlfet^od?MD_b=9IdldQvARIvmc?Qg5If|FY_sUB}r<=KJ{q0l2w
zi-KH-%_QUeGa>1(P0Kk<b69-zkd>G<Z10a62W8EKBa2j`aa{Hzi_5d{C~MNcA-i<U
z4Y09Og?Oz^#7VL6%Z1?chj%EUh}cW&jPDoT#Y;wS>wUpDO~~>!*uv7Q)4z)I`s%YM
zt5U|Vs+o9oQXkl<bz8yd_YNNZ{Pl3E6u)98b+K9bW{Q@C)QvHvnTSkVtbrgmXLFyr
zc=TRP!*h?Eb`@LKq){o4H4A66zTGZV7Oo&Uer<SBS|&li6m01<DvJ{jvkozGGUzmj
z@Tc&|3&Nw#O|AhFex;namp89iAn1vn&_Tr^9a|I3N2A7~2--a-J{byevRBUX0sB5H
z2rQbGBJx&Iu|d7n#0JcL&r)mizs_xq(RCnPh}-MfL|#QPRZeuVB^sxoav(#F8NR`=
zs<3Iz^;FmF>P565${VQEOV?U}zs3K0$&qu*VM%7jD@;N&XS221c)k{eGbbYR=5tH4
ztIapJ=H+}`l%=3>5!1o<wmY|l*HPGW8yUkl$EU&Bhjx?8g}5j)E5bAWs9{BKhq+vM
zeE5?mUQOs+Nm*&?(<vRZ?Du$<Wd?1;O(j)cmQ5GdEu7xIQmrIBjHo!6`IH8!G&CBy
zL2}Rh^e$6kRu3JWO`uz{#)kC{kF&b0pgfMTgPll*j9Foe)PISq`i7PtJabvDRc6Iu
zk&yf~^dXbfkFIzjm2iQLY+yh9uA_B2H5k*#cZNv~HpiwTs6$cD*+!uIx?U_<K0Z^k
z63T&(uuab9>pma#{AcocrY0H2mqw!b)t<)+j?N-F<Y6g<gJ*>ngu#1z9xCTQCFY5J
zc-qZ)q^+6--@F)_#%{Rfr0`W)WCba35XdWp`9^S0!&Z`(O-Onicp!X*6bJ$BEpC3V
zFMfy2qUGL8QDTC*Rpo7`#{?j}?YhWzfQ9e*$Se8SIETBq>%irk*;9TjY9>*;bmX!v
zsqSE6AwPe7DDramOVZj1uBLONxvFjv4BIPV-^|kzsJll@{+_m88df2rnnTOlJA7z1
zUe|<f=0rPDhlOO05)P%o(P&idyEC@(eS2O%KY0NipPRi097KL(+dxta0WMRqign+k
z`or?nVoKVt?dLrOpGy2VS|RXtw$SA1)yt0B{Dm{2*@!!(YWvtV?%8N|TJBmVw~$c;
z>!D`wiE&du@Q3*MEA!3vuBC&%!3iMJf1}KTklm3wF*PnDICu+mkT>7LbOsmuwJtD0
z#*qL%5O3Z|iCYvk<Iw5RLq=UmR*?&i7|ypJ+w|+!ZGT7T%(Ub1p$5Z<jHplG=2cC;
zC(-ODWszw8^%yzk_hk<0^QmnK=RT(mndu}^eky8d>6oY=?go!qhu~w0oK#Qvd$%uy
zT6}9ZoI0Hg9UEO*gG7cYi%rZiI@;m!7sq8ZqLa^$5~usHYYdU&z6L^?Y{1}EsX7zK
zk|Y%`Y`I<Z&0iN~1><8ah=@!pq8N7jbGF!+51gvr2J2?vbmDy>FPECKzySy@Vu(L+
z*{y17+lgt4+Vc-YQhpFQv={<9GZ$`da9uLVp0qnG&syjVKChhtj&Fv9jxlOhS&o>{
zw$@rFf^Syyi;2Im6W5beeb?PHN;)ll_+Aens3DaA+tf3f-$P!0SI7l%&+N@F^S*1;
zylbly#}Sl(+u)5N9O^=l2+LIb8xJYBr}6Fkcdq+v$Z?;+SfOOXpT2y=ZC#rlxdNQ4
zkT7#wgImN1nmN`xal0U=rtlN3KUOZjwh@?CLNOo}1m|vAYtp;m(<?65Z88t#uMj$*
zv=gWU4may7z!}oc*DX&Du#mB{HRd&a$;6l=_WbG)gNMP)G7<X*WQQf9G<B&~r>_XQ
zf1FRfQ|e2j7APDxSNO+NW%Ht~SZB&Z#FUFucjOE5!i=hdlHIFqF`|s*y#lc_24q4l
zo`$2nI+Gi9LU?CcO=c3Z?!a89`=GbbmWEO<`>ff!&tBH<S3|!1zV_`b2vx-CiFqA9
zMJ*XG<72&v_3Gmlm-P4LD%~XoYC-6iQd_GVCm#Cq52zcWz+vm!$k^!N3FiTpBQERR
z;mXK_oTB^a{`Y<?#hZ6n+riQIML9bwx!iA3uVz$}rN?kciF>;`So!#FIUFkD@#=a^
zB-1MO7cU7dH6uVec!)e9mY6OisjJ4V1k%-#_RJ`P&nlyN{J=SzJdPqe-xtmbB?U+O
zEEGv}j;*=p&h5)WTGG7xSZ)fzfHpVxox{5Q?u2qB^}=68Npb!~TRz4rZ#_I6%Y;(g
zt26o--A)jk<?|0qjeXr6c3DYHbuXraz!$B-U$DeS`Nv2rI5Zt8FcdPWT{gb3da50R
zHkrNY+ElE*2pfu|huoEACu3omntri$KazhUoB0@F>5?+j>U^=rCU4h05PWKlHx9TD
zj@MkT+h##J>_(n(_9N;k*u@&rs4yJhHo7u%d;saxeJxjc3M1b8H94v8-4c%$RA`ip
zrKRbM{!L<kXVrY@F`d%;BXxU@7OOMU!usypg41Ze1#>VWjBv2|F^08aBfyHp2MMGl
z0y&tr`N8q$$ta=``;O^gegbaSvGH+gyj0YsMJ2^n#-<QE#TH0=Nc&vqHo!Sm)z#G?
zx_;Ic_6E-6<#;TVOn^)Gpr;s)>ET9Ji)C#+Hlu=;ITdmpP2fD61-d;d`)=kHJsD&O
zPH)szE+s*u=-nn_Ppbv%wwr~`<f{h|pU!M<k}vxD+o&k0pW>Ajl%^-9CZ|~#nVDYR
zeaC7tH_t0AEG*71DI%k!rs*HKONolU22gPJKJ_(YeHzAbTxhY5o8<f^%1&__-Qkv!
zF$zc6DSVa8k;sBf30WFhSCo~M7L{MW*>8Wzks6+UQn%+mawVuO;-o*=<ChbAK3H_H
zKzrjaD4=U?Z4K@03rbL)hxa6I>7XR^UQDi|Cn2b8MR^2w`K)Dc)#biz*mJt1jFE+D
zTv0yu74n9+Q#V7XoB!i36R*=cdg5%|^@}>6;3+?HhAq|iPt7`K!w<sh!zrz9i+97I
z%ek~5nvnhh%^^Xd!QtT_iLC%*W3o}NzIX8XfPiXpy5FyaUsVrmkEF0RdG>5w6c#<v
zrvnUpzEt>x)*;c7VlfbYJqsG~<JpvOMn1<nB}QhzB8~70@+<PG2q<Zvz%WEp8c;5-
zo<AsaeQGBhCe;{ea8++Q*mb^`v!|UY(Q4dt-aHjVysFIA2*+is^Q`r4UVN{%--TxQ
zMIO$MDHc_qSOCoF1p_hy;B7YHD><)6(})*=P^4uqtUd5$MQ6*!3NYDk1LVI9(I>Z#
zj+@THBr6t9m)sdWKs1Jx&045DjWkpjD$i1B85-1oXqg=}k%zmeW>V<x8xRSCIelq>
z1aHHbo#6UTnk2l7u$QgQ=?2`tizsKan}UM8u)xf8cV|yJL0j9H6`Gl!-xnJB+}^&5
zaZ)iZ4rOyQhgiVh8}MUh-Kz*eM$pd-u$#lV0PJ3CCm|9LSV|5^QWiv7+*YrQjL5RG
zpu9YE^Q<g_j_0}sxpxCj@k@DoP&5ceBE*T{zks3d8QwPvoG@6X@)jY&NMB!HSC;?@
zYH;uv6afR{#EBCju#28<l+Zd9!p3vuan121X~h`6deq^YR_?D$k37(rrc(bp1^CC*
z%jfBs06Ip-e{8GwW5LRwCu#n+72&@%N%K!jW&U@kXzFSIJ<0t4-bv<czn0_tVUqa|
zcL;yN7wi9I67b*n`g;+>Z#&-pz|Aw3{(vu*zgQ##^k?)RFMIpD{rZ1*k<1U={0Uz_
z+<g4G{rX!z{=Eq6KUswJ7xMAvqRKx33_$m{g!~&}{{g~&0_V?7*k7#kWBq%b-`@cH
z4*>Q9H-Ey{k3Hf4)Pk}6Eh7KM*MESoAGrAwzJ4yj{}aFfbPRth`G2p3|DUgf{|THw
zLF|XCnm-|o?Qekn-Gu!IP1q0I{0U#Izr6eX!PNrm-}w3)U;hEVe&FU$_+tBuUNE-5
zd%^z3*MESoAGrB5zW&05Wc%BM{2O2Y3BI0j^Cx_<{82vs9Cj3RvJ;lK)3Gzaqt(;F
zqoZMZ_BQp~Kmg0L=zNaiS)BeAIp7b(0J>k@ZhsKI0J`72hY6XO+Zov4(f+~p`aij~
z3R4&ePo_gzJVQ0Y$bo(th%~-grBSt~fDN7>QUKcn2+Ms*I-`Hf|4?!hr^(4FMoDz+
zW2P5A!gZytbrM9$hbh~uYaW9V_f<JorJ3oK-#he!BvMhNF}k(Zp?WoFF5spX*a)zp
z7EuD^0^WCUCY9(8rA2KN1DI7*JuFl$JN-S;%(PTIDa4l-?IQcG%TexM?*;(}A8I+w
zXG;7HlJRC)H}EmNX+7?G)1W%dDh}wff?kP?`xLEvv4wJ@^Do#EMvM|);^HiUOGAt_
z+(Iwg);-yTtkZ0Ik0FJ5lh${g7~-&uhtH7fEUloGGa@xGULqK2ihaP(0Wgl;*U`rl
zU1ItZyGiUcNYyadU$|%p->@{4#5mzxb&=}UyD15+kx*s_vD-;Kt{G{*lO<53E>cSy
zP5P_>4e1|f{AG$tV`N?Y{dZ~mqiop|K}?%Azi_I9ewH%e(xxUp=HzLku#kiIWL6Z1
zN%<?E!FlE%<@<^oMCk|8<{Pp^Z$O*mE)_%yzb^VQBozpWZZtdCEEBoYi3KURj3GEX
zj|C5tz8`kr)0mTy_iv|Vv=5kQRd~n4xS4KesFnS$8{c%~YQciuLZZQE%kY?vF=T}p
zVM3yZaPeh<AD8F`Q~vaq3zp3uo*OYf-G3c1{|S<3oH4S||H2+{^!#7IC!=EogsF^<
zje(^d-fwE1oPn*Cy^WrMEgpdGx0aIM%F+%<@f`A7_lTr{zKIT>l@pBGvuiz|q05NJ
z!py4iPw4%{F3;$dv9Z#VH?YG~1O62d0%G65$qr8gkM{RbE4*hiep>+E&osHYfzSpf
z`y*IE0f6_zQy>g5_;+ps0G<>7#ZJFDngalS>w^C87$i<X(khu3rRj`v3(EB1*dWwh
zyx_eUqUg8rD!Iu{h^Zqbr#F=$YEK#WBQ3-be1sH}Z}0u4&$fn=XF-pwy`-gA0s--&
z!Aa||L^R8LFX{t$v}UEF@iK(BOA)N*Sz7pcuy+JP{Ec@Bq2)GQ)r~|B#ar+CFY5;B
zL*gw~mk#{_O~;WBUmFL<t=S_tVM59}q28R4S?C0qhMu2;WRt!I!}q32F(Qy<lwL>E
z&lAF1URe_9bZipB59fm=o~~1bIOrAV!x2ZoZ{L7sNiU(1aYcaNJ>@4fMYPCYUFE2_
z+SU;g&^6^2{fhC*+J0C}$@i%wp^DM`o7REAPO}UbGc@X5ABIb0Zt0^>8Vbc_wuuMp
zS@y-~l1N@eKV9bqreg)Cs%i-*m0lg9mQe^^%6jG2D9_g^<0kKdT|ed&RA27!i=_|)
z;Z+{Pow;wgMHVDRK^;3h@$S@vRLWtDd`Itn>|?OxlD}k`_)J)*U(tx^7z@E`kn2g|
zDB&-J=)^J$Es{;y>R?KVvn@f2_7xPMu$giA+AH}Gt>^b-%M8U98lPq2rb8ZGg=JzU
zo61#>=9bMDvGdafn1b=yv3w>d$x-?2#~AA~bxWjo^1fSb7#1CTBvDK-^7@-x*tAsh
zl|*m>d7tx)8*fPtTcAuF_Nx};jVc#i4kFdLS+~*r((cB@ON>R67}+C{E7@7bB!wB4
z&#x4nlghJH*4sOE-#J3&vsAM5^ckkgPem;3b?q|3&uWpN#NY9RQ|p%h1?T-h-!mkc
zSOLFt-m^yg3#UJu{r`sZ0KYkJ{GIcDU>&&e#lOLMKVJTo-2W2i{gr3}{F|cbbM&HA
zCmwphNPX~C8E{o~&HhM!$j6hSD1FFo(D4fJb#32a;-!e`&0-M@`P`7CqPK43o373{
z{Seg586I>=sCmHUSh@&deS-iyg!2lF^a`-EPJ13S+73A4$8X)GP^!JVD8z+h#UHw4
zBVx{Fu3?aedl*}I>5&_ho6&Q`+i|Uj#-c}33f{F>pvNfUlf<tlOh+8iqJ*N78B1QG
zIAhG|v01hPl$z1Gf=G+}D>ycZ1eOcmVYt8i3|SwGhJ$J)1Sdut6)kdS(b|+Ew6J`s
zhL!%YSEAeV11p<V%48Q?x2oim4ySVSM0W4H5{6sV_iy}C-<!@tE*FQ>=K66_nI+k3
zt1>)bUE=hmqSrWhp1xN}?$9dvdLRXxv+?qtd4ag<`}uaw^<N?EmrBb(_dCJ>|KqkD
z@GosU;NNfCf4uy^im-oGl%6@p_ILc_{YmlwMTtF7T(IKNiks-$0tL-a4*HFe06)bC
z!%s)B3_nZyQzFU%#n(@Z6Y!%J<$!YOk22<8d6!?uPRHEJ=vi<+XX!V&sbpYdYhq=I
zM+=}~{6hrvzc@t=?`J0PXjN3-1KR_jyab*#{?SPM5|==_-<ba|>3(JBR{{Tv*nXt-
z{Dpwg{Z_31f|Bl+2@a(Ep&|eqnZHb#<yo-)jPkb%{A)S@;Md1{j`3&J{xv1TFVw2x
z{q|-4nhvO4{JH)7p&QW3+w0mne*mg53O4ozKO0s)9b1E+55?tW1!V*%MGVXx4D3ww
zbfgUIft1hB1PpBTY)n4bS=qn<=zsGKENH1`rEg*h{Hl^VdU944I+nkO2$|T}+VLCf
z*x)g;0X^F4{B{EXRx+)!iN2jN5N|L{Ku@@TJm`Mh{W?FV@^AiN{!O|c@zMWqVoirf
zPyY;>KmC4-i3#Zc_@6NSqs+h9_h+^JbG7`eCMg{YV1@k`)o89`1cW~QPfETYsvtER
zaJLg`M&N8G02^?;4X8e{098CuAhVe0y|XkjHvs03_MNTXv$Dws+yn*a%=hOFH9ZhA
zwEQ|BL<~%fjO}1pfv(YM<?ReCl%C&^Fwpt&Vd#Oit@4usj~NIZ;D>VhQTxw@XZo2D
zpweeR4`iU9I^ZAJ_(#aEBL7kqf7BTe?mzDVc#MGOT>W>7W3`HfvD!3-$H-(ZwWr8b
zpn-Uey*+hbjsEW3v~q<Nr)mwcUQeGcsWkzU?dxd=-A_628fejB-cMCXmGCfT__H&m
z)J3gdI-r6xfL2TKXFVNUy5QM}urPqoEZ%H7^J$uG=>fCa`;Oj{(}lCNh`Y2a&hI_V
z!<(O4YosKr1WEdfHP!0{ZVl|SZdUi=2Jo{-JVK{DkH&98E*>=qY?p6fr-w1z_aOz~
zC9(D?&4kjq-z6`#d5swn8oRR4XttQ1Q+o=|JFb47yluM3-MOPFQ7`^3&9M^*jJD3Q
z$kE32mZtf9azLo{;>uW<wz)}DYb1CF_lp&$w3<;E>TT-kl8BWIs6}KVn0rw&Uc%i6
z%>Z0$6p&iwk*aVWeH!H25KHOwP56hcV@ek8#KMc2qeMkJtUb(gBZ;_0R`5eB9ghJA
z>FFFE`Bo;SUSuOhPW(vP;iYy5)qa^2m)<bqcGhO!MBfNRMV*{PkQ114nbqXvM>l`W
zv37X@oJXs)G~b=M$zFVwJW;1~^#rLw<vg9tYc#!Oa>bb=$~aE@Meph_47re*6t7@V
zna>Oy(6I5ny<fhHCV!Pgo=m_X93n?vg*}(1Hjgmm$E-BfzZJBktLxqv3lq1iVvT&Y
zE?AyI34YmiAt&mK!!YeDT;|pY22VS|lrb477g5$5oq!l8Ip)8nTiz6h7;AeY$BV-6
zf4b<edt=Fs7cZt_uvm+NcD9biJg;48|KiMne*m!K6+C{)JpC~Z33b4+wia}r^&>aI
zM^vGUmnpHO06`ekcr~)q{1hUHYcC=(f&;S6%tm~GXOW5*F+pw4Nh{gsdm}RY1FYa`
zNxG3t`MLX0G7D!+F}3tyx$TzE5wd$eLsC*E^D*RcEncJU0k+cGP6OIb`_OQWxOy{Z
zU2v{fhXGOCD*KZdmYzazcj*DE;kmkXw#(x^=m>3FQo|oUq_3)HNZh@H4XAx2)Zew$
zyY~Ftw9gP*37G>0%?^F-O@jv|;LSZ1$kK+J=fy;wM=PX36sjuA@iD*{LJveN0fP%x
z8~jo0lcciwlllex?I2aN$dfJypUQRiF7B4~8QWPQ`Wq4aZf+!xmuePO!)A2-LNH9P
z%Q$3(k3jP|?&%Qe_L_VNt@CvPWzb;-Cn^=Z5Sb0dFJ8jpmPIBaCY-!*Xa_|T$vZ^c
zz$a-Cs1>&>$Ewz%7tBw6W6ABJQFmf2am}W}0nI+`=Xin^U9giycD8r4(YR}<sFSOK
zTgA4CKSo@gKvcS>YZg;uOtP%@YUvPb*I~oVkn<q0BqD=Ss#MXKuIoZp1NW9y!wK@U
zvC%jmZnW<s1k^yx%Y)qvgbZAC&@HdmWzg!NC7>)`EZ!V#uDoaTRqwJ9-EOqWd=CN-
zq-9YZoXRcYbb~-WQqZX!DaVR3;2dE!r9-sM0J8#$gGuzNG3?POIUhnIRdkDWm|njP
zzn+6U^Nn(QUs0wt*<u!E@I?SX=_tA$(l@r|jpxe42w3=rCS@-uw5c%4!l{^)@Fq@R
za9uKd=t}@1x%bYwvQw<XA-6u$ag@Qzlqk(2dTyndH~Z(8xx@b0>N8h$WxlW+|EE(3
z#nK!NOx;{}0ZKR2r#3{+$hJE9@5F86c-PxS`2mOu2Zcw6g}Pd(cLg)bT`d%sishxj
z?urM$2NfLozNp%CXme(`IbUa5cLHFRoM{rnM-97Y=ww1`Upebr`%32Q2Am|)E(QiR
z?Q%VdtQt#HICN^MzQg|5JwY{Z8zYIa>Tzz((ygij<GF+ANALa^?md=P&)@MHxw7m0
zg9!yQfQ^pAR5*H1w?SORCRmJ>Yd-`Ie2xl@!PR|gBN_#eBXShuKll-J(fd3riDQwV
z4zZuVvhVWv+WNDRU51`HRl<(xrZX1MZM#;Ij5peiW8|w@Lv(3g(C{t;;b!|&w`#9b
zAujk(INg<QKZ(knZDu`k=^K(1E`oa0T5(;?vBJFI{&4qmM;&}E*JJ~<;m4TNf`_1o
znlEpg?aeex@y8Yeec)?EuG#P8QNLiQV)?nSaQ5yxa73vnN!)mmMM4;QA-A!uz#LN?
zLwta(gTIF}))W$XMCeF=nL|1<>G4(cNi*e~Q0n$#8T|;jJLwEq$;)YPthVGf>=iDr
zZBtN$0=(M=;~u9bqIN<SM(FGzqP+@?igXwI*$993dX7A8vFH<&3zthipWLEJw1Fff
z=o%L}@l_%pV#+dHs#%ucz^QHybwZ;EiS+*KMuw1Jr9Ctiaeazn{nn-ABl~(+MbUl%
z&LiXZAJ9J8(yFIpH8;d#QN4|T#~u;;h@bg%o>j28ABv0Q+Wi_E8#IXwC&;nwa02pi
zXr(nyj<HXvfN0uRtNUeEFONrA-s($kVm+AvNPQ>Xzd9|QdBGv};-xAh;P$!nvO0@0
z+gxExz`@50g`r67dQ7btS&WQe-WRpIV(xiE@R%J}{_CkBou7jf!X3qDi2`IIl7ex_
zo!h&kCqMCpq;*q8-P^zeUchPvXa!b9_G1}-CjG(Zrno!St&{57GHE@0%)2UfbjmP-
z2!d0th=c?5#56hf7@ZN@-S!i8{fa!e)Px{?Ti*gLwt|Zhv(>)KM+xcLx#^>@{LFmf
zOt#TC=6yNe)~VZ_L^RFMXry!Ad`oQ~?C6~!kJt`+o2KA$-?uwg>k{C)xU`g6a<m%c
zh>-s=Y1vP$_1MfbmymNdjG`SD*R%3WY%G*&rFgsLF}yg7mt`;4arJ!Z7F3gJB}C%t
z#Ngvp$9}fBHF-f!c!tF7oMPJRDH;-I<xf*n9bDm3!t&DJ1{Xw?iigVf?#*Yc=y4g7
zNl6j1jiD60wvw-1Lp>dLh@rL6Gg4Yvz`foO(x}xdqPe#(6=HD|%Dw44V)+#Bx6Q&F
zkLw=FbM!&UEu_4aw+dguNs)yDM|os`(D%(r*Gjy^b-n7-{AVlJ($soN71NLd(g^MV
z$=m8X_a^EzJ0{&xP$9RK3eYG9;Xovxd)*0$<AMICgA|?`6_wr|qiI@o)z+r^hSN>^
z`-qnhSc(zv#Q(ym{h^6Ht7r5KEdQ`-e;Fpfcb5MfTEC)#s+frK?^-{##Is8IQ#<@8
zz5h3}?RPEz|D^XnE4u&C`|0U{+Uh^_e)=CX`TwMO1NByB;I5C)&lngOeq5jb|FeDY
z(>C}+7*JpT8Qb%_KV$fLWdX*<g2w`^rRReg*va(#77H-O=lfqdcn)I)rUndyd4Bdx
z_Z$oG?H~Vsy~_&RRN-gH@40@q5q{?9SM0xCVV-0E74~dpJRi^0&)4VFe&zp}=J|Lo
z?~mud$_u1@P8k>m^Bn$s{Qv&_g^lzd#`_mB{ZDfDoa#T@R=<qje@5-^(EAC+pSIP1
z3D&=|t{8#4Ls2sTca#Az0QbfM8m`R$rFF#u+-3C-))mmW{)2VJ@@%&Lw61_%5dSc#
zn4T9bJqL^6F#&_$IT-yku9$%({N2<7Fap#5VMPBhwSe~Xvu!T-hYpXQA^&1({nokk
z%hUoe0)7~e|IH}Yp{wf$wQ1*Vwl}n|iQcUVMt=2uL3@JtVh!Hs#XBUtcfp7s5xGSB
zYN%u<I%~`)<FR>8WiVM(2ORcHQkdnZ-AOO&L<<(DpsBx9uYWONPqm(8th9He7oDCx
zs)_kp88hk7h>5(g?D!p=hKS-L!_dKFWh~A2dPvA^w}|B%&8y=zUqq`i2ZxU)D$Wo0
zA7LeKO`rkYJe7~Vf~EIV>K*Q<=l%@aaoeSUFB%-S%X+z+M(b31veUC+$hjLvmpDg+
zMq~IqXK+WpMk88o3LeZ(0M7w;#3IV{+7|D}h;*KlybA6+=CtOkbk<gH4iB5dYt)A0
zHvTuCg_-&Go7`60;SD&oy4>Dfeie1twRHA7PhP(wx^tiE$1!9Vk`A3kN9N_Y-jqXR
zNqL$M6JBClQoT<vQa+Pr++aFc<jKBU_Bf!Wndmm9-J_VJT`fn|iuI(65t`Z6lekiK
zd;C(8HCXHxI=?}}Aat$x#YkxiXSKA_vZjNAYJhLhKY}`HI?;Er{c?HYTjwQ(9@RMd
zB|AgqI=X_%ZIVA%yHvSgyrqP`!Iik)1P&I5yLd!uSeXt<h2|FtcT`Dg24QB^PmZ_z
z+b#tH$0T~M98d?LB=Gi_Y}V}=kF;&6Mgq_i45>3TVLg&uc_|^Wg=gW!nINDu9>2U(
z&V;~b809-H$caFqEF&n?)!mm0sD^Sed|g8C`vJb9a#ibPY%cGUNhrB)%a%1`fKJU$
z2Z@=6=EGHrr;SC-_xo{@!UiqhZpNPPm`nPcdlypag_^65>+gcH2oLzhkuQeT$F7Yo
zOM}gp29^eFb7@?SnvA4V8nQ0L9o@>TovDwSI}nP}I=}lCwoq;|8D-a(*C@4dzE6VG
zYCj$@OIXD*fLQoka?K2}n+3Z>nbdZ=*S{AhuDBg%V?VTe=A2vFRNmyW8CLMEwkAOK
z7UFY8!UVxL^A|(6blg@^Mr>s+pAVWkrf9Ujupt%&w@`kf(Q?p)!0kUHab1r`7`8kl
zqr{E`+wvm%!gBN3Kq4S{$5t+I2iZNtwm7(2EgKe6DfeA|1R2w#epD?Jdi#t+<TA;}
zruA(in{RiooVV{@J1hH+Ckt3Y3~3PA3_S5isXev!K3Qcqscz6Q-LsciUWaba(jVpC
zaHB;ZEpp8B#e!RN1yg#9e`WGBgHw*}9(Byw2cIHuYE$yF(p_M&*6KkuIKw0ySWDdE
z3fxAO^rv2P7Twblz5{pjOcflh#dQqX0;mWrd?X2t$ZYm=eS0Ol5D18nG#RP*-X`o8
zxJy?P%rT_VouI1za@X}5!AZ4k8vy(RXTdPF_ce7YV<4~)bQ<m>$kR@4>h6ufLh}Lq
zXW>1|TjDkyW1XFg!M69>{<}TBbH_snRT6dV*7mEq#~;x8hUZrau!|rqKYH9IAU_Tb
zaT;Ig5qG<pdwn!VqQ2;fF!Tan#ST<KFM*}k2A~;1$NTk&RKhLnLk*P6)|CLAxL%<f
z5i@5>9ow2KdW72o9l7+6w{;%Sxgtm%W4eCAx*@zb$ds-lYRc_1UK*!A%y7`W%c=Ro
zQE=DLBFK~f6wq##hk3+u-xDu0P+HYAf2+T5uQz#}aUva7%`85Tb$E8zy7=nwIwgPp
zJU7*Q*p<C?Y;q}X=QfGW^f9!{?51f`V_$avOYsP^*&XV<nnQ&9?4wqLXf}J6zt)=;
zkj4GXGl!jPFbQL~7>p10_U+<Yoq{78rTAr|>OIKsQ;nlw(=|U!r<Up@)r=>N<I4oL
z*~vjdn3aR6v%VLqdM#Qxa<I-FIB8x60pG43sa0Biwp{A|7-!XVI!IaSr0Fbp-S41S
z*Cc<3R=PSpJbXNifbWdKkq4t*TRuz8X<C+tCJPN2$DZ}tv9p?8(S?9dTEJX~C`;I+
z2u<%josw_k$$NsnZ<oNy1tF?{<gKx_+SahAd-ew!u`HcjNA9-A$YR~0cItEEGPbIy
zTTJRIA=u(~MbO$qI^VD=h`EOW%eV;6^No;OoMS~}%WJ1_MXwR@FC!L41SRx8=`l<C
zjeP~-{wBnWWW4%lK@%^wvl*10P}LGJl?yM%IX$gRL|Ytjjkup%X>zw)uSnH(J$yO5
zU8j7F)3TLShV<IZO<q=3*aV(2WXjIr{4QIVY5f|L4EpF^WE4iL3jtTx(XxWBN*W4^
z-_WCX7?;#?U*rQbe!I|V854fHIJPDRH1iJb31{R=+zSDbmBa)*gaok0A;KJa;&(Bp
z#)r(vx4L}H@~^L_*+IT#&*t;yvN6UDOC#2J0xDVdD|akrIkvWr2Ir`D8?VdnZ#okX
z_Wb!Syt{gL_8#v2AERdDI{6tsNuj~)<0dCJRN)Vt%0g{=92@B0Q0GZ@OKZeK5KN8=
zxKi3z^}irEB)ff8Ni0cYf#!T5o+&my9Zds!s1r68hrN{6mH-Bp*N)kFaE%t49ZzuC
zi-uz`WT9hCEkUq41?9|+CoSA0<r^M9!8A6?kIhBj)<8VFi`N)g6;c!_&A#b<Ao1Q;
zRPT7!oj8qhw<1^q``gl5ri26W_MWtIL5#bhmDZbW>B;d0<`u0uwIL^$j%;oK&jj`H
zQ!E?f(f-I_z*=SY*h)rmCl}oWNAwad+?(}w6?{&**JTaJ27QsXBuDo_%e+;%hIcg?
z8u0r0y5oFAYDrGV@_}0M*~qW=A``BB5qV!5mt`2lu=YE%dh;6cT0y;UkIu}IO^D@v
zrOtwrjvys~-P{=`qg%?6yzMx-6h7D0t}U(WIkrt(EFdRL5?G~`wzw{)1k&Cokd97w
zd`8G~P*!Eq+(k&3Egbw%bIm8!eT!5^!>grvoyL$%1)oCt;d5p(&dwJ|6-YT=LlAuj
zCY?n|^ZMlLD!D+#tx8b0TO#g7c<y3jK_YJFP~;ursfI&lckIJmh1$;1Dy)jc7oOD?
z^jfM=iB+jB$HvD?fw=Xwu6FdJsajf`PVLu@kL8(`wq@wpIEV?Kz~)6h+uif^qwUpl
zJB&0(gbd&|+pZzMF;qt6+7^?5bLo~}dOY`Ye8QZK1KhhHvNMipdPz2l1~yVPRIp*9
zHS^Omk0O2`)#bVFzE-|klD{x9wA*cV%rzT<QVt2!dhp$5aD7_Yd{chINCm^juqp}F
zJ91g(TKmElJ~<$$ri`Bv39h=rcx-6~#2ND%9aRzfwPlv*oWUO1!1$#X?ks97zTPRI
zqCsEbB$)^knURGHk`Vx}iWyiHa}I&1d^iH-cr9Me?USVP_UJGq4kS&YtdWIt%^?@!
zkU?wj?5fIHc&j7Ry{moIPDiY00f4EJ1SNUQ6vBgh9)@ti+5tY6ex~MBFp#`+)y0*X
z3Yyr~t8&=tSPx0C)Na!hG2aolx}aP75H4rv{B`n^>YzkX40gOZ&(li*9qpKci$Ep_
z_G(^IXMlU>dj67Ej@p&eMzP{@M$~=hTTU=f98C~z`)vrfy{CZOw@nlnp75JD<M;N3
zUqvTU1X4wA4<Cz`OOOkWXQs`1U^c%SwW<L<)z3To;qpY#a12(Sa;6t!uTMXn+->r-
zzJDwc09lh*HBopCH)?Q$MzK=Pt0g~!uNTeED3B`@02b$N2ka^%khTTvFsQgENgXZp
zSTI1ECI=p^yN|$3*C2my>eRTmb~6JvOZ%F1=%tsEO8BWrkXKygs}O{FKB|y-L_Aey
zc)&(#RYgpG)rG8Zx<oK^PL-(Eo-aii+~}@Aq3|4keM48sanamFf_sI*8#o8>sPxB<
z9q(7UMs|Rcz3s|MSu;o7<(&}4l2q2D@0HGh4R5x-jz`(G&!k5nZgX0Iha_CWe_h0$
zzk-^+eJ!8KJ8U%#W8pZW3&GLrHT;@`2gL*V<Xxm>6wgFQN<N3BmkPS^n&^dKviXa1
z!aNXCF5|u_-f~lW<uvhR#sZx)C<L9^#}(|j#_q*t|CqD#=9>&_X;<^rrCHDjD!7~o
zZti3b?l)GO9FA0mO1KnnXmPME^o<A;IgA3jN4TrM58CzwEco+h6Y+>D)AA`Vn!2qi
zuEn@iiQx-zeDmS$Xaz04@+QO-;k0%mCNd$lAlY6&Htr>B>kDqTGbK{?=?a2wM~^s;
z^E^Qjs%-WJ7^xKwP0w>EC1Ttow!Tq=mX8>VgK|<1^pvjqVzOUzPW_gZk(ISIcg+r7
z1s?o7b}Rm&J+9t5d6sO~mrmt{mc_v+8UZ4kE-&=9L!(I7`?H#9es+|Me$HM@f|uGH
zG9Qcs_!Ub~9~b8!Jo7H8o{Byc%ea=xxaRUEBtXKuXJp1v-!B*&YdWWC6>4l4nWf7r
zxnr0adUw)-28ueE#C*;WrEV$_I&C07UUG(i;{rkKE(ew_AYJi_iCi|9;?*P)*_RFx
z73Ti=sJ)zu$_%e6ExEc^#rUEEocjzRvucr)-Cp`kB18CtYq;x)K1{0I3B{V6=!n?Y
zqnY=&<05wwW;v|5bG9xOS}E+ZHlJX~L+X9c_%bgCk(Y{=<5?dU7R9A4P}Fbu{bktJ
zM6mCAm)6|xkg?PJSm}5K98gZ51ffB31)&itMpsQCN9ZfG2<1V7U?N}m`;-Yejjx`?
z2QbMUR8t@l7b$Qk^pb(dJ=~#blOkRB+9i3Ts}p$8D&J5}njV&YD85wYY)oAtHEk7i
zVuRH2czJHBqJAOsU9YsSGQBYR)fZ=|JA}b(z1egVoLL0&syXF?w;l5>kTTsVAqi)m
z+QU+pO)1}Mc;koIEMSR(4nd%6czuL=CxTv8=^(jg)Pizh!>2qXZxlc^ghkGf+{pz^
z2YVuw=C$*jt<B;>J=uMsxX-xfe<^Vvef-sd@4D*{@f-0;<wRRIu+1bBCN($a&4u6q
z<Hl8(w!kwu=w-%?mliiOOQvdwZYij%Bey2~RA8ARFb=~$bo>P@NE&w1{l3<JFZzS^
z9meQw)iGWEE3i?`N3_cdR88=DJt&mRH5l)Hc8z8jjf$LC-<il3z$c^#>SMkNvVqJR
zf;0=y6-eGh#A5DX=KD4&Rz~^as<T~3@kjNxBjU0iulnk=a8}ChUX7$sNUkqw&8`^5
z)1;G!r#icsoa8ffttIAq#A-CNmLGfjjzv|6Aa8~gVw8cUK?xhI^!m+c>&0An<6@Px
zkfim-_lgjlClGO+-(O?rTeeY`kwzBEnKL`%^=VQ(@^lO-eJp?RK4gK;mdZ?;rX<(n
zf#tPp<xw@VvY*+~SiOw3^^BZr4A0!rKu-ZfwIfkOUwjJ4;-LtS)|@_IRAPz<qG6v|
z@k<r_HGcaXQG>hF>6l6=@)#NxM@GoR*rXpGvVDRG4@`^u#H!gIQa*o9IQ1w#*{s$Z
zv}~U~5(b^9VJpI{Ha<{m1uzt9A2kk)G!$YHhzJPo8J$3UgbuW`N^h}_O(`k3CXG#Z
z-0Ke|8`xDltkW2w0sb{gsX~R05Npl%*&1sic(Er{(=A$g%_Qn-9Euta)&9c4C7Dq#
z3x~DIM<nJJvjh><UcI!mZL>%lvXFfX7AgDnlK`x1o-B*351##ieo$*@s0`TRN)Q2o
z?6~f*?}B2#(M7DTh;xz3$S_xc%a)@i<(6UKYX(_YZMWUFai<K=`|!2v@~qr7sW?b_
z*A5MK_o^l<=S)1!$I+cdhW1u*3IAd)e!{d5-A0v{g1MECiLbu5&FI?Yp_kR^Wzzr-
z7{5U#%3n41gok>!KCFCyU8Zf|IIu%3ZsdEs?*YCEk0hOj1nr_HOu?&oqX?HUm#NJ+
zmqqjfJ-BLiiW-0*|8CX-ud&r-&$~mcpz-#cVMH?kmhJdN_?GmD;*55JB<<nch{l(@
zX%$6@Hyx*13tYT$O6k6#p+=XsjJbGk!z9dj_Uy{)dwuzfWING1qFEvYFZ!Y8ghph0
zP6Ny8$Io_T@lvU3-ZgWX3DT(hrWc6Lui)4)tnXt&8;-44yApX+okX2XR!uL!S3fs9
z!oJZS;;DNeB6F3h^LijZYl3T-i+n|?e^4<NY^2mDQ(2x&{>iV6DNB(Mx`X2M>+-?f
zwBx78`+aeqYpswbu>E5^Q)17~_3Gtfce(fJhi;)-%g(4Rjr;}grp(mY8)?OvX8je!
zDhL4^M~go29G<}s5Srs4YzXRpDHKQw?ad(Hvp*3qLn5Ily-%i!7&(Q%%Z&ATkF`Z0
z)kwOePa`)GWx6MG^{K-$N(f~WewyU-t%BHI3@jyyB^|!^r;v}cc$1y11!Qv7;Px;k
zkRT~+jnJs*3DH!G`4b82v|wny-|mVY_%GW{ry6y_9UU;c4R0CRH4p0y=~|Hxq;eOV
zU;0*dPK<q&lUvdE&?Z=QiF35aU}})45w@$69e?r~)up?ZC@*K;KISc=*JrvD@2q~J
zcrR(4DM)BH=PJ3HM;r;uISblbN!-g!a5w;UH$f7@S5n209a)H7QORGzESf}QF;}Vp
z$k7OHz`CTo@Eb$6?5#`Q__nB@9k-!?+VGmTkXLEKC)~w9{`8xaC~(IYI^hj5>aG`C
zulMZaR%J{2K1y?B#jNtOt)iHZ?as&;)a9z!S#5NOZ)mvROnzLFu*u_JX}Ip6@nWcq
zl)$05>ni^|r`7q|jW+77CM#1k57Qgw3-H|x5F_h}H_M<)0&KLCc-2bOWuLCk=;N^c
zbv|O#?!*@cFB)gU2s0Vh&yi&7ZfsRm&9}EMRI7wa23SlT>${nLE?ywmx+D=7hAnwq
zd%wB^O46d42SyUl#~(uc<VIXUdI&R;+8<H$9h=(??iS1c(LDIkLvl*X-6|5n;7N2i
zylRs-0)8%wYkYBMS5VrD-?OnI5ee}2762z6hlCh*+?!0|m%mBT2uZCPctO#~KSnJ0
zLA9K%&-?At5k?7ISD|e3ibO2vYF}Qq3JQBbbmG#-Nw;)LPkpM|)vbn|@q`^(TrrY2
z^uyles2+M8)^IKiqI_)CbSXJ>NH!Spd+yA1ING?g`tK^<)cHhuLEgJ~?K6vl2yx0b
z_XRh`33(rQg<71?VA{xnKr4Q4{%TKaEh%U(_3@Q1S$R8;f1(CG2ueC^gn0a_5*+&V
z{$-{d86(c_HwR%7LOn=Hc?(~{v)3?g>xJ1@+{4avba8gBaxsqzPWaoDn-9n*EyoKk
z+@7ZRr};)fM&V)otZ!O;`-e*{+cQP2QhB4n7sfQdm?mVuLZ<khtI%1}WF^CaB3^1!
z6gxE;Znz^q2C@%o;8HdB8LcnwSg7!7#o`lF^01*$-k|v>^DL~=R<eTHLvd6|uEQD{
zVXelkiF|@5B~womB_td6O7W^#`D(JKc)ts>GE06qS>4vkK9Y=LC=<9!Y3<L9M<zRp
z-7a8URSsYiy(+nB*5{!tb_LoR2F9^=>~nthT}~L7ID|rky7W`Rfa=f-^!I-D^%ZD!
zqWccb2MA>7QOi`|-)yweiqt&Wm~C@z<|PA)Fh9X1x^I-++&_lKe1cEQjJ0*+9_@CV
zXZ8rOSnqq!XzRwj7H)`b+1gC3&c(T4zRTC#20Ofb^1a=GbyhEV5L`6rLp|PS7m2Od
z%a@zCBy=<0xh^SXly4MQa)RX~0d%;VHrPb<2&y(<uR@53#kPA>964l+z)(<(plMCh
zs1c5^L=PNQ;k(9*D7U^dRGI3OFT)eL@s|Ls4q@G%2193=jQ7LX%%0%f@T7G|ym1SZ
z(_@z@@~kur(ssBi)SHno$!7e|G)%M^Xk&9T1n`MPO&BICm4lIEd_3*~j=h<h=3Zd4
zr-<A!jgCR*aMyqndNJ5WTN@8Q3}ti*L|cqz0v)W%%v$Y*EBF;<$wI#z!=Ikns8!Xl
zL8t1ZPB;Ya_AtEae|+Y0H>zD*KVk-uka*o!dMlTunmoBfg_HbY<;|4WM+&-=WnNb-
zUsYd!Fn;~1Iimarl|xFMY%!P0uSAE1s5tdX(c)M|S>4*DXl8fI_jma$(tMShp0fqb
z{qBw)@OD6Nt}^(LFXc40w;Vq=j^@&kj<m=LB*03y$+nVm81oZcWZgfeXl7ex#^<(&
z;F-2F%ebR)MputB9%R4HETkf@P~wOk<Uf?jm%&>$$0a6*8^=M9y?U{k;e-pF3;_F<
zAf&D*J>VV2|IsS;Fhh8?wuLF@5^@y-JMfz?`PkUFqdp@CU{opellwY?o^Xhe1@vv#
zs?#Ui(KM;xn;Y#zCJ&dYgG;+0Z(ilY^kf_nsS4_{{F)5;a`3n4n`H%&gd(5Cq)DMz
zm}Y%6qUG!!kiovC)XFFJQp|%yw;zVJ$8^nOfIb`?n!gl5ReABKMSByBmr9n&jx;He
zhah0Yl!x$+37K7(U>b*0@-2Da%ppbwux639vSr@Il1=x~p6toyD_UP)NO(EshAV)i
zt&Oc+k7c=P>mFLGInlpLhnd&@PH4w+;=Q+P>fz4)`kkFJI}_H%*39XQm!}(fiVC^Y
z12MhjikS(iuT!eq$_P@ad@PNyv&}*HIxf6;iMGO~;>WECgf8&{CE<@y$!qpZQ-wYI
z?*ze6N<pV3X~#g@bIB({B%fksB9>q8O;&ZVL|g<|!d#F&4v_)g`H`Q{?j{y-b+u|P
zG>0X4F<O3N)Ev=w*rsjN_0bT`CIBenh(+QVyoiPC2Y4rSF3>zOeZPFDh4ymfxYc<1
zL6@WZ&dU05W(0O-f_&xc*ULhO?@Cy;138Ct{X-;S1(W?DDGlWnkTU!CV1u&X<%qd3
z4p7cX#rj}y$*5LyUh*#uw<2H$VD#H6JY?TG+Fpzh@A_<62yK+mRbp7}CBo17e#~((
z<S+D#C)iYTF>me`O<QUHQeQwjwj7tj!<o+Mv9VHLa}w|G)<VYRDty(Y>ncaH>X>Vz
zG5pf3&FcGk=od;zG^LO}eUWnxs+O@>9^5hlK>O;uud^IHx=gFeI^Z<s?Umogm`-tB
zR>CTvPY({^d9wT__Z;Nb@T#+K>}4VKbs|GyQ(tFOn7pBZciFv$9~OIM4x+jtZ8sjA
zWkmcruNvL~v1fZLm{bZ%sIj`aRs$)t6Z}zNuYOyu`b{y7cnDgBUgc=t)ra>jpSY-$
zqcI#Hr3^*4Bx=4ZD901VOb0ave3mK8cwM5<Gl>AsJuVb^pXw5j@6io$ao2rE9UQdD
zhwYiKVtxh20GgN>RIM_%jtgrqFT!MYdY-hHxQp+RcX^Y~bu>t|+7CyJgxF|iPeC3m
zGl@W)2Wk=aKDGYzbRe!Z<@I?r#Z&(!{ERX}V4ELL=K{8Av8A$Go%rX&jj8$M@c_d(
zF&|?D&wJB+1Y&;8JI8g}PoD3bj4xS2a6Roz6Fp7tAfB@4xMi4pTfg8X$s}()VK5$+
ze9J#LJgtYBETBnR{=5N~#gyP6@@~epmEr1*R@&31^x>k5?IrG`ckQy%elZpkd)put
z2gW19)Mp-kS%ReW;RYKx(dzJ_t>|IAF*ThRvxKSD{e6>s1>j&llb1{3nx%^qx1Z$G
z@6<O7(b7HZS_c*%i!v?{NQZpNnY*5Hx?@7vSTf*l-L5ZcGfGhvZT(x)(SuCO*`>zG
z(~@g2)=H?Z4BQ>US-!bdU$Q^x|9_o*1z1+i+U}N?knUDmz_)`&8YHDf0cns1rIGF~
zX-VOukyJuD6p$2@kP<<Z5CjzAU$5VGZ+ZF7`OkI03zj#}%slhVGixoFd+zyc(U!2<
zo-#P4RtRFUiaVm^e{#R35s}VJ7d_A0T%*8ujjGx^-o{KB-qlMaDBDn>HmN>RpMuM5
zThdPA_Pl(l^1YUjVt>_wH2UNBnWxUNzB4rw$qBh)1}ox?s)Kf;URmN@Cy)F!oj8SS
zsH_u$#@X=~CmESa0^r%Dg&Yz7qaj+M?TK!S@mUL!=`K6aA@xI=+B826_F{qUFS$x?
zHt!ci5==_hI=oG0KC(11S55g6)&FeF+SeWN9OvKq&bXztB0hePz<t}`xZ<@~%i5g=
z@}m{1`LL?@Rr!~ygElGDZm<XF=yxq#W$nsE%nh^+N^mB~i6*N(1nYBUeV24|viJL@
zXnudWO#vaCb4wE3axk0zl>U^w)vB!ipNJN}>F7w{FC+iqp8wubaCXfaSPuTb@vF5A
zHFR`T{$N^Mcf4o*4@3)0<p9a{|BYw?L;gXuI7_hpo96JFZg7q~@r#Iny>yQu9{i1A
zXb^v20rmWQ(H}!!0LTd#g2S($VyypbhlXL6w*UF_Hz5K9)P%YIO~Ls4I|li0ISe7<
zZ*R{M1^zkc|4bD4KgIf=cmjZy7V6(LY#0;)(Es7+|4*U-z!U#BQ2>k~zW*j)!!axO
ze=`Lzi~WC41pt=yA5;MhH{uLc;P=+P|KuIy_ofF-;{At}{cEqr@Bag2a`3NK{x@27
zk0FT%jZUgWW6n>%;_*1KXQFdTN%WradNLfeiq}EG3J>E=aBQyMl>*^`i6esoaW1gV
zGLk|z`GPJ9E~!ydFd5yZ)6{lKW7MW$90hh;QM)rHQ-0hK*I~UfFuc}xP_b}NFZbEO
z>{|1wxchKxqwRX)4?`)Es{x_>PjRAdNuLxoT+qn)AQ#Z1DPhSTDw-*p_AFm4^MX{B
z{cWE&`FvF`eB2LilcepxX*{NSA=X;K4Z4;=jsy!@cLnpQ?}GLkgbcq+CC8<Qo4)J(
z_Tj`w1$P%e3Wt2}fZQtK!5p>z1eH*(fC=iJ^N&`Qg5&BahAE*tV`IiS6L~&Q9-91x
zn;Jw#7l^|LdLKfyOFudH!lW`eZjXI+L&$ZnXW^kHC-Q)KVLL@@W#TV0lFIDX^_!CA
z<u6>6n_H3t+?%w)v{EvlQ?vapT(nl@o@?-9PH{ZAVv3?!{BHc%*a2U#jQN#r*d5yB
z?tzDIkMe%LeADlg6-2Ttt{6(fB*d4gM=P4CSMk>kA)Q14K64_J653<6y1eg4K2)}M
z&qJIcI+j3N-4w@#gO8+j*lE#dZKyLokjQzs-P3=uC3LT%vHK_n*>~hE_@LIQ<?Ec*
zt1V|XbrMa6mSr-q>}%15U5O>1X3%7Fl~eN5zAzi{Veuk{%?A?3hvBY2Y|*Po8<*-K
z=F7LdvPP6T{MMdMpNyBSM5~TQ#>oful&!|TJs9i|_m-K6`jH*g!av-spFm`5Rq!D1
zX~(ArYS+jTR@kiSwe8zo^S5qWrA)ZT-3-64O<^y-a8)IX`7@&HN2IHMT^Ltsoyq-Y
zE!5c;r~P_e)kUE#PqT|`IBUO3tyaSvi?-GSDVhZiIPv*PXlAL&GJLBNSwU=C1A>Y?
zBbyaB<kAOv+13O|8#XIgbRV(gUnAyOyJKAB2-mux1sRK`NEbHWo;w!vBajSKU%Pok
zGe5+;>+BQVSqS2DBaXRVq``;6FL+GzIQ*iV1nn5NYUCoR)(h}hcEU1&a^y1EmJ}sE
z{sXD-puW4JD)+dH!SeocGYie|fe2NLb;;v<lCtCWT%3n)lXcJDR|bDKsicYEnpj9Y
z^^a(X?s=;NfB9`n@VU{g`6YhG-Q-3NIR2Xl4KsmP*Pa=93tvlu7)gs1**Lgn(hwL1
zz7!L(=y;g}d6UD`JRiSl$p5_eW&@$^%O`I>m(m&zdf5hNxTrra_uER|9aIYXZisxX
zXK}Q!US?!luC-woY2>JAoK(2UuLXQ<<5BWer7Z6EEqanRl8d05?lLitlj3<tcJY<I
z;=jVPq`&JE_t+#<O(#8$48GzEGejnGjW#oL5%>{`u{;bLT{^ySpOV|-aokF$0#`s`
zM;J$E-!^ZZ)~7{uOInxQu8?7diaA3n|3ihvH{18j!GfVwEy7fEf*N>fm&xVlBYg<X
z@<?K-avmvNU*RzCU}|Z2p_`xgLH^rAGM>(#)-&uOjf*!5d3W&}jQ_P3kzfukxa=>B
zZwBrm|71eX!r`#QX|poi?|Gv!FPg0Ssut^dx0kVLso*0#^1F_?l)Oru>*gd!!C#`v
zqs1c3qWW4GUq`>W?16{q()CahhNneX2~GPkYMag{IpGL*(!!pVnhSb9^vXR6Jjr0}
zxfj7Ahqg5FSKSuOqolo-F8v{)XN9{qu0^e_h`97$pPwuMN1?vcXke_SYv?F*B30{P
zUxe&+xD!zmSTM=(BoPisnzc%5UMZ2c#jg(#k@1yVdz}jsdz#}L?aSRMJ0EAHkWS4>
zCcl^@LA&u7ze=}>@Jmo`hi#_}ax>tK=37^%*pl!7^8^-1&JErNiO&Zh9+6_|mlB>9
zrWtXhX^22q3&phQCL?}|D_0cU$@eM=(q^|WOdGrUv1^ZauQ58r#{AN<d+d;Tn#+z6
zt)$Lzk%w?1;|#-0;8&`sG<q#g>Rt*0O(VQAXP!5lmbVr?Jt$9Ty&m(r1RXB&9kZ=|
zCv6L~Lz(S(G%E@7U%uI|o$SPEAnPZOC<uPu@0YwwyGxwK^JIXmMYj5;vOv<aBw~%1
z+i!6)OK(CXnBJ<A7eLnqybM>`*V8_V@6qz4r}wyl$RW31S$;4;<ggA6n_JaH&8Tkr
zeM9}Y@PpPnMdkgJ(}?SjrkgE+Bg@FImzAy?7;!Ov0~j9e>f=!f2c4)|CaZcnwa4GS
zbuc^Owgq)n2XQ@ARC$_CHA9fsZ<sZtw`lR5lP~m1iLu55S>=z}b%`tTm8Q35P{z1v
z@u?!O(h@iKxtebecLyJ$!saYv>boDQ$_L$fGFhUdj6YICs!G|<cc2Yx4&+yr=IOa<
zkj}r8^DiDe2PJFbXQ0x%PU(+T{-S?TF3pWEI3rS6NFl^en#@I@2d1&IY#J1=eE-~n
zO)vaahGEza@1WRzrAaPJRq8VHY7^bE15(#1<=xvsBk8df0difp2KN+XiiKr-5RM40
zjwJyL9)*+;oF&*ffY#c`G)p^Q?BjNF3gKtAXfw8KBeqBMS&;h57Qx}ql_Rf+5}k)~
znx(g+$u`D+l&S2$CgOQBVY-mc_%(=6vi!}fudi;gQ<*p<(U8C<@Ykh$<82eagNg|&
za%vyDA9=nb-#n<<C2KS%C|!w^Qqhysur`c)ta2}@8y~@;2OkO<(u$jWgFj%#m&Fw<
z=<P<MiA<QSdqJ!1)$8^486AxC1E{F7j}tX0u4=I_T~hj~hU9+wz$=usw?{IwH2RT2
zhJipx!E8fV!D6nS-1w=JKCwMH`%jv#zcMZug-<kE;Y2dJ!OeKX@dpjL<_sermo*bD
zb{UIzXbvlQ_TuwvbBmz+dDMyU^wd7lUwN%Nb!|4VmaS-x^G8w5zJ6QjOAr+=#Y<+f
z%1Xz7Sxt=}q;>EIoX`l*Y?CRbj~$bjXvE{S#XV3yfim9K${ZT!Q8j)dHreleZ?%z&
z<JwWh4I?K@?GPz+kpnrW`c#<WN)1IaH;XKx%t(67%z9$y(6z2F@dN!Yf?>#BjX>hf
zlIvrndTC{Loh`z8A!TGbkxHpDudLVq8oB<Wc#=~P)H=*cv$0H&FSNgZr6zk(OH>~}
z>cONL3CZ_cFErE!iOurLqXk%W29uwax_6{lI7{c1vq>v(ONbQ-dob)bwy~*LkSj(~
zRXuY2l!hj>7*^{7mNc(6l^aB;PCRf|vR5nn+7uM_{Mpj8!Y9Im%fz16fv<BZa7x32
zox;nr0^PyeP0Qx}b8N^+ool8dIJAe}_?;F%<E~^$av-M!rEI=h1e5q*4vumlG(ENF
z6myXplO~G0p01!wM1Q(W!6r_$2$qa>8hAL%SNL!&wVx>MM3yM7l{L6;j;_-JH}TT-
zCKe0fB#O$zK29+|ip~_t*zMp8&6@q98gDN`I&~x|JE<KB7dPHr_ZWLv7(|g14N*^|
z$k~mP@z~%9w)10Iw83>Lh#%K{YXj+o`dtpT1FX{<L!9O?)|CqBpSXgp$T$SM@fUSP
zTU^3tLULz83uvO<Q1-AEXA=&-{d+X+nxQ_!>Uf^xpQYHEg!<PmDT)y7S|)o|;vKb|
zD)irS2w<5us}9*!KtK*UlN52Zq$QPh#Q0+^cBc(J0(QG>9q8R${j8<^M2j8!oCr?w
zxFESQ7gL8ioybyeh1K1O-NGR$7IhM05r5u=i+b<WN75u&k$g$T$zO3fyMvWG?0L&a
zXEq+v<K&-U9siOq<ZuRC>97alIh6ALy(ioLggl^^5#T1~G`|`}T{K<m45<3$sMu_?
zq`J|H^DezDXMLtx-oYq61M63n4<v|8-&kr7`gRueunih!n&-606xzYt`f-W9!QPcu
zP)uySL=LGcFIq{vcwaxhn~s-J%%U8t&S9d*_n?`cZdrPyu&iftaY-rEF{+Gg@h%_#
zC3=<QB=OFVi0|<Ypm#FJ1&cT%cIvyf4##C&Y!Uamhp%tyO{=%Yf9Cbu@cYPRr--bl
zzNFDtGQPs3NgZhm8x6l2^3L@!zo8t9puN?!j5%eK(nd~IjrWhjJ6(;4&4$9J3<g!d
z(~QOStE7%A=1KApoH)AJgAn8PSAOod2~yq<(^==tg*;j#jwmh9Evj1yP8_wK@Rl}M
z88f%bfJu`TjK;lT6p4E~Z?`EvO32Nvw=gsiD(~tio#(TvV&?6lDs3-aYcR)~Q*@1O
z5oXz5HDT3uN5xn+hC+jJc9YGi%aHR$9|ccroFj7dMqqaLTSFykXxj6aqpAqaOxAX8
z+iK=b&u_;bJoCdEH}darKbq;bcTl}6CiCgAwdO$NVv*gH<jSn6Q&P{DlrJ$~)@G#-
zln&lF%ztLgh4Bm6DLC#=O0+LH)sI;3%P2J!ZpATh#-L|nSYPk7ZhG?PaOEt|^*?uI
zR3RN%kBHrNh<aXbzPIKWUGA9u)moS3>YWc!X%r*)cdZ3xnpVCHI8W4O4p+p9?Pv1J
zkE~nkv+)`FISnWzNZz{zu5jPzu6@Nk)}rMxjC+IbIhl6&_DG0JcCpsY(x1&A%0u04
z6<OP}jQb?JwpI*uZ{^)C`YH92p+49&V2ZC^AYa2yr%t|L($8!Ol{3B_t?W%UO_9#W
zXA_fZ1>d_fdDWb2sf_EiHmyr3QQ^+d`N^eur<&2Ypf-W^+y!+FGKLA<);n>3RTmae
zrn*s(4`+zxHpN_-mG3kczjlY1Jx@^9<BlLbGU4)$kk%e+>!BrYJ=ZbUH%$t3kn1#=
z@FSt_jlJ*oJV^uPldRyY_+{{pI@OW)-@HOio`m34)b!sQ!)YAM^JjhQE*HyMS-9iS
z#ibPDRp#C08!C}Jyg<V3>&xxS<F7mIzhA;-rmaIg5I!4td=jCASk``x61`G5bKyba
z8wJ~FRWg#d@4gJEFs9K2=)Pq<xjjF<0^a`-E>F|b?;o+SF|g5_s>=F##M-{dquNEz
zNBp)`>+V`(PeE?h3r|WXL7RI-pLGdld2c)_$$m8Y*uLL{_@-q>DQQ7uEgxQ{(5MxS
zmH|CCm#q$yy?3w7J@2d{y>Yh2uK46^Ss^vU^g8f*bD_!DKw(wVVd3I3^v90l=A(&Q
ztP+kNWhT3nK7L(hSD0BtekVKp7%y)fJk8!~&FR@zLKoYSkSPdG?psv>e^?yn=I%Be
z*bKvUr4xtQT_1JZ)t=q%-7hf8I3{~~vivqB{BX5ENW^>fQ6sYDYkkhd$?lqpUjt9U
z9=~k_Z^b>k&%=ocOZ(J)Jr9PrxSiYWMGxN}r<~R^uTiPXr(e!eVKsz13R>h<)xfM9
zY#8qp^x7;hOw5yrk{ur2<b}(cF;um$CPc=Ta&4x?5G(AkSU6|CD!$%0GemQ-b+TYB
zlHK<7`v^&AIw|gr5?SDvV<zV#Vp!WXif_Vh<aOmL1J>jd9-Zm<t|8M1UgwW)k;ycA
zp%h(OfhwP>5l=$<vwm*=g_m7}CMmdH?xoYI7R38bMttp}mzr1GH&9O2&WvO~UGLf)
z#~g*LLDl>|xn$(s%kOcWT<IL87o8Gw!-zw|bXal~H7dlEv`;E5`ZvEdyS@|6$Pno!
zf47xmyt}Hv?rQ)!{Sva|f4X1wW?)+C^DDHg<rG1G|M2khcU!HEKP!>0R~zC^_nTeY
z+1gv14u@6=yNNgnODMm7P^~1xvn>K&`LL<B$4z613(unc;!qGC$673~M4Xahl(}(X
z($G?<F=W2`-iQ06*Fd7p6c<b9FFTe>6iR9v5REv~@Fgp^loE|-fdzDGFU~Nes><U^
z??l4Z#Y2>12pzJt<epkfmg|NY_BdHX?|LP}LOT3XZjZYxP~Gxc<Lc76<vzXD*FNgl
z_w=xqq(P9chE6YyhQ45}|N3~x;D|Xb+eJ{=a^S1c@9-}B!+7P3FrL>6pSantG&9OL
zgX3s)9F}yK14@|5VRONQm$UQem2iuwygvj>+R+*pTv|M`Vodk)B^{vhj|->pxKNV^
zDh?G~SDoWDLh$7gFHAUxQp6`YDc+IOHVv)QioedJN3XL!gSKuX5dM&qsaHz9C?@iw
z_kQn4ivU~H!^1}&WX$ptdIbe@BRNTSmL&3_oq8gqVMO4=#DQU#u<f5YnJZfcJl@W-
z0QruRzeBT#s^Fc%x2RJkmt51h_g4u6*T!Fvbrq{R=}(v7-O1Ca?bQ#tolYzv_iW7W
z29$R9DDtjFg3X0GhO`dfUia-LXA&{{*^BLPwjjI6cK&695M{=)YJSG~mG`UyW&9V#
zdIiU=+hld_8ajxS%sPr#j;(vPMry6A$`|42v#O8s(5iommRhH&yG+n01+I&Otk;X=
z&O20gaK7JM66tn8c~8*^Bl=}JbS?;!-1vy&JO%<SQIoR9;GI$hd*Xj2QM^$uhm#D7
z>c6^VmF%J9W888hA~&H+_KJ|<$FJ+{%Fh#qTXMgZ?PWS|CNRI`nsbQAvTT2`AH}q^
zEiPO7K5DW%V-tK|p)trpWx1m6nRZq56XN9|=U7>}yqTPMk73_tM5G&gW$IrsClbNW
zstTLb4Gle1k34B4l2RGQiLQ+_bGuqg5q_@iWxDA5Wp5pqa5xJs#fol}5ffmW+gX1i
zstD$vcNP}=AUNuKfXt__@;S)%usAB6d#;|q+h4r=`~f@tR<X0EQpf!XID9x0M=#DS
z_|Rc&NHYT#Iy!3O)lFUGs&8#yJIrQwF(J71ONJkKRp)kn-Eo2#U1WqVcTbRhUKNgf
zq)BqkYpYbD>rGivsR=AQjtk*^-KT|YKk;-bY${PU9j$i{ySCFd6XvT{_5-+72nX{!
zZ|;k54y{H!HPFvRbH}`|@i7!wRng#TN_>?CkGNXbI|M^PUZjb=%E_U;93jK~Nt{U{
zlKSfNpG$sKk)K$TsaFML{UarcIi>{CMF&1|$1~WKPcEtL6qzS1atTPHm6+b`GHtl7
z`L>vu-yaQJt$@;GknV7^KIvGs`f9in?hz@{!$O(%c8tx-r|F83rf%K+568<krE~4J
z4m;nM6J4qLk}JLM-amx1(6(_$W|_K|(07dvI?~he?HwWzJ(UfgDje*T%ZlYhCD(n5
zMJD5I89ylQ#MIHCFB#6)WYr&YF4rEpY(Dt#sb;}q!`(!icP48<SI#9-ZD=~QJ<Y-U
zS{v+YsHO6Fib2DZr_oabkx#<VE?M}!=^CKfoa`&hU&juJ@9XH+w3SKnrPtv^NDw7n
zkl8>Q)#w7hPgU0vT~Ep-M3w4Z<W{G$lJ3vKd#Ol5Nxwq9`&hW%_B6j%0nc=9io`wB
zDay1}mWQvKoR;M3R@>=7<SXNFQOk0=xG4H=^`4&-+AihX2Ws!OX{kexsKh-BZb^D2
zIlU2<)J>k%7M)q!j%GttevWz2?MUPwz!-|)p=?jIR^U=K4{(y}sV>**V*Fw<IHNpd
zXi4_2$e`?Yf&c6_rEA7d{jUKX3?!F$LhJ1+yy(_QtV8oqIaZ@~+lC>-#RbWA6U2S|
z6IlsJ10CIZ)u+*SdfjTXjh^gK_=eB)wY_RpZ69hGXdCdA_3!q1;rHTp{xvZDG)dOe
z*qokMCRQ%cn6K+cH?F=LtS`M4W2+?aoM&pg_B-ve=f3AMd=k0Q&NOLDYmw$dQw7W5
zd(J--9G7d}5=~mBov!~lnjnU0s5nEnCW|2Ln^ZLH3o&V3Y+`iA2Am2f=e?*07wg5(
z$eAIbHUI6~t*whC3x6T<(Mf`au=sD1)*I!C6-nayIzzZG$rRo&jOodmjhR1ile)sQ
zPC#k-zH|DX5bXIXvk1h^v~YF5Zf_xRcfrE4P5St*l-PJu+M6pUN?Ai}&COf8_+A3@
zr?MkbpHP`x;kgUPWNPWhK54QNriRm9O=+qR2d?+Zk$E|*;8;BF*nn?m33QZc-Lejw
z89>{xFFT14*L{;+vwUE2BvcIcsi&vahQuBsmvDt`%IX5^lzDiK6~vU{9UoE_e}oE`
z+H4Zp9;Mz}qPrG1|7>rehdDS)V%zEEqYT=Ex%OzAM+U0=l_YZkB8mPX`Vmg918uqO
zI++I>p<mKQQ?2BNAy?AT9|Py&@vae53((lzeKr7XisevFg;vK3G<1SG_EDZU+Ivg$
z&1}lhQ}-&gZ$xKXXTP@&x33;{$>L^*rcs@2KKlTfl@=hio6#X4NMp|orc82ob^9!0
z_#|q%Maf~_b};;A-<USlZ4+M*e~r>pEg2h@JA<X~lC2LsC?l1Ao;1<V$zJ&$G2d3s
z$Fi0GR7z!*;bcDMg2VFb#Jq&As0Rm<FGCz=#W-c<aicG<tXyXG4DsI{uD9wXv4qpc
zuHqCFPtx)jMkt8ebqysgQ7(zG%UtudmhSUSyR~((yxeQ)sHU{pc_zSfgo=!55Opj@
z<d3&NiVMy3rB!E94mMBS)pUP`V5K&L2lU#llC>ynz7W~83>vX+oH2G)U(X%8fDA-1
zS>0?9t<~urNN&84wfQinY4=HAYkV%_l@su2W682aO<H%{j6_uWZB6v|1b^bH!e^g|
zdG0$B9aL9^Rt=R#ZoCtrxkvBKVwDi4d3{Xwks{OM3&t<E@*XaFq)_Dwy!Q$2!;Q+>
zl1n5PEL>%O){tmBbE-^&lYT#9O(V+u?lv{y&Ixmsl9_QF(nd%{rq-nRVTpdJDSO9w
zcz|VD*Uz%p#E-iXn>3QV7sryM2d42g`tDM;3UDTI(<R;@R?2>+Iz*WiaMQ~f$31#*
zkWPO;xyvDW3Lc~(_Ps0r0zKTfsW0X-f54me%tYrpMNtLzId?-bJJnA<e{rxm!{|Ru
zRHTo<Ha(G9vhHs#<(`<>s5FI9=49uHrKYY;Q5^+(J+zlO`ZDd<|5_Bz*eg?r%P_{#
zz5DtF<!~tOl&c<N5&20(gT6gy{<}{OwsN<9)!+IU3#AgATEGqSLCRrqPHGJX61<G2
zI}AHVuY~yOwpm0N3M`<`n=?tUo0*SqeH~_<*~?$%x+Uf*=HtO)m~&vzCh{c3iw@lP
z6=BKax7FEE6*3^<AcBnZ4)A7NsB-O=is>s~ozVL37s{+Y)ydS5IoH8vvXFlot)QU%
zwg)6Z{nmF-4mes=)rlr5x7rz2r1dzLgEN0U&tTTc`Wy6qn;cWv&ndFNxoyim4W+k?
zr1ywZ->|bzlbaYd{52Lxr4!aP<OUg_-J(~Icp1KphJNd{do`VD<@{yUSoZtd<*lEE
zH|3}mdA)RxPkLetV!Iq6p^FmY%r2&QE6eGFipO^gsoE{miIR3+CZuazL&{dOIXv9%
zQ(6mvKP`UsNHgWmOl|d3i}m9VQXi(jg?#0j`+3sHaD|-HUg~XR9rOA^yc&nn0{R4h
zok#aIN6!@t4%#cKvbIu&;d>Ng1ceof&l66_*73#+3fnp6qW4a#g&4xAjmXG8xQ1>w
z%XrL+UivFnGPuvRSo$bL<}jbrXPu(Whe*<t$XGl$S1dRe5?saDsm|Ov!qU0iO`2#t
z6?1F5bIXKqb%ee18cXK_G}u@qcq{qv^um(l9N|B$X8)E5K!Ty@|E?<j)=1;iv$!km
z>S|$s_ns%mO(j)X4pmc64hRU0<o}QHFX1uFZe>1T|38QNO%8oPxJnod0d#vcfivRW
zyf^^C(qA%+9&Ue>`mKe=r()sh;OJ)Y$B!^8&c7;@6~QzGLV(~PFa!mK8G=B(z`y^R
z{@d`^s=JLFppONH{97&!P;E4KHv{y2!M}ykWLzvv0l_i=_*>iR+AjbQoRh^!4P!P_
z1FP)B*Hj(N{{;Tnm+j$VVF|2OgP~Aj(0@KS5O6pk=4Q$93j;&oPz2xs=7YoGZw$DE
zVwSW2!~hvsFh<JwPYiR7S!~C`Aea*>urL@#DDo@@g#Zi8XD~1bg+!ch7X}9w<<FJ{
zoH^$U6auJ)VcEf8n9!Xq3x%KnLd01N2E%A=VqtJ7wtqkbFv5C&+5vHaVPnA1!_LPF
zhQRJG#tu*)J5wKk0WzZ47#xhzeEYLq5Rm<V_QM$r@CAWU*Z<QFz@V5zkN(7fHjo(Q
z$Fmp|jgk1n#xN&DoW+1VIA;e(U<eObc94I-5a-4X3`fGS`itoYphs}FJ_G^+NW`7R
zz;G1y7=Zvgj6T5`Ul0iBxg0`);Fy_r#tsGfC7gH$L!yCCY`cHRdjtY~E-pwE5~EOm
zraqvJb8$vNpcwU!vv$A~#EJ_DAg@5NeL<o@2<-7dq9N#W^?}akJrIL)c@Ox4Ia~6q
zFAxMqCh{x>g<|I);2#`wddL|&fLwEK4g#?{R~Cr|ZcA8Yfye_yowM~JQ9uN-F*N90
zZlE9tK(pm+Sri1=9CjYV5P{D4jDmvB-NR5I5O$t|P#_2bJ13E7pfFZ_K;JOBmw&ba
z<TxCORTj|HMq<t&K5GX-VJI_yVjwj7*HZ%vLt-Ra&tNDR<eV=k*!g@$0|SEP9|(;E
z8pf&*jR2vrd<Fq!vF|UyIg#ha7hovCG32T<{-Kdj(785{sB^iCM#0aGIS_;MeFLTu
zc5a|xU_krkY`Z`foQoA24#Un#pdV1|e8Kb$U|5~44=8&sPk~rr=LRsoV9e<Of5rea
z=Gb!|6DtH(tT1KIJu84))4BNz#0q$lpJ@Zg7bNz51JgI`yaJA!f+4Wx4A3s>yw6Y=
z>|8&fz>WNDyO<n5pZ72*_B;pL1#S}9Wnoav3(nbC!GMP-HU>vvzgqyBw&?Ty0EYK`
z8|d@>fP?;_AAqR-xpvRZb3lV1g#F9|FkpbO%c79j&n+OCF=9Vh{Y4|Op8;SXgU<N^
z284yN+W;fc*!M)>)dGy2rvL`Q&KC>@NdBDl1;DVMWq=(N@<+RFE~bDMtIMyGE^gX*
zVO~)I)hsPXM>l}b2h2eXB~;15(vbt0qra|Y0nKJHB*@eh3OuhsW{|rm)Ln$Rg#`kN
qLYkUEQNY_4$U=hne>eGCkIB^yczOTz&I@=3+~$b6x#iU5iT?-o)P$G-

literal 0
HcmV?d00001

diff --git a/test/core/run.py b/test/core/run.py
index ec07929c4..924b42c69 100755
--- a/test/core/run.py
+++ b/test/core/run.py
@@ -22,10 +22,14 @@
 arguments = parser.parse_args()
 sys.argv = sys.argv[:1]
 
+main_test_files = glob.glob(os.path.join(inputDir, "*.wast"))
+# SIMD test files are in a subdirectory.
+simd_test_files = glob.glob(os.path.join(inputDir, "simd", "*.wast"))
+
 wasmCommand = arguments.wasm
 jsCommand = arguments.js
 outputDir = arguments.out
-inputFiles = arguments.file if arguments.file else glob.glob(os.path.join(inputDir, "*.wast"))
+inputFiles = arguments.file if arguments.file else main_test_files + simd_test_files
 
 if not os.path.exists(wasmCommand):
   sys.stderr.write("""\
@@ -92,7 +96,6 @@ def _runTestFile(self, inputPath):
     self._runCommand(('%s -d "%s" -o "%s"') % (wasmCommand, wasm2Path, wast2Path), logPath)
     self._compareFile(wastPath, wast2Path)
 
-    # Convert to JavaScript
     jsPath = self._auxFile(outputPath.replace(".wast", ".js"))
     logPath = self._auxFile(jsPath + ".log")
     self._runCommand(('%s -d "%s" -o "%s"') % (wasmCommand, inputPath, jsPath), logPath)
diff --git a/test/core/simd/meta/README.md b/test/core/simd/meta/README.md
new file mode 100644
index 000000000..835e1bba9
--- /dev/null
+++ b/test/core/simd/meta/README.md
@@ -0,0 +1,55 @@
+# Generated SIMD Spec Tests from gen_tests.py
+
+`gen_tests.py` builds partial SIMD spec tests using templates in `simd_*.py`.
+Currently it only support following simd test files generation.
+
+- 'simd_i8x16_cmp.wast'
+- 'simd_i16x8_cmp.wast'
+- 'simd_i32x4_cmp.wast'
+- 'simd_f32x4_cmp.wast'
+- 'simd_f64x2_cmp.wast'
+- 'simd_i8x16_arith.wast'
+- 'simd_i8x16_arith2.wast'
+- 'simd_i16x8_arith.wast'
+- 'simd_i16x8_arith2.wast'
+- 'simd_i32x4_arith.wast'
+- 'simd_i32x4_arith2.wast'
+- 'simd_f32x4_arith.wast'
+- 'simd_i64x2_arith.wast'
+- 'simd_f64x2_arith.wast'
+- 'simd_bitwise.wast'
+- 'simd_i8x16_sat_arith.wast'
+- 'simd_i16x8_sat_arith.wast'
+- 'simd_f32x4.wast'
+- 'simd_f64x2.wast'
+- 'simd_f32x4_rounding.wast'
+- 'simd_f64x2_rounding.wast'
+- 'simd_f32x4_pmin_pmax.wast'
+- 'simd_f64x2_pmin_pmax.wast'
+- 'simd_i32x4_dot_i16x8.wast'
+- 'simd_load8_lane.wast'
+- 'simd_load16_lane.wast'
+- 'simd_load32_lane.wast'
+- 'simd_load64_lane.wast,
+- 'simd_store8_lane.wast'
+- 'simd_store16_lane.wast'
+- 'simd_store32_lane.wast'
+- 'simd_store64_lane.wast,
+- 'simd_i16x8_extmul_i8x16.wast'
+- 'simd_i32x4_extmul_i16x8.wast'
+- 'simd_i64x2_extmul_i32x4.wast'
+- 'simd_int_to_int_widen.wast'
+- 'simd_i32x4_trunc_sat_f32x4.wast'
+- 'simd_i32x4_trunc_sat_f64x2.wast'
+- 'simd_i16x8_q15mulr_sat_s.wast',
+- 'simd_i16x8_extadd_pairwise_i8x16.wast',
+- 'simd_i32x4_extadd_pairwise_i16x8.wast',
+
+
+Usage:
+
+```
+$ python gen_tests.py -a
+```
+
+This script requires Python 3.6+, more details are documented in `gen_tests.py`.
diff --git a/test/core/simd/meta/gen_tests.py b/test/core/simd/meta/gen_tests.py
new file mode 100644
index 000000000..5be84835c
--- /dev/null
+++ b/test/core/simd/meta/gen_tests.py
@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+
+"""
+This script is used for generating WebAssembly SIMD test cases.
+It requires Python 3.6+.
+"""
+import sys
+import argparse
+import importlib
+
+
+SUBMODULES = (
+    'simd_i8x16_cmp',
+    'simd_i16x8_cmp',
+    'simd_i32x4_cmp',
+    'simd_i64x2_cmp',
+    'simd_f32x4_cmp',
+    'simd_f64x2_cmp',
+    'simd_i8x16_arith',
+    'simd_i16x8_arith',
+    'simd_i32x4_arith',
+    'simd_f32x4_arith',
+    'simd_i64x2_arith',
+    'simd_f64x2_arith',
+    'simd_sat_arith',
+    'simd_bitwise',
+    'simd_f32x4',
+    'simd_f64x2',
+    'simd_int_arith2',
+    'simd_f32x4_rounding',
+    'simd_f64x2_rounding',
+    'simd_f32x4_pmin_pmax',
+    'simd_f64x2_pmin_pmax',
+    'simd_i32x4_dot_i16x8',
+    'simd_load_lane',
+    'simd_store_lane',
+    'simd_ext_mul',
+    'simd_int_to_int_extend',
+    'simd_int_trunc_sat_float',
+    'simd_i16x8_q15mulr_sat_s',
+    'simd_extadd_pairwise',
+)
+
+
+def gen_group_tests(mod_name):
+    """mod_name is the back-end script name without the.py extension.
+    There must be a gen_test_cases() function in each module."""
+    mod = importlib.import_module(mod_name)
+    mod.gen_test_cases()
+
+
+def main():
+    """
+    Default program entry
+    """
+
+    parser = argparse.ArgumentParser(
+        description='Front-end script to call other modules to generate SIMD tests')
+    parser.add_argument('-a', '--all', dest='gen_all', action='store_true',
+                        default=False, help='Generate all the tests')
+    parser.add_argument('-i', '--inst', dest='inst_group', choices=SUBMODULES,
+                        help='Back-end scripts that generate the SIMD tests')
+    args = parser.parse_args()
+
+    if len(sys.argv) < 2:
+        parser.print_help()
+
+    if args.inst_group:
+        gen_group_tests(args.inst_group)
+    if args.gen_all:
+        for mod_name in SUBMODULES:
+            gen_group_tests(mod_name)
+
+
+if __name__ == '__main__':
+    main()
+    print('Done.')
diff --git a/test/core/simd/meta/simd.py b/test/core/simd/meta/simd.py
new file mode 100644
index 000000000..5ff38bbe8
--- /dev/null
+++ b/test/core/simd/meta/simd.py
@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+
+"""
+This python file is a tool class for SIMD and
+currently only supports generating v128 const constant data.
+"""
+
+
+class SIMD:
+
+    # Constant template
+    CONST = '({value_type}.const {value})'
+
+    # v128 Constant template
+    V128_CONST = '(v128.const {lane_type} {value})'
+
+    @staticmethod
+    def const(value, value_type):
+        """
+        generation constant data, [e.g. i32, i64, f32, f64]
+        Params:
+            value: constant data, string or list,
+            lane_type: lane type, [i32, i64, f32, f64]
+        """
+        return SIMD.CONST.format(value_type=value_type, value=''.join(str(value)))
+
+    @staticmethod
+    def v128_const(value, lane_type):
+        """
+        generation v128 constant data, [e.g. i8x16, i16x8, i32x4, f32x4]
+        Params:
+            value: constant data, string or list,
+            lane_type: lane type, [e.g. i8x16, i16x8, i32x4, f32x4]
+        """
+        if lane_type.lower().find('x') == -1:
+            return SIMD.const(value, lane_type)
+
+        lane_cnt = int(lane_type[1:].split('x')[1])
+
+        # value is a string type, generating constant data
+        # of value according to the number of lanes
+        if isinstance(value, str):
+            data_elem = [value] * lane_cnt
+
+        # If value is type of list, generate constant data
+        # according to combination of list contents and number of lanes
+        elif isinstance(value, list):
+
+            # If it is an empty list, generate all constant data with 0x00
+            if len(value) == 0:
+                return SIMD.v128_const('0x00', lane_type)
+
+            data_elem = []
+
+            # Calculate the number of times each element in value is copied
+            times = lane_cnt // len(value)
+
+            # Calculate whether the data needs to be filled according to
+            # the number of elements in the value list and the number of lanes.
+            complement = lane_cnt % len(value)
+            complement_item = ''
+
+            # If the number of elements in the value list is greater than the number of lanes,
+            # paste data with the number of lanes from the value list.
+            if times == 0:
+                times = 1
+                complement = 0
+
+                value = value[0:lane_cnt]
+
+            # Copy data
+            for item in value:
+                data_elem.extend([item] * times)
+                complement_item = item
+
+            # Fill in the data
+            if complement > 0:
+                data_elem.extend([complement_item] * complement)
+
+        # Get string
+        data_elem = ' '.join(data_elem)
+
+        # Returns v128 constant text
+        return SIMD.V128_CONST.format(lane_type=lane_type, value=data_elem)
diff --git a/test/core/simd/meta/simd_arithmetic.py b/test/core/simd/meta/simd_arithmetic.py
new file mode 100644
index 000000000..dcdc8f973
--- /dev/null
+++ b/test/core/simd/meta/simd_arithmetic.py
@@ -0,0 +1,328 @@
+#!/usr/bin/env python3
+
+"""Base class for generating cases integer and floating-point numbers
+arithmetic and saturate arithmetic operations.
+
+Class SimdArithmeticCase is the base class of all kinds of arithmetic
+operation cases. It provides a skeleton to generate the normal, invalid and
+combined cases. Subclasses only provide the test data sets. In some special
+cases, you may need to override the methods in base class to fulfill your
+case generation.
+"""
+
+from simd import SIMD
+from test_assert import AssertReturn, AssertInvalid
+from simd_lane_value import LaneValue
+from simd_integer_op import ArithmeticOp
+
+
+i8 = LaneValue(8)
+i16 = LaneValue(16)
+i32 = LaneValue(32)
+i64 = LaneValue(64)
+
+
+class SimdArithmeticCase:
+
+    UNARY_OPS = ('neg',)
+    BINARY_OPS = ('add', 'sub', 'mul')
+    LANE_VALUE = {'i8x16': i8, 'i16x8': i16, 'i32x4': i32, 'i64x2': i64}
+
+    TEST_FUNC_TEMPLATE_HEADER = (
+            ';; Tests for {} arithmetic operations on major boundary values and all special values.\n\n')
+
+    def op_name(self, op):
+        """ Full instruction name.
+        Subclasses can overwrite to provide custom instruction names that don't
+        fit the default of {shape}.{op}.
+        """
+        return '{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op)
+
+    def __str__(self):
+        return self.get_all_cases()
+
+    @property
+    def lane(self):
+        return self.LANE_VALUE.get(self.LANE_TYPE)
+
+    @property
+    def dst_lane(self):
+        return self.lane
+
+    @property
+    def src_lane(self):
+        # Used for arithmetic that extends the lane, e.g. i16x8 lanes, which
+        # are extended multiply to i32x4.
+        if hasattr(self, 'SRC_LANE_TYPE'):
+            return self.LANE_VALUE.get(self.SRC_LANE_TYPE)
+        else:
+            return self.lane
+
+    @property
+    def normal_unary_op_test_data(self):
+        lane = self.src_lane
+        return [0, 1, -1, lane.max - 1, lane.min + 1, lane.min, lane.max, lane.mask]
+
+    @property
+    def normal_binary_op_test_data(self):
+        lane = self.src_lane
+        return [
+            (0, 0),
+            (0, 1),
+            (1, 1),
+            (0, -1),
+            (1, -1),
+            (-1, -1),
+            (lane.quarter - 1, lane.quarter),
+            (lane.quarter, lane.quarter),
+            (-lane.quarter + 1, -lane.quarter),
+            (-lane.quarter, -lane.quarter),
+            (-lane.quarter - 1, -lane.quarter),
+            (lane.max - 2, 1),
+            (lane.max - 1, 1),
+            (-lane.min, 1),
+            (lane.min + 2, -1),
+            (lane.min + 1, -1),
+            (lane.min, -1),
+            (lane.max, lane.max),
+            (lane.min, lane.min),
+            (lane.min, lane.min + 1),
+            (lane.mask, 0),
+            (lane.mask, 1),
+            (lane.mask, -1),
+            (lane.mask, lane.max),
+            (lane.mask, lane.min),
+            (lane.mask, lane.mask)
+        ]
+
+    @property
+    def bin_test_data(self):
+        return [
+            (self.normal_binary_op_test_data, [self.LANE_TYPE] * 3),
+            (self.hex_binary_op_test_data, [self.LANE_TYPE] * 3)
+        ]
+
+    @property
+    def unary_test_data(self):
+        return [
+            (self.normal_unary_op_test_data, [self.LANE_TYPE] * 2),
+            (self.hex_unary_op_test_data, [self.LANE_TYPE] * 2)
+        ]
+
+    @property
+    def combine_ternary_arith_test_data(self):
+        return {
+            'add-sub': [
+                [str(i) for i in range(self.LANE_LEN)],
+                [str(i * 2) for i in range(self.LANE_LEN)],
+                [str(i * 2) for i in range(self.LANE_LEN)],
+                [str(i) for i in range(self.LANE_LEN)]
+            ],
+            'sub-add': [
+                [str(i) for i in range(self.LANE_LEN)],
+                [str(i * 2) for i in range(self.LANE_LEN)],
+                [str(i * 2) for i in range(self.LANE_LEN)],
+                [str(i) for i in range(self.LANE_LEN)]
+            ],
+            'mul-add': [
+                [str(i) for i in range(self.LANE_LEN)],
+                [str(i) for i in range(self.LANE_LEN)],
+                ['2'] * self.LANE_LEN,
+                [str(i * 4) for i in range(self.LANE_LEN)]
+            ],
+            'mul-sub': [
+                [str(i * 2) for i in range(self.LANE_LEN)],
+                [str(i) for i in range(self.LANE_LEN)],
+                [str(i) for i in range(self.LANE_LEN)],
+                [str(pow(i, 2)) for i in range(self.LANE_LEN)]
+            ]
+        }
+
+    @property
+    def combine_binary_arith_test_data(self):
+        return {
+            'add-neg': [
+                [str(i) for i in range(self.LANE_LEN)],
+                [str(i) for i in range(self.LANE_LEN)],
+                ['0'] * self.LANE_LEN
+            ],
+            'sub-neg': [
+                [str(i) for i in range(self.LANE_LEN)],
+                [str(i) for i in range(self.LANE_LEN)],
+                [str(-i * 2) for i in range(self.LANE_LEN)]
+            ],
+            'mul-neg': [
+                [str(i) for i in range(self.LANE_LEN)],
+                ['2'] * self.LANE_LEN,
+                [str(-i * 2) for i in range(self.LANE_LEN)]
+            ]
+        }
+
+    def gen_test_func_template(self):
+        template = [
+                self.TEST_FUNC_TEMPLATE_HEADER.format(self.LANE_TYPE), '(module']
+
+        for op in self.BINARY_OPS:
+            template.append('  (func (export "{op}") (param v128 v128) (result v128) '
+                            '({op} (local.get 0) (local.get 1)))'.format(op=self.op_name(op)))
+        for op in self.UNARY_OPS:
+            template.append('  (func (export "{op}") (param v128) (result v128) '
+                            '({op} (local.get 0)))'.format(op=self.op_name(op)))
+
+        template.append(')\n')
+        return template
+
+    def gen_test_template(self):
+        template = self.gen_test_func_template()
+
+        template.append('{normal_cases}')
+        template.append('\n{invalid_cases}')
+        template.append('\n{combine_cases}')
+
+        return '\n'.join(template)
+
+    def get_case_data(self):
+        case_data = []
+
+        # i8x16.op (i8x16) (i8x16)
+        for op in self.BINARY_OPS:
+            o = ArithmeticOp(op)
+            op_name = self.LANE_TYPE + '.' + op
+            case_data.append(['#', op_name])
+            for data_group, v128_forms in self.bin_test_data:
+                for data in data_group:
+                    case_data.append([op_name, [str(data[0]), str(data[1])],
+                                      str(o.binary_op(data[0], data[1], self.src_lane, self.dst_lane)),
+                                     v128_forms])
+            for data_group in self.full_bin_test_data:
+                for data in data_group.get(op_name):
+                    case_data.append([op_name, *data])
+
+        for op in self.UNARY_OPS:
+            o = ArithmeticOp(op)
+            op_name = self.LANE_TYPE + '.' + op
+            case_data.append(['#', op_name])
+            for data_group, v128_forms in self.unary_test_data:
+                for data in data_group:
+                    case_data.append([op_name, [str(data)],
+                                      str(o.unary_op(data, self.dst_lane)),
+                                      v128_forms])
+
+        return case_data
+
+    def get_invalid_cases(self):
+        invalid_cases = [';; type check']
+
+        unary_template = '(assert_invalid (module (func (result v128) '\
+                         '({name} ({operand})))) "type mismatch")'
+        binary_template = '(assert_invalid (module (func (result v128) '\
+                          '({name} ({operand_1}) ({operand_2})))) "type mismatch")'
+
+
+        for op in self.UNARY_OPS:
+            invalid_cases.append(unary_template.format(name=self.op_name(op),
+                                                       operand='i32.const 0'))
+        for op in self.BINARY_OPS:
+            invalid_cases.append(binary_template.format(name=self.op_name(op),
+                                                        operand_1='i32.const 0',
+                                                        operand_2='f32.const 0.0'))
+
+        return '\n'.join(invalid_cases) + self.argument_empty_test()
+
+    def argument_empty_test(self):
+        """Test cases with empty argument.
+        """
+        cases = []
+
+        cases.append('\n\n;; Test operation with empty argument\n')
+
+        case_data = {
+            'op': '',
+            'extended_name': 'arg-empty',
+            'param_type': '',
+            'result_type': '(result v128)',
+            'params': '',
+        }
+
+        for op in self.UNARY_OPS:
+            case_data['op'] = self.op_name(op)
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        for op in self.BINARY_OPS:
+            case_data['op'] = self.op_name(op)
+            case_data['extended_name'] = '1st-arg-empty'
+            case_data['params'] = SIMD.v128_const('0', self.LANE_TYPE)
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        return '\n'.join(cases)
+
+    def get_combine_cases(self):
+        combine_cases = [';; combination\n(module']
+        ternary_func_template = '  (func (export "{func}") (param v128 v128 v128) (result v128)\n' \
+                              '    ({lane}.{op1} ({lane}.{op2} (local.get 0) (local.get 1))'\
+                              '(local.get 2)))'
+        for func in sorted(self.combine_ternary_arith_test_data):
+            func_parts = func.split('-')
+            combine_cases.append(ternary_func_template.format(func=func,
+                                                            lane=self.LANE_TYPE,
+                                                            op1=func_parts[0],
+                                                            op2=func_parts[1]))
+        binary_func_template = '  (func (export "{func}") (param v128 v128) (result v128)\n'\
+                             '    ({lane}.{op1} ({lane}.{op2} (local.get 0)) (local.get 1)))'
+        for func in sorted(self.combine_binary_arith_test_data):
+            func_parts = func.split('-')
+            combine_cases.append(binary_func_template.format(func=func,
+                                                           lane=self.LANE_TYPE,
+                                                           op1=func_parts[0],
+                                                           op2=func_parts[1]))
+        combine_cases.append(')\n')
+
+        for func, test in sorted(self.combine_ternary_arith_test_data.items()):
+            combine_cases.append(str(AssertReturn(func,
+                                 [SIMD.v128_const(elem, self.LANE_TYPE) for elem in test[:-1]],
+                                 SIMD.v128_const(test[-1], self.LANE_TYPE))))
+        for func, test in sorted(self.combine_binary_arith_test_data.items()):
+            combine_cases.append(str(AssertReturn(func,
+                                 [SIMD.v128_const(elem, self.LANE_TYPE) for elem in test[:-1]],
+                                 SIMD.v128_const(test[-1], self.LANE_TYPE))))
+
+        return '\n'.join(combine_cases)
+
+    def get_normal_case(self):
+        s = SIMD()
+        case_data = self.get_case_data()
+        cases = []
+
+        for item in case_data:
+            # Recognize '#' as a commentary
+            if item[0] == '#':
+                cases.append('\n;; {}'.format(item[1]))
+                continue
+
+            instruction, param, ret, lane_type = item
+            v128_result = s.v128_const(ret, lane_type[-1])
+            v128_params = []
+            for i, p in enumerate(param):
+                v128_params.append(s.v128_const(p, lane_type[i]))
+            cases.append(str(AssertReturn(instruction, v128_params, v128_result)))
+
+        return '\n'.join(cases)
+
+    def get_all_cases(self):
+        case_data = {'lane_type': self.LANE_TYPE,
+                     'normal_cases': self.get_normal_case(),
+                     'invalid_cases': self.get_invalid_cases(),
+                     'combine_cases': self.get_combine_cases()
+                     }
+        return self.gen_test_template().format(**case_data)
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_{lane_type}_arith.wast'.format(lane_type=self.LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            fp.write(self.get_all_cases())
diff --git a/test/core/simd/meta/simd_bitwise.py b/test/core/simd/meta/simd_bitwise.py
new file mode 100644
index 000000000..adba5ab6a
--- /dev/null
+++ b/test/core/simd/meta/simd_bitwise.py
@@ -0,0 +1,502 @@
+#!/usr/bin/env python3
+
+"""
+This file is used for generating bitwise test cases
+"""
+
+from simd import SIMD
+from test_assert import AssertReturn, AssertInvalid
+
+
+class SimdBitWise(SIMD):
+    """
+    Generate common tests
+    """
+
+    UNARY_OPS = ('not',)
+    BINARY_OPS = ('and', 'or', 'xor', 'andnot',)
+    TERNARY_OPS = ('bitselect',)
+
+    # Test case template
+    CASE_TXT = """;; Test all the bitwise operators on major boundary values and all special values.
+
+(module
+  (func (export "not") (param $0 v128) (result v128) (v128.not (local.get $0)))
+  (func (export "and") (param $0 v128) (param $1 v128) (result v128) (v128.and (local.get $0) (local.get $1)))
+  (func (export "or") (param $0 v128) (param $1 v128) (result v128) (v128.or (local.get $0) (local.get $1)))
+  (func (export "xor") (param $0 v128) (param $1 v128) (result v128) (v128.xor (local.get $0) (local.get $1)))
+  (func (export "bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+    (v128.bitselect (local.get $0) (local.get $1) (local.get $2))
+  )
+  (func (export "andnot") (param $0 v128) (param $1 v128) (result v128) (v128.andnot (local.get $0) (local.get $1)))
+)
+{normal_case}"""
+
+    @staticmethod
+    def init_case_data(case_data):
+        """
+        Rearrange const data into standard format
+        e.g. [0][i32x4] => (v128.const i32x4 0 0 0 0)
+             [0][i32]   => (i32.const 0)
+        """
+
+        s_i = SIMD()
+
+        lst_i_p_r = []
+
+        for item in case_data:
+            # Recognize '#' as a commentary
+            if item[0] == '#':
+                comment = '\n' if len(item[1]) == 0 else '\n;; {}'.format(item[1])
+                lst_i_p_r.append(['#', comment])
+                continue
+
+            # Params: instruction: instruction name;
+            #         params: param for instruction;
+            #         rets: excepted result;
+            #         lane_type: lane type for param and ret
+            instruction, params, rets, lane_type = item
+
+            p_const_list = []
+            for idx, param in enumerate(params):
+                p_const_list.append(s_i.v128_const(param, lane_type[idx]))
+
+            r_const_list = []
+            for idx, ret in enumerate(rets):
+                r_const_list.append(s_i.v128_const(ret, lane_type[idx + len(params)]))
+
+            lst_i_p_r.append([instruction, p_const_list, r_const_list])
+
+        return lst_i_p_r
+
+    # Generate normal case with test datas
+    def get_normal_case(self):
+        """
+        Generate normal case with test data
+        """
+
+        lst_i_p_r = self.init_case_data(self.get_case_data())
+
+        cases = []
+        for ipr in lst_i_p_r:
+
+            if ipr[0] == '#':
+                cases.append(ipr[1])
+                continue
+
+            cases.append(str(AssertReturn(ipr[0],
+                                          ipr[1],
+                                          ipr[2])))
+
+        return '\n'.join(cases)
+
+    def get_invalid_case(self):
+        """
+        Generate invalid case with test data
+        """
+
+        case_data = [
+            # i8x16
+            ['#', 'Type check'],
+            ['#', ''],
+
+            ['#', 'not'],
+            ["v128.not", ['0'], [], ['i32']],
+
+            ['#', 'and'],
+            ["v128.and", ['0', '0'], [], ['i32', 'i32x4']],
+            ["v128.and", ['0', '0'], [], ['i32x4', 'i32']],
+            ["v128.and", ['0', '0'], [], ['i32', 'i32']],
+
+            ['#', 'or'],
+            ["v128.or", ['0', '0'], [], ['i32', 'i32x4']],
+            ["v128.or", ['0', '0'], [], ['i32x4', 'i32']],
+            ["v128.or", ['0', '0'], [], ['i32', 'i32']],
+
+            ['#', 'xor'],
+            ["v128.xor", ['0', '0'], [], ['i32', 'i32x4']],
+            ["v128.xor", ['0', '0'], [], ['i32x4', 'i32']],
+            ["v128.xor", ['0', '0'], [], ['i32', 'i32']],
+
+            ['#', 'bitselect'],
+            ["v128.bitselect", ['0', '0', '0'], [], ['i32', 'i32x4', 'i32x4']],
+            ["v128.bitselect", ['0', '0', '0'], [], ['i32x4', 'i32x4', 'i32']],
+            ["v128.bitselect", ['0', '0', '0'], [], ['i32', 'i32', 'i32']],
+
+            ['#', 'andnot'],
+            ["v128.andnot", ['0', '0'], [], ['i32', 'i32x4']],
+            ["v128.andnot", ['0', '0'], [], ['i32x4', 'i32']],
+            ["v128.andnot", ['0', '0'], [], ['i32', 'i32']]
+        ]
+
+        lst_ipr = self.init_case_data(case_data)
+
+        str_invalid_case_func_tpl = '\n(assert_invalid (module (func (result v128)' \
+                                    ' ({op} {operand}))) "type mismatch")'
+
+        lst_invalid_case_func = []
+
+        for ipr in lst_ipr:
+
+            if ipr[0] == '#':
+                lst_invalid_case_func.append(ipr[1])
+                continue
+            else:
+                lst_invalid_case_func.append(
+                    str_invalid_case_func_tpl.format(op=ipr[0], operand=' '.join(ipr[1]))
+                )
+
+        return '\n{}\n'.format(''.join(lst_invalid_case_func))
+
+    def get_combination_case(self):
+        """
+        Generate combination case with test data
+        """
+
+        str_in_block_case_func_tpl = '\n  (func (export "{op}-in-block")' \
+                                     '\n    (block' \
+                                     '\n      (drop' \
+                                     '\n        (block (result v128)' \
+                                     '\n          ({op}' \
+                                     '{block_with_result}' \
+                                     '\n          )' \
+                                     '\n        )' \
+                                     '\n      )' \
+                                     '\n    )' \
+                                     '\n  )'
+        str_nested_case_func_tpl = '\n  (func (export "nested-{op}")' \
+                                   '\n    (drop' \
+                                   '\n      ({op}' \
+                                   '{block_with_result}' \
+                                   '\n      )' \
+                                   '\n    )' \
+                                   '\n  )'
+
+        case_data = [
+            ["v128.not", ['0'], [], ['i32']],
+            ["v128.and", ['0', '1'], [], ['i32', 'i32']],
+            ["v128.or", ['0', '1'], [], ['i32', 'i32']],
+            ["v128.xor", ['0', '1'], [], ['i32', 'i32']],
+            ["v128.bitselect", ['0', '1', '2'], [], ['i32', 'i32', 'i32']],
+            ["v128.andnot", ['0', '1'], [], ['i32', 'i32']],
+        ]
+        lst_ipr = self.init_case_data(case_data)
+
+        lst_in_block_case_func = []
+        lst_nested_case_func = []
+        lst_in_block_case_assert = []
+        lst_nested_case_assert = []
+        lst_argument_empty_case = []
+
+        for ipr in lst_ipr:
+
+            lst_block = ['\n            (block (result v128) (v128.load {}))'.format(x) for x in ipr[1]]
+            lst_in_block_case_func.append(
+                str_in_block_case_func_tpl.format(op=ipr[0], block_with_result=''.join(lst_block))
+            )
+
+            tpl_1 = '\n        ({op}' \
+                    '{combined_operation}' \
+                    '\n        )'
+            tpl_2 = '\n          ({op}' \
+                    '{combined_operation}' \
+                    '\n          )'
+            tpl_3 = '\n            (v128.load {value})'
+
+            lst_tpl_3 = [tpl_3.format(value=x) for x in ipr[1]]
+            lst_tpl_2 = [tpl_2.format(op=ipr[0], combined_operation=''.join(lst_tpl_3))] * len(ipr[1])
+            lst_tpl_1 = [tpl_1.format(op=ipr[0], combined_operation=''.join(lst_tpl_2))] * len(ipr[1])
+
+            lst_nested_case_func.append(
+                str_nested_case_func_tpl.format(op=ipr[0], block_with_result=''.join(lst_tpl_1))
+            )
+
+            lst_in_block_case_assert.append('\n(assert_return (invoke "{}-in-block"))'.format(ipr[0]))
+            lst_nested_case_assert.append('\n(assert_return (invoke "nested-{}"))'.format(ipr[0]))
+
+        return '\n;; Combination\n' \
+               '\n(module (memory 1)' \
+               '{in_block_cases}' \
+               '{nested_cases}' \
+               '\n  (func (export "as-param")' \
+               '\n    (drop' \
+               '\n      (v128.or' \
+               '\n        (v128.and' \
+               '\n          (v128.not' \
+               '\n            (v128.load (i32.const 0))' \
+               '\n          )' \
+               '\n          (v128.not' \
+               '\n            (v128.load (i32.const 1))' \
+               '\n          )' \
+               '\n        )' \
+               '\n        (v128.xor' \
+               '\n          (v128.bitselect' \
+               '\n            (v128.load (i32.const 0))' \
+               '\n            (v128.load (i32.const 1))' \
+               '\n            (v128.load (i32.const 2))' \
+               '\n          )' \
+               '\n          (v128.andnot' \
+               '\n            (v128.load (i32.const 0))' \
+               '\n            (v128.load (i32.const 1))' \
+               '\n          )' \
+               '\n        )' \
+               '\n      )' \
+               '\n    )' \
+               '\n  )' \
+               '\n)' \
+               '{assert_in_block_cases}' \
+               '{assert_of_nested_cases}' \
+               '\n(assert_return (invoke "as-param"))\n'.format(in_block_cases=''.join(lst_in_block_case_func),
+                                                    nested_cases=''.join(lst_nested_case_func),
+                                                    assert_in_block_cases=''.join(lst_in_block_case_assert),
+                                                    assert_of_nested_cases=''.join(lst_nested_case_assert))
+
+    def get_argument_empty_case(self):
+        """
+        Generate argument empty cases
+        """
+
+        cases = []
+
+        param_1 = SIMD.v128_const('0', 'i32x4')
+
+        cases.append('\n\n;; Test operation with empty argument\n')
+
+        case_data = {
+            'op': '',
+            'extended_name': 'arg-empty',
+            'param_type': '',
+            'result_type': '(result v128)',
+            'params': '',
+        }
+
+        for op in self.UNARY_OPS:
+            case_data['op'] = 'v128.' + op
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        for op in self.BINARY_OPS:
+            case_data['op'] = 'v128.' + op
+            case_data['extended_name'] = '1st-arg-empty'
+            case_data['params'] = param_1
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        for op in self.TERNARY_OPS:
+            case_data['op'] = 'v128.' + op
+            case_data['extended_name'] = '1st-arg-empty'
+            case_data['params'] = param_1 + ' ' + param_1
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+            case_data['extended_name'] = 'two-args-empty'
+            case_data['params'] = param_1
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        return '\n'.join(cases) + '\n'
+
+
+    def get_all_cases(self):
+        """
+        generate all test cases
+        """
+
+        case_data = {'normal_case': self.get_normal_case()}
+
+        # Add tests for unkonow operators for i32x4
+        return self.CASE_TXT.format(**case_data) + self.get_invalid_case() + self.get_combination_case() + self.get_argument_empty_case()
+
+    def get_case_data(self):
+        """
+        Overload base class method and set test data for bitwise.
+        """
+        return [
+            # i32x4
+            ['#', 'i32x4'],
+            ["not", ['0'], ['-1'], ['i32x4', 'i32x4']],
+            ["not", ['-1'], ['0'], ['i32x4', 'i32x4']],
+            ["not", [['-1', '0', '-1', '0']], [['0', '-1', '0', '-1']], ['i32x4', 'i32x4']],
+            ["not", [['0', '-1', '0', '-1']], [['-1', '0', '-1', '0']], ['i32x4', 'i32x4']],
+            ["not", ['0x55555555'], ['0xAAAAAAAA'], ['i32x4', 'i32x4']],
+            ["not", ['3435973836'], ['858993459'], ['i32x4', 'i32x4']],
+            ['not', ['01_234_567_890'], ['3060399405'], ['i32x4', 'i32x4']],
+            ['not', ['0x0_1234_5678'], ['0xedcba987'], ['i32x4', 'i32x4']],
+            ["and", [['0', '-1'], ['0', '-1', '0', '-1']], [['0', '0', '0', '-1']], ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['0', '0'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['0', '-1'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['0', '0xFFFFFFFF'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['1', '1'], ['1'], ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['255', '85'], ['85'], ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['255', '128'], ['128'], ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['2863311530', ['10', '128', '5', '165']], [['10', '128', '0', '160']],
+                    ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['0xFFFFFFFF', '0x55555555'], ['0x55555555'], ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['0xFFFFFFFF', '0xAAAAAAAA'], ['0xAAAAAAAA'], ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['0xFFFFFFFF', '0x0'], ['0x0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['0x55555555', ['0x5555', '0xFFFF', '0x55FF', '0x5FFF']], ['0x5555'],
+                    ['i32x4', 'i32x4', 'i32x4']],
+            ['and', ['01_234_567_890', '01_234_567_890'], ['1234567890'], ['i32x4', 'i32x4', 'i32x4']],
+            ['and', ['0x0_1234_5678', '0x0_90AB_cdef'], ['0x10204468'], ['i32x4', 'i32x4', 'i32x4']],
+            ["or", [['0', '0', '-1', '-1'], ['0', '-1', '0', '-1']], [['0', '-1', '-1', '-1']],
+                   ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['0', '0'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['0', '-1'], ['-1'], ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['0', '0xFFFFFFFF'], ['0xFFFFFFFF'], ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['1', '1'], ['1'], ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['255', '85'], ['255'], ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['255', '128'], ['255'], ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['2863311530', ['10', '128', '5', '165']], [['2863311530', '2863311535']],
+                   ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['0xFFFFFFFF', '0x55555555'], ['0xFFFFFFFF'], ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['0xFFFFFFFF', '0xAAAAAAAA'], ['0xFFFFFFFF'], ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['0xFFFFFFFF', '0x0'], ['0xFFFFFFFF'], ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['0x55555555', ['0x5555', '0xFFFF', '0x55FF', '0x5FFF']],
+                   [['0x55555555', '0x5555ffff', '0x555555ff', '0x55555fff']],
+                   ['i32x4', 'i32x4', 'i32x4']],
+            ['or', ['01_234_567_890', '01_234_567_890'], ['1234567890'], ['i32x4', 'i32x4', 'i32x4']],
+            ['or', ['0x0_1234_5678', '0x0_90AB_cdef'], ['0x92bfdfff'], ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", [['0', '0', '-1', '-1'], ['0', '-1', '0', '-1']], [['0', '-1', '-1', '0']],
+                    ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['0', '0'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['0', '-1'], ['-1'], ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['0', '0xFFFFFFFF'], ['0xFFFFFFFF'], ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['1', '1'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['255', '85'], ['170'], ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['255', '128'], ['127'], ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['2863311530', ['10', '128', '5', '165']],
+                    [['2863311520', '2863311402', '2863311535', '2863311375']],
+                    ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['0xFFFFFFFF', '0x55555555'], ['0xAAAAAAAA'], ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['0xFFFFFFFF', '0xAAAAAAAA'], ['0x55555555'], ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['0xFFFFFFFF', '0x0'], ['0xFFFFFFFF'], ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['0x55555555', ['0x5555', '0xFFFF', '0x55FF', '0x5FFF']],
+                    [['0x55550000', '0x5555AAAA', '0x555500AA', '0x55550AAA']],
+                    ['i32x4', 'i32x4', 'i32x4']],
+            ['xor', ['01_234_567_890', '01_234_567_890'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ['xor', ['0x0_1234_5678', '0x0_90AB_cdef'], ['0x829f9b97'], ['i32x4', 'i32x4', 'i32x4']],
+            ["bitselect", ['0xAAAAAAAA', '0xBBBBBBBB',
+                           ['0x00112345', '0xF00FFFFF', '0x10112021', '0xBBAABBAA']],
+                          [['0xBBAABABA', '0xABBAAAAA', '0xABAABBBA', '0xAABBAABB']],
+                          ['i32x4', 'i32x4', 'i32x4', 'i32x4']],
+            ["bitselect", ['0xAAAAAAAA', '0xBBBBBBBB', '0x00000000'], ['0xBBBBBBBB'],
+                          ['i32x4', 'i32x4', 'i32x4', 'i32x4']],
+            ["bitselect", ['0xAAAAAAAA', '0xBBBBBBBB', '0x11111111'], ['0xAAAAAAAA'],
+                          ['i32x4', 'i32x4', 'i32x4', 'i32x4']],
+            ["bitselect", ['0xAAAAAAAA', '0xBBBBBBBB',
+                           ['0x01234567', '0x89ABCDEF', '0xFEDCBA98', '0x76543210']],
+                          [['0xBABABABA', '0xABABABAB']],
+                          ['i32x4', 'i32x4', 'i32x4', 'i32x4']],
+            ["bitselect", ['0xAAAAAAAA', '0x55555555',
+                           ['0x01234567', '0x89ABCDEF', '0xFEDCBA98', '0x76543210']],
+                          [['0x54761032', '0xDCFE98BA', '0xAB89EFCD', '0x23016745']],
+                          ['i32x4', 'i32x4', 'i32x4', 'i32x4']],
+            ["bitselect", ['0xAAAAAAAA', '0x55555555',
+                           ['0x55555555', '0xAAAAAAAA', '0x00000000', '0xFFFFFFFF']],
+                          [['0x00000000', '0xFFFFFFFF', '0x55555555', '0xAAAAAAAA']],
+                          ['i32x4', 'i32x4', 'i32x4', 'i32x4']],
+            ['bitselect', ['01_234_567_890', '03_060_399_406', '0xcdefcdef'], ['2072391874'],
+                          ['i32x4', 'i32x4', 'i32x4', 'i32x4']],
+            ['bitselect', ['0x0_1234_5678', '0x0_90AB_cdef', '0xcdefcdef'], ['0x10244468'],
+                          ['i32x4', 'i32x4', 'i32x4', 'i32x4']],
+            ["andnot", [['0', '-1'], ['0', '-1', '0', '-1']], [['0', '0', '-1', '0']], ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['0', '0'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['0', '-1'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['0', '0xFFFFFFFF'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['1', '1'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['255', '85'], ['170'], ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['255', '128'], ['127'], ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['2863311530', ['10', '128', '5', '165']], [['2863311520', '2863311402', '2863311530', '2863311370']],
+                       ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['0xFFFFFFFF', '0x55555555'], ['0xAAAAAAAA'], ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['0xFFFFFFFF', '0xAAAAAAAA'], ['0x55555555'], ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['0xFFFFFFFF', '0x0'], ['0xFFFFFFFF'], ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['0x55555555', ['0x5555', '0xFFFF', '0x55FF', '0x5FFF']], ['0x55550000'],
+                       ['i32x4', 'i32x4', 'i32x4']],
+            ['andnot', ['01_234_567_890', '01_234_567_890'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ['andnot', ['0x0_1234_5678', '0x0_90AB_cdef'], ['0x02141210'], ['i32x4', 'i32x4', 'i32x4']],
+
+            ['#', 'for float special data [e.g. -nan nan -inf inf]'],
+            ["not", ['-nan'], ['5.87747e-39'], ['f32x4', 'f32x4']],
+            ["not", ['nan'], ['-5.87747e-39'], ['f32x4', 'f32x4']],
+            ["not", ['-inf'], ['0x007fffff'], ['f32x4', 'i32x4']],
+            ["not", ['inf'], ['0x807fffff'], ['f32x4', 'i32x4']],
+
+            ["and", ['-nan', '-nan'], ['0xffc00000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["and", ['-nan', 'nan'], ['nan'], ['f32x4', 'f32x4', 'f32x4']],
+            ["and", ['-nan', '-inf'], ['-inf'], ['f32x4', 'f32x4', 'f32x4']],
+            ["and", ['-nan', 'inf'], ['inf'], ['f32x4', 'f32x4', 'f32x4']],
+            ["and", ['nan', 'nan'], ['nan'], ['f32x4', 'f32x4', 'f32x4']],
+            ["and", ['nan', '-inf'], ['inf'], ['f32x4', 'f32x4', 'f32x4']],
+            ["and", ['nan', 'inf'], ['inf'], ['f32x4', 'f32x4', 'f32x4']],
+            ["and", ['-inf', '-inf'], ['-inf'], ['f32x4', 'f32x4', 'f32x4']],
+            ["and", ['-inf', 'inf'], ['inf'], ['f32x4', 'f32x4', 'f32x4']],
+            ["and", ['inf', 'inf'], ['inf'], ['f32x4', 'f32x4', 'f32x4']],
+
+            ["or", ['-nan', '-nan'], ['0xffc00000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["or", ['-nan', 'nan'], ['0xffc00000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["or", ['-nan', '-inf'], ['0xffc00000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["or", ['-nan', 'inf'], ['0xffc00000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["or", ['nan', 'nan'], ['nan'], ['f32x4', 'f32x4', 'f32x4']],
+            ["or", ['nan', '-inf'], ['0xffc00000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["or", ['nan', 'inf'], ['nan'], ['f32x4', 'f32x4', 'f32x4']],
+            ["or", ['-inf', '-inf'], ['-inf'], ['f32x4', 'f32x4', 'f32x4']],
+            ["or", ['-inf', 'inf'], ['-inf'], ['f32x4', 'f32x4', 'f32x4']],
+            ["or", ['inf', 'inf'], ['inf'], ['f32x4', 'f32x4', 'f32x4']],
+
+            ["xor", ['-nan', '-nan'], ['0'], ['f32x4', 'f32x4', 'f32x4']],
+            ["xor", ['-nan', 'nan'], ['-0'], ['f32x4', 'f32x4', 'f32x4']],
+            ["xor", ['-nan', '-inf'], ['0x00400000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["xor", ['-nan', 'inf'], ['0x80400000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["xor", ['nan', 'nan'], ['0'], ['f32x4', 'f32x4', 'f32x4']],
+            ["xor", ['nan', '-inf'], ['0x80400000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["xor", ['nan', 'inf'], ['0x00400000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["xor", ['-inf', '-inf'], ['0'], ['f32x4', 'f32x4', 'f32x4']],
+            ["xor", ['-inf', 'inf'], ['0x80000000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["xor", ['inf', 'inf'], ['0'], ['f32x4', 'f32x4', 'f32x4']],
+
+            ["bitselect", ['-nan', '-nan','0xA5A5A5A5'], ['0xffc00000'], ['f32x4', 'f32x4', 'f32x4', 'i32x4']],
+            ["bitselect", ['-nan', 'nan','0xA5A5A5A5'], ['nan'], ['f32x4', 'f32x4', 'f32x4', 'f32x4']],
+            ["bitselect", ['-nan', '-inf','0xA5A5A5A5'], ['-inf'], ['f32x4', 'f32x4', 'f32x4', 'f32x4']],
+            ["bitselect", ['-nan', 'inf','0xA5A5A5A5'], ['inf'], ['f32x4', 'f32x4', 'f32x4', 'f32x4']],
+            ["bitselect", ['nan', 'nan','0xA5A5A5A5'], ['nan'], ['f32x4', 'f32x4', 'f32x4', 'f32x4']],
+            ["bitselect", ['nan', '-inf','0xA5A5A5A5'], ['-inf'], ['f32x4', 'f32x4', 'f32x4', 'f32x4']],
+            ["bitselect", ['nan', 'inf','0xA5A5A5A5'], ['inf'], ['f32x4', 'f32x4', 'f32x4', 'f32x4']],
+            ["bitselect", ['-inf', '-inf','0xA5A5A5A5'], ['-inf'], ['f32x4', 'f32x4', 'f32x4', 'f32x4']],
+            ["bitselect", ['-inf', 'inf','0xA5A5A5A5'], ['inf'], ['f32x4', 'f32x4', 'f32x4', 'f32x4']],
+            ["bitselect", ['inf', 'inf','0xA5A5A5A5'], ['inf'], ['f32x4', 'f32x4', 'f32x4', 'f32x4']],
+
+            ["andnot", ['-nan', '-nan'], ['0x00000000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["andnot", ['-nan', 'nan'], ['-0'], ['f32x4', 'f32x4', 'f32x4']],
+            ["andnot", ['-nan', '-inf'], ['0x00400000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["andnot", ['-nan', 'inf'], ['0x80400000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["andnot", ['nan', 'nan'], ['0x00000000'], ['f32x4', 'f32x4', 'f32x4']],
+            ["andnot", ['nan', '-inf'], ['0x00400000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["andnot", ['nan', 'inf'], ['0x00400000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["andnot", ['-inf', '-inf'], ['0x00000000'], ['f32x4', 'f32x4', 'f32x4']],
+            ["andnot", ['-inf', 'inf'], ['0x80000000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["andnot", ['inf', 'inf'], ['0x00000000'], ['f32x4', 'f32x4', 'i32x4']]
+        ]
+
+    def gen_test_cases(self):
+        """
+        Generate test case file
+        """
+        with open('../simd_bitwise.wast', 'w+') as f_out:
+            f_out.write(self.get_all_cases())
+
+
+def gen_test_cases():
+    """
+    Generate test case file
+    """
+    bit_wise = SimdBitWise()
+    bit_wise.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_compare.py b/test/core/simd/meta/simd_compare.py
new file mode 100644
index 000000000..584985082
--- /dev/null
+++ b/test/core/simd/meta/simd_compare.py
@@ -0,0 +1,412 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+This class is used to generate common tests for SIMD comparison instructions.
+Defines the test template to generate corresponding test file(simd_*_cmp.wast)
+via using variable test data set and subclass from sub test template
+"""
+
+import abc
+from simd import SIMD
+from test_assert import AssertReturn, AssertInvalid
+
+
+# Generate common comparison tests
+class SimdCmpCase(object):
+
+    __metaclass__ = abc.ABCMeta
+
+    # Test case template
+    CASE_TXT = """
+;; Test all the {lane_type} comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) ({lane_type}.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) ({lane_type}.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x v128) (param $y v128) (result v128) ({lane_type}.lt_s (local.get $x) (local.get $y)))
+  (func (export "lt_u") (param $x v128) (param $y v128) (result v128) ({lane_type}.lt_u (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x v128) (param $y v128) (result v128) ({lane_type}.le_s (local.get $x) (local.get $y)))
+  (func (export "le_u") (param $x v128) (param $y v128) (result v128) ({lane_type}.le_u (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x v128) (param $y v128) (result v128) ({lane_type}.gt_s (local.get $x) (local.get $y)))
+  (func (export "gt_u") (param $x v128) (param $y v128) (result v128) ({lane_type}.gt_u (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x v128) (param $y v128) (result v128) ({lane_type}.ge_s (local.get $x) (local.get $y)))
+  (func (export "ge_u") (param $x v128) (param $y v128) (result v128) ({lane_type}.ge_u (local.get $x) (local.get $y)))
+)
+
+{normal_case}
+
+
+;; Type check
+
+(assert_invalid (module (func (result v128) ({lane_type}.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.ge_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.gt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.le_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.lt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+
+
+;; combination
+
+(module (memory 1)
+  (func (export "eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          ({lane_type}.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          ({lane_type}.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "lt_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          ({lane_type}.lt_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "le_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          ({lane_type}.le_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "gt_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          ({lane_type}.gt_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ge_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          ({lane_type}.ge_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-eq")
+    (drop
+      ({lane_type}.eq
+        ({lane_type}.eq
+          ({lane_type}.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        ({lane_type}.eq
+          ({lane_type}.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ne")
+    (drop
+      ({lane_type}.ne
+        ({lane_type}.ne
+          ({lane_type}.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        ({lane_type}.ne
+          ({lane_type}.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-lt_s")
+    (drop
+      ({lane_type}.lt_s
+        ({lane_type}.lt_s
+          ({lane_type}.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        ({lane_type}.lt_s
+          ({lane_type}.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-le_u")
+    (drop
+      ({lane_type}.le_u
+        ({lane_type}.le_u
+          ({lane_type}.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        ({lane_type}.le_u
+          ({lane_type}.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-gt_u")
+    (drop
+      ({lane_type}.gt_u
+        ({lane_type}.gt_u
+          ({lane_type}.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        ({lane_type}.gt_u
+          ({lane_type}.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ge_s")
+    (drop
+      ({lane_type}.ge_s
+        ({lane_type}.ge_s
+          ({lane_type}.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        ({lane_type}.ge_s
+          ({lane_type}.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      ({lane_type}.ge_u
+        ({lane_type}.eq
+          ({lane_type}.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        ({lane_type}.ne
+          ({lane_type}.gt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.lt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "eq-in-block"))
+(assert_return (invoke "ne-in-block"))
+(assert_return (invoke "lt_s-in-block"))
+(assert_return (invoke "le_u-in-block"))
+(assert_return (invoke "gt_u-in-block"))
+(assert_return (invoke "ge_s-in-block"))
+(assert_return (invoke "nested-eq"))
+(assert_return (invoke "nested-ne"))
+(assert_return (invoke "nested-lt_s"))
+(assert_return (invoke "nested-le_u"))
+(assert_return (invoke "nested-gt_u"))
+(assert_return (invoke "nested-ge_s"))
+(assert_return (invoke "as-param"))
+
+"""
+
+    # lane type [e.g. i8x16, i16x8, i32x4, f32x4]
+    LANE_TYPE = 'i8x16'
+
+    def __init__(self):
+        super(SimdCmpCase, self).__init__()
+
+    def __str__(self):
+        return self.get_all_cases()
+
+    # This method requires subclass overloading with its own type of test data.
+    @abc.abstractmethod
+    def get_case_data(self):
+        pass
+
+    # Generate normal case with test datas
+    def get_normal_case(self):
+
+        s = SIMD()
+
+        case_data = self.get_case_data()
+
+        cases = []
+
+        for item in case_data:
+            # Recognize '#' as a commentary
+            if item[0] == '#':
+                cases.append('\n;; {}'.format(item[1]))
+                continue
+
+            """
+            Generate assert_return
+            Params: instruction: instruction name;
+                    param: param for instruction;
+                    ret: excepted result;
+                    lane_type: lane type
+            """
+            instruction, param, ret, lane_type = item
+            cases.append(str(AssertReturn(instruction,
+                                          [s.v128_const(param[0], lane_type[0]),
+                                           s.v128_const(param[1], lane_type[1])],
+                                          s.v128_const(ret, lane_type[2]))))
+
+        return '\n'.join(cases)
+
+    def argument_empty_test(self):
+        """Test cases with empty argument.
+        """
+        cases = []
+
+        cases.append('\n;; Test operation with empty argument\n')
+
+        case_data = {
+            'op': '',
+            'extended_name': 'arg-empty',
+            'param_type': '',
+            'result_type': '(result v128)',
+            'params': '',
+        }
+
+        for op in self.BINARY_OPS:
+            case_data['op'] = '{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op)
+            case_data['extended_name'] = '1st-arg-empty'
+            case_data['params'] = SIMD.v128_const('0', self.LANE_TYPE)
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        return '\n'.join(cases)
+
+    # Generate all test cases
+    def get_all_cases(self):
+
+        case_data = {'normal_case': self.get_normal_case(),
+                     'lane_type': self.LANE_TYPE}
+
+        # Generate tests using the test template
+        return self.CASE_TXT.format(**case_data) + self.argument_empty_test()
+
+    # Generate test case file
+    def gen_test_cases(self):
+        with open('../simd_{}_cmp.wast'.format(self.LANE_TYPE), 'w+') as f_out:
+            f_out.write(self.get_all_cases())
+            f_out.close()
diff --git a/test/core/simd/meta/simd_ext_mul.py b/test/core/simd/meta/simd_ext_mul.py
new file mode 100644
index 000000000..30a4082f2
--- /dev/null
+++ b/test/core/simd/meta/simd_ext_mul.py
@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+
+""" Base class for generating extended multiply instructions.  These
+instructions 2 inputs of the same (narrower) lane shape, multiplies
+corresponding lanes with extension (no overflow/wraparound), producing 1 output
+of a (wider) shape. These instructions can choose to work on the low or high
+halves of the inputs, and perform signed or unsigned multiply.
+
+Subclasses need to define 3 attributes:
+  - LANE_TYPE (this is the output shape)
+  - SRC_LANE_TYPE (this is the input (narrower) shape)
+  - BINARY_OPS (list of operations)
+"""
+
+from simd_arithmetic import SimdArithmeticCase
+
+
+class SimdExtMulCase(SimdArithmeticCase):
+    UNARY_OPS = ()
+
+    @property
+    def full_bin_test_data(self):
+        return []
+
+    def get_combine_cases(self):
+        return ''
+
+    @property
+    def bin_test_data(self):
+        lane_forms = [self.SRC_LANE_TYPE, self.SRC_LANE_TYPE, self.LANE_TYPE]
+        return [(self.normal_binary_op_test_data, lane_forms)]
+
+    @property
+    def hex_binary_op_test_data(self):
+        return []
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_{wide}_extmul_{narrow}.wast'.format(
+                wide=self.LANE_TYPE, narrow=self.SRC_LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            fp.write(self.get_all_cases())
+
+
+class SimdI16x8ExtMulCase(SimdExtMulCase):
+    LANE_TYPE = 'i16x8'
+    SRC_LANE_TYPE = 'i8x16'
+    BINARY_OPS = ('extmul_low_i8x16_s', 'extmul_high_i8x16_s',
+                  'extmul_low_i8x16_u', 'extmul_high_i8x16_u')
+
+
+class SimdI32x4ExtMulCase(SimdExtMulCase):
+    LANE_TYPE = 'i32x4'
+    SRC_LANE_TYPE = 'i16x8'
+    BINARY_OPS = ('extmul_low_i16x8_s', 'extmul_high_i16x8_s',
+                  'extmul_low_i16x8_u', 'extmul_high_i16x8_u')
+
+
+class SimdI64x2ExtMulCase(SimdExtMulCase):
+    LANE_TYPE = 'i64x2'
+    SRC_LANE_TYPE = 'i32x4'
+    BINARY_OPS = ('extmul_low_i32x4_s', 'extmul_high_i32x4_s',
+                  'extmul_low_i32x4_u', 'extmul_high_i32x4_u')
+
+
+def gen_test_cases():
+    simd_i16x8_ext_mul_case = SimdI16x8ExtMulCase()
+    simd_i16x8_ext_mul_case.gen_test_cases()
+    simd_i32x4_ext_mul_case = SimdI32x4ExtMulCase()
+    simd_i32x4_ext_mul_case.gen_test_cases()
+    simd_i64x2_ext_mul_case = SimdI64x2ExtMulCase()
+    simd_i64x2_ext_mul_case.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_extadd_pairwise.py b/test/core/simd/meta/simd_extadd_pairwise.py
new file mode 100644
index 000000000..8a398414d
--- /dev/null
+++ b/test/core/simd/meta/simd_extadd_pairwise.py
@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+
+from simd_arithmetic import SimdArithmeticCase, i16
+from simd_integer_op import ArithmeticOp
+
+
+class SimdExtAddPairwise(SimdArithmeticCase):
+    BINARY_OPS = ()
+
+    def unary_op(self, x, signed):
+        # For test data we always splat a single value to the
+        # entire v128, so doubling the input works.
+        return ArithmeticOp.get_valid_value(x, self.src_lane, signed=signed) * 2
+
+    @property
+    def hex_unary_op_test_data(self):
+        return []
+
+    @property
+    def unary_test_data(self):
+        return [
+            (self.normal_unary_op_test_data, [self.SRC_LANE_TYPE,self.LANE_TYPE]),
+        ]
+
+    def get_case_data(self):
+        case_data = []
+        for op in self.UNARY_OPS:
+            op_name = self.op_name(op)
+            case_data.append(['#', op_name])
+            for data_group, v128_forms in self.unary_test_data:
+                for data in data_group:
+                    case_data.append([op_name, [str(data)],
+                        str(self.unary_op(data, op.endswith('s'))),
+                        v128_forms])
+        return case_data
+
+    def get_combine_cases(self):
+        return ''
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_{}_extadd_pairwise_{}.wast'.format(self.LANE_TYPE, self.SRC_LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            fp.write(self.get_all_cases())
+
+class SimdI16x8ExtAddPairwise(SimdExtAddPairwise):
+    UNARY_OPS = ('extadd_pairwise_i8x16_s','extadd_pairwise_i8x16_u')
+    LANE_TYPE = 'i16x8'
+    SRC_LANE_TYPE = 'i8x16'
+
+class SimdI32x4ExtAddPairwise(SimdExtAddPairwise):
+    UNARY_OPS = ('extadd_pairwise_i16x8_s','extadd_pairwise_i16x8_u')
+    LANE_TYPE = 'i32x4'
+    SRC_LANE_TYPE = 'i16x8'
+
+def gen_test_cases():
+    simd_i16x8_arith = SimdI16x8ExtAddPairwise()
+    simd_i32x4_arith = SimdI32x4ExtAddPairwise()
+    simd_i16x8_arith.gen_test_cases()
+    simd_i32x4_arith.gen_test_cases()
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_f32x4.py b/test/core/simd/meta/simd_f32x4.py
new file mode 100644
index 000000000..b9b6b0f9f
--- /dev/null
+++ b/test/core/simd/meta/simd_f32x4.py
@@ -0,0 +1,376 @@
+#!/usr/bin/env python3
+
+"""
+Generate f32x4 [abs, min, max] cases.
+"""
+
+from simd_f32x4_arith import Simdf32x4ArithmeticCase
+from simd_float_op import FloatingPointSimpleOp
+from simd import SIMD
+from test_assert import AssertReturn
+
+
+class Simdf32x4Case(Simdf32x4ArithmeticCase):
+    UNARY_OPS = ('abs',)
+    BINARY_OPS = ('min', 'max',)
+    floatOp = FloatingPointSimpleOp()
+
+    FLOAT_NUMBERS = (
+        '0x0p+0', '-0x0p+0', '0x1p-149', '-0x1p-149', '0x1p-126', '-0x1p-126', '0x1p-1', '-0x1p-1', '0x1p+0', '-0x1p+0',
+        '0x1.921fb6p+2', '-0x1.921fb6p+2', '0x1.fffffep+127', '-0x1.fffffep+127', 'inf', '-inf'
+    )
+
+    LITERAL_NUMBERS = (
+        '0123456789e019', '0123456789e-019',
+        '0123456789.e019', '0123456789.e+019',
+        '-0123456789.0123456789'
+    )
+    NAN_NUMBERS = ('nan', '-nan', 'nan:0x200000', '-nan:0x200000')
+    binary_params_template = ('({assert_type} (invoke "{func}" ', '{operand_1}', '{operand_2})', '{expected_result})')
+    unary_param_template = ('({assert_type} (invoke "{func}" ', '{operand})', '{expected_result})')
+    binary_nan_template = ('({assert_type} (invoke "{func}" ', '{operand_1}', '{operand_2}))')
+    unary_nan_template = ('({assert_type} (invoke "{func}" ', '{operand}))')
+
+    def full_op_name(self, op_name):
+        return self.LANE_TYPE + '.' + op_name
+
+    @staticmethod
+    def v128_const(lane, value):
+
+        return SIMD().v128_const(value, lane)
+
+    def gen_test_func_template(self):
+
+        # Get function code
+        template = Simdf32x4ArithmeticCase.gen_test_func_template(self)
+
+        # Function template
+        tpl_func = '  (func (export "{func}"){params} (result v128) ({op} {operand_1}{operand_2}))'
+
+        # Const data for min and max
+        lst_instr_with_const = [
+            [
+                [['0', '1', '2', '-3'], ['0', '2', '1', '3']],
+                [['0', '1', '1', '-3'], ['0', '2', '2', '3']]
+            ],
+            [
+                [['0', '1', '2', '3'], ['0', '1', '2', '3']],
+                [['0', '1', '2', '3'], ['0', '1', '2', '3']]
+            ],
+            [
+                [['0x00', '0x01', '0x02', '0x80000000'], ['0x00', '0x02', '0x01', '2147483648']],
+                [['0x00', '0x01', '0x01', '0x80000000'], ['0x00', '0x02', '0x02', '2147483648']]
+            ],
+            [
+                [['0x00', '0x01', '0x02', '0x80000000'], ['0x00', '0x01', '0x02', '0x80000000']],
+                [['0x00', '0x01', '0x02', '0x80000000'], ['0x00', '0x01', '0x02', '0x80000000']]
+            ]
+        ]
+
+        # Assert data
+        lst_oprt_with_const_assert = {}
+
+        # Generate func and assert
+        for op in self.BINARY_OPS:
+
+            op_name = self.full_op_name(op)
+
+            # Add comment for the case script "  ;; [f32x4.min, f32x4.max] const vs const"
+            template.insert(len(template)-1, '  ;; {} const vs const'.format(op_name))
+
+            # Add const vs const cases
+            for case_data in lst_instr_with_const:
+
+                func = "{op}_with_const_{index}".format(op=op_name, index=len(template)-7)
+                template.insert(len(template)-1,
+                                tpl_func.format(func=func, params='', op=op_name,
+                                                operand_1=self.v128_const('f32x4', case_data[0][0]),
+                                                operand_2=' ' + self.v128_const('f32x4', case_data[0][1])))
+
+                ret_idx = 0 if op == 'min' else 1
+
+                if op not in lst_oprt_with_const_assert:
+                    lst_oprt_with_const_assert[op] = []
+
+                lst_oprt_with_const_assert[op].append([func, case_data[1][ret_idx]])
+
+            # Add comment for the case script "  ;; [f32x4.min, f32x4.max] param vs const"
+            template.insert(len(template)-1, '  ;; {} param vs const'.format(op_name))
+
+            case_cnt = 0
+
+            # Add param vs const cases
+            for case_data in lst_instr_with_const:
+
+                func = "{}_with_const_{}".format(op_name, len(template)-7)
+
+                # Cross parameters and constants
+                if case_cnt in (0, 3):
+                    operand_1 = '(local.get 0)'
+                    operand_2 = self.v128_const('f32x4', case_data[0][0])
+                else:
+                    operand_1 = self.v128_const('f32x4', case_data[0][0])
+                    operand_2 = '(local.get 0)'
+
+                template.insert(len(template)-1,
+                                tpl_func.format(func=func, params='(param v128)', op=op_name,
+                                                operand_1=operand_1, operand_2=' ' + operand_2))
+
+                ret_idx = 0 if op == 'min' else 1
+
+                if op not in lst_oprt_with_const_assert:
+                    lst_oprt_with_const_assert[op] = []
+
+                lst_oprt_with_const_assert[op].append([func, case_data[0][1], case_data[1][ret_idx]])
+
+                case_cnt += 1
+
+        # Generate func for abs
+        op_name = self.full_op_name('abs')
+        func = "{}_with_const".format(op_name)
+        template.insert(len(template)-1, '')
+        template.insert(len(template)-1,
+                        tpl_func.format(func=func, params='', op=op_name,
+                                        operand_1=self.v128_const('f32x4', ['-0', '-1', '-2', '-3']), operand_2=''))
+
+        # Test different lanes go through different if-then clauses
+        lst_diff_lane_vs_clause = [
+            [
+                'f32x4.min',
+                [['nan', '0', '0', '1'], ['0', '-nan', '1', '0']],
+                [['nan:canonical', 'nan:canonical', '0', '0']],
+                ['f32x4', 'f32x4', 'f32x4']
+            ],
+            [
+                'f32x4.min',
+                [['nan', '0', '0', '0'], ['0', '-nan', '1', '0']],
+                [['nan:canonical', 'nan:canonical', '0', '0']],
+                ['f32x4', 'f32x4', 'f32x4']
+            ],
+            [
+                'f32x4.max',
+                [['nan', '0', '0', '1'], ['0', '-nan', '1', '0']],
+                [['nan:canonical', 'nan:canonical', '1', '1']],
+                ['f32x4', 'f32x4', 'f32x4']
+            ],
+            [
+                'f32x4.max',
+                [['nan', '0', '0', '0'], ['0', '-nan', '1', '0']],
+                [['nan:canonical', 'nan:canonical', '1', '0']],
+                ['f32x4', 'f32x4', 'f32x4']
+            ]
+        ]
+
+        # Template for assert
+        tpl_assert = '(assert_return\n' \
+                     '  (invoke "{func}"\n' \
+                     '    {operand_1}\n' \
+                     '    {operand_2}\n' \
+                     '  )\n' \
+                     '  {expected_result}\n' \
+                     ')'
+
+        lst_diff_lane_vs_clause_assert = []
+
+        # Add comment in wast script
+        lst_diff_lane_vs_clause_assert.append('')
+        lst_diff_lane_vs_clause_assert.append(';; Test different lanes go through different if-then clauses')
+
+        for case_data in lst_diff_lane_vs_clause:
+
+            lst_diff_lane_vs_clause_assert.append(';; {lane_type}'.format(lane_type=case_data[0]))
+
+            lst_diff_lane_vs_clause_assert.append(tpl_assert.format(
+                func=case_data[0],
+                operand_1=self.v128_const(case_data[3][0], case_data[1][0]),
+                operand_2=self.v128_const(case_data[3][1], case_data[1][1]),
+                expected_result=self.v128_const(case_data[3][2], case_data[2][0])
+            ))
+
+        lst_diff_lane_vs_clause_assert.append('')
+
+        # Add test for operations with constant operands
+        for key in lst_oprt_with_const_assert:
+            op_name = self.full_op_name(key)
+            case_cnt = 0
+            for case_data in lst_oprt_with_const_assert[key]:
+
+                # Add comment for the param combination
+                if case_cnt == 0:
+                    template.append(';; {} const vs const'.format(op_name))
+                if case_cnt == 4:
+                    template.append(';; {} param vs const'.format(op_name))
+
+                # Cross parameters and constants
+                if case_cnt < 4:
+                    template.append(str(AssertReturn(case_data[0], [], self.v128_const('f32x4', case_data[1]))))
+                else:
+                    template.append(str(AssertReturn(case_data[0], [self.v128_const('f32x4', case_data[1])], self.v128_const('f32x4', case_data[2]))))
+                case_cnt += 1
+
+        # Generate and append f32x4.abs assert
+        op_name = self.full_op_name('abs')
+        func = "{}_with_const".format(op_name)
+        template.append('')
+        template.append(str(AssertReturn(func, [], self.v128_const('f32x4', ['0', '1', '2', '3']))))
+
+        template.extend(lst_diff_lane_vs_clause_assert)
+
+        return template
+
+    @property
+    def combine_ternary_arith_test_data(self):
+        return {
+            'min-max': [
+                ['1.125'] * 4, ['0.25'] * 4, ['0.125'] * 4, ['0.125'] * 4
+            ],
+            'max-min': [
+                ['1.125'] * 4, ['0.25'] * 4, ['0.125'] * 4, ['0.25'] * 4
+            ]
+        }
+
+    @property
+    def combine_binary_arith_test_data(self):
+        return {
+            'min-abs': [
+                ['-1.125'] * 4, ['0.125'] * 4, ['0.125'] * 4
+            ],
+            'max-abs': [
+                ['-1.125'] * 4, ['0.125'] * 4, ['1.125'] * 4
+            ]
+        }
+
+    def get_normal_case(self):
+        """Normal test cases from WebAssembly core tests.
+        """
+        cases = []
+        binary_test_data = []
+        unary_test_data = []
+
+        for op in self.BINARY_OPS:
+            op_name = self.full_op_name(op)
+            for operand1 in self.FLOAT_NUMBERS:
+                for operand2 in self.FLOAT_NUMBERS:
+                    result = self.floatOp.binary_op(op, operand1, operand2)
+                    if 'nan' not in result:
+                        # Normal floating point numbers as the results
+                        binary_test_data.append([op_name, operand1, operand2, result])
+                    else:
+                        # Since the results contain the 'nan' string, the result literals would be
+                        # nan:canonical
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:canonical'])
+
+            for operand1 in self.LITERAL_NUMBERS:
+                for operand2 in self.LITERAL_NUMBERS:
+                    result = self.floatOp.binary_op(op, operand1, operand2, hex_form=False)
+                    binary_test_data.append([op_name, operand1, operand2, result])
+
+            for operand1 in self.NAN_NUMBERS:
+                for operand2 in self.FLOAT_NUMBERS:
+                    if 'nan:' in operand1 or 'nan:' in operand2:
+                        # When the arguments contain 'nan:', the result literal is nan:arithmetic
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:arithmetic'])
+                    else:
+                        # No 'nan' string found, then the result literal is nan:canonical
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:canonical'])
+                for operand2 in self.NAN_NUMBERS:
+                    if 'nan:' in operand1 or 'nan:' in operand2:
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:arithmetic'])
+                    else:
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:canonical'])
+
+        for case in binary_test_data:
+            cases.append(str(AssertReturn(case[0],
+                        [SIMD.v128_const(c, self.LANE_TYPE) for c in case[1:-1]],
+                        SIMD.v128_const(case[-1], self.LANE_TYPE))))
+
+        # Test opposite signs of zero
+        lst_oppo_signs_0 = [
+            '\n;; Test opposite signs of zero',
+            [
+                'f32x4.min',
+                [['0', '0', '-0', '+0'], ['+0', '-0', '+0', '-0']],
+                [['0', '-0', '-0', '-0']],
+                ['f32x4', 'f32x4', 'f32x4']
+            ],
+            [
+                'f32x4.min',
+                [['-0', '-0', '-0', '-0'], ['+0', '+0', '+0', '+0']],
+                [['-0', '-0', '-0', '-0']],
+                ['f32x4', 'f32x4', 'f32x4']
+            ],
+            [
+                'f32x4.max',
+                [['0', '0', '-0', '+0'], ['+0', '-0', '+0', '-0']],
+                [['0', '0', '0', '0']],
+                ['f32x4', 'f32x4', 'f32x4']
+            ],
+            [
+                'f32x4.max',
+                [['-0', '-0', '-0', '-0'], ['+0', '+0', '+0', '+0']],
+                [['+0', '+0', '+0', '+0']],
+                ['f32x4', 'f32x4', 'f32x4']
+            ],
+            '\n'
+        ]
+
+        # Generate test case for opposite signs of zero
+        for case_data in lst_oppo_signs_0:
+
+            if isinstance(case_data, str):
+                cases.append(case_data)
+                continue
+
+            cases.append(str(AssertReturn(case_data[0],
+                                          [self.v128_const(case_data[3][0], case_data[1][0]),
+                                           self.v128_const(case_data[3][1], case_data[1][1])],
+                                          self.v128_const(case_data[3][2], case_data[2][0]))))
+
+        for operand in self.FLOAT_NUMBERS + self.LITERAL_NUMBERS:
+            op_name = self.full_op_name('abs')
+            hex_literal = True
+            if operand in self.LITERAL_NUMBERS:
+                hex_literal = False
+            result = self.floatOp.unary_op('abs', operand, hex_form=hex_literal)
+            # Abs operation is valid for all the floating point numbers
+            unary_test_data.append([op_name, operand, result])
+
+        for case in unary_test_data:
+            cases.append(str(AssertReturn(case[0],
+                        [SIMD.v128_const(elem, self.LANE_TYPE) for elem in case[1:-1]],
+                        SIMD.v128_const(case[-1], self.LANE_TYPE))))
+
+        self.get_unknown_operator_case(cases)
+
+        return '\n'.join(cases)
+
+    def get_unknown_operator_case(self, cases):
+        """Unknown operator cases.
+        """
+
+        tpl_assert = "(assert_malformed (module quote \"(memory 1) (func (result v128) " \
+                     "({lane_type}.{op} {value}))\") \"unknown operator\")"
+
+        unknown_op_cases = ['\n\n;; Unknown operators\n']
+        cases.extend(unknown_op_cases)
+
+        for lane_type in ['i8x16', 'i16x8', 'i32x4', 'i64x2']:
+
+            for op in self.BINARY_OPS:
+                cases.append(tpl_assert.format(lane_type=lane_type, op=op, value=' '.join([self.v128_const('i32x4', '0')]*2)))
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_{lane_type}.wast'.format(lane_type=self.LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            txt_test_case = self.get_all_cases()
+            txt_test_case = txt_test_case.replace('f32x4 arithmetic', 'f32x4 [abs, min, max]')
+            fp.write(txt_test_case)
+
+
+def gen_test_cases():
+    simd_f32x4_case = Simdf32x4Case()
+    simd_f32x4_case.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_f32x4_arith.py b/test/core/simd/meta/simd_f32x4_arith.py
new file mode 100644
index 000000000..1a56c05c4
--- /dev/null
+++ b/test/core/simd/meta/simd_f32x4_arith.py
@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+
+"""
+Generate f32x4 floating-point arithmetic operation cases.
+"""
+
+from simd_arithmetic import SimdArithmeticCase
+from simd_float_op import FloatingPointArithOp
+from test_assert import AssertReturn
+from simd import SIMD
+
+
+class F32ArithOp(FloatingPointArithOp):
+    maximum = '0x1.fffffep+127'
+
+
+class Simdf32x4ArithmeticCase(SimdArithmeticCase):
+    LANE_LEN = 4
+    LANE_TYPE = 'f32x4'
+
+    floatOp = F32ArithOp()
+    UNARY_OPS = ('neg', 'sqrt')
+    BINARY_OPS = ('add', 'sub', 'mul', 'div')
+
+    FLOAT_NUMBERS = (
+        '0x0p+0', '-0x0p+0', '0x1p-149', '-0x1p-149', '0x1p-126', '-0x1p-126', '0x1p-1', '-0x1p-1', '0x1p+0', '-0x1p+0',
+        '0x1.921fb6p+2', '-0x1.921fb6p+2', '0x1.fffffep+127', '-0x1.fffffep+127', 'inf', '-inf'
+    )
+    LITERAL_NUMBERS = ('0123456789', '0123456789e019', '0123456789e+019', '0123456789e-019',
+                       '0123456789.', '0123456789.e019', '0123456789.e+019', '0123456789.e-019',
+                       '0123456789.0123456789', '0123456789.0123456789e019',
+                       '0123456789.0123456789e+019', '0123456789.0123456789e-019',
+                       '0x0123456789ABCDEF', '0x0123456789ABCDEFp019',
+                       '0x0123456789ABCDEFp+019', '0x0123456789ABCDEFp-019',
+                       '0x0123456789ABCDEF.', '0x0123456789ABCDEF.p019',
+                       '0x0123456789ABCDEF.p+019', '0x0123456789ABCDEF.p-019',
+                       '0x0123456789ABCDEF.019aF', '0x0123456789ABCDEF.019aFp019',
+                       '0x0123456789ABCDEF.019aFp+019', '0x0123456789ABCDEF.019aFp-019'
+    )
+    NAN_NUMBERS = ('nan', '-nan', 'nan:0x200000', '-nan:0x200000')
+
+    def full_op_name(self, op_name):
+        return self.LANE_TYPE + '.' + op_name
+
+    @staticmethod
+    def v128_const(lane, value):
+        return '(v128.const {lane_type} {value})'.format(lane_type=lane, value=' '.join([str(value)] * 4))
+
+    @property
+    def combine_ternary_arith_test_data(self):
+        return {
+            'add-sub': [
+                ['1.125'] * 4, ['0.25'] * 4, ['0.125'] * 4, ['1.0'] * 4
+            ],
+            'sub-add': [
+                ['1.125'] * 4, ['0.25'] * 4, ['0.125'] * 4, ['1.25'] * 4
+            ],
+            'mul-add': [
+                ['1.25'] * 4, ['0.25'] * 4, ['0.25'] * 4, ['0.375'] * 4
+            ],
+            'mul-sub': [
+                ['1.125'] * 4, ['0.125'] * 4, ['0.25'] * 4, ['0.25'] * 4
+            ],
+            'div-add': [
+                ['1.125'] * 4, ['0.125'] * 4, ['0.25'] * 4, ['5.0'] * 4
+            ],
+            'div-sub': [
+                ['1.125'] * 4, ['0.125'] * 4, ['0.25'] * 4, ['4.0'] * 4
+            ],
+            'mul-div': [
+                ['1.125'] * 4, ['0.125'] * 4, ['0.25'] * 4, ['2.25'] * 4
+            ],
+            'div-mul': [
+                ['1.125'] * 4, ['4'] * 4, ['0.25'] * 4, ['18.0'] * 4
+            ]
+        }
+
+    @property
+    def combine_binary_arith_test_data(self):
+        return {
+            'add-neg': [
+                ['1.125'] * 4, ['0.125'] * 4, ['-1.0'] * 4
+            ],
+            'sub-neg': [
+                ['1.125'] * 4, ['0.125'] * 4, ['-1.25'] * 4
+            ],
+            'mul-neg': [
+                ['1.5'] * 4, ['0.25'] * 4, ['-0.375'] * 4
+            ],
+            'div-neg': [
+                ['1.5'] * 4, ['0.25'] * 4, ['-6'] * 4
+            ],
+            'add-sqrt': [
+                ['2.25'] * 4, ['0.25'] * 4, ['1.75'] * 4
+            ],
+            'sub-sqrt': [
+                ['2.25'] * 4, ['0.25'] * 4, ['1.25'] * 4
+            ],
+            'mul-sqrt': [
+                ['2.25'] * 4, ['0.25'] * 4, ['0.375'] * 4
+            ],
+            'div-sqrt': [
+                ['2.25'] * 4, ['0.25'] * 4, ['6'] * 4
+            ]
+        }
+
+    def get_normal_case(self):
+        """Normal test cases from WebAssembly core tests
+        """
+        cases = []
+        binary_test_data = []
+        unary_test_data = []
+
+        for op in self.BINARY_OPS:
+            op_name = self.full_op_name(op)
+            for operand1 in self.FLOAT_NUMBERS:
+                for operand2 in self.FLOAT_NUMBERS:
+                    result = self.floatOp.binary_op(op, operand1, operand2)
+                    if 'nan' not in result:
+                        # Normal floating point numbers as the results
+                        binary_test_data.append([op_name, operand1, operand2, result])
+                    else:
+                        # Since the results contain the 'nan' string, the result literals would be
+                        # nan:canonical
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:canonical'])
+
+            for operand1 in self.NAN_NUMBERS:
+                for operand2 in self.FLOAT_NUMBERS:
+                    if 'nan:' in operand1 or 'nan:' in operand2:
+                        # When the arguments contain 'nan:', the result literal is nan:arithmetic
+                        # Consider the different order of arguments as different cases.
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:arithmetic'])
+                        binary_test_data.append([op_name, operand2, operand1, 'nan:arithmetic'])
+                    else:
+                        # No 'nan' string found, then the result literal is nan:canonical.
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:canonical'])
+                        binary_test_data.append([op_name, operand2, operand1, 'nan:canonical'])
+                for operand2 in self.NAN_NUMBERS:
+                    if 'nan:' in operand1 or 'nan:' in operand2:
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:arithmetic'])
+                    else:
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:canonical'])
+
+            for operand in self.LITERAL_NUMBERS:
+                if self.LANE_TYPE == 'f32x4':
+                    single_precision = True
+                else:
+                    single_precision = False
+                result = self.floatOp.binary_op(op, operand, operand, single_prec=single_precision)
+                binary_test_data.append([op_name, operand, operand, result])
+
+        for case in binary_test_data:
+            cases.append(str(AssertReturn(case[0],
+                        [SIMD.v128_const(elem, self.LANE_TYPE) for elem in case[1:-1]],
+                        SIMD.v128_const(case[-1], self.LANE_TYPE))))
+
+        for operand in self.FLOAT_NUMBERS + self.NAN_NUMBERS + self.LITERAL_NUMBERS:
+            if 'nan:' in operand:
+                unary_test_data.append([op_name, operand, 'nan:arithmetic'])
+            elif 'nan' in operand:
+                unary_test_data.append([op_name, operand, 'nan:canonical'])
+            else:
+                # Normal floating point numbers for sqrt operation
+                op_name = self.full_op_name('sqrt')
+                result = self.floatOp.float_sqrt(operand)
+                if 'nan' not in result:
+                    # Get the sqrt value correctly
+                    unary_test_data.append([op_name, operand, result])
+                else:
+                    #
+                    unary_test_data.append([op_name, operand, 'nan:canonical'])
+
+        for operand in self.FLOAT_NUMBERS + self.NAN_NUMBERS + self.LITERAL_NUMBERS:
+            op_name = self.full_op_name('neg')
+            result = self.floatOp.float_neg(operand)
+            # Neg operation is valid for all the floating point numbers
+            unary_test_data.append([op_name, operand, result])
+
+        for case in unary_test_data:
+            cases.append(str(AssertReturn(case[0],
+                        [SIMD.v128_const(elem, self.LANE_TYPE) for elem in case[1:-1]],
+                        SIMD.v128_const(case[-1], self.LANE_TYPE))))
+
+        self.mixed_nan_test(cases)
+
+        return '\n'.join(cases)
+
+    @property
+    def mixed_sqrt_nan_test_data(self):
+        return {
+            "sqrt_canon": [
+                ('-1.0', 'nan', '4.0', '9.0'),
+                ('nan:canonical', 'nan:canonical', '2.0', '3.0')
+            ],
+            'sqrt_arith': [
+                ('nan:0x200000', '-nan:0x200000', '16.0', '25.0'),
+                ('nan:arithmetic', 'nan:arithmetic', '4.0', '5.0')
+            ],
+            'sqrt_mixed': [
+                ('-inf', 'nan:0x200000', '36.0', '49.0'),
+                ('nan:canonical', 'nan:arithmetic', '6.0', '7.0')
+            ]
+        }
+
+    def mixed_nan_test(self, cases):
+        """Mixed f32x4 tests when only expects NaNs in a subset of lanes.
+        """
+        mixed_cases = ['\n\n;; Mixed f32x4 tests when some lanes are NaNs', '(module\n']
+        cases.extend(mixed_cases)
+        for test_type, test_data in sorted(self.mixed_sqrt_nan_test_data.items()):
+            func = ['  (func (export "{lane}_{t}") (result v128)'.format(
+                lane=self.LANE_TYPE, t=test_type),
+                    '    ({lane}.{op} (v128.const {lane} {value})))'.format(
+                lane=self.LANE_TYPE, op=test_type.split('_')[0], value=' '.join(test_data[0]))]
+            cases.extend(func)
+        cases.append(')\n')
+
+        for test_type, test_data in sorted(self.mixed_sqrt_nan_test_data.items()):
+            cases.append('(assert_return (invoke "{lane}_{t}") (v128.const {lane} {result}))'.format(
+                lane=self.LANE_TYPE, t=test_type, result=' '.join(test_data[1])))
+
+
+def gen_test_cases():
+    simd_f32x4_arith = Simdf32x4ArithmeticCase()
+    simd_f32x4_arith.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
\ No newline at end of file
diff --git a/test/core/simd/meta/simd_f32x4_cmp.py b/test/core/simd/meta/simd_f32x4_cmp.py
new file mode 100644
index 000000000..8b3b30b6b
--- /dev/null
+++ b/test/core/simd/meta/simd_f32x4_cmp.py
@@ -0,0 +1,507 @@
+#!/usr/bin/env python3
+
+"""
+This file is used for generating simd_f32x4_cmp.wast file.
+Which inherites from `SimdCmpCase` class, overloads
+the `get_test_cases` method, and reset the Test Case template.
+The reason why this is different from other cmp files is that
+f32x4 only has 6 comparison instructions but with amounts of
+test datas.
+"""
+import struct
+from simd_compare import SimdCmpCase
+
+
+# Generate f32x4 test case
+class Simdf32x4CmpCase(SimdCmpCase):
+
+    LANE_TYPE = 'f32x4'
+
+    BINARY_OPS = ['eq', 'ne', 'lt', 'le', 'gt', 'ge']
+
+    # Test template, using this template to generate tests with variable test datas.
+    CASE_TXT = """;; Test all the {lane_type} comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (f32x4.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (f32x4.ne (local.get $x) (local.get $y)))
+  (func (export "lt") (param $x v128) (param $y v128) (result v128) (f32x4.lt (local.get $x) (local.get $y)))
+  (func (export "le") (param $x v128) (param $y v128) (result v128) (f32x4.le (local.get $x) (local.get $y)))
+  (func (export "gt") (param $x v128) (param $y v128) (result v128) (f32x4.gt (local.get $x) (local.get $y)))
+  (func (export "ge") (param $x v128) (param $y v128) (result v128) (f32x4.ge (local.get $x) (local.get $y)))
+)
+{normal_case}
+
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (f32x4.eq (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.ge (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.gt (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.le (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.lt (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.ne (i64.const 0) (f64.const 0)))) "type mismatch")
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.eq (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.ge (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.gt (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.le (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.lt (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.ne (local.get $x) (local.get $y)))") "unknown operator")
+
+
+;; Combination
+
+(module (memory 1)
+  (func (export "eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "lt-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.lt
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "le-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.le
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "gt-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.gt
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ge-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.ge
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-eq")
+    (drop
+      (f32x4.eq
+        (f32x4.eq
+          (f32x4.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.eq
+          (f32x4.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ne")
+    (drop
+      (f32x4.ne
+        (f32x4.ne
+          (f32x4.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.ne
+          (f32x4.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-lt")
+    (drop
+      (f32x4.lt
+        (f32x4.lt
+          (f32x4.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.lt
+          (f32x4.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-le")
+    (drop
+      (f32x4.le
+        (f32x4.le
+          (f32x4.le
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.le
+          (f32x4.le
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-gt")
+    (drop
+      (f32x4.gt
+        (f32x4.gt
+          (f32x4.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.gt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.gt
+          (f32x4.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.gt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ge")
+    (drop
+      (f32x4.ge
+        (f32x4.ge
+          (f32x4.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ge
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.ge
+          (f32x4.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ge
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (f32x4.ge
+        (f32x4.eq
+          (f32x4.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.ne
+          (f32x4.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+
+(assert_return (invoke "eq-in-block"))
+(assert_return (invoke "ne-in-block"))
+(assert_return (invoke "lt-in-block"))
+(assert_return (invoke "le-in-block"))
+(assert_return (invoke "gt-in-block"))
+(assert_return (invoke "ge-in-block"))
+(assert_return (invoke "nested-eq"))
+(assert_return (invoke "nested-ne"))
+(assert_return (invoke "nested-lt"))
+(assert_return (invoke "nested-le"))
+(assert_return (invoke "nested-gt"))
+(assert_return (invoke "nested-ge"))
+(assert_return (invoke "as-param"))
+"""
+
+    # Overloads base class method and sets test data for f32x4.
+    def get_case_data(self):
+
+        case_data = []
+
+        operand1 = ('nan', '0x1p-149', '-nan:0x200000', '-inf', '0x1.921fb6p+2',
+                    '0x1p+0', '-0x1.fffffep+127', '-0x0p+0', '-0x1p-1', '0x1.fffffep+127',
+                    '-nan', '-0x1p-149', '-0x1p-126', '0x1p-1', '-0x1.921fb6p+2',
+                    'nan:0x200000', '0x0p+0', 'inf', '-0x1p+0', '0x1p-126')
+        operand2 = ('nan', '0x1p-149', '-nan:0x200000', '-inf', '0x1.921fb6p+2',
+                    '0x1p+0', '-0x1.fffffep+127', '-0x0p+0', '-0x1p-1', '0x1.fffffep+127',
+                    '-nan', '-0x1p-149', '-0x1p-126', '0x1p-1', '-0x1.921fb6p+2',
+                    'nan:0x200000', '0x0p+0', 'inf', '-0x1p+0', '0x1p-126')
+        LITERAL_NUMBERS = (
+            '0123456789e019', '0123456789e-019',
+            '0123456789.e019', '0123456789.e+019',
+            '0123456789.0123456789')
+        Ops = ('eq', 'ne', 'lt', 'le', 'gt', 'ge')
+
+        # Combinations between operand1 and operand2
+        for op in Ops:
+            case_data.append(['#', op])
+            for param1 in operand1:
+                for param2 in operand2:
+                    case_data.append([op, [param1, param2], self.operate(op, param1, param2), ['f32x4', 'f32x4', 'i32x4']])
+
+            for param1 in LITERAL_NUMBERS:
+                for param2 in LITERAL_NUMBERS:
+                    case_data.append([op, [param1, param2], self.operate(op, param1, param2), ['f32x4', 'f32x4', 'i32x4']])
+        # eq
+        case_data.append(['#', 'eq'])
+
+        # f32x4.eq  (f32x4) (i8x16)
+        case_data.append(['#', 'f32x4.eq  (f32x4) (i8x16)'])
+        case_data.append(['eq', [['-1', '0', '1', '2.0'], ['-1', '-1', '-1', '-1', '0', '0', '0', '0', '1', '1', '1', '1', '2', '2', '2']], ['0', '-1', '0', '0'], ['f32x4', 'i8x16', 'i32x4']])
+
+        # f32x4.eq  (f32x4) (i16x8)
+        case_data.append(['#', 'f32x4.eq  (f32x4) (i16x8)'])
+        case_data.append(['eq', [['-1', '0', '1', '2.0'], ['-1', '-1', '0', '0', '1', '1', '2']], ['0', '-1', '0', '0'], ['f32x4', 'i16x8', 'i32x4']])
+
+        # f32x4.eq  (f32x4) (i32x4)
+        case_data.append(['#', 'f32x4.eq  (f32x4) (i32x4)'])
+        case_data.append(['eq', [['-1', '0', '1', '2.0'], ['3212836864', '0', '1', '2']], ['-1 -1', '0', '0', ''], ['f32x4', 'i32x4', 'i32x4']])
+
+        # ne
+        case_data.append(['#', 'ne'])
+
+        # f32x4.ne  (f32x4) (i8x16)
+        case_data.append(['#', 'f32x4.ne  (f32x4) (i8x16)'])
+        case_data.append(['ne', [['-1', '0', '1', '2.0'], ['-1', '-1', '-1', '-1', '0', '0', '0', '0', '1', '1', '1', '1', '2', '2', '2']], ['-1', '0', '-1', '-1'], ['f32x4', 'i8x16', 'i32x4']])
+
+        # f32x4.ne  (f32x4) (i16x8)
+        case_data.append(['#', 'f32x4.ne  (f32x4) (i16x8)'])
+        case_data.append(['ne', [['-1', '0', '1', '2.0'], ['-1', '-1', '0', '0', '1', '1', '2']], ['-1', '0', '-1', '-1'], ['f32x4', 'i16x8', 'i32x4']])
+
+        # f32x4.ne  (f32x4) (i32x4)
+        case_data.append(['#', 'f32x4.ne  (f32x4) (i32x4)'])
+        case_data.append(['ne', [['-1', '0', '1', '2.0'], ['3212836864', '0', '1', '2']], ['0', '0', '-1', '-1'], ['f32x4', 'i32x4', 'i32x4']])
+
+        # lt
+        case_data.append(['#', 'lt'])
+
+        # f32x4.lt  (f32x4) (i8x16)
+        case_data.append(['#', 'f32x4.lt  (f32x4) (i8x16)'])
+        case_data.append(['lt', [['-1', '0', '1', '2.0'], ['-1', '-1', '-1', '-1', '0', '0', '0', '0', '1', '1', '1', '1', '2', '2', '2']], ['0', '0', '0', '0'], ['f32x4', 'i8x16', 'i32x4']])
+
+        # f32x4.lt  (f32x4) (i16x8)
+        case_data.append(['#', 'f32x4.lt  (f32x4) (i16x8)'])
+        case_data.append(['lt', [['-1', '0', '1', '2.0'], ['-1', '-1', '0', '0', '1', '1', '2']], ['0', '0', '0', '0'], ['f32x4', 'i16x8', 'i32x4']])
+
+        # f32x4.lt  (f32x4) (i32x4)
+        case_data.append(['#', 'f32x4.lt  (f32x4) (i32x4)'])
+        case_data.append(['lt', [['-1', '0', '1', '2.0'], ['3212836864', '0', '1', '2']], ['0', '0', '0', '0'], ['f32x4', 'i32x4', 'i32x4']])
+
+        # le
+        case_data.append(['#', 'le'])
+
+        # f32x4.le  (f32x4) (i8x16)
+        case_data.append(['#', 'f32x4.le  (f32x4) (i8x16)'])
+        case_data.append(['le', [['-1', '0', '1', '2.0'], ['-1', '-1', '-1', '-1', '0', '0', '0', '0', '1', '1', '1', '1', '2', '2', '2']], ['0', '-1', '0', '0'], ['f32x4', 'i8x16', 'i32x4']])
+
+        # f32x4.le  (f32x4) (i16x8)
+        case_data.append(['#', 'f32x4.le  (f32x4) (i16x8)'])
+        case_data.append(['le', [['-1', '0', '1', '2.0'], ['-1', '-1', '0', '0', '1', '1', '2']], ['0', '-1', '0', '0'], ['f32x4', 'i16x8', 'i32x4']])
+
+        # f32x4.le  (f32x4) (i32x4)
+        case_data.append(['#', 'f32x4.le  (f32x4) (i32x4)'])
+        case_data.append(['le', [['-1', '0', '1', '2.0'], ['3212836864', '0', '1', '2']], ['-1', '-1', '0', '0'], ['f32x4', 'i32x4', 'i32x4']])
+
+        # gt
+        case_data.append(['#', 'gt'])
+
+        # f32x4.gt  (f32x4) (i8x16)
+        case_data.append(['#', 'f32x4.gt  (f32x4) (i8x16)'])
+        case_data.append(['gt', [['-1', '0', '1', '2.0'], ['-1', '-1', '-1', '-1', '0', '0', '0', '0', '1', '1', '1', '1', '2', '2', '2']], ['0', '0', '-1', '-1'], ['f32x4', 'i8x16', 'i32x4']])
+
+        # f32x4.gt  (f32x4) (i16x8)
+        case_data.append(['#', 'f32x4.gt  (f32x4) (i16x8)'])
+        case_data.append(['gt', [['-1', '0', '1', '2.0'], ['-1', '-1', '0', '0', '1', '1', '2']], ['0', '0', '-1', '-1'], ['f32x4', 'i16x8', 'i32x4']])
+
+        # f32x4.gt  (f32x4) (i32x4)
+        case_data.append(['#', 'f32x4.gt  (f32x4) (i32x4)'])
+        case_data.append(['gt', [['-1', '0', '1', '2.0'], ['3212836864', '0', '1', '2']], ['0', '0', '-1', '-1'], ['f32x4', 'i32x4', 'i32x4']])
+
+        # ge
+        case_data.append(['#', 'ge'])
+
+        # f32x4.ge  (f32x4) (i8x16)
+        case_data.append(['#', 'f32x4.ge  (f32x4) (i8x16)'])
+        case_data.append(['ge', [['-1', '0', '1', '2.0'], ['-1', '-1', '-1', '-1', '0', '0', '0', '0', '1', '1', '1', '1', '2', '2', '2']], ['0', '-1', '-1', '-1'], ['f32x4', 'i8x16', 'i32x4']])
+
+        # f32x4.ge  (f32x4) (i16x8)
+        case_data.append(['#', 'f32x4.ge  (f32x4) (i16x8)'])
+        case_data.append(['ge', [['-1', '0', '1', '2.0'], ['-1', '-1', '0', '0', '1', '1', '2']], ['0', '-1', '-1', '-1'], ['f32x4', 'i16x8', 'i32x4']])
+
+        # f32x4.ge  (f32x4) (i32x4)
+        case_data.append(['#', 'f32x4.ge  (f32x4) (i32x4)'])
+        case_data.append(['ge', [['-1', '0', '1', '2.0'], ['3212836864', '0', '1', '2']], ['-1', '-1', '-1', '-1'], ['f32x4', 'i32x4', 'i32x4']])
+
+        return case_data
+
+    def special_float2dec(self, p):
+        if p in ('0x0p+0', '-0x0p+0'):
+            return 0.0
+        if p == 'inf':
+            return float(340282366920938463463374607431768211456)
+        if p == '-inf':
+            return -float(340282366920938463463374607431768211456)
+
+        if '0x' in p:
+            f = float.fromhex(p)
+        else:
+            f = float(p)
+
+        return struct.unpack('f', struct.pack('f', f))[0]
+
+    def operate(self, op, p1, p2):
+        for p in (p1, p2):
+            if 'nan' in p:
+                if op == 'ne':
+                    return '-1'
+                else:
+                    return '0'
+
+        num1 = self.special_float2dec(p1)
+        num2 = self.special_float2dec(p2)
+
+        if op == 'eq':
+            if num1 == num2:
+                return '-1'
+
+        if op == 'ne':
+            if num1 != num2:
+                return '-1'
+        if op == 'lt':
+            if num1 < num2:
+                return '-1'
+        if op == 'le':
+            if num1 <= num2:
+                return '-1'
+        if op == 'gt':
+            if num1 > num2:
+                return '-1'
+        if op == 'ge':
+            if num1 >= num2:
+                return '-1'
+
+        return '0'
+
+
+def gen_test_cases():
+    f32x4 = Simdf32x4CmpCase()
+    f32x4.gen_test_cases()
+
+
+if __name__ == '__main__':
+    f32x4 = Simdf32x4CmpCase()
+    f32x4.gen_test_cases()
diff --git a/test/core/simd/meta/simd_f32x4_pmin_pmax.py b/test/core/simd/meta/simd_f32x4_pmin_pmax.py
new file mode 100644
index 000000000..42fa6229b
--- /dev/null
+++ b/test/core/simd/meta/simd_f32x4_pmin_pmax.py
@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+
+"""
+Generate f32x4 [pmin, pmax] cases.
+"""
+
+from simd_f32x4_arith import Simdf32x4ArithmeticCase
+from simd_float_op import FloatingPointSimpleOp
+from simd import SIMD
+from test_assert import AssertReturn
+
+
+class Simdf32x4PminPmaxCase(Simdf32x4ArithmeticCase):
+    UNARY_OPS = ()
+    BINARY_OPS = ('pmin', 'pmax',)
+    floatOp = FloatingPointSimpleOp()
+
+    def get_combine_cases(self):
+        return ''
+
+    def get_normal_case(self):
+        """Normal test cases from WebAssembly core tests.
+        """
+        cases = []
+        binary_test_data = []
+        unary_test_data = []
+
+        for op in self.BINARY_OPS:
+            op_name = self.full_op_name(op)
+            for operand1 in self.FLOAT_NUMBERS + self.LITERAL_NUMBERS:
+                for operand2 in self.FLOAT_NUMBERS + self.LITERAL_NUMBERS:
+                    result = self.floatOp.binary_op(op, operand1, operand2)
+                    binary_test_data.append([op_name, operand1, operand2, result])
+
+            # pmin and pmax always return operand1 if either operand is a nan
+            for operand1 in self.NAN_NUMBERS:
+                for operand2 in self.FLOAT_NUMBERS + self.LITERAL_NUMBERS + self.NAN_NUMBERS:
+                    binary_test_data.append([op_name, operand1, operand2, operand1])
+            for operand2 in self.NAN_NUMBERS:
+                for operand1 in self.FLOAT_NUMBERS + self.LITERAL_NUMBERS:
+                    binary_test_data.append([op_name, operand1, operand2, operand1])
+
+        for case in binary_test_data:
+            cases.append(str(AssertReturn(case[0],
+                        [SIMD.v128_const(c, self.LANE_TYPE) for c in case[1:-1]],
+                        SIMD.v128_const(case[-1], self.LANE_TYPE))))
+
+        self.get_unknown_operator_case(cases)
+
+        return '\n'.join(cases)
+
+    def get_unknown_operator_case(self, cases):
+        """Unknown operator cases.
+        """
+
+        tpl_assert = "(assert_malformed (module quote \"(memory 1) (func (result v128) " \
+                     "({lane_type}.{op} {value}))\") \"unknown operator\")"
+
+        unknown_op_cases = ['\n\n;; Unknown operators\n']
+        cases.extend(unknown_op_cases)
+
+        for lane_type in ['i8x16', 'i16x8', 'i32x4', 'i64x2']:
+
+            for op in self.BINARY_OPS:
+                cases.append(tpl_assert.format(lane_type=lane_type, op=op, value=' '.join([self.v128_const('i32x4', '0')]*2)))
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_{lane_type}_pmin_pmax.wast'.format(lane_type=self.LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            txt_test_case = self.get_all_cases()
+            txt_test_case = txt_test_case.replace(
+                    self.LANE_TYPE + ' arithmetic',
+                    self.LANE_TYPE + ' [pmin, pmax]')
+            fp.write(txt_test_case)
+
+
+def gen_test_cases():
+    simd_f32x4_pmin_pmax_case = Simdf32x4PminPmaxCase()
+    simd_f32x4_pmin_pmax_case.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_f32x4_rounding.py b/test/core/simd/meta/simd_f32x4_rounding.py
new file mode 100644
index 000000000..2512326d6
--- /dev/null
+++ b/test/core/simd/meta/simd_f32x4_rounding.py
@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+
+"""
+Generate f32x4 [ceil, floor, trunc, nearest] cases.
+"""
+
+from simd_f32x4_arith import Simdf32x4ArithmeticCase
+from simd_float_op import FloatingPointRoundingOp
+from simd import SIMD
+from test_assert import AssertReturn
+
+
+class Simdf32x4RoundingCase(Simdf32x4ArithmeticCase):
+    UNARY_OPS = ('ceil', 'floor', 'trunc', 'nearest')
+    BINARY_OPS = ()
+    floatOp = FloatingPointRoundingOp()
+
+    def get_combine_cases(self):
+        return ''
+
+    def get_normal_case(self):
+        """Normal test cases from WebAssembly core tests.
+        """
+        cases = []
+        unary_test_data = []
+
+        for op in self.UNARY_OPS:
+            op_name = self.full_op_name(op)
+            for operand in self.FLOAT_NUMBERS:
+                result = self.floatOp.unary_op(op, operand)
+                if 'nan' in result:
+                    unary_test_data.append([op_name, operand, 'nan:canonical'])
+                else:
+                    unary_test_data.append([op_name, operand, result])
+
+            for operand in self.LITERAL_NUMBERS:
+                result = self.floatOp.unary_op(op, operand, hex_form=False)
+                unary_test_data.append([op_name, operand, result])
+
+            for operand in self.NAN_NUMBERS:
+                if 'nan:' in operand:
+                    unary_test_data.append([op_name, operand, 'nan:arithmetic'])
+                else:
+                    unary_test_data.append([op_name, operand, 'nan:canonical'])
+
+        for case in unary_test_data:
+            cases.append(str(AssertReturn(case[0],
+                        [SIMD.v128_const(elem, self.LANE_TYPE) for elem in case[1:-1]],
+                        SIMD.v128_const(case[-1], self.LANE_TYPE))))
+
+        self.get_unknown_operator_case(cases)
+
+        return '\n'.join(cases)
+
+    def get_unknown_operator_case(self, cases):
+        """Unknown operator cases.
+        """
+
+        tpl_assert = "(assert_malformed (module quote \"(memory 1) (func (result v128) " \
+                     "({lane_type}.{op} {value}))\") \"unknown operator\")"
+
+        unknown_op_cases = ['\n\n;; Unknown operators\n']
+        cases.extend(unknown_op_cases)
+
+        for lane_type in ['i8x16', 'i16x8', 'i32x4', 'i64x2']:
+            for op in self.UNARY_OPS:
+                cases.append(tpl_assert.format(lane_type=lane_type, op=op, value=self.v128_const('i32x4', '0')))
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_{lane_type}_rounding.wast'.format(lane_type=self.LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            txt_test_case = self.get_all_cases()
+            txt_test_case = txt_test_case.replace(
+                    self.LANE_TYPE + ' arithmetic',
+                    self.LANE_TYPE + ' [ceil, floor, trunc, nearest]')
+            fp.write(txt_test_case)
+
+
+def gen_test_cases():
+    simd_f32x4_case = Simdf32x4RoundingCase()
+    simd_f32x4_case.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_f64x2.py b/test/core/simd/meta/simd_f64x2.py
new file mode 100644
index 000000000..e6b80ee2c
--- /dev/null
+++ b/test/core/simd/meta/simd_f64x2.py
@@ -0,0 +1,395 @@
+#!/usr/bin/env python3
+
+"""
+Generate f64x2 [abs, min, max] cases.
+"""
+
+from simd_f32x4 import Simdf32x4Case
+from simd_f32x4_arith import Simdf32x4ArithmeticCase
+from test_assert import AssertReturn
+from simd import SIMD
+
+
+class Simdf64x2Case(Simdf32x4Case):
+
+    LANE_TYPE = 'f64x2'
+
+    FLOAT_NUMBERS = (
+        '0x0p+0', '-0x0p+0', '0x1p-1074', '-0x1p-1074', '0x1p-1022', '-0x1p-1022', '0x1p-1', '-0x1p-1', '0x1p+0', '-0x1p+0',
+        '0x1.921fb54442d18p+2', '-0x1.921fb54442d18p+2', '0x1.fffffffffffffp+1023', '-0x1.fffffffffffffp+1023', 'inf', '-inf'
+    )
+    LITERAL_NUMBERS = ('01234567890123456789e038', '01234567890123456789e-038',
+                       '0123456789.e038', '0123456789.e+038',
+                       '-01234567890123456789.01234567890123456789'
+    )
+    NAN_NUMBERS = ('nan', '-nan', 'nan:0x4000000000000', '-nan:0x4000000000000')
+
+    def gen_test_func_template(self):
+
+        # Get function code
+        template = Simdf32x4ArithmeticCase.gen_test_func_template(self)
+
+        # Function template
+        tpl_func = '  (func (export "{func}"){params} (result v128) ({op} {operand_1}{operand_2}))'
+
+        # Raw data list specific for "const vs const" and "param vs const" tests"
+        const_test_raw_data = [
+            [
+                [['0', '1'], ['0', '2']],
+                [['0', '1'], ['0', '2']]
+            ],
+            [
+                [['2', '-3'], ['1', '3']],
+                [['1', '-3'], ['2', '3']]
+            ],
+            [
+                [['0', '1'], ['0', '1']],
+                [['0', '1'], ['0', '1']]
+            ],
+            [
+                [['2', '3'], ['2', '3']],
+                [['2', '3'], ['2', '3']]
+            ],
+            [
+                [['0x00', '0x01'], ['0x00', '0x02']],
+                [['0x00', '0x01'], ['0x00', '0x02']]
+            ],
+            [
+                [['0x02', '0x80000000'], ['0x01', '2147483648']],
+                [['0x01', '0x80000000'], ['0x02', '2147483648']]
+            ],
+            [
+                [['0x00', '0x01'], ['0x00', '0x01']],
+                [['0x00', '0x01'], ['0x00', '0x01']]
+            ],
+            [
+                [['0x02', '0x80000000'], ['0x02', '0x80000000']],
+                [['0x02', '0x80000000'], ['0x02', '0x80000000']]
+            ]
+        ]
+
+        # Test data list combined with `const_test_raw_data` and corresponding ops and function names
+        # specific for "const vs const" and "param vs const" tests
+        const_test_data = {}
+
+        # Generate func and assert
+        for op in self.BINARY_OPS:
+
+            op_name = self.full_op_name(op)
+
+            # Add comment for the case script "  ;; [f64x2.min, f64x2.max] const vs const"
+            template.insert(len(template)-1, '  ;; {} const vs const'.format(op_name))
+
+            # Add const vs const cases
+            for case_data in const_test_raw_data:
+
+                func = "{op}_with_const_{index}".format(op=op_name, index=len(template)-7)
+                template.insert(len(template)-1,
+                                tpl_func.format(func=func, params='', op=op_name,
+                                                operand_1=self.v128_const('f64x2', case_data[0][0]),
+                                                operand_2=' ' + self.v128_const('f64x2', case_data[0][1])))
+
+                ret_idx = 0 if op == 'min' else 1
+
+                if op not in const_test_data:
+                    const_test_data[op] = []
+
+                const_test_data[op].append([func, case_data[1][ret_idx]])
+
+            # Add comment for the case script "  ;; [f64x2.min, f64x2.max] param vs const"
+            template.insert(len(template)-1, '  ;; {} param vs const'.format(op_name))
+
+            case_cnt = 0
+
+            # Add param vs const cases
+            for case_data in const_test_raw_data:
+
+                func = "{op}_with_const_{index}".format(op=op_name, index=len(template)-7)
+
+                # Cross parameters and constants
+                if case_cnt in (0, 3):
+                    operand_1 = '(local.get 0)'
+                    operand_2 = self.v128_const('f64x2', case_data[0][0])
+                else:
+                    operand_1 = self.v128_const('f64x2', case_data[0][0])
+                    operand_2 = '(local.get 0)'
+
+                template.insert(len(template)-1,
+                                tpl_func.format(func=func, params=' (param v128)', op=op_name,
+                                                operand_1=operand_1, operand_2=' ' + operand_2))
+
+                ret_idx = 0 if op == 'min' else 1
+
+                if op not in const_test_data:
+                    const_test_data[op] = []
+
+                const_test_data[op].append([func, case_data[0][1], case_data[1][ret_idx]])
+
+                case_cnt += 1
+
+        # Generate func for abs
+        op_name = self.full_op_name('abs')
+        template.insert(len(template)-1, '')
+        func = "{op}_with_const_{index}".format(op=op_name, index=35)
+        template.insert(len(template)-1,
+                        tpl_func.format(func=func, params='', op=op_name,
+                                        operand_1=self.v128_const('f64x2', ['-0', '-1']), operand_2=''))
+        func = "{op}_with_const_{index}".format(op=op_name, index=36)
+        template.insert(len(template)-1,
+                        tpl_func.format(func=func, params='', op=op_name,
+                                        operand_1=self.v128_const('f64x2', ['-2', '-3']), operand_2=''))
+
+        # Test different lanes go through different if-then clauses
+        lst_diff_lane_vs_clause = [
+            [
+                'f64x2.min',
+                [['nan', '0'], ['0', '1']],
+                [['nan:canonical', '0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.min',
+                [['0', '1'], ['-nan', '0']],
+                [['nan:canonical', '0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.min',
+                [['0', '1'], ['-nan', '1']],
+                [['nan:canonical', '1']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.max',
+                [['nan', '0'], ['0', '1']],
+                [['nan:canonical', '1']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.max',
+                [['0', '1'], ['-nan', '0']],
+                [['nan:canonical', '1']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.max',
+                [['0', '1'], ['-nan', '1']],
+                [['nan:canonical', '1']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ]
+        ]
+
+        # Template for assert
+        tpl_assert = '(assert_return\n' \
+                     '  (invoke "{func}"\n' \
+                     '    {operand_1}\n' \
+                     '    {operand_2}\n' \
+                     '  )\n' \
+                     '  {expected_result}\n' \
+                     ')'
+
+        lst_diff_lane_vs_clause_assert = []
+
+        # Add comment in wast script
+        lst_diff_lane_vs_clause_assert.append('')
+        lst_diff_lane_vs_clause_assert.append(';; Test different lanes go through different if-then clauses')
+
+        for case_data in lst_diff_lane_vs_clause:
+
+            lst_diff_lane_vs_clause_assert.append(';; {lane_type}'.format(lane_type=case_data[0]))
+
+            lst_diff_lane_vs_clause_assert.append(tpl_assert.format(
+                func=case_data[0],
+                operand_1=self.v128_const(case_data[3][0], case_data[1][0]),
+                operand_2=self.v128_const(case_data[3][1], case_data[1][1]),
+                expected_result=self.v128_const(case_data[3][2], case_data[2][0])
+            ))
+
+        lst_diff_lane_vs_clause_assert.append('')
+
+        # Add test for operations with constant operands
+        for key in const_test_data:
+            op_name = self.full_op_name(key)
+            case_cnt = 0
+            for case_data in const_test_data[key]:
+
+                # Add comment for the param combination
+                if case_cnt == 0:
+                    template.append(';; {} const vs const'.format(op_name))
+                if case_cnt == 4:
+                    template.append(';; {} param vs const'.format(op_name))
+
+                # Cross parameters and constants
+                if case_cnt < 8:
+                    template.append(str(AssertReturn(case_data[0], [], self.v128_const('f64x2', case_data[1]))))
+                else:
+                    template.append(str(AssertReturn(case_data[0], [self.v128_const('f64x2', case_data[1])], self.v128_const('f64x2', case_data[2]))))
+                case_cnt += 1
+
+        # Generate and append f64x2.abs assert
+        op_name = self.full_op_name('abs')
+        template.append('')
+        func = "{op}_with_const_{index}".format(op=op_name, index=35)
+        template.append(str(AssertReturn(func, [], self.v128_const('f64x2', ['0', '1']))))
+        func = "{op}_with_const_{index}".format(op=op_name, index=36)
+        template.append(str(AssertReturn(func, [], self.v128_const('f64x2', ['2', '3']))))
+
+        template.extend(lst_diff_lane_vs_clause_assert)
+
+        return template
+
+    @property
+    def combine_ternary_arith_test_data(self):
+        # This method overrides the base class method from SimdArithmeticCase
+        # used for generating test data for min and max combination tests.
+        return {
+            'min-max': [
+                ['1.125'] * 2, ['0.25'] * 2, ['0.125'] * 2, ['0.125'] * 2
+            ],
+            'max-min': [
+                ['1.125'] * 2, ['0.25'] * 2, ['0.125'] * 2, ['0.25'] * 2
+            ]
+        }
+
+    @property
+    def combine_binary_arith_test_data(self):
+        # This method overrides the base class method from SimdArithmeticCase
+        # used for generating test data for min, max and abs combination tests.
+        return {
+            'min-abs': [
+                ['-1.125'] * 2, ['0.125'] * 2, ['0.125'] * 2
+            ],
+            'max-abs': [
+                ['-1.125'] * 2, ['0.125'] * 2, ['1.125'] * 2
+            ]
+        }
+
+    def get_normal_case(self):
+        """Normal test cases from WebAssembly core tests
+        """
+        cases = []
+        binary_test_data = []
+        unary_test_data = []
+
+        for op in self.BINARY_OPS:
+            op_name = self.full_op_name(op)
+            for operand1 in self.FLOAT_NUMBERS:
+                for operand2 in self.FLOAT_NUMBERS:
+                    result = self.floatOp.binary_op(op, operand1, operand2)
+                    if 'nan' not in result:
+                        # Normal floating point numbers as the results
+                        binary_test_data.append([op_name, operand1, operand2, result])
+                    else:
+                        # Since the results contain the 'nan' string, the result literals would be
+                        # nan:canonical
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:canonical'])
+
+            for operand1 in self.NAN_NUMBERS:
+                for operand2 in self.FLOAT_NUMBERS:
+                    if 'nan:' in operand1 or 'nan:' in operand2:
+                        # When the arguments contain 'nan:', the result literal is nan:arithmetic
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:arithmetic'])
+                    else:
+                        # No 'nan' string found, then the result literal is nan:canonical
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:canonical'])
+                for operand2 in self.NAN_NUMBERS:
+                    if 'nan:' in operand1 or 'nan:' in operand2:
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:arithmetic'])
+                    else:
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:canonical'])
+
+            for operand1 in self.LITERAL_NUMBERS:
+                for operand2 in self.LITERAL_NUMBERS:
+                    result = self.floatOp.binary_op(op, operand1, operand2, hex_form=False)
+                    binary_test_data.append([op_name, operand1, operand2, result])
+
+        for case in binary_test_data:
+            cases.append(str(AssertReturn(case[0],
+                        [SIMD.v128_const(elem, self.LANE_TYPE) for elem in case[1:-1]],
+                        SIMD.v128_const(case[-1], self.LANE_TYPE))))
+
+        # Test opposite signs of zero
+        lst_oppo_signs_0 = [
+            '\n;; Test opposite signs of zero',
+            [
+                'f64x2.min',
+                [['0', '0'], ['+0', '-0']],
+                [['0', '-0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.min',
+                [['-0', '+0'], ['+0', '-0']],
+                [['-0', '-0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.min',
+                [['-0', '-0'], ['+0', '+0']],
+                [['-0', '-0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.max',
+                [['0', '0'], ['+0', '-0']],
+                [['0', '0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.max',
+                [['-0', '+0'], ['+0', '-0']],
+                [['0', '0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.max',
+                [['-0', '-0'], ['+0', '+0']],
+                [['+0', '+0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            '\n'
+        ]
+
+        # Generate test case for opposite signs of zero
+        for case_data in lst_oppo_signs_0:
+
+            if isinstance(case_data, str):
+                cases.append(case_data)
+                continue
+
+            cases.append(str(AssertReturn(case_data[0],
+                                          [self.v128_const(case_data[3][0], case_data[1][0]),
+                                           self.v128_const(case_data[3][1], case_data[1][1])],
+                                          self.v128_const(case_data[3][2], case_data[2][0]))))
+
+        for p in self.FLOAT_NUMBERS + self.LITERAL_NUMBERS:
+            op_name = self.full_op_name('abs')
+            hex_literal = True
+            if p in self.LITERAL_NUMBERS:
+                hex_literal = False
+            result = self.floatOp.unary_op('abs', p, hex_form=hex_literal)
+            # Abs operation is valid for all the floating point numbers
+            unary_test_data.append([ op_name, p, result])
+
+        for case in unary_test_data:
+            cases.append(str(AssertReturn(case[0],
+                        [SIMD.v128_const(c, self.LANE_TYPE) for c in case[1:-1]],
+                        SIMD.v128_const(case[-1], self.LANE_TYPE))))
+
+        return '\n'.join(cases)
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_{lane_type}.wast'.format(lane_type=self.LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            txt_test_case = self.get_all_cases()
+            txt_test_case = txt_test_case.replace('f64x2 arithmetic', 'f64x2 [abs, min, max]')
+            fp.write(txt_test_case)
+
+
+def gen_test_cases():
+    simd_f64x2_case = Simdf64x2Case()
+    simd_f64x2_case.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
\ No newline at end of file
diff --git a/test/core/simd/meta/simd_f64x2_arith.py b/test/core/simd/meta/simd_f64x2_arith.py
new file mode 100644
index 000000000..df29d7b2d
--- /dev/null
+++ b/test/core/simd/meta/simd_f64x2_arith.py
@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+
+"""
+Generate f32x4 floating-point arithmetic operation cases.
+"""
+
+from simd_f32x4_arith import Simdf32x4ArithmeticCase
+from simd_float_op import FloatingPointArithOp
+
+
+class F64ArithOp(FloatingPointArithOp):
+    maximum = '0x1.fffffffffffffp+1023'
+
+
+class Simdf64x2ArithmeticCase(Simdf32x4ArithmeticCase):
+
+    LANE_LEN = 2
+    LANE_TYPE = 'f64x2'
+
+    floatOp = F64ArithOp()
+
+    FLOAT_NUMBERS = (
+        '0x0p+0', '-0x0p+0', '0x1p-1022', '-0x1p-1022', '0x1p-1', '-0x1p-1', '0x1p+0', '-0x1p+0',
+        '0x1.921fb54442d18p+2', '-0x1.921fb54442d18p+2', '0x1.fffffffffffffp+1023', '-0x1.fffffffffffffp+1023',
+        '0x0.0000000000001p-1022', '0x0.0000000000001p-1022', 'inf', '-inf'
+    )
+    LITERAL_NUMBERS = ('0123456789', '0123456789e019', '0123456789e+019', '0123456789e-019',
+                       '0123456789.', '0123456789.e019', '0123456789.e+019', '0123456789.e-019',
+                       '0123456789.0123456789', '0123456789.0123456789e019',
+                       '0123456789.0123456789e+019', '0123456789.0123456789e-019',
+                       '0x0123456789ABCDEFabcdef', '0x0123456789ABCDEFabcdefp019',
+                       '0x0123456789ABCDEFabcdefp+019', '0x0123456789ABCDEFabcdefp-019',
+                       '0x0123456789ABCDEFabcdef.', '0x0123456789ABCDEFabcdef.p019',
+                       '0x0123456789ABCDEFabcdef.p+019', '0x0123456789ABCDEFabcdef.p-019',
+                       '0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef',
+                       '0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019',
+                       '0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019',
+                       '0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019'
+    )
+    NAN_NUMBERS = ('nan', '-nan', 'nan:0x4000000000000', '-nan:0x4000000000000')
+
+    @staticmethod
+    def v128_const(lane, value):
+        return '(v128.const {lane_type} {value})'.format(lane_type=lane, value=' '.join([str(value)] * 2))
+
+    @property
+    def combine_ternary_arith_test_data(self):
+        return {
+            'add-sub': [
+                ['1.125'] * 2, ['0.25'] * 2, ['0.125'] * 2, ['1.0'] * 2
+            ],
+            'sub-add': [
+                ['1.125'] * 2, ['0.25'] * 2, ['0.125'] * 2, ['1.25'] * 2
+            ],
+            'mul-add': [
+                ['1.25'] * 2, ['0.25'] * 2, ['0.25'] * 2, ['0.375'] * 2
+            ],
+            'mul-sub': [
+                ['1.125'] * 2, ['0.125'] * 2, ['0.25'] * 2, ['0.25'] * 2
+            ],
+            'div-add': [
+                ['1.125'] * 2, ['0.125'] * 2, ['0.25'] * 2, ['5.0'] * 2
+            ],
+            'div-sub': [
+                ['1.125'] * 2, ['0.125'] * 2, ['0.25'] * 2, ['4.0'] * 2
+            ],
+            'mul-div': [
+                ['1.125'] * 2, ['0.125'] * 2, ['0.25'] * 2, ['2.25'] * 2
+            ],
+            'div-mul': [
+                ['1.125'] * 2, ['4'] * 2, ['0.25'] * 2, ['18.0'] * 2
+            ]
+        }
+
+    @property
+    def combine_binary_arith_test_data(self):
+        return {
+            'add-neg': [
+                ['1.125'] * 2, ['0.125'] * 2, ['-1.0'] * 2
+            ],
+            'sub-neg': [
+                ['1.125'] * 2, ['0.125'] * 2, ['-1.25'] * 2
+            ],
+            'mul-neg': [
+                ['1.5'] * 2, ['0.25'] * 2, ['-0.375'] * 2
+            ],
+            'div-neg': [
+                ['1.5'] * 2, ['0.25'] * 2, ['-6'] * 2
+            ],
+            'add-sqrt': [
+                ['2.25'] * 2, ['0.25'] * 2, ['1.75'] * 2
+            ],
+            'sub-sqrt': [
+                ['2.25'] * 2, ['0.25'] * 2, ['1.25'] * 2
+            ],
+            'mul-sqrt': [
+                ['2.25'] * 2, ['0.25'] * 2, ['0.375'] * 2
+            ],
+            'div-sqrt': [
+                ['2.25'] * 2, ['0.25'] * 2, ['6'] * 2
+            ]
+        }
+
+    def get_invalid_cases(self):
+        return super().get_invalid_cases().replace('32', '64')
+
+    @property
+    def mixed_nan_test_data(self):
+        return {
+            'neg_canon': [
+                ('nan', '1.0'), ('nan:canonical', '-1.0'),
+            ],
+            'sqrt_canon': [
+                ('4.0', '-nan'), ('2.0', 'nan:canonical'),
+            ],
+            'add_arith': [
+                ('nan:0x8000000000000', '1.0'), ('nan', '1.0'),
+                ('nan:arithmetic', '2.0'),
+            ],
+            'sub_arith': [
+                ('1.0', '-1.0'), ('-nan', '1.0'), ('nan:canonical', '-2.0'),
+            ],
+            'mul_mixed': [
+                ('nan:0x8000000000000', '1.0'), ('2.0', 'nan'),
+                ('nan:arithmetic', 'nan:canonical')
+            ],
+            'div_mixed': [
+                ('nan', '1.0'), ('2.0', '-nan:0x8000000000000'),
+                ('nan:canonical', 'nan:arithmetic')
+            ]
+        }
+
+    def mixed_nan_test(self, cases):
+        """Mixed f64x2 tests when only expects NaNs in a subset of lanes."""
+        mixed_cases = [
+            '\n;; Mixed f64x2 tests when some lanes are NaNs', '(module']
+        for test_type, test_data in sorted(self.mixed_nan_test_data.items()):
+            op = test_type.split('_')[0]
+            if op in self.UNARY_OPS:
+                mixed_cases.extend([
+                    '  (func (export "{lane}_{t}") (result v128)'.format(lane=self.LANE_TYPE, t=test_type),
+                    '    ({lane}.{op} (v128.const {lane} {param})))'.format(
+                        lane=self.LANE_TYPE, op=op, param=' '.join(test_data[0]))])
+            if op in self.BINARY_OPS:
+                mixed_cases.extend([
+                    '  (func (export "{lane}_{t}") (result v128)'.format(lane=self.LANE_TYPE, t=test_type),
+                    '    ({lane}.{op} (v128.const {lane} {param1}) (v128.const {lane} {param2})))'.format(
+                        lane=self.LANE_TYPE, op=op,
+                        param1=' '.join(test_data[0]),
+                        param2=' '.join(test_data[1]))])
+        mixed_cases.append(')\n')
+        for test_type, test_data in sorted(self.mixed_nan_test_data.items()):
+            mixed_cases.append('(assert_return (invoke "{lane}_{t}") (v128.const {lane} {result}))'.format(
+                lane=self.LANE_TYPE, t=test_type, result=' '.join(test_data[-1])
+            ))
+        cases.extend(mixed_cases)
+
+
+def gen_test_cases():
+    simd_f64x2_arith = Simdf64x2ArithmeticCase()
+    simd_f64x2_arith.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
\ No newline at end of file
diff --git a/test/core/simd/meta/simd_f64x2_cmp.py b/test/core/simd/meta/simd_f64x2_cmp.py
new file mode 100644
index 000000000..10ae36484
--- /dev/null
+++ b/test/core/simd/meta/simd_f64x2_cmp.py
@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+
+"""
+This file is used for generating simd_f64x2_cmp.wast file.
+Which inherites from `SimdArithmeticCase` class, overloads
+the `get_test_cases` method, and reset the Test Case template.
+The reason why this is different from other cmp files is that
+f64x2 only has 6 comparison instructions but with amounts of
+test datas.
+"""
+
+from simd_arithmetic import SimdArithmeticCase
+from simd_float_op import FloatingPointCmpOp
+from test_assert import AssertReturn
+from simd import SIMD
+
+
+class Simdf64x2CmpCase(SimdArithmeticCase):
+    LANE_LEN = 4
+    LANE_TYPE = 'f64x2'
+
+    UNARY_OPS = ()
+    BINARY_OPS = ('eq', 'ne', 'lt', 'le', 'gt', 'ge',)
+    floatOp = FloatingPointCmpOp()
+
+    FLOAT_NUMBERS_SPECIAL = ('0x1p-1074', '-inf', '0x1.921fb54442d18p+2',
+                             '0x1p+0', '-0x1.fffffffffffffp+1023', '-0x0p+0', '-0x1p-1', '0x1.fffffffffffffp+1023',
+                             '-0x1p-1074', '-0x1p-1022', '0x1p-1', '-0x1.921fb54442d18p+2',
+                             '0x0p+0', 'inf', '-0x1p+0', '0x1p-1022'
+                            )
+    LITERAL_NUMBERS = ('01234567890123456789e038', '01234567890123456789e-038',
+                       '0123456789.e038', '0123456789.e+038',
+                       '01234567890123456789.01234567890123456789'
+
+    )
+    FLOAT_NUMBERS_NORMAL = ('-1', '0', '1', '2.0')
+    NAN_NUMBERS = ('nan', '-nan', 'nan:0x4000000000000', '-nan:0x4000000000000')
+
+    def full_op_name(self, op_name):
+        return self.LANE_TYPE + '.' + op_name
+
+    @staticmethod
+    def v128_const(lane, value):
+        lane_cnt = 2 if lane in ['f64x2', 'i64x2'] else 4
+        return '(v128.const {lane_type} {value})'.format(lane_type=lane, value=' '.join([str(value)] * lane_cnt))
+
+    @property
+    def combine_ternary_arith_test_data(self):
+        return {}
+
+    @property
+    def combine_binary_arith_test_data(self):
+        return ['f64x2.eq', 'f64x2.ne', 'f64x2.lt', 'f64x2.le', 'f64x2.gt', 'f64x2.ge']
+
+    def get_combine_cases(self):
+        combine_cases = [';; combination\n(module (memory 1)']
+
+        # append funcs
+        binary_func_template = '  (func (export "{op}-in-block")\n' \
+                             '    (block\n' \
+                             '      (drop\n' \
+                             '        (block (result v128)\n' \
+                             '          ({op}\n' \
+                             '            (block (result v128) (v128.load (i32.const 0)))\n' \
+                             '            (block (result v128) (v128.load (i32.const 1)))\n' \
+                             '          )\n' \
+                             '        )\n' \
+                             '      )\n' \
+                             '    )\n' \
+                             '  )'
+        for func in self.combine_binary_arith_test_data:
+            combine_cases.append(binary_func_template.format(op=func))
+
+        binary_func_template = '  (func (export "nested-{func}")\n' \
+                             '    (drop\n' \
+                             '      ({func}\n' \
+                             '        ({func}\n' \
+                             '          ({func}\n' \
+                             '            (v128.load (i32.const 0))\n' \
+                             '            (v128.load (i32.const 1))\n' \
+                             '          )\n' \
+                             '          ({func}\n' \
+                             '            (v128.load (i32.const 2))\n' \
+                             '            (v128.load (i32.const 3))\n' \
+                             '          )\n' \
+                             '        )\n' \
+                             '        ({func}\n' \
+                             '          ({func}\n' \
+                             '            (v128.load (i32.const 0))\n' \
+                             '            (v128.load (i32.const 1))\n' \
+                             '          )\n' \
+                             '          ({func}\n' \
+                             '            (v128.load (i32.const 2))\n' \
+                             '            (v128.load (i32.const 3))\n' \
+                             '          )\n' \
+                             '        )\n' \
+                             '      )\n' \
+                             '    )\n' \
+                             '  )' \
+
+        for func in self.combine_binary_arith_test_data:
+            combine_cases.append(binary_func_template.format(func=func))
+
+        combine_cases.append('  (func (export "as-param")\n'
+                             '    (drop\n'
+                             '      (f64x2.eq\n'
+                             '        (f64x2.ne\n'
+                             '          (f64x2.lt\n'
+                             '            (v128.load (i32.const 0))\n'
+                             '            (v128.load (i32.const 1))\n'
+                             '          )\n'
+                             '          (f64x2.le\n'
+                             '            (v128.load (i32.const 2))\n'
+                             '            (v128.load (i32.const 3))\n'
+                             '          )\n'
+                             '        )\n'
+                             '        (f64x2.gt\n'
+                             '          (f64x2.ge\n'
+                             '            (v128.load (i32.const 0))\n'
+                             '            (v128.load (i32.const 1))\n'
+                             '          )\n'
+                             '          (f64x2.eq\n'
+                             '            (v128.load (i32.const 2))\n'
+                             '            (v128.load (i32.const 3))\n'
+                             '          )\n'
+                             '        )\n'
+                             '      )\n'
+                             '    )\n'
+                             '  )')
+
+        combine_cases.append(')')
+
+        # append assert
+        binary_case_template = ('(assert_return (invoke "{func}-in-block"))')
+        for func in self.combine_binary_arith_test_data:
+            combine_cases.append(binary_case_template.format(func=func))
+
+        binary_case_template = ('(assert_return (invoke "nested-{func}"))')
+        for func in self.combine_binary_arith_test_data:
+            combine_cases.append(binary_case_template.format(func=func))
+
+        combine_cases.append('(assert_return (invoke "as-param"))\n')
+
+        return '\n'.join(combine_cases)
+
+    def get_normal_case(self):
+        """Normal test cases from WebAssembly core tests
+        """
+        cases = []
+        binary_test_data = []
+        unary_test_data = []
+
+        for op in self.BINARY_OPS:
+            op_name = self.full_op_name(op)
+            for operand1 in self.FLOAT_NUMBERS_SPECIAL:
+                for operand2 in self.FLOAT_NUMBERS_SPECIAL + self.NAN_NUMBERS:
+                    result = self.floatOp.binary_op(op, operand1, operand2)
+                    binary_test_data.append([op_name, operand1, operand2, result])
+
+            for operand1 in self.LITERAL_NUMBERS:
+                for operand2 in self.LITERAL_NUMBERS:
+                    result = self.floatOp.binary_op(op, operand1, operand2)
+                    binary_test_data.append([op_name, operand1, operand2, result])
+
+            for operand1 in self.NAN_NUMBERS:
+                for operand2 in self.FLOAT_NUMBERS_SPECIAL + self.NAN_NUMBERS:
+                    result = self.floatOp.binary_op(op, operand1, operand2)
+                    binary_test_data.append([op_name, operand1, operand2, result])
+
+        for op in self.BINARY_OPS:
+            op_name = self.full_op_name(op)
+            for operand1 in self.FLOAT_NUMBERS_NORMAL:
+                for operand2 in self.FLOAT_NUMBERS_NORMAL:
+                    result = self.floatOp.binary_op(op, operand1, operand2)
+                    binary_test_data.append([op_name, operand1, operand2, result])
+
+        for case in binary_test_data:
+            cases.append(str(AssertReturn(case[0],
+                        [SIMD.v128_const(elem, self.LANE_TYPE) for elem in case[1:-1]],
+                        SIMD.v128_const(case[-1], 'i64x2'))))
+
+        for case in unary_test_data:
+            cases.append(str(AssertReturn(case[0],
+                        [SIMD.v128_const(elem, self.LANE_TYPE) for elem in case[1:-1]],
+                        SIMD.v128_const(case[-1], 'i64x2'))))
+
+        self.get_unknown_operator_case(cases)
+
+        return '\n'.join(cases)
+
+    def get_unknown_operator_case(self, cases):
+        """Unknown operator cases.
+        """
+
+        tpl_assert = "(assert_malformed (module quote \"(memory 1) (func " \
+                     " (param $x v128) (param $y v128) (result v128) " \
+                     "({lane_type}.{op} (local.get $x) (local.get $y)))\") \"unknown operator\")"
+
+        cases.append('\n\n;; unknown operators')
+
+        for lane_type in ['f2x64']:
+            for op in self.BINARY_OPS:
+                cases.append(tpl_assert.format(lane_type=lane_type,
+                                               op=op))
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_{lane_type}_cmp.wast'.format(lane_type=self.LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            txt_test_case = self.get_all_cases()
+            txt_test_case = txt_test_case.replace('f64x2 arithmetic', 'f64x2 comparison')
+            fp.write(txt_test_case)
+
+
+def gen_test_cases():
+    simd_f64x2_cmp = Simdf64x2CmpCase()
+    simd_f64x2_cmp.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
\ No newline at end of file
diff --git a/test/core/simd/meta/simd_f64x2_pmin_pmax.py b/test/core/simd/meta/simd_f64x2_pmin_pmax.py
new file mode 100644
index 000000000..c97badd48
--- /dev/null
+++ b/test/core/simd/meta/simd_f64x2_pmin_pmax.py
@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+
+"""
+Generate f64x2 [pmin, pmax] cases.
+"""
+
+from simd_f32x4_pmin_pmax import Simdf32x4PminPmaxCase
+from simd_f64x2_arith import Simdf64x2ArithmeticCase
+from simd_float_op import FloatingPointSimpleOp
+from simd import SIMD
+from test_assert import AssertReturn
+
+
+class Simdf64x2PminPmaxCase(Simdf32x4PminPmaxCase):
+    LANE_TYPE = 'f64x2'
+    FLOAT_NUMBERS = Simdf64x2ArithmeticCase.FLOAT_NUMBERS
+    LITERAL_NUMBERS = Simdf64x2ArithmeticCase.LITERAL_NUMBERS
+    NAN_NUMBERS = Simdf64x2ArithmeticCase.NAN_NUMBERS
+
+
+def gen_test_cases():
+    simd_f64x2_pmin_pmax_case = Simdf64x2PminPmaxCase()
+    simd_f64x2_pmin_pmax_case.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_f64x2_rounding.py b/test/core/simd/meta/simd_f64x2_rounding.py
new file mode 100644
index 000000000..a0a389e2f
--- /dev/null
+++ b/test/core/simd/meta/simd_f64x2_rounding.py
@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+
+"""
+Generate f64x2 [ceil, floor, trunc, nearest] cases.
+"""
+
+from simd_f32x4_rounding import Simdf32x4RoundingCase
+from simd_f64x2 import Simdf64x2Case
+from simd_f64x2_arith import Simdf64x2ArithmeticCase
+from simd_float_op import FloatingPointRoundingOp
+from simd import SIMD
+from test_assert import AssertReturn
+
+
+class Simdf64x2RoundingCase(Simdf32x4RoundingCase):
+
+    LANE_TYPE = 'f64x2'
+    FLOAT_NUMBERS = Simdf64x2ArithmeticCase.FLOAT_NUMBERS
+    LITERAL_NUMBERS = Simdf64x2ArithmeticCase.LITERAL_NUMBERS
+    NAN_NUMBERS = Simdf64x2ArithmeticCase.NAN_NUMBERS
+
+
+def gen_test_cases():
+    simd_f64x2_case = Simdf64x2RoundingCase()
+    simd_f64x2_case.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_float_op.py b/test/core/simd/meta/simd_float_op.py
new file mode 100644
index 000000000..4e65443a6
--- /dev/null
+++ b/test/core/simd/meta/simd_float_op.py
@@ -0,0 +1,303 @@
+#!/usr/bin/env python3
+
+"""Common floating-point number operations for f32x4 and f64x2"""
+
+from abc import abstractmethod
+import math
+import struct
+
+
+class FloatingPointOp:
+
+    maximum = None
+
+    @abstractmethod
+    def binary_op(self, op: str, p1: str, p2: str) -> str:
+        pass
+
+    def of_string(self, value: str) -> float:
+        if '0x' in value:
+            return float.fromhex(value)
+        else:
+            return float(value)
+
+    def is_hex(self, value:str) -> bool:
+        return '0x' in value
+
+    def to_single_precision(self, value: float) -> str:
+        # Python only has doubles, when reading in float, we need to convert to
+        # single-precision first.
+        return struct.unpack('f', struct.pack('f', value))[0]
+
+
+class FloatingPointArithOp(FloatingPointOp):
+    """Common arithmetic ops for both f32x4 and f64x2:
+        neg, sqrt, add, sub, mul, div
+    """
+
+    def binary_op(self, op: str, p1: str, p2: str, single_prec=False) -> str:
+        """Binary operation on p1 and p2 with the operation specified by op
+
+        :param op: add, sub, mul, div
+        :param p1: float number in hex
+        :param p2: float number in hex
+        :return:
+        """
+        hex_form = self.is_hex(p1) or self.is_hex(p2)
+        f1 = self.of_string(p1)
+        f2 = self.of_string(p2)
+
+        if op == 'add':
+            if 'inf' in p1 and 'inf' in p2 and p1 != p2:
+                return '-nan'
+            result = f1 + f2
+
+        elif op == 'sub':
+            if 'inf' in p1 and 'inf' in p2 and p1 == p2:
+                return '-nan'
+            result = f1 - f2
+
+        elif op == 'mul':
+            if '0x0p+0' in p1 and 'inf' in p2 or 'inf' in p1 and '0x0p+0' in p2:
+                return '-nan'
+            if single_prec:
+                # For some literals, f32x4.mul operation may cause precision lost.
+                # Use struct.unpack('f', struct.pack('f', literal)) to compensate
+                # single precision lost of f32
+                f1 = struct.unpack('f', struct.pack('f', f1))[0]
+                f2 = struct.unpack('f', struct.pack('f', f2))[0]
+                result = struct.unpack('f', struct.pack('f', f1 * f2))[0]
+            else:
+                result = f1 * f2
+
+        elif op == 'div':
+            if '0x0p+0' in p1 and '0x0p+0' in p2:
+                return '-nan'
+            if 'inf' in p1 and 'inf' in p2:
+                return '-nan'
+
+            try:
+                result = f1 / f2
+                return self.get_valid_float(result, self.maximum, hex_form)
+            except ZeroDivisionError:
+                if p1[0] == p2[0]:
+                    return 'inf'
+                elif p1 == 'inf' and p2 == '0x0p+0':
+                    return 'inf'
+                else:
+                    return '-inf'
+
+        else:
+            raise Exception('Unknown binary operation')
+
+        return self.get_valid_float(result, self.maximum, hex_form)
+
+    def get_valid_float(self, value, maximum_literals, hex_form=False):
+        if value > float.fromhex(maximum_literals):
+            return 'inf'
+        if value < float.fromhex('-' + maximum_literals):
+            return '-inf'
+
+        if hex_form:
+            return value.hex()
+        else:
+            return str(value)
+
+    def float_sqrt(self, p):
+        if p == '-0x0p+0':
+            return '-0x0p+0'
+
+        try:
+            if '0x' in p:
+                f = float.fromhex(p)
+                result = float.hex(math.sqrt(f))
+            else:
+                f = float(p)
+                result = str(math.sqrt(f))
+        except ValueError:
+            result = '-nan'
+
+        return result
+
+    def float_neg(self, p):
+        if p == 'nan':
+            return '-nan'
+        try:
+            if '0x' in p:
+                f = float.fromhex(p)
+                result = float.hex(-f)
+            else:
+                f = float(p)
+                result = str(-f)
+        except ValueError:
+            if p.startswith('nan:'):
+                return '-' + p
+            if p.startswith('-nan:'):
+                return p[1:]
+
+        return result
+
+
+class FloatingPointSimpleOp(FloatingPointOp):
+    """Common simple ops for both f32x4 and f64x2: abs, min, max, pmin, pmax"""
+
+    def binary_op(self, op: str, p1: str, p2: str, hex_form=True) -> str:
+        """Binary operation on p1 and p2 with the operation specified by op
+
+        :param op: min, max,
+        :param p1: float number in hex
+        :param p2: float number in hex
+        :return:
+        """
+        f1 = self.of_string(p1)
+        f2 = self.of_string(p2)
+
+        if '-nan' in [p1, p2] and 'nan' in [p1, p2]:
+            return p1
+
+        if 'nan' in [p1, p2]:
+            return 'nan'
+
+        if '-nan' in [p1, p2]:
+            return '-nan'
+
+        # pmin and pmax semantics follow C++'s std::min std::max
+        if op == 'pmin':
+            r = f2 if f2 < f1 else f1
+            if hex_form:
+                return r.hex()
+            else:
+                return str(r)
+
+        if op == 'pmax':
+            r = f2 if f1 < f2 else f1
+            if hex_form:
+                return r.hex()
+            else:
+                return str(r)
+
+        if op == 'min':
+            if '-0x0p+0' in [p1, p2] and '0x0p+0' in [p1, p2]:
+                return '-0x0p+0'
+            if hex_form:
+                return min(f1, f2).hex()
+            else:
+                return p1 if f1 <= f2 else p2
+
+        elif op == 'max':
+            if '-0x0p+0' in [p1, p2] and '0x0p+0' in [p1, p2]:
+                return '0x0p+0'
+            if hex_form:
+                return max(f1, f2).hex()
+            else:
+                return p1 if f1 > f2 else p2
+
+        else:
+            raise Exception('Unknown binary operation: {}'.format(op))
+
+    def unary_op(self, op: str, p1: str, hex_form=True) -> str:
+        """Unnary operation on p1 with the operation specified by op
+
+        :param op: abs,
+        :param p1: float number in hex
+        :return:
+        """
+        f1 = self.of_string(p1)
+        if op == 'abs':
+            if hex_form:
+                return abs(f1).hex()
+            else:
+                return p1 if not p1.startswith('-') else p1[1:]
+
+        raise Exception('Unknown unary operation: {}'.format(op))
+
+
+class FloatingPointCmpOp(FloatingPointOp):
+
+    def binary_op(self, op: str, p1: str, p2: str) -> str:
+        """Binary operation on p1 and p2 with the operation specified by op
+
+        :param op: eq, ne, lt, le, gt, ge
+        :param p1: float number in hex
+        :param p2: float number in hex
+        :return:
+        """
+
+        # ne
+        # if either p1 or p2 is a NaN, then return True
+        if op == 'ne' and ('nan' in p1.lower() or 'nan' in p2.lower()):
+            return '-1'
+
+        # other instructions
+        # if either p1 or p2 is a NaN, then return False
+        if 'nan' in p1.lower() or 'nan' in p2.lower():
+            return '0'
+
+        f1 = self.of_string(p1)
+        f2 = self.of_string(p2)
+
+        if op == 'eq':
+            return '-1' if f1 == f2 else '0'
+
+        elif op == 'ne':
+            return '-1' if f1 != f2 else '0'
+
+        elif op == 'lt':
+            return '-1' if f1 < f2 else '0'
+
+        elif op == 'le':
+            return '-1' if f1 <= f2 else '0'
+
+        elif op == 'gt':
+            return '-1' if f1 > f2 else '0'
+
+        elif op == 'ge':
+            return '-1' if f1 >= f2 else '0'
+        else:
+            raise Exception('Unknown binary operation')
+
+
+class FloatingPointRoundingOp(FloatingPointOp):
+    def unary_op(self, op: str, p1: str, hex_form=True) -> str:
+        """Unnary operation on p1 with the operation specified by op
+
+        :param op: ceil, floor, trunc, nearest
+        :param p1: float number in hex
+        :return:
+        """
+        f1 = self.of_string(p1)
+
+        if 'nan' in p1:
+            return 'nan'
+
+        if 'inf' in p1:
+            return p1
+
+        # The rounding ops don't treat -0.0 correctly, e.g.:
+        # math.ceil(-0.4) returns +0.0, so copy the sign.
+        elif op == 'ceil':
+            r = math.copysign(math.ceil(f1), f1)
+            if hex_form:
+                return r.hex()
+            else:
+                return str(r)
+        elif op == 'floor':
+            r = math.copysign(math.floor(f1), f1)
+            if hex_form:
+                return r.hex()
+            else:
+                return str(r)
+        elif op == 'trunc':
+            r = math.copysign(math.trunc(f1), f1)
+            if hex_form:
+                return r.hex()
+            else:
+                return str(r)
+        elif op == 'nearest':
+            r = math.copysign(round(f1), f1)
+            if hex_form:
+                return r.hex()
+            else:
+                return str(r)
+        else:
+            raise Exception('Unknown binary operation')
diff --git a/test/core/simd/meta/simd_i16x8_arith.py b/test/core/simd/meta/simd_i16x8_arith.py
new file mode 100644
index 000000000..110907104
--- /dev/null
+++ b/test/core/simd/meta/simd_i16x8_arith.py
@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+
+"""
+Generate i16x8 integer arithmetic operation cases.
+"""
+
+from simd_arithmetic import SimdArithmeticCase
+
+
+class SimdI16x8ArithmeticCase(SimdArithmeticCase):
+
+    LANE_LEN = 8
+    LANE_TYPE = 'i16x8'
+
+    @property
+    def hex_binary_op_test_data(self):
+        return [
+            ('0x3fff', '0x4000'),
+            ('0x4000', '0x4000'),
+            ('-0x3fff', '-0x4000'),
+            ('-0x4000', '-0x4000'),
+            ('-0x4000', '-0x4001'),
+            ('0x7fff', '0x7fff'),
+            ('0x7fff', '0x01'),
+            ('0x8000', '-0x01'),
+            ('0x7fff', '0x8000'),
+            ('0x8000', '0x8000'),
+            ('0xffff', '0x01'),
+            ('0xffff', '0xffff')
+        ]
+
+    @property
+    def hex_unary_op_test_data(self):
+        return ['0x01', '-0x01', '-0x8000', '-0x7fff', '0x7fff', '0x8000', '0xffff']
+
+    @property
+    def underscore_literal_test_data(self):
+        return {
+            'i16x8.add': [
+                [['012_345', '056_789'], '03_598', ['i16x8'] * 3],
+                [['0x0_1234', '0x0_5678'], '0x0_68ac', ['i16x8'] * 3]
+            ],
+            'i16x8.sub': [
+                [['056_789', '012_345'], '044_444', ['i16x8'] * 3],
+                [['0x0_5678', '0x0_1234'], '0x0_4444', ['i16x8'] * 3]
+            ],
+            'i16x8.mul': [
+                [['012_345', '056_789'], '021_613', ['i16x8'] * 3],
+                [['0x0_1234', '0x0_cdef'], '0x0_a28c', ['i16x8'] * 3]
+            ]
+        }
+
+    @property
+    def i16x8_i8x16_test_data(self):
+        return {
+            'i16x8.add': [
+                [['0x7fff', ['0', '0x80'] * 8], '-1', ['i16x8', 'i8x16', 'i16x8']],
+                [['1', '255'], '0', ['i16x8', 'i8x16', 'i16x8']]
+            ],
+            'i16x8.sub': [
+                [['0x7fff', ['0', '0x80'] * 8], '-1', ['i16x8', 'i8x16', 'i16x8']],
+                [['1', '255'], '0x02', ['i16x8', 'i8x16', 'i16x8']]
+            ],
+            'i16x8.mul': [
+                [['0x1000', '0x10'], '0', ['i16x8', 'i8x16', 'i16x8']],
+                [['65535', '255'], '0x01', ['i16x8', 'i8x16', 'i16x8']]
+            ]
+        }
+
+    @property
+    def i16x8_i32x4_test_data(self):
+        return {
+            'i16x8.add': [
+                [['0x7fff', '0x80008000'], '-1', ['i16x8', 'i32x4', 'i16x8']],
+                [['1', '0xffffffff'], '0', ['i16x8', 'i32x4', 'i16x8']]
+            ],
+            'i16x8.sub': [
+                [['0x7fff', '0x80008000'], '-1', ['i16x8', 'i32x4', 'i16x8']],
+                [['1', '0xffffffff'], '0x02', ['i16x8', 'i32x4', 'i16x8']]
+            ],
+            'i16x8.mul': [
+                [['0x8000', '0x00020002'], '0', ['i16x8', 'i32x4', 'i16x8']],
+                [['65535', '0xffffffff'], '0x01', ['i16x8', 'i32x4', 'i16x8']]
+            ]
+        }
+
+    @property
+    def i16x8_f32x4_test_data(self):
+        return {
+            'i16x8.add': [
+                [['0x8000', '+0.0'], '0x8000', ['i16x8', 'f32x4', 'i16x8']],
+                [['0x8000', '-0.0'], ['0x8000', '0'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['0x8000', '1.0'], ['0x8000', '0xbf80'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['0x8000', '-1.0'], ['0x8000', '0x3f80'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '+inf'], ['0x01', '0x7f81'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '-inf'], ['0x01', '0xff81'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', 'nan'], ['0x01', '0x7fc1'] * 4, ['i16x8', 'f32x4', 'i16x8']]
+            ],
+            'i16x8.sub': [
+                [['0x8000', '+0.0'], '0x8000', ['i16x8', 'f32x4', 'i16x8']],
+                [['0x8000', '-0.0'], ['0x8000', '0'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['0x8000', '1.0'], ['0x8000', '0x4080'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['0x8000', '-1.0'], ['0x8000', '0xc080'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '+inf'], ['0x01', '0x8081'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '-inf'], ['0x01', '0x81'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', 'nan'], ['0x01', '0x8041'] * 4, ['i16x8', 'f32x4', 'i16x8']]
+            ],
+            'i16x8.mul': [
+                [['0x8000', '+0.0'], '0', ['i16x8', 'f32x4', 'i16x8']],
+                [['0x8000', '-0.0'], '0', ['i16x8', 'f32x4', 'i16x8']],
+                [['0x8000', '1.0'], '0', ['i16x8', 'f32x4', 'i16x8']],
+                [['0x8000', '-1.0'], '0', ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '+inf'], ['0', '0x7f80'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '-inf'], ['0', '0xff80'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', 'nan'], ['0', '0x7fc0'] * 4, ['i16x8', 'f32x4', 'i16x8']]
+            ]
+        }
+
+    @property
+    def combine_dec_hex_test_data(self):
+        return {
+            'i16x8.add': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7'],
+                  ['0', '0xffff', '0xfffe', '0xfffd', '0xfffc', '0xfffb', '0xfffa', '0xfff9']],
+                 ['0'] * 8, ['i16x8'] * 3]
+            ],
+            'i16x8.sub': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7'],
+                  ['0', '0xffff', '0xfffe', '0xfffd', '0xfffc', '0xfffb', '0xfffa', '0xfff9']],
+                 ['0', '0x02', '0x04', '0x06', '0x08', '0x0a', '0x0c', '0x0e'], ['i16x8'] * 3]
+            ],
+            'i16x8.mul': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7'],
+                  ['0', '0xffff', '0xfffe', '0xfffd', '0xfffc', '0xfffb', '0xfffa', '0xfff9']],
+                 ['0', '0xffff', '0xfffc', '0xfff7', '0xfff0', '0xffe7', '0xffdc', '0xffcf'],
+                 ['i16x8'] * 3]
+            ]
+        }
+
+    @property
+    def range_test_data(self):
+        return {
+            'i16x8.add': [
+                [[[str(i) for i in range(8)], [str(i * 2) for i in range(8)]],
+                 [str(i * 3) for i in range(8)], ['i16x8'] * 3]
+            ],
+            'i16x8.sub': [
+                [[[str(i) for i in range(8)], [str(i * 2) for i in range(8)]],
+                 [str(-i) for i in range(8)], ['i16x8'] * 3]
+            ],
+            'i16x8.mul': [
+                [[[str(i) for i in range(8)], [str(i * 2) for i in range(8)]],
+                 ['0', '0x02', '0x08', '0x12', '0x20', '0x32', '0x48', '0x62'],
+                 ['i16x8'] * 3]
+            ]
+        }
+
+    @property
+    def full_bin_test_data(self):
+        return [
+            self.i16x8_i8x16_test_data,
+            self.i16x8_i32x4_test_data,
+            self.i16x8_f32x4_test_data,
+            self.combine_dec_hex_test_data,
+            self.range_test_data,
+            self.underscore_literal_test_data
+        ]
+
+
+def gen_test_cases():
+    simd_i16x8_arith = SimdI16x8ArithmeticCase()
+    simd_i16x8_arith.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
\ No newline at end of file
diff --git a/test/core/simd/meta/simd_i16x8_cmp.py b/test/core/simd/meta/simd_i16x8_cmp.py
new file mode 100644
index 000000000..c575cdd0e
--- /dev/null
+++ b/test/core/simd/meta/simd_i16x8_cmp.py
@@ -0,0 +1,825 @@
+#!/usr/bin/env python3
+
+"""
+This file is used for generating i16x8 related test cases
+which inherites from the 'SimdCmpCase' class and overloads
+with the 'get_test_cases' method.
+"""
+
+from simd_compare import SimdCmpCase
+
+
+# Generate i16x8 test case
+class Simdi16x8CmpCase(SimdCmpCase):
+
+    LANE_TYPE = 'i16x8'
+
+    BINARY_OPS = ['eq', 'ne', 'lt_s', 'lt_u', 'le_s', 'le_u', 'gt_s', 'gt_u', 'ge_s', 'ge_u']
+
+    # Overloads base class method and sets test data for i16x8.
+    def get_case_data(self):
+
+        case_data = []
+
+        # eq
+        # i16x8.eq  (i16x8) (i16x8)
+        case_data.append(['#', 'eq'])
+        case_data.append(['#', 'i16x8.eq  (i16x8) (i16x8)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['eq', ['0xFFFF', '0xFFFF'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['0x0000', '0x0000'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['0xF0F0', '0xF0F0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['0x0F0F', '0x0F0F'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['0xFFFF', '0x0000'], ['0xFFFF', '0x0000']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['0x0000', '0xFFFF'], ['0x0000', '0xFFFF']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB'],
+                          ['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['eq', ['0xFFFF', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['0xFFFF', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['0x8080', '32896'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['0x8080', '-32640'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['0x8180', '0x8382', '0xFEFD', '0x00FF', '0x0100', '0x7F02', '0xFD80', '0xFFFE'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['eq', ['-1', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['0', '0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['65535', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['65535', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['65535', '0'], ['65535', '0']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['0', '65535'], ['0', '65535']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['-32768', '65534', '-1', '-0', '0', '1', '2', '65535'],
+                          ['32768', '-2', '-1', '-0', '0', '1', '2', '-1']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['eq', [['0x0000', '0xc300', '0x0000', '0xc2fe', '0x0000', '0xbf80', '0x0000', '0x0000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i16x8', 'f32x4', 'i16x8']])
+        case_data.append(['eq', [['0x0000', '0x3f80', '0x0000', '0x42fe', '0x0000', '0x4300', '0x0000', '0x437f'],
+                          ['1.0', '127.0', '128.0', '255.0']], '-1', ['i16x8', 'f32x4', 'i16x8']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['eq', ['0x0F0F', '0xF0F0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['0x0000', '0xFFFF'], ['0xFFFF', '0x0000']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['0x0001', '0x0203', '0x0409', '0x1011', '0x120A', '0x0B1A', '0x1BAA', '0xABFF'],
+                          ['0xFFAB', '0xAA1B', '0x1A0B', '0x0A12', '0x1110', '0x0904', '0x0302', '0x0100']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['0x8000', '0x8001', '0x8002', '0x8003', '0x8004', '0x8005', '0x8006', '0x8007'],
+                          ['32775', '32774', '32773', '32772', '32771', '32770', '32769', '32768']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['32768', '32769', '65534', '65535', '0', '-1', '-32767', '-32768'],
+                          ['-32768', '-32767', '-1', '0', '65535', '65534', '32769', '32768']], ['-1', '-1', '0', '0', '0', '0', '-1', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+
+        # i16x8.eq  (i16x8) (i8x16)
+        case_data.append(['#', 'i16x8.eq  (i16x8) (i8x16)'])
+        case_data.append(['eq', ['0xFFFF', '0xFF'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['eq', ['65535', '255'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['eq', ['0', '0'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['eq', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['eq', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['eq', [['-128', '-128', '0', '0', '1', '1', '255', '255'],
+                          ['-128', '0', '1', '255']], ['0', '0', '-1', '-1', '0', '0', '0', '0'], ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['eq', ['0x5555', '0xAA'], '0', ['i16x8', 'i8x16', 'i16x8']])
+
+        # i16x8.eq  (i16x8) (i32x4)
+        case_data.append(['#', 'i16x8.eq  (i16x8) (i32x4)'])
+        case_data.append(['eq', ['0xFFFF', '0xFFFFFFFF'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['eq', ['65535', '4294967295'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['eq', ['0', '0'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['eq', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['eq', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['eq', [['65535', '0', '1', '32768'], ['65535', '0', '1', '32768']], ['-1', '0', '-1', '-1', '-1', '0', '-1', '0'], ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['eq', ['0x5555', '0xAAAAAAAA'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['eq', ['012_345', '12345'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['0x0_1234', '0x1234'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # ne
+        # i16x8.ne  (i16x8) (i16x8)
+        case_data.append(['#', 'ne'])
+        case_data.append(['#', 'i16x8.ne  (i16x8) (i16x8)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ne', ['0xFFFF', '0xFFFF'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', ['0x0000', '0x0000'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', ['0xF0F0', '0xF0F0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', ['0x0F0F', '0x0F0F'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['0xFFFF', '0x0000'], ['0xFFFF', '0x0000']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['0x0000', '0xFFFF'], ['0x0000', '0xFFFF']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB'],
+                          ['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['ne', ['0xFFFF', '65535'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', ['0xFFFF', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', ['0x8080', '32896'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', ['0x8080', '-32640'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['0x8180', '0x8382', '0xFEFD', '0x00FF', '0x0100', '0x7F02', '0xFD80', '0xFFFE'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['ne', ['-1', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', ['0', '0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', ['255', '255'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', ['65535', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['255', '0'], ['255', '0']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['0', '255'], ['0', '255']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['255', '32767', '-0', '0', '1', '2', '65534', '65535'],
+                          ['255', '32767', '0', '0', '1', '2', '-2', '-1']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['ne', [['0x0000', '0xc300', '0x0000', '0xc2fe', '0x0000', '0xbf80', '0x0000', '0x0000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i16x8', 'f32x4', 'i16x8']])
+        case_data.append(['ne', [['0x0000', '0x3f80', '0x0000', '0x42fe', '0x0000', '0x4300', '0x0000', '0x437f'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i16x8', 'f32x4', 'i16x8']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['ne', ['0x0F0F', '0xF0F0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['0x0000', '0xFFFF'], ['0xFFFF', '0x0000']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['0x0001', '0x0203', '0x0409', '0x1011', '0x120A', '0x0B1A', '0x1BAA', '0xABFF'],
+                          ['0xFFAB', '0xAA1B', '0x1A0B', '0x0A12', '0x1110', '0x0904', '0x0302', '0x0100']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['0x8081', '0x8283', '0xFDFE', '0xFF00', '0x0001', '0x027F', '0x80FD', '0xFEFF'],
+                          ['65279', '33021', '639', '1', '65280', '65022', '33411', '32897']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['128', '129', '130', '131', '-0', '255', '32766', '32767'],
+                          ['32767', '32766', '255', '-0', '131', '130', '129', '28']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # i16x8.ne  (i16x8) (i8x16)
+        case_data.append(['#', 'i16x8.ne  (i16x8) (i8x16)'])
+        case_data.append(['ne', ['0xFFFF', '0xFF'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ne', ['65535', '255'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ne', ['0', '0'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ne', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ne', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ne', [['-128', '-128', '0', '0', '1', '1', '255', '255'], ['-128', '0', '1', '255']],
+                          ['-1', '-1', '0', '0', '-1', '-1', '-1', '-1'], ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ne', ['0x5555', '0xAA'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+
+        # i16x8.ne  (i16x8) (i32x4)
+        case_data.append(['#', 'i16x8.ne  (i16x8) (i32x4)'])
+        case_data.append(['ne', ['0xFFFF', '0xFFFFFFFF'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ne', ['65535', '4294967295'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ne', ['0', '0'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ne', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ne', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ne', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['0', '-1', '0', '0', '0', '-1', '0', '-1'], ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ne', ['0x5555', '0xAAAAAAAA'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ne', ['012_345', '12345'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', ['0x0_1234', '0x1234'], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # lt_s
+        # i16x8.lt_s  (i16x8) (i16x8)
+        case_data.append(['#', 'lt_s'])
+        case_data.append(['#', 'i16x8.lt_s  (i16x8) (i16x8)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['lt_s', ['0xFFFF', '0xFFFF'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['0x0000', '0x0000'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['0xF0F0', '0xF0F0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['0x0F0F', '0x0F0F'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['0xFFFF', '0x0000'], ['0xFFFF', '0x0000']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['0x0000', '0xFFFF'], ['0x0000', '0xFFFF']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB'],
+                          ['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['0xFFFF', '65535'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['0xFFFF', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['0x8080', '32896'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['0x8080', '-32640'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['0x8180', '0x8382', '0xFEFD', '0x00FF', '0x0100', '0x7F02', '0xFD80', '0xFFFE'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['-1', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['0', '0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['255', '255'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['65535', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['255', '0'], ['255', '0']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['0', '255'], ['0', '255']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['255', '32767', '-0', '0', '1', '2', '65534', '65535'], ['255', '32767', '0', '0', '1', '2', '-2', '-1']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['0x0000', '0xc300', '0x0000', '0xc2fe', '0x0000', '0xbf80', '0x0000', '0x0000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i16x8', 'f32x4', 'i16x8']])
+        case_data.append(['lt_s', [['0x0000', '0x3f80', '0x0000', '0x42fe', '0x0000', '0x4300', '0x0000', '0x437f'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i16x8', 'f32x4', 'i16x8']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['lt_s', ['0x0F0F', '0xF0F0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['0x0000', '0xFFFF'], ['0xFFFF', '0x0000']], ['0', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['0x0001', '0x0203', '0x0409', '0x1011', '0x120A', '0x0B1A', '0x1BAA', '0xABFF'],
+                          ['0xFFAB', '0xAA1B', '0x1A0B', '0x0A12', '0x1110', '0x0904', '0x0302', '0x0100']], ['0', '0', '-1', '0', '0', '0', '0', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['0x8081', '0x8283', '0xFDFE', '0xFF00', '0x0001', '0x027F', '0x80FD', '0xFEFF'],
+                          ['65279', '33021', '639', '1', '65280', '65022', '33411', '32897']], ['-1', '0', '-1', '-1', '0', '0', '-1', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['128', '129', '130', '131', '-0', '255', '32766', '32767'],
+                          ['32767', '32766', '255', '-0', '131', '130', '129', '28']], ['-1', '-1', '-1', '0', '-1', '0', '0', '0'], ['i16x8', 'i16x8', 'i16x8']])
+
+        # i16x8.lt_s  (i16x8) (i8x16)
+        case_data.append(['#', 'i16x8.lt_s  (i16x8) (i8x16)'])
+        case_data.append(['lt_s', ['0xFFFF', '0xFF'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_s', ['65535', '255'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_s', ['0', '0'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_s', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_s', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_s', [['-128', '-128', '0', '0', '1', '1', '255', '255'], ['-128', '0', '1', '255']],
+                          ['0', '0', '0', '0', '-1', '-1', '0', '0'], ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_s', ['0x5555', '0xAA'], '0', ['i16x8', 'i8x16', 'i16x8']])
+
+        # i16x8.lt_s  (i16x8) (i32x4)
+        case_data.append(['#', 'i16x8.lt_s  (i16x8) (i32x4)'])
+        case_data.append(['lt_s', ['0xFFFF', '0xFFFFFFFF'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_s', ['65535', '4294967295'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_s', ['0', '0'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_s', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_s', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_s', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['0', '-1', '0', '0', '0', '0', '0', '0'], ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_s', ['0x5555', '0xAAAAAAAA'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_s', ['012_345', '12345'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['0x0_1234', '0x1234'], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # lt_u
+        # i16x8.lt_u  (i16x8) (i16x8)
+        case_data.append(['#', 'lt_u'])
+        case_data.append(['#', 'i16x8.lt_u  (i16x8) (i16x8)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['lt_u', ['0xFFFF', '0xFFFF'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', ['0x0000', '0x0000'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', ['0xF0F0', '0xF0F0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', ['0x0F0F', '0x0F0F'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['0xFFFF', '0x0000'], ['0xFFFF', '0x0000']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['0x0000', '0xFFFF'], ['0x0000', '0xFFFF']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB'],
+                          ['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['lt_u', ['0xFFFF', '65535'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', ['0xFFFF', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', ['0x8080', '32896'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', ['0x8080', '-32640'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['0x8180', '0x8382', '0xFEFD', '0x00FF', '0x0100', '0x7F02', '0xFD80', '0xFFFE'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['lt_u', ['-1', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', ['0', '0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', ['255', '255'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', ['65535', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['255', '0'], ['255', '0']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['0', '255'], ['0', '255']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['255', '32767', '-0', '0', '1', '2', '65534', '65535'],
+                          ['255', '32767', '0', '0', '1', '2', '-2', '-1']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['lt_u', [['0x0000', '0xc300', '0x0000', '0xc2fe', '0x0000', '0xbf80', '0x0000', '0x0000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i16x8', 'f32x4', 'i16x8']])
+        case_data.append(['lt_u', [['0x0000', '0x3f80', '0x0000', '0x42fe', '0x0000', '0x4300', '0x0000', '0x437f'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i16x8', 'f32x4', 'i16x8']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['lt_u', ['0x0F0F', '0xF0F0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['0x0000', '0xFFFF'], ['0xFFFF', '0x0000']], ['-1', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['0x0001', '0x0203', '0x0409', '0x1011', '0x120A', '0x0B1A', '0x1BAA', '0xABFF'],
+                          ['0xFFAB', '0xAA1B', '0x1A0B', '0x0A12', '0x1110', '0x0904', '0x0302', '0x0100']], ['-1', '-1', '-1', '0', '0', '0', '0', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['0x8081', '0x8283', '0xFDFE', '0xFF00', '0x0001', '0x027F', '0x80FD', '0xFEFF'],
+                          ['65279', '33021', '639', '1', '65280', '65022', '33411', '32897']], ['-1', '0', '0', '0', '-1', '-1', '-1', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['128', '129', '130', '131', '-0', '255', '32766', '32767'],
+                          ['32767', '32766', '255', '-0', '131', '130', '129', '28']], ['-1', '-1', '-1', '0', '-1', '0', '0', '0'], ['i16x8', 'i16x8', 'i16x8']])
+
+        # i16x8.lt_u  (i16x8) (i8x16)
+        case_data.append(['#', 'i16x8.lt_u  (i16x8) (i8x16)'])
+        case_data.append(['lt_u', ['0xFFFF', '0xFF'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_u', ['65535', '255'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_u', ['0', '0'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_u', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_u', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_u', [['-128', '-128', '0', '0', '1', '1', '255', '255'], ['-128', '0', '1', '255']], ['0', '-1'], ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_u', ['0x5555', '0xAA'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+
+        # i16x8.lt_u  (i16x8) (i32x4)
+        case_data.append(['#', 'i16x8.lt_u  (i16x8) (i32x4)'])
+        case_data.append(['lt_u', ['0xFFFF', '0xFFFFFFFF'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_u', ['65535', '4294967295'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_u', ['0', '0'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_u', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_u', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_u', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']],
+                          ['0', '-1', '0', '0', '0', '0', '0', '0'], ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_u', ['0x5555', '0xAAAAAAAA'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_u', ['012_345', '12345'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', ['0x0_1234', '0x1234'], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # le_s
+        # i16x8.le_s  (i16x8) (i16x8)
+        case_data.append(['#', 'le_s'])
+        case_data.append(['#', 'i16x8.le_s  (i16x8) (i16x8)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['le_s', ['0xFFFF', '0xFFFF'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', ['0x0000', '0x0000'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', ['0xF0F0', '0xF0F0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', ['0x0F0F', '0x0F0F'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['0xFFFF', '0x0000'], ['0xFFFF', '0x0000']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['0x0000', '0xFFFF'], ['0x0000', '0xFFFF']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB'],
+                          ['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['le_s', ['0xFFFF', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', ['0xFFFF', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', ['0x8080', '32896'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', ['0x8080', '-32640'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['0x8180', '0x8382', '0xFEFD', '0x00FF', '0x0100', '0x7F02', '0xFD80', '0xFFFE'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['le_s', ['-1', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', ['0', '0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', ['65535', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', ['65535', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['65535', '0'], ['65535', '0']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['0', '65535'], ['0', '65535']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['-32768', '65534', '-1', '-0', '0', '1', '2', '65535'],
+                          ['32768', '-2', '-1', '-0', '0', '1', '2', '-1']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['le_s', [['0x0000', '0xc300', '0x0000', '0xc2fe', '0x0000', '0xbf80', '0x0000', '0x0000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i16x8', 'f32x4', 'i16x8']])
+        case_data.append(['le_s', [['0x0000', '0x3f80', '0x0000', '0x42fe', '0x0000', '0x4300', '0x0000', '0x437f'],
+                          ['1.0', '127.0', '128.0', '255.0']], '-1', ['i16x8', 'f32x4', 'i16x8']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['le_s', ['0x0F0F', '0xF0F0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['0x0000', '0xFFFF'], ['0xFFFF', '0x0000']], ['0', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['0x0001', '0x0203', '0x0409', '0x1011', '0x120A', '0x0B1A', '0x1BAA', '0xABFF'],
+                          ['0xFFAB', '0xAA1B', '0x1A0B', '0x0A12', '0x1110', '0x0904', '0x0302', '0x0100']], ['0', '0', '-1', '0', '0', '0', '0', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['0x8000', '0x8001', '0x8002', '0x8003', '0x8004', '0x8005', '0x8006', '0x8007'],
+                          ['32775', '32774', '32773', '32772', '32771', '32770', '32769', '32768']], ['-1', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['32768', '32769', '65534', '65535', '0', '-1', '-32767', '-32768'],
+                          ['-32768', '-32767', '-1', '0', '65535', '65534', '32769', '32768']], ['-1', '-1', '-1', '-1', '0', '0', '-1', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+
+        # i16x8.le_s  (i16x8) (i8x16)
+        case_data.append(['#', 'i16x8.le_s  (i16x8) (i8x16)'])
+        case_data.append(['le_s', ['0xFFFF', '0xFF'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_s', ['65535', '255'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_s', ['0', '0'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_s', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_s', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_s', [['-128', '-128', '0', '0', '1', '1', '255', '255'], ['-128', '0', '1', '255']],
+                          ['0', '0', '-1', '-1', '-1', '-1', '0', '0'], ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_s', ['0x5555', '0xAA'], '0', ['i16x8', 'i8x16', 'i16x8']])
+
+        # i16x8.le_s  (i16x8) (i32x4)
+        case_data.append(['#', 'i16x8.le_s  (i16x8) (i32x4)'])
+        case_data.append(['le_s', ['0xFFFF', '0xFFFFFFFF'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_s', ['65535', '4294967295'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_s', ['0', '0'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_s', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_s', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_s', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['-1', '-1', '-1', '-1', '-1', '0', '-1', '0'], ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_s', ['0x5555', '0xAAAAAAAA'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_s', ['012_345', '12345'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', ['0x0_1234', '0x1234'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # le_u
+        # i16x8.le_u  (i16x8) (i16x8)
+        case_data.append(['#', 'le_u'])
+        case_data.append(['#', 'i16x8.le_u  (i16x8) (i16x8)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['le_u', ['0xFFFF', '0xFFFF'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', ['0x0000', '0x0000'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', ['0xF0F0', '0xF0F0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', ['0x0F0F', '0x0F0F'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['0xFFFF', '0x0000'], ['0xFFFF', '0x0000']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['0x0000', '0xFFFF'], ['0x0000', '0xFFFF']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB'],
+                          ['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['le_u', ['0xFFFF', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', ['0xFFFF', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', ['0x8080', '32896'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', ['0x8080', '-32640'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['0x8180', '0x8382', '0xFEFD', '0x00FF', '0x0100', '0x7F02', '0xFD80', '0xFFFE'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['le_u', ['-1', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', ['0', '0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', ['65535', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', ['65535', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['65535', '0'], ['65535', '0']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['0', '65535'], ['0', '65535']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['-32768', '65534', '-1', '-0', '0', '1', '2', '65535'], ['32768', '-2', '-1', '-0', '0', '1', '2', '-1']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['le_u', [['0x0000', '0xc300', '0x0000', '0xc2fe', '0x0000', '0xbf80', '0x0000', '0x0000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i16x8', 'f32x4', 'i16x8']])
+        case_data.append(['le_u', [['0x0000', '0x3f80', '0x0000', '0x42fe', '0x0000', '0x4300', '0x0000', '0x437f'],
+                          ['1.0', '127.0', '128.0', '255.0']], '-1', ['i16x8', 'f32x4', 'i16x8']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['le_u', ['0x0F0F', '0xF0F0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['0x0000', '0xFFFF'], ['0xFFFF', '0x0000']], ['-1', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['0x0001', '0x0203', '0x0409', '0x1011', '0x120A', '0x0B1A', '0x1BAA', '0xABFF'],
+                          ['0xFFAB', '0xAA1B', '0x1A0B', '0x0A12', '0x1110', '0x0904', '0x0302', '0x0100']], ['-1', '-1', '-1', '0', '0', '0', '0', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['0x8000', '0x8001', '0x8002', '0x8003', '0x8004', '0x8005', '0x8006', '0x8007'],
+                          ['32775', '32774', '32773', '32772', '32771', '32770', '32769', '32768']], ['-1', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['32768', '32769', '65534', '65535', '0', '-1', '-32767', '-32768'],
+                          ['-32768', '-32767', '-1', '0', '65535', '65534', '32769', '32768']], ['-1', '-1', '-1', '0', '-1', '0', '-1', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+
+        # i16x8.le_u  (i16x8) (i8x16)
+        case_data.append(['#', 'i16x8.le_u  (i16x8) (i8x16)'])
+        case_data.append(['le_u', ['0xFFFF', '0xFF'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_u', ['65535', '255'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_u', ['0', '0'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_u', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_u', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_u', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['0', '0', '-1', '-1', '-1', '-1', '-1', '-1'], ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_u', ['0x5555', '0xAA'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+
+        # i16x8.le_u  (i16x8) (i32x4)
+        case_data.append(['#', 'i16x8.le_u  (i16x8) (i32x4)'])
+        case_data.append(['le_u', ['0xFFFF', '0xFFFFFFFF'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_u', ['65535', '4294967295'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_u', ['0', '0'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_u', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_u', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_u', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['-1', '-1', '-1', '-1', '-1', '0', '-1', '0'], ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_u', ['0x5555', '0xAAAAAAAA'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_u', ['012_345', '12345'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', ['0x0_edcb', '-0x1234'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # gt_s
+        # i16x8.gt_s  (i16x8) (i16x8)
+        case_data.append(['#', 'gt_s'])
+        case_data.append(['#', 'i16x8.gt_s  (i16x8) (i16x8)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['gt_s', ['0xFFFF', '0xFFFF'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', ['0x0000', '0x0000'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', ['0xF0F0', '0xF0F0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', ['0x0F0F', '0x0F0F'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['0xFFFF', '0x0000'], ['0xFFFF', '0x0000']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['0x0000', '0xFFFF'], ['0x0000', '0xFFFF']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB'],
+                          ['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['gt_s', ['0xFFFF', '65535'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', ['0xFFFF', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', ['0x8080', '32896'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', ['0x8080', '-32640'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['0x8180', '0x8382', '0xFEFD', '0x00FF', '0x0100', '0x7F02', '0xFD80', '0xFFFE'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['gt_s', ['-1', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', ['0', '0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', ['65535', '65535'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', ['65535', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['65535', '0'], ['65535', '0']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['0', '65535'], ['0', '65535']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['-32768', '65534', '-1', '-0', '0', '1', '2', '65535'], ['32768', '-2', '-1', '-0', '0', '1', '2', '-1']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['gt_s', [['0x0000', '0xc300', '0x0000', '0xc2fe', '0x0000', '0xbf80', '0x0000', '0x0000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i16x8', 'f32x4', 'i16x8']])
+        case_data.append(['gt_s', [['0x0000', '0x3f80', '0x0000', '0x42fe', '0x0000', '0x4300', '0x0000', '0x437f'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i16x8', 'f32x4', 'i16x8']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['gt_s', ['0x0F0F', '0xF0F0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['0x0000', '0xFFFF'], ['0xFFFF', '0x0000']], ['-1', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['0x0001', '0x0203', '0x0409', '0x1011', '0x120A', '0x0B1A', '0x1BAA', '0xABFF'],
+                          ['0xFFAB', '0xAA1B', '0x1A0B', '0x0A12', '0x1110', '0x0904', '0x0302', '0x0100']], ['-1', '-1', '0', '-1', '-1', '-1', '-1', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['0x8000', '0x8001', '0x8002', '0x8003', '0x8004', '0x8005', '0x8006', '0x8007'],
+                          ['32775', '32774', '32773', '32772', '32771', '32770', '32769', '32768']], ['0', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['32768', '32769', '65534', '65535', '0', '-1', '-32767', '-32768'],
+                          ['-32768', '-32767', '-1', '0', '65535', '65534', '32769', '32768']], ['0', '0', '0', '0', '-1', '-1', '0', '0'], ['i16x8', 'i16x8', 'i16x8']])
+
+        # i16x8.gt_s  (i16x8) (i8x16)
+        case_data.append(['#', 'i16x8.gt_s  (i16x8) (i8x16)'])
+        case_data.append(['gt_s', ['0xFFFF', '0xFF'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_s', ['65535', '255'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_s', ['0', '0'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_s', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_s', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_s', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['-1', '0', '0', '-1'], ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_s', ['0x5555', '0xAA'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+
+        # i16x8.gt_s  (i16x8) (i32x4)
+        case_data.append(['#', 'i16x8.gt_s  (i16x8) (i32x4)'])
+        case_data.append(['gt_s', ['0xFFFF', '0xFFFFFFFF'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_s', ['65535', '4294967295'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_s', ['0', '0'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_s', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_s', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_s', [['65535', '0', '1', '32768'], ['65535', '0', '1', '32768']], ['0', '0', '0', '0', '0', '-1', '0', '0'], ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_s', ['0x5555', '0xAAAAAAAA'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_s', ['012_345', '12345'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', ['0x0_1234', '0x1234'], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # gt_u
+        # i16x8.gt_u  (i16x8) (i16x8)
+        case_data.append(['#', 'gt_u'])
+        case_data.append(['#', 'i16x8.gt_u  (i16x8) (i16x8)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['gt_u', ['0xFFFF', '0xFFFF'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', ['0x0000', '0x0000'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', ['0xF0F0', '0xF0F0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', ['0x0F0F', '0x0F0F'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', [['0xFFFF', '0x0000'], ['0xFFFF', '0x0000']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', [['0x0000', '0xFFFF'], ['0x0000', '0xFFFF']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', [['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB'],
+                          ['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['gt_u', ['0xFFFF', '65535'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', ['0xFFFF', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', ['0x8080', '32896'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', ['0x8080', '-32640'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', [['0x8180', '0x8382', '0xFEFD', '0x00FF', '0x0100', '0x7F02', '0xFD80', '0xFFFE'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['eq', ['-1', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['0', '0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['65535', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['65535', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['65535', '0'], ['65535', '0']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['0', '65535'], ['0', '65535']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['-32768', '65534', '-1', '-0', '0', '1', '2', '65535'],
+                          ['32768', '-2', '-1', '-0', '0', '1', '2', '-1']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['gt_u', [['0x0000', '0xc300', '0x0000', '0xc2fe', '0x0000', '0xbf80', '0x0000', '0x0000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i16x8', 'f32x4', 'i16x8']])
+        case_data.append(['gt_u', [['0x0000', '0x3f80', '0x0000', '0x42fe', '0x0000', '0x4300', '0x0000', '0x437f'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i16x8', 'f32x4', 'i16x8']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['gt_u', ['0x0F0F', '0xF0F0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', [['0x0000', '0xFFFF'], ['0xFFFF', '0x0000']], ['0', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', [['0x0001', '0x0203', '0x0409', '0x1011', '0x120A', '0x0B1A', '0x1BAA', '0xABFF'],
+                          ['0xFFAB', '0xAA1B', '0x1A0B', '0x0A12', '0x1110', '0x0904', '0x0302', '0x0100']], ['0', '0', '0', '-1', '-1', '-1', '-1', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', [['0x8000', '0x8001', '0x8002', '0x8003', '0x8004', '0x8005', '0x8006', '0x8007'],
+                          ['32775', '32774', '32773', '32772', '32771', '32770', '32769', '32768']], ['0', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', [['32768', '32769', '65534', '65535', '0', '-1', '-32767', '-32768'],
+                          ['-32768', '-32767', '-1', '0', '65535', '65534', '32769', '32768']], ['0', '0', '0', '-1', '0', '-1', '0', '0'], ['i16x8', 'i16x8', 'i16x8']])
+
+        # i16x8.gt_u  (i16x8) (i8x16)
+        case_data.append(['#', 'i16x8.gt_u  (i16x8) (i8x16)'])
+        case_data.append(['gt_u', ['0xFFFF', '0xFF'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_u', ['65535', '255'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_u', ['0', '0'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_u', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_u', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_u', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['-1', '0', '0', '0'], ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_u', ['0x5555', '0xAA'], '0', ['i16x8', 'i8x16', 'i16x8']])
+
+        # i16x8.gt_u  (i16x8) (i32x4)
+        case_data.append(['#', 'i16x8.gt_u  (i16x8) (i32x4)'])
+        case_data.append(['gt_u', ['0xFFFF', '0xFFFFFFFF'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_u', ['65535', '4294967295'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_u', ['0', '0'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_u', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_u', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_u', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['0', '0', '0', '0', '0', '-1', '0', '-1'], ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_u', ['0x5555', '0xAAAAAAAA'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_u', ['012_345', '12345'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', ['0x0_1234', '0x1234'], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # ge_s
+        # i16x8.ge_s  (i16x8) (i16x8)
+        case_data.append(['#', 'ge_s'])
+        case_data.append(['#', 'i16x8.ge_s  (i16x8) (i16x8)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ge_s', ['0xFFFF', '0xFFFF'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', ['0x0000', '0x0000'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', ['0xF0F0', '0xF0F0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', ['0x0F0F', '0x0F0F'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['0xFFFF', '0x0000'], ['0xFFFF', '0x0000']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['0x0000', '0xFFFF'], ['0x0000', '0xFFFF']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB'],
+                          ['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['ge_s', ['0xFFFF', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', ['0xFFFF', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', ['0x8080', '32896'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', ['0x8080', '-32640'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['0x8180', '0x8382', '0xFEFD', '0x00FF', '0x0100', '0x7F02', '0xFD80', '0xFFFE'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['ge_s', ['-1', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', ['0', '0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', ['65535', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', ['65535', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['65535', '0'], ['65535', '0']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['0', '65535'], ['0', '65535']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['-32768', '65534', '-1', '-0', '0', '1', '2', '65535'], ['32768', '-2', '-1', '-0', '0', '1', '2', '-1']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['ge_s', [['0x0000', '0xc300', '0x0000', '0xc2fe', '0x0000', '0xbf80', '0x0000', '0x0000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i16x8', 'f32x4', 'i16x8']])
+        case_data.append(['ge_s', [['0x0000', '0x3f80', '0x0000', '0x42fe', '0x0000', '0x4300', '0x0000', '0x437f'],
+                          ['1.0', '127.0', '128.0', '255.0']], '-1', ['i16x8', 'f32x4', 'i16x8']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['ge_s', ['0x0F0F', '0xF0F0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['0x0000', '0xFFFF'], ['0xFFFF', '0x0000']], ['-1', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['0x0001', '0x0203', '0x0409', '0x1011', '0x120A', '0x0B1A', '0x1BAA', '0xABFF'],
+                          ['0xFFAB', '0xAA1B', '0x1A0B', '0x0A12', '0x1110', '0x0904', '0x0302', '0x0100']], ['-1', '-1', '0', '-1', '-1', '-1', '-1', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['0x8000', '0x8001', '0x8002', '0x8003', '0x8004', '0x8005', '0x8006', '0x8007'],
+                          ['32775', '32774', '32773', '32772', '32771', '32770', '32769', '32768']], ['0', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['32768', '32769', '65534', '65535', '0', '-1', '-32767', '-32768'],
+                          ['-32768', '-32767', '-1', '0', '65535', '65534', '32769', '32768']], ['-1', '-1', '0', '0', '-1', '-1', '-1', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+
+        # i16x8.ge_s  (i16x8) (i8x16)
+        case_data.append(['#', 'i16x8.ge_s  (i16x8) (i8x16)'])
+        case_data.append(['ge_s', ['0xFFFF', '0xFF'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_s', ['65535', '255'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_s', ['0', '0'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_s', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_s', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_s', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['-1', '-1', '-1', '-1', '0', '0', '-1', '-1'], ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_s', ['0xAAAA', '0x55'], '0', ['i16x8', 'i8x16', 'i16x8']])
+
+        # i16x8.ge_s  (i16x8) (i32x4)
+        case_data.append(['#', 'i16x8.ge_s  (i16x8) (i32x4)'])
+        case_data.append(['ge_s', ['0xFFFF', '0xFFFFFFFF'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_s', ['65535', '4294967295'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_s', ['0', '0'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_s', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_s', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_s', [['65535', '0', '1', '32768'], ['65535', '0', '1', '32768']], ['-1', '0', '-1', '-1', '-1', '-1', '-1', '0'], ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_s', ['0x5555', '0xAAAAAAAA'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_s', ['012_345', '12345'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', ['0x0_1234', '0x1234'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # ge_u
+        # i16x8.ge_u  (i16x8) (i16x8)
+        case_data.append(['#', 'ge_u'])
+        case_data.append(['#', 'i16x8.ge_u  (i16x8) (i16x8)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ge_u', ['0xFFFF', '0xFFFF'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', ['0x0000', '0x0000'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', ['0xF0F0', '0xF0F0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', ['0x0F0F', '0x0F0F'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['0xFFFF', '0x0000'], ['0xFFFF', '0x0000']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['0x0000', '0xFFFF'], ['0x0000', '0xFFFF']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB'],
+                          ['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['ge_u', ['0xFFFF', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', ['0xFFFF', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', ['0x8080', '32896'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', ['0x8080', '-32640'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['0x8180', '0x8382', '0xFEFD', '0x00FF', '0x0100', '0x7F02', '0xFD80', '0xFFFE'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['ge_u', ['-1', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', ['0', '0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', ['65535', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', ['65535', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['65535', '0'], ['65535', '0']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['0', '65535'], ['0', '65535']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['-32768', '65534', '-1', '-0', '0', '1', '2', '65535'], ['32768', '-2', '-1', '-0', '0', '1', '2', '-1']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['ge_u', [['0x0000', '0xc300', '0x0000', '0xc2fe', '0x0000', '0xbf80', '0x0000', '0x0000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i16x8', 'f32x4', 'i16x8']])
+        case_data.append(['ge_u', [['0x0000', '0x3f80', '0x0000', '0x42fe', '0x0000', '0x4300', '0x0000', '0x437f'],
+                          ['1.0', '127.0', '128.0', '255.0']], '-1', ['i16x8', 'f32x4', 'i16x8']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['ge_u', ['0x0F0F', '0xF0F0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['0x0000', '0xFFFF'], ['0xFFFF', '0x0000']], ['0', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['0x0001', '0x0203', '0x0409', '0x1011', '0x120A', '0x0B1A', '0x1BAA', '0xABFF'],
+                          ['0xFFAB', '0xAA1B', '0x1A0B', '0x0A12', '0x1110', '0x0904', '0x0302', '0x0100']], ['0', '0', '0', '-1', '-1', '-1', '-1', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['0x8000', '0x8001', '0x8002', '0x8003', '0x8004', '0x8005', '0x8006', '0x8007'],
+                          ['32775', '32774', '32773', '32772', '32771', '32770', '32769', '32768']], ['0', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['32768', '32769', '65534', '65535', '0', '-1', '-32767', '-32768'],
+                          ['-32768', '-32767', '-1', '0', '65535', '65534', '32769', '32768']], ['-1', '-1', '0', '-1', '0', '-1', '-1', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+
+        # i16x8.ge_u  (i16x8) (i8x16)
+        case_data.append(['#', 'i16x8.ge_u  (i16x8) (i8x16)'])
+        case_data.append(['ge_u', ['0xFFFF', '0xFF'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_u', ['65535', '255'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_u', ['0', '0'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_u', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_u', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_u', [['-128', '-128', '0', '0', '1', '1', '255', '255'], ['-128', '0', '1', '255']], ['-1', '0'], ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_u', ['0xAAAA', '0x55'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+
+        # i16x8.ge_u  (i16x8) (i32x4)
+        case_data.append(['#', 'i16x8.ge_u  (i16x8) (i32x4)'])
+        case_data.append(['ge_u', ['0xFFFF', '0xFFFFFFFF'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_u', ['65535', '4294967295'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_u', ['0', '0'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_u', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_u', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_u', [['65535', '0', '1', '32768'], ['-128', '0', '1', '255']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_u', ['0x5555', '0xAAAAAAAA'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_u', ['012_345', '12345'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', ['0x0_1234', '0x1234'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        return case_data
+
+
+def gen_test_cases():
+    i16x8 = Simdi16x8CmpCase()
+    i16x8.gen_test_cases()
+
+
+if __name__ == '__main__':
+    i16x8 = Simdi16x8CmpCase()
+    i16x8.gen_test_cases()
diff --git a/test/core/simd/meta/simd_i16x8_q15mulr_sat_s.py b/test/core/simd/meta/simd_i16x8_q15mulr_sat_s.py
new file mode 100644
index 000000000..bf59331f2
--- /dev/null
+++ b/test/core/simd/meta/simd_i16x8_q15mulr_sat_s.py
@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+
+from simd_arithmetic import SimdArithmeticCase
+
+
+"""Generate test cases for i16x8.mulr_sat_s
+"""
+class SimdI16x8Q15MulRSatS(SimdArithmeticCase):
+    LANE_TYPE = 'i16x8'
+    UNARY_OPS = ()
+    BINARY_OPS = ('q15mulr_sat_s',)
+
+    @property
+    def full_bin_test_data(self):
+        return []
+
+    @property
+    def hex_binary_op_test_data(self):
+        return []
+
+    def get_combine_cases(self):
+        return ''
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_i16x8_q15mulr_sat_s.wast'
+        with open(wast_filename, 'w') as fp:
+            fp.write(self.get_all_cases())
+
+
+def gen_test_cases():
+    simd_i16x8_q16mulr_sat_s = SimdI16x8Q15MulRSatS()
+    simd_i16x8_q16mulr_sat_s.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_i32x4_arith.py b/test/core/simd/meta/simd_i32x4_arith.py
new file mode 100644
index 000000000..b402b02cb
--- /dev/null
+++ b/test/core/simd/meta/simd_i32x4_arith.py
@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+
+"""
+Generate i32x4 integer arithmetic operation cases.
+"""
+
+from simd_arithmetic import SimdArithmeticCase
+
+
+class SimdI32x4ArithmeticCase(SimdArithmeticCase):
+
+    LANE_LEN = 4
+    LANE_TYPE = 'i32x4'
+
+    @property
+    def hex_binary_op_test_data(self):
+        return [
+            ('0x3fffffff', '0x40000000'),
+            ('0x40000000', '0x40000000'),
+            ('-0x3fffffff', '-0x40000000'),
+            ('-0x40000000', '-0x40000000'),
+            ('-0x40000000', '-0x40000001'),
+            ('0x7fffffff', '0x7fffffff'),
+            ('0x7fffffff', '0x01'),
+            ('0x80000000', '-0x01'),
+            ('0x7fffffff', '0x80000000'),
+            ('0x80000000', '0x80000000'),
+            ('0xffffffff', '0x01'),
+            ('0xffffffff', '0xffffffff')
+        ]
+
+    @property
+    def hex_unary_op_test_data(self):
+        return ['0x01', '-0x01', '-0x80000000', '-0x7fffffff', '0x7fffffff', '0x80000000', '0xffffffff']
+
+    @property
+    def underscore_literal_test_data(self):
+        return {
+            'i32x4.add': [
+                [['01_234_567_890', '01_234_567_890'], '02_469_135_780', ['i32x4'] * 3],
+                [['0x0_1234_5678', '0x0_90AB_cdef'], '0x0_a2e0_2467', ['i32x4'] * 3]
+            ],
+            'i32x4.sub': [
+                [['03_214_567_890 ', '01_234_567_890 '], '01_980_000_000', ['i32x4'] * 3],
+                [['0x0_90AB_cdef', '0x0_1234_5678'], '0x0_7e77_7777', ['i32x4'] * 3]
+            ],
+            'i32x4.mul': [
+                [['0_123_456_789', '0_987_654_321'], '04_227_814_277', ['i32x4'] * 3],
+                [['0x0_1234_5678', '0x0_90AB_cdef'], '0x0_2a42_d208', ['i32x4'] * 3]
+            ]
+        }
+
+    @property
+    def i32x4_i8x16_test_data(self):
+        return {
+            'i32x4.add': [
+                [['0x7fffffff', ['0', '0', '0', '0x80'] * 4], '-1', ['i32x4', 'i8x16', 'i32x4']],
+                [['1', '255'], '0', ['i32x4', 'i8x16', 'i32x4']]
+            ],
+            'i32x4.sub': [
+                [['0x7fffffff', ['0', '0', '0', '0x80'] * 4], '-1', ['i32x4', 'i8x16', 'i32x4']],
+                [['1', '255'], '2', ['i32x4', 'i8x16', 'i32x4']]
+            ],
+            'i32x4.mul': [
+                [['0x10000000', '0x10'], '0', ['i32x4', 'i8x16', 'i32x4']],
+                [['0xffffffff', '255'], '1', ['i32x4', 'i8x16', 'i32x4']]
+            ]
+        }
+
+    @property
+    def i32x4_i16x8_test_data(self):
+        return {
+            'i32x4.add': [
+                [['0x7fffffff', ['0', '0x8000'] * 4], '-1', ['i32x4', 'i16x8', 'i32x4']],
+                [['1', '0xffff'], '0', ['i32x4', 'i16x8', 'i32x4']]
+            ],
+            'i32x4.sub': [
+                [['0x7fffffff', ['0', '0x8000'] * 4], '-1', ['i32x4', 'i16x8', 'i32x4']],
+                [['1', '0xffff'], '0x02', ['i32x4', 'i16x8', 'i32x4']]
+            ],
+            'i32x4.mul': [
+                [['0x80000000', ['0', '0x02'] * 4], '0', ['i32x4', 'i16x8', 'i32x4']],
+                [['0xffffffff', '0xffff'], '1', ['i32x4', 'i16x8', 'i32x4']]
+            ]
+        }
+
+    @property
+    def i32x4_f32x4_test_data(self):
+        return {
+            'i32x4.add': [
+                [['0x80000000', '+0.0'], '0x80000000', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x80000000', '-0.0'], '0', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x80000000', '1.0'], '0xbf800000', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x80000000', '-1.0'], '0x3f800000', ['i32x4', 'f32x4', 'i32x4']],
+                [['1', '+inf'], '0x7f800001', ['i32x4', 'f32x4', 'i32x4']],
+                [['1', '-inf'], '0xff800001', ['i32x4', 'f32x4', 'i32x4']],
+                [['1', 'nan'], '0x7fc00001', ['i32x4', 'f32x4', 'i32x4']]
+            ],
+            'i32x4.sub': [
+                [['0x80000000', '+0.0'], '0x80000000', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x80000000', '-0.0'], '0', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x80000000', '1.0'], '0x40800000', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x80000000', '-1.0'], '0xc0800000', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x1', '+inf'], '0x80800001', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x1', '-inf'], '0x00800001', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x1', 'nan'], '0x80400001', ['i32x4', 'f32x4', 'i32x4']]
+            ],
+            'i32x4.mul': [
+                [['0x8000', '+0.0'], '0', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x8000', '-0.0'], '0', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x8000', '1.0'], '0', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x8000', '-1.0'], '0', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x1', '+inf'], '0x7f800000', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x1', '-inf'], '0xff800000', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x1', 'nan'], '0x7fc00000', ['i32x4', 'f32x4', 'i32x4']]
+            ]
+        }
+
+    @property
+    def combine_dec_hex_test_data(self):
+        return {
+            'i32x4.add': [
+                [[['0', '1', '2', '3'],
+                  ['0', '0xffffffff', '0xfffffffe', '0xfffffffd']],
+                 ['0'] * 16, ['i32x4'] * 3]
+            ],
+            'i32x4.sub': [
+                [[['0', '1', '2', '3'],
+                  ['0', '0xffffffff', '0xfffffffe', '0xfffffffd']],
+                 ['0', '0x02', '0x04', '0x06'], ['i32x4'] * 3]
+            ],
+            'i32x4.mul': [
+                [[['0', '1', '2', '3'],
+                  ['0', '0xffffffff', '0xfffffffe', '0xfffffffd']],
+                 ['0', '0xffffffff', '0xfffffffc', '0xfffffff7'],
+                 ['i32x4'] * 3]
+            ]
+        }
+
+    @property
+    def range_test_data(self):
+        return {
+            'i32x4.add': [
+                [[[str(i) for i in range(4)], [str(i * 2) for i in range(4)]],
+                 [str(i * 3) for i in range(4)], ['i32x4'] * 3]
+            ],
+            'i32x4.sub': [
+                [[[str(i) for i in range(4)], [str(i * 2) for i in range(4)]],
+                 [str(-i) for i in range(4)], ['i32x4'] * 3]
+            ],
+            'i32x4.mul': [
+                [[[str(i) for i in range(4)], [str(i * 2) for i in range(4)]],
+                 ['0', '0x02', '0x08', '0x12'],
+                 ['i32x4'] * 3]
+            ]
+        }
+
+    @property
+    def full_bin_test_data(self):
+        return [
+            self.i32x4_i8x16_test_data,
+            self.i32x4_i16x8_test_data,
+            self.i32x4_f32x4_test_data,
+            self.combine_dec_hex_test_data,
+            self.range_test_data,
+            self.underscore_literal_test_data
+        ]
+
+
+def gen_test_cases():
+    simd_i32x4_arith = SimdI32x4ArithmeticCase()
+    simd_i32x4_arith.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
\ No newline at end of file
diff --git a/test/core/simd/meta/simd_i32x4_cmp.py b/test/core/simd/meta/simd_i32x4_cmp.py
new file mode 100644
index 000000000..41a093ee6
--- /dev/null
+++ b/test/core/simd/meta/simd_i32x4_cmp.py
@@ -0,0 +1,837 @@
+#!/usr/bin/env python3
+
+"""
+This file is used for generating i32x4 related test cases
+which inherites from the 'SimdCmpCase' class and overloads
+with the 'get_test_cases' method.
+"""
+
+from simd_compare import SimdCmpCase
+
+
+# Generate i32x4 test case
+class Simdi32x4CmpCase(SimdCmpCase):
+
+    LANE_TYPE = 'i32x4'
+
+    BINARY_OPS = ['eq', 'ne', 'lt_s', 'lt_u', 'le_s', 'le_u', 'gt_s', 'gt_u', 'ge_s', 'ge_u']
+
+    # Overload base class method and set test data for i32x4.
+    def get_case_data(self):
+
+        case_data = []
+
+        # eq
+        # i32x4.eq  (i32x4) (i32x4)
+        case_data.append(['#', 'eq'])
+        case_data.append(['#', 'i32x4.eq  (i32x4) (i32x4)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['eq', ['0xFFFFFFFF', '0xFFFFFFFF'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', ['0x00000000', '0x00000000'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', ['0xF0F0F0F0', '0xF0F0F0F0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', ['0x0F0F0F0F', '0x0F0F0F0F'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['0xFFFFFFFF', '0x00000000'], ['0xFFFFFFFF', '0x00000000']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['0x00000000', '0xFFFFFFFF'], ['0x00000000', '0xFFFFFFFF']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['eq', ['0xFFFFFFFF', '4294967295'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', ['0xFFFFFFFF', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', ['0x80808080', '2155905152'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', ['0x80808080', '-2139062144'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['0x83828180', '0x00FFFEFD', '0x7F020100', '0xFFFEFD80'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['eq', ['-1', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', ['0', '0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', ['4294967295', '4294967295'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', ['4294967295', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['4294967295', '0'], ['4294967295', '0']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['0', '4294967295'], ['0', '4294967295']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['-2147483647', '4294967295', '0', '-1'], ['2147483649', '-1', '0', '-1']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['eq', [['0xc3000000', '0xc2fe0000', '0xbf800000', '0x00000000'], ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i32x4', 'f32x4', 'i32x4']])
+        case_data.append(['eq', [['0x3f800000', '0x42fe0000', '0x43000000', '0x437f0000'], ['1.0', '127.0', '128.0', '255.0']], '-1', ['i32x4', 'f32x4', 'i32x4']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['eq', ['0x0F0F0F0F', '0xF0F0F0F0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['0x00000000', '0xFFFFFFFF'], ['0xFFFFFFFF', '0x00000000']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['0x02030001', '0x10110409', '0x0B1A120A', '0xABFF1BAA'],
+                          ['0xAA1BFFAB', '0x0A121A0B', '0x09041110', '0x01000302']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['0x80018000', '0x80038002', '0x80058004', '0x80078006'],
+                          ['2147975174', '2147844100', '2147713026', '2147581952']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['2147483648', '2147483647', '0', '-1'], ['-2147483648', '-2147483647', '-1', '0']], ['-1', '0', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+
+        # i32x4.eq  (i32x4) (i8x16)
+        case_data.append(['#', 'i32x4.eq  (i32x4) (i8x16)'])
+        case_data.append(['eq', ['0xFFFFFFFF', '0xFF'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['eq', ['4294967295', '255'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['eq', ['0', '0'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['eq', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['eq', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['eq', [['-8323200', '0', '1', '4294967295'], ['-128', '0', '1', '255']], ['0', '-1', '0', '-1'], ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['eq', ['0x55555555', '0xAA'], '0', ['i32x4', 'i8x16', 'i32x4']])
+
+        # i32x4.eq  (i32x4) (i16x8)
+        case_data.append(['#', 'i32x4.eq  (i32x4) (i16x8)'])
+        case_data.append(['eq', ['0xFFFFFFFF', '0xFFFF'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['eq', ['4294967295', '65535'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['eq', ['0', '0'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['eq', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['eq', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['eq', [['4294967295', '0', '1', '65535'], ['65535', '65535', '0', '0', '1', '0', '65535', '65535']], ['-1', '-1', '-1', '0'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['eq', ['0x55555555', '0xAAAA'], '0', ['i32x4', 'i16x8', 'i32x4']])
+
+        case_data.append(['eq', ['0_123_456_789', '123456789'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', ['0x0_1234_5678', '0x12345678'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # ne
+        # i32x4.ne  (i32x4) (i32x4)
+        case_data.append(['#', 'ne'])
+        case_data.append(['#', 'i32x4.ne  (i32x4) (i32x4)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ne', ['0xFFFFFFFF', '0xFFFFFFFF'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', ['0x00000000', '0x00000000'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', ['0xF0F0F0F0', '0xF0F0F0F0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', ['0x0F0F0F0F', '0x0F0F0F0F'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['0xFFFFFFFF', '0x00000000'], ['0xFFFFFFFF', '0x00000000']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['0x00000000', '0xFFFFFFFF'], ['0x00000000', '0xFFFFFFFF']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['ne', ['0xFFFFFFFF', '4294967295'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', ['0xFFFFFFFF', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', ['0x80808080', '2155905152'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', ['0x80808080', '-2139062144'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['0x83828180', '0x00FFFEFD', '0x7F020100', '0xFFFEFD80'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['ne', ['-1', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', ['0', '0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', ['4294967295', '4294967295'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', ['4294967295', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['4294967295', '0'], ['4294967295', '0']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['0', '4294967295'], ['0', '4294967295']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['-2147483647', '4294967295', '0', '-1'], ['2147483649', '-1', '0', '-1']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['ne', [['0xc3000000', '0xc2fe0000', '0xbf800000', '0x00000000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i32x4', 'f32x4', 'i32x4']])
+        case_data.append(['ne', [['0x3f800000', '0x42fe0000', '0x43000000', '0x437f0000'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i32x4', 'f32x4', 'i32x4']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['ne', ['0x0F0F0F0F', '0xF0F0F0F0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['0x00000000', '0xFFFFFFFF'], ['0xFFFFFFFF', '0x00000000']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['0x02030001', '0x10110409', '0x0B1A120A', '0xABFF1BAA'],
+                          ['0xAA1BFFAB', '0x0A121A0B', '0x09041110', '0x01000302']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['0x80018000', '0x80038002', '0x80058004', '0x80078006'],
+                          ['2147975174', '2147844100', '2147713026', '2147581952']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['2147483648', '2147483647', '0', '-1'], ['-2147483648', '-2147483647', '-1', '0']], ['0', '-1', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+
+        # i32x4.ne  (i32x4) (i8x16)
+        case_data.append(['#', 'i32x4.ne  (i32x4) (i8x16)'])
+        case_data.append(['ne', ['0xFFFFFFFF', '0xFF'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ne', ['4294967295', '255'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ne', ['0', '0'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ne', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ne', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ne', [['-8323200', '0', '1', '4294967295'], ['-128', '0', '1', '255']], ['-1', '0', '-1', '0'], ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ne', ['0x55555555', '0xAA'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+
+        # i32x4.ne  (i32x4) (i16x8)
+        case_data.append(['#', 'i32x4.ne  (i32x4) (i16x8)'])
+        case_data.append(['ne', ['0xFFFFFFFF', '0xFFFF'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ne', ['4294967295', '65535'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ne', ['0', '0'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ne', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ne', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ne', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['-1', '0', '-1', '-1'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ne', ['0xAAAAAAAA', '0x5555'], ['-1', '-1', '-1', '-1'], ['i32x4', 'i16x8', 'i32x4']])
+
+        case_data.append(['ne', ['0_123_456_789', '123456789'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', ['0x0_1234_5678', '0x12345678'], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # lt_s
+        # i32x4.lt_s  (i32x4) (i32x4)
+        case_data.append(['#', 'lt_s'])
+        case_data.append(['#', 'i32x4.lt_s  (i32x4) (i32x4)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['lt_s', ['0xFFFFFFFF', '0xFFFFFFFF'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', ['0x00000000', '0x00000000'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', ['0xF0F0F0F0', '0xF0F0F0F0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', ['0x0F0F0F0F', '0x0F0F0F0F'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['0xFFFFFFFF', '0x00000000'], ['0xFFFFFFFF', '0x00000000']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['0x00000000', '0xFFFFFFFF'], ['0x00000000', '0xFFFFFFFF']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['lt_s', ['0xFFFFFFFF', '4294967295'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', ['0xFFFFFFFF', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', ['0x80808080', '2155905152'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', ['0x80808080', '-2139062144'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['0x83828180', '0x00FFFEFD', '0x7F020100', '0xFFFEFD80'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['lt_s', ['-1', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', ['0', '0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', ['4294967295', '4294967295'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', ['4294967295', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['4294967295', '0'], ['4294967295', '0']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['0', '4294967295'], ['0', '4294967295']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['-2147483647', '4294967295', '0', '-1'],
+                          ['2147483649', '-1', '0', '-1']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['lt_s', [['0xc3000000', '0xc2fe0000', '0xbf800000', '0x00000000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i32x4', 'f32x4', 'i32x4']])
+        case_data.append(['lt_s', [['0x3f800000', '0x42fe0000', '0x43000000', '0x437f0000'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i32x4', 'f32x4', 'i32x4']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['lt_s', ['0x0F0F0F0F', '0xF0F0F0F0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['0x00000000', '0xFFFFFFFF'], ['0xFFFFFFFF', '0x00000000']], ['0', '0', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['0x02030001', '0x10110409', '0x0B1A120A', '0xABFF1BAA'],
+                          ['0xAA1BFFAB', '0x0A121A0B', '0x09041110', '0x01000302']], ['0', '0', '0', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['0x80018000', '0x80038002', '0x80058004', '0x80078006'],
+                          ['2147975174', '2147844100', '2147713026', '2147581952']], ['-1', '-1', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['2147483648', '2147483647', '0', '-1'], ['-2147483648', '-2147483647', '-1', '0']], ['0', '0', '0', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+
+        # i32x4.lt_s  (i32x4) (i8x16)
+        case_data.append(['#', 'i32x4.lt_s  (i32x4) (i8x16)'])
+        case_data.append(['lt_s', ['0xFFFFFFFF', '0xFF'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_s', ['4294967295', '255'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_s', ['0', '0'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_s', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_s', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_s', [['-8323200', '0', '1', '4294967295'], ['-128', '0', '1', '255']], ['0', '0', '-1', '0'], ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_s', ['0x55555555', '0xAA'], '0', ['i32x4', 'i8x16', 'i32x4']])
+
+        # i32x4.lt_s  (i32x4) (i16x8)
+        case_data.append(['#', 'i32x4.lt_s  (i32x4) (i16x8)'])
+        case_data.append(['lt_s', ['0xFFFFFFFF', '0xFFFF'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_s', ['4294967295', '65535'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_s', ['0', '0'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_s', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_s', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_s', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['0', '0', '-1', '-1'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_s', ['0xAAAAAAAA', '0x5555'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+
+        case_data.append(['lt_s', ['0_123_456_789', '123456789'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', ['0x0_90AB_cdef', '-0x6f543210'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # lt_u
+        # i32x4.lt_u  (i32x4) (i32x4)
+        case_data.append(['#', 'lt_u'])
+        case_data.append(['#', 'i32x4.lt_u  (i32x4) (i32x4)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['lt_u', ['0xFFFFFFFF', '0xFFFFFFFF'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', ['0x00000000', '0x00000000'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', ['0xF0F0F0F0', '0xF0F0F0F0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', ['0x0F0F0F0F', '0x0F0F0F0F'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['0xFFFFFFFF', '0x00000000'], ['0xFFFFFFFF', '0x00000000']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['0x00000000', '0xFFFFFFFF'], ['0x00000000', '0xFFFFFFFF']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['lt_u', ['0xFFFFFFFF', '4294967295'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', ['0xFFFFFFFF', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', ['0x80808080', '2155905152'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', ['0x80808080', '-2139062144'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['0x83828180', '0x00FFFEFD', '0x7F020100', '0xFFFEFD80'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['lt_u', ['-1', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', ['0', '0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', ['4294967295', '4294967295'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', ['4294967295', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['4294967295', '0'], ['4294967295', '0']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['0', '4294967295'], ['0', '4294967295']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['-2147483647', '4294967295', '0', '-1'], ['2147483649', '-1', '0', '-1']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['lt_u', [['0xc3000000', '0xc2fe0000', '0xbf800000', '0x00000000'], ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i32x4', 'f32x4', 'i32x4']])
+        case_data.append(['lt_u', [['0x3f800000', '0x42fe0000', '0x43000000', '0x437f0000'], ['1.0', '127.0', '128.0', '255.0']], '0', ['i32x4', 'f32x4', 'i32x4']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['lt_u', ['0x0F0F0F0F', '0xF0F0F0F0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['0x00000000', '0xFFFFFFFF'], ['0xFFFFFFFF', '0x00000000']], ['-1', '-1', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['0x02030001', '0x10110409', '0x0B1A120A', '0xABFF1BAA'],
+                          ['0xAA1BFFAB', '0x0A121A0B', '0x09041110', '0x01000302']], ['-1', '0', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['0x80018000', '0x80038002', '0x80058004', '0x80078006'],
+                          ['2147975174', '2147844100', '2147713026', '2147581952']], ['-1', '-1', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['2147483648', '2147483647', '0', '-1'], ['-2147483648', '-2147483647', '-1', '0']], ['0', '-1', '-1', '0'], ['i32x4', 'i32x4', 'i32x4']])
+
+        # i32x4.lt_u  (i32x4) (i8x16)
+        case_data.append(['#', 'i32x4.lt_u  (i32x4) (i8x16)'])
+        case_data.append(['lt_u', ['0xFFFFFFFF', '0xFF'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_u', ['4294967295', '255'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_u', ['0', '0'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_u', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_u', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_u', [['-8323200', '0', '1', '4294967295'], ['-128', '0', '1', '255']], ['0', '0', '-1', '0'], ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_u', ['0x55555555', '0xAA'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+
+        # i32x4.lt_u  (i32x4) (i16x8)
+        case_data.append(['#', 'i32x4.lt_u  (i32x4) (i16x8)'])
+        case_data.append(['lt_u', ['0xFFFFFFFF', '0xFFFF'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_u', ['4294967295', '65535'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_u', ['0', '0'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_u', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_u', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_u', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['0', '0', '-1', '-1'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_u', ['0xAAAAAAAA', '0x5555'], '0', ['i32x4', 'i16x8', 'i32x4']])
+
+        case_data.append(['lt_u', ['0_123_456_789', '123456789'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', ['0x0_90AB_cdef', '-0x6f543210'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # le_s
+        # i32x4.le_s  (i32x4) (i32x4)
+        case_data.append(['#', 'le_s'])
+
+        case_data.append(['#', 'i32x4.le_s  (i32x4) (i32x4)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['le_s', ['0xFFFFFFFF', '0xFFFFFFFF'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', ['0x00000000', '0x00000000'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', ['0xF0F0F0F0', '0xF0F0F0F0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', ['0x0F0F0F0F', '0x0F0F0F0F'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['0xFFFFFFFF', '0x00000000'], ['0xFFFFFFFF', '0x00000000']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['0x00000000', '0xFFFFFFFF'], ['0x00000000', '0xFFFFFFFF']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['le_s', ['0xFFFFFFFF', '4294967295'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', ['0xFFFFFFFF', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', ['0x80808080', '2155905152'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', ['0x80808080', '-2139062144'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['0x83828180', '0x00FFFEFD', '0x7F020100', '0xFFFEFD80'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['le_s', ['-1', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', ['0', '0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', ['4294967295', '4294967295'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', ['4294967295', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['4294967295', '0'], ['4294967295', '0']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['0', '4294967295'], ['0', '4294967295']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['-2147483647', '4294967295', '0', '-1'],
+                          ['2147483649', '-1', '0', '-1']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['le_s', [['0xc3000000', '0xc2fe0000', '0xbf800000', '0x00000000'], ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i32x4', 'f32x4', 'i32x4']])
+        case_data.append(['le_s', [['0x3f800000', '0x42fe0000', '0x43000000', '0x437f0000'], ['1.0', '127.0', '128.0', '255.0']], '-1', ['i32x4', 'f32x4', 'i32x4']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['le_s', ['0x0F0F0F0F', '0xF0F0F0F0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['0x00000000', '0xFFFFFFFF'], ['0xFFFFFFFF', '0x00000000']], ['0', '0', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['0x02030001', '0x10110409', '0x0B1A120A', '0xABFF1BAA'],
+                          ['0xAA1BFFAB', '0x0A121A0B', '0x09041110', '0x01000302']], ['0', '0', '0', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['0x80018000', '0x80038002', '0x80058004', '0x80078006'],
+                          ['2147975174', '2147844100', '2147713026', '2147581952']], ['-1', '-1', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['2147483648', '2147483647', '0', '-1'], ['-2147483648', '-2147483647', '-1', '0']], ['-1', '0', '0', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+
+        # i32x4.le_s  (i32x4)(i8x16)
+        case_data.append(['#', 'i32x4.le_s  (i32x4)(i8x16)'])
+        case_data.append(['le_s', ['0xFFFFFFFF', '0xFF'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_s', ['4294967295', '255'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_s', ['0', '0'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_s', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_s', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_s', [['-8323200', '0', '1', '4294967295'], ['-128', '0', '1', '255']], ['0', '-1', '-1', '-1'], ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_s', ['0x55555555', '0xAA'], '0', ['i32x4', 'i8x16', 'i32x4']])
+
+        # i32x4.le_s  (i32x4) (i16x8)
+        case_data.append(['#', 'i32x4.le_s  (i32x4) (i16x8)'])
+        case_data.append(['le_s', ['0xFFFFFFFF', '0xFFFF'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_s', ['4294967295', '65535'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_s', ['0', '0'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_s', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_s', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_s', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['0', '-1', '-1', '-1'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_s', ['0xAAAAAAAA', '0x5555'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+
+        case_data.append(['le_s', ['0_123_456_789', '123456789'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', ['0x0_1234_5678', '0x12345678'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # le_u
+        # i32x4.le_u  (i32x4) (i32x4)
+        case_data.append(['#', 'le_u'])
+
+        case_data.append(['#', 'i32x4.le_u  (i32x4) (i32x4)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['le_u', ['0xFFFFFFFF', '0xFFFFFFFF'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', ['0x00000000', '0x00000000'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', ['0xF0F0F0F0', '0xF0F0F0F0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', ['0x0F0F0F0F', '0x0F0F0F0F'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['0xFFFFFFFF', '0x00000000'], ['0xFFFFFFFF', '0x00000000']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['0x00000000', '0xFFFFFFFF'], ['0x00000000', '0xFFFFFFFF']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['le_u', ['0xFFFFFFFF', '4294967295'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', ['0xFFFFFFFF', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', ['0x80808080', '2155905152'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', ['0x80808080', '-2139062144'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['0x83828180', '0x00FFFEFD', '0x7F020100', '0xFFFEFD80'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['le_u', ['-1', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', ['0', '0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', ['4294967295', '4294967295'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', ['4294967295', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['4294967295', '0'], ['4294967295', '0']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['0', '4294967295'], ['0', '4294967295']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['-2147483647', '4294967295', '0', '-1'], ['2147483649', '-1', '0', '-1']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['le_u', [['0xc3000000', '0xc2fe0000', '0xbf800000', '0x00000000'], ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i32x4', 'f32x4', 'i32x4']])
+        case_data.append(['le_u', [['0x3f800000', '0x42fe0000', '0x43000000', '0x437f0000'], ['1.0', '127.0', '128.0', '255.0']], '-1', ['i32x4', 'f32x4', 'i32x4']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['le_u', ['0x0F0F0F0F', '0xF0F0F0F0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['0x00000000', '0xFFFFFFFF'], ['0xFFFFFFFF', '0x00000000']], ['-1', '-1', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['0x02030001', '0x10110409', '0x0B1A120A', '0xABFF1BAA'],
+                          ['0xAA1BFFAB', '0x0A121A0B', '0x09041110', '0x01000302']], ['-1', '0', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['0x80018000', '0x80038002', '0x80058004', '0x80078006'],
+                          ['2147975174', '2147844100', '2147713026', '2147581952']], ['-1', '-1', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['2147483648', '2147483647', '0', '-1'], ['-2147483648', '-2147483647', '-1', '0']], ['-1', '-1', '-1', '0'], ['i32x4', 'i32x4', 'i32x4']])
+
+        # i32x4.le_u  (i32x4) (i8x16)
+        case_data.append(['#', 'i32x4.le_u  (i32x4) (i8x16)'])
+        case_data.append(['le_u', ['0xFFFFFFFF', '0xFF'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_u', ['4294967295', '255'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_u', ['0', '0'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_u', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_u', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_u', [['-8323200', '0', '1', '4294967295'], ['-128', '0', '1', '255']], ['0', '-1', '-1', '-1'], ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_u', ['0x55555555', '0xAA'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+
+        # i32x4.le_u  (i32x4) (i16x8)
+        case_data.append(['#', 'i32x4.le_u  (i32x4) (i16x8)'])
+        case_data.append(['le_u', ['0xFFFFFFFF', '0xFFFF'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_u', ['4294967295', '65535'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_u', ['0', '0'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_u', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_u', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_u', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['0', '-1', '-1', '-1'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_u', ['0xAAAAAAAA', '0x5555'], '0', ['i32x4', 'i16x8', 'i32x4']])
+
+        case_data.append(['le_u', ['0_123_456_789', '123456789'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', ['0x0_90AB_cdef', '0x90ABcdef'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # gt_s
+        # i32x4.gt_s  (i32x4) (i32x4)
+        case_data.append(['#', 'gt_s'])
+
+        case_data.append(['#', 'i32x4.gt_s  (i32x4) (i32x4)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['gt_s', ['0xFFFFFFFF', '0xFFFFFFFF'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', ['0x00000000', '0x00000000'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', ['0xF0F0F0F0', '0xF0F0F0F0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', ['0x0F0F0F0F', '0x0F0F0F0F'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['0xFFFFFFFF', '0x00000000'], ['0xFFFFFFFF', '0x00000000']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['0x00000000', '0xFFFFFFFF'], ['0x00000000', '0xFFFFFFFF']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['gt_s', ['0xFFFFFFFF', '4294967295'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', ['0xFFFFFFFF', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', ['0x80808080', '2155905152'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', ['0x80808080', '-2139062144'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['0x83828180', '0x00FFFEFD', '0x7F020100', '0xFFFEFD80'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['gt_s', ['-1', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', ['0', '0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', ['4294967295', '4294967295'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', ['4294967295', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['4294967295', '0'], ['4294967295', '0']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['0', '4294967295'], ['0', '4294967295']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['-2147483647', '4294967295', '0', '-1'], ['2147483649', '-1', '0', '-1']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['gt_s', [['0xc3000000', '0xc2fe0000', '0xbf800000', '0x00000000'], ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i32x4', 'f32x4', 'i32x4']])
+        case_data.append(['gt_s', [['0x3f800000', '0x42fe0000', '0x43000000', '0x437f0000'], ['1.0', '127.0', '128.0', '255.0']], '0', ['i32x4', 'f32x4', 'i32x4']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['gt_s', ['0x0F0F0F0F', '0xF0F0F0F0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['0x00000000', '0xFFFFFFFF'], ['0xFFFFFFFF', '0x00000000']], ['-1', '-1', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['0x02030001', '0x10110409', '0x0B1A120A', '0xABFF1BAA'],
+                          ['0xAA1BFFAB', '0x0A121A0B', '0x09041110', '0x01000302']], ['-1', '-1', '-1', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['0x80018000', '0x80038002', '0x80058004', '0x80078006'],
+                          ['2147975174', '2147844100', '2147713026', '2147581952']], ['0', '0', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['2147483648', '2147483647', '0', '-1'], ['-2147483648', '-2147483647', '-1', '0']], ['0', '-1', '-1', '0'], ['i32x4', 'i32x4', 'i32x4']])
+
+        # i32x4.gt_s  (i32x4) (i8x16)
+        case_data.append(['#', 'i32x4.gt_s  (i32x4) (i8x16)'])
+        case_data.append(['gt_s', ['0xFFFFFFFF', '0xFF'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_s', ['4294967295', '255'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_s', ['0', '0'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_s', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_s', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_s', [['-8323200', '0', '1', '4294967295'], ['-128', '0', '1', '255']], ['-1', '0', '0', '0'], ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_s', ['0x55555555', '0xAA'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+
+        # i32x4.gt_s  (i32x4) (i16x8)
+        case_data.append(['#', 'i32x4.gt_s  (i32x4) (i16x8)'])
+        case_data.append(['gt_s', ['0xFFFFFFFF', '0xFFFF'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_s', ['4294967295', '65535'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_s', ['0', '0'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_s', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_s', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_s', [['65535', '0', '1', '32768'], ['65535', '65535', '0', '0', '1', '1', '32768', '32768']], ['-1', '0', '0', '-1'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_s', ['0xAAAAAAAA', '0x5555'], '0', ['i32x4', 'i16x8', 'i32x4']])
+
+        case_data.append(['gt_s', ['0_123_456_789', '123456789'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', ['0x0_90AB_cdef', '-0x6f543211'], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # gt_u
+        # i32x4.gt_u  (i32x4) (i32x4)
+        case_data.append(['#', 'gt_u'])
+
+        case_data.append(['#', 'i32x4.gt_u  (i32x4) (i32x4)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['gt_u', ['0xFFFFFFFF', '0xFFFFFFFF'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', ['0x00000000', '0x00000000'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', ['0xF0F0F0F0', '0xF0F0F0F0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', ['0x0F0F0F0F', '0x0F0F0F0F'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['0xFFFFFFFF', '0x00000000'], ['0xFFFFFFFF', '0x00000000']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['0x00000000', '0xFFFFFFFF'], ['0x00000000', '0xFFFFFFFF']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['gt_u', ['0xFFFFFFFF', '4294967295'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', ['0xFFFFFFFF', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', ['0x80808080', '2155905152'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', ['0x80808080', '-2139062144'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['0x83828180', '0x00FFFEFD', '0x7F020100', '0xFFFEFD80'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['gt_u', ['-1', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', ['0', '0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', ['4294967295', '4294967295'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', ['4294967295', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['4294967295', '0'], ['4294967295', '0']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['0', '4294967295'], ['0', '4294967295']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['-2147483647', '4294967295', '0', '-1'], ['2147483649', '-1', '0', '-1']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['gt_u', [['0xc3000000', '0xc2fe0000', '0xbf800000', '0x00000000'], ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i32x4', 'f32x4', 'i32x4']])
+        case_data.append(['gt_u', [['0x3f800000', '0x42fe0000', '0x43000000', '0x437f0000'], ['1.0', '127.0', '128.0', '255.0']], '0', ['i32x4', 'f32x4', 'i32x4']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['gt_u', ['0x0F0F0F0F', '0xF0F0F0F0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['0x00000000', '0xFFFFFFFF'], ['0xFFFFFFFF', '0x00000000']], ['0', '0', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['0x02030001', '0x10110409', '0x0B1A120A', '0xABFF1BAA'],
+                          ['0xAA1BFFAB', '0x0A121A0B', '0x09041110', '0x01000302']], ['0', '-1', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['0x80018000', '0x80038002', '0x80058004', '0x80078006'],
+                          ['2147975174', '2147844100', '2147713026', '2147581952']], ['0', '0', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['2147483648', '2147483647', '0', '-1'], ['-2147483648', '-2147483647', '-1', '0']], ['0', '0', '0', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+
+        # i32x4.gt_u  (i32x4) (i8x16)
+        case_data.append(['#', 'i32x4.gt_u  (i32x4) (i8x16)'])
+        case_data.append(['gt_u', ['0xFFFFFFFF', '0xFF'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_u', ['4294967295', '255'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_u', ['0', '0'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_u', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_u', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_u', [['-8323200', '0', '1', '4294967295'], ['-128', '0', '1', '255']], ['-1', '0', '0', '0'], ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_u', ['0x55555555', '0xAA'], '0', ['i32x4', 'i8x16', 'i32x4']])
+
+        # i32x4.gt_u  (i32x4) (i16x8)
+        case_data.append(['#', 'i32x4.gt_u  (i32x4) (i16x8)'])
+        case_data.append(['gt_u', ['0xFFFFFFFF', '0xFFFF'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_u', ['4294967295', '65535'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_u', ['0', '0'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_u', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_u', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], ['0', '0', '0', '0'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_u', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['-1', '0', '0', '0'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_u', ['0xAAAAAAAA', '0x5555'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+
+        case_data.append(['gt_u', ['0_123_456_789', '123456789'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', ['0x0_1234_5678', '0x12345678'], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # ge_s
+        # i32x4.ge_s  (i32x4) (i32x4)
+        case_data.append(['#', 'ge_s'])
+
+        case_data.append(['#', 'i32x4.ge_s  (i32x4) (i32x4)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ge_s', ['0xFFFFFFFF', '0xFFFFFFFF'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', ['0x00000000', '0x00000000'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', ['0xF0F0F0F0', '0xF0F0F0F0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', ['0x0F0F0F0F', '0x0F0F0F0F'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['0xFFFFFFFF', '0x00000000'], ['0xFFFFFFFF', '0x00000000']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['0x00000000', '0xFFFFFFFF'], ['0x00000000', '0xFFFFFFFF']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['ge_s', ['0xFFFFFFFF', '4294967295'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', ['0xFFFFFFFF', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', ['0x80808080', '2155905152'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', ['0x80808080', '-2139062144'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['0x83828180', '0x00FFFEFD', '0x7F020100', '0xFFFEFD80'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['ge_s', ['-1', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', ['0', '0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', ['4294967295', '4294967295'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', ['4294967295', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['4294967295', '0'], ['4294967295', '0']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['0', '4294967295'], ['0', '4294967295']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['-2147483647', '4294967295', '0', '-1'], ['2147483649', '-1', '0', '-1']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['ge_s', [['0xc3000000', '0xc2fe0000', '0xbf800000', '0x00000000'], ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i32x4', 'f32x4', 'i32x4']])
+        case_data.append(['ge_s', [['0x3f800000', '0x42fe0000', '0x43000000', '0x437f0000'], ['1.0', '127.0', '128.0', '255.0']], '-1', ['i32x4', 'f32x4', 'i32x4']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['ge_s', ['0x0F0F0F0F', '0xF0F0F0F0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['0x00000000', '0xFFFFFFFF'], ['0xFFFFFFFF', '0x00000000']], ['-1', '-1', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['0x02030001', '0x10110409', '0x0B1A120A', '0xABFF1BAA'],
+                          ['0xAA1BFFAB', '0x0A121A0B', '0x09041110', '0x01000302']], ['-1', '-1', '-1', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['0x80018000', '0x80038002', '0x80058004', '0x80078006'],
+                          ['2147975174', '2147844100', '2147713026', '2147581952']], ['0', '0', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['2147483648', '2147483647', '0', '-1'], ['-2147483648', '-2147483647', '-1', '0']], ['-1', '-1', '-1', '0'], ['i32x4', 'i32x4', 'i32x4']])
+
+        # i32x4.ge_s  (i32x4) (i8x16)
+        case_data.append(['#', 'i32x4.ge_s  (i32x4) (i8x16)'])
+        case_data.append(['ge_s', ['0xFFFFFFFF', '0xFF'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_s', ['4294967295', '255'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_s', ['0', '0'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_s', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_s', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_s', [['-8323200', '0', '1', '4294967295'], ['-128', '0', '1', '255']], ['-1', '-1', '0', '-1'], ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_s', ['0x55555555', '0x55'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+
+        # i32x4.ge_s  (i32x4) (i16x8)
+        case_data.append(['#', 'i32x4.ge_s  (i32x4) (i16x8)'])
+        case_data.append(['ge_s', ['0xFFFFFFFF', '0xFFFF'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_s', ['4294967295', '65535'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_s', ['0', '0'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_s', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_s', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_s', [['65535', '0', '1', '32768'], ['65535', '65535', '0', '0', '1', '1', '32768', '32768']], ['-1', '-1', '0', '-1'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_s', ['0xAAAAAAAA', '0x5555'], '0', ['i32x4', 'i16x8', 'i32x4']])
+
+        case_data.append(['ge_s', ['0_123_456_789', '123456789'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', ['0x0_1234_5678', '0x12345678'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # ge_u
+        # i32x4.ge_u  (i32x4) (i32x4)
+        case_data.append(['#', 'ge_u'])
+
+        case_data.append(['#', 'i32x4.ge_u  (i32x4) (i32x4)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ge_u', ['0xFFFFFFFF', '0xFFFFFFFF'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', ['0x00000000', '0x00000000'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', ['0xF0F0F0F0', '0xF0F0F0F0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', ['0x0F0F0F0F', '0x0F0F0F0F'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['0xFFFFFFFF', '0x00000000'], ['0xFFFFFFFF', '0x00000000']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['0x00000000', '0xFFFFFFFF'], ['0x00000000', '0xFFFFFFFF']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['ge_u', ['0xFFFFFFFF', '4294967295'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', ['0xFFFFFFFF', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', ['0x80808080', '2155905152'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', ['0x80808080', '-2139062144'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['0x83828180', '0x00FFFEFD', '0x7F020100', '0xFFFEFD80'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['ge_u', ['-1', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', ['0', '0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', ['4294967295', '4294967295'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', ['4294967295', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['4294967295', '0'], ['4294967295', '0']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['0', '4294967295'], ['0', '4294967295']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['-2147483647', '4294967295', '0', '-1'], ['2147483649', '-1', '0', '-1']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['ge_u', [['0xc3000000', '0xc2fe0000', '0xbf800000', '0x00000000'], ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i32x4', 'f32x4', 'i32x4']])
+        case_data.append(['ge_u', [['0x3f800000', '0x42fe0000', '0x43000000', '0x437f0000'], ['1.0', '127.0', '128.0', '255.0']], '-1', ['i32x4', 'f32x4', 'i32x4']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['ge_u', ['0x0F0F0F0F', '0xF0F0F0F0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['0x00000000', '0xFFFFFFFF'], ['0xFFFFFFFF', '0x00000000']], ['0', '0', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['0x02030001', '0x10110409', '0x0B1A120A', '0xABFF1BAA'],
+                          ['0xAA1BFFAB', '0x0A121A0B', '0x09041110', '0x01000302']], ['0', '-1', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['0x80018000', '0x80038002', '0x80058004', '0x80078006'],
+                          ['2147975174', '2147844100', '2147713026', '2147581952']], ['0', '0', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['2147483648', '2147483647', '0', '-1'], ['-2147483648', '-2147483647', '-1', '0']], ['-1', '0', '0', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+
+        # i32x4.ge_u  (i32x4) (i8x16)
+        case_data.append(['#', 'i32x4.ge_u  (i32x4) (i8x16)'])
+        case_data.append(['ge_u', ['0xFFFFFFFF', '0xFF'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_u', ['4294967295', '255'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_u', ['0', '0'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_u', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_u', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_u', [['-8323200', '0', '1', '4294967295'], ['-128', '0', '1', '255']],
+                          ['-1', '-1', '0', '-1'], ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_u', ['0xAAAAAAAA', '0x55'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+
+        # i32x4.ge_u  (i32x4) (i16x8)
+        case_data.append(['#', 'i32x4.ge_u  (i32x4) (i16x8)'])
+        case_data.append(['ge_u', ['0xFFFFFFFF', '0xFFFF'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_u', ['4294967295', '65535'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_u', ['0', '0'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_u', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_u', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_u', [['-128', '0', '1', '255'], ['65535', '65535', '0', '0', '1', '1', '32768', '32768']], ['0', '-1', '0', '0'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_u', ['0xAAAAAAAA', '0x5555'], ['-1', '-1', '-1', '-1'], ['i32x4', 'i16x8', 'i32x4']])
+
+        case_data.append(['ge_u', ['0_123_456_789', '123456789'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', ['0x0_1234_5678', '0x12345678'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        return case_data
+
+    # generate all test cases
+    def get_all_cases(self):
+
+        # Add tests for unkonow operators for i32x4
+        return SimdCmpCase.get_all_cases(self) + """
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.eq (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ne (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.lt_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.lt_u (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.le_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.le_u (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.gt_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.gt_u (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ge_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ge_u (local.get $x) (local.get $y)))") "unknown operator")
+
+"""
+
+
+def gen_test_cases():
+    i32x4 = Simdi32x4CmpCase()
+    i32x4.gen_test_cases()
+
+
+if __name__ == '__main__':
+    i32x4 = Simdi32x4CmpCase()
+    i32x4.gen_test_cases()
diff --git a/test/core/simd/meta/simd_i32x4_dot_i16x8.py b/test/core/simd/meta/simd_i32x4_dot_i16x8.py
new file mode 100644
index 000000000..1d62fc102
--- /dev/null
+++ b/test/core/simd/meta/simd_i32x4_dot_i16x8.py
@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+
+from simd_arithmetic import SimdArithmeticCase, i16
+from simd_integer_op import ArithmeticOp
+
+
+class SimdI32x4DotI16x8TestCase(SimdArithmeticCase):
+    LANE_TYPE = 'i32x4'
+    UNARY_OPS = ()
+    BINARY_OPS = ('dot_i16x8_s',)
+
+    @property
+    def lane(self):
+        return i16
+
+    def binary_op(self, x, y, lane):
+        # For test data we always splat a single value to the
+        # entire v128, so '* 2' will work here.
+        return ArithmeticOp.get_valid_value(x, i16) * ArithmeticOp.get_valid_value(y, i16) * 2
+
+    @property
+    def hex_binary_op_test_data(self):
+        return []
+
+    @property
+    def bin_test_data(self):
+        return [
+            (self.normal_binary_op_test_data, ['i16x8', 'i16x8', 'i32x4']),
+            (self.hex_binary_op_test_data, ['i16x8', 'i16x8', 'i32x4'])
+        ]
+
+    def get_case_data(self):
+        case_data = []
+        op_name = 'i32x4.dot_i16x8_s'
+        case_data.append(['#', op_name])
+        for data_group, v128_forms in self.bin_test_data:
+            for data in data_group:
+                case_data.append([op_name, [str(data[0]), str(data[1])],
+                    str(self.binary_op(data[0], data[1], self.lane)),
+                    v128_forms])
+        return case_data
+
+    def get_combine_cases(self):
+        return ''
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_i32x4_dot_i16x8.wast'
+        with open(wast_filename, 'w') as fp:
+            fp.write(self.get_all_cases())
+
+def gen_test_cases():
+    simd_i16x8_arith = SimdI32x4DotI16x8TestCase()
+    simd_i16x8_arith.gen_test_cases()
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_i64x2_arith.py b/test/core/simd/meta/simd_i64x2_arith.py
new file mode 100644
index 000000000..a65bcc389
--- /dev/null
+++ b/test/core/simd/meta/simd_i64x2_arith.py
@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+
+"""
+Generate i64x2 integer arithmetic operation cases.
+"""
+
+from simd_arithmetic import SimdArithmeticCase
+
+
+class SimdI64x2ArithmeticCase(SimdArithmeticCase):
+
+    LANE_LEN = 2
+    LANE_TYPE = 'i64x2'
+
+    @property
+    def hex_binary_op_test_data(self):
+        return [
+            ('0x3fffffffffffffff', '0x4000000000000000'),
+            ('0x4000000000000000', '0x4000000000000000'),
+            ('-0x3fffffffffffffff', '-0x40000000fffffff'),
+            ('-0x4000000000000000', '-0x400000000000000'),
+            ('-0x4000000000000000', '-0x400000000000001'),
+            ('0x7fffffffffffffff', '0x7ffffffffffffff'),
+            ('0x7fffffffffffffff', '0x01'),
+            ('0x8000000000000000', '-0x01'),
+            ('0x7fffffffffffffff', '0x8000000000000000'),
+            ('0x8000000000000000', '0x8000000000000000'),
+            ('0xffffffffffffffff', '0x01'),
+            ('0xffffffffffffffff', '0xffffffffffffffff')
+        ]
+
+    @property
+    def hex_unary_op_test_data(self):
+        return ['0x01', '-0x01', '-0x8000000000000000', '-0x7fffffffffffffff',
+                '0x7fffffffffffffff', '0x8000000000000000', '0xffffffffffffffff']
+
+    @property
+    def underscore_literal_test_data(self):
+        return {
+            'i64x2.add': [
+                [['01_234_567_890_123_456_789', '01_234_567_890_123_456_789'],
+                 '02_469_135_780_246_913_578', ['i64x2'] * 3],
+                [['0x0_1234_5678_90AB_cdef', '0x0_90AB_cdef_1234_5678'],
+                 '0x0_a2e0_2467_a2e0_2467', ['i64x2'] * 3]
+            ],
+            'i64x2.sub': [
+                [['03_214_567_890_123_456_789', '01_234_567_890_123_456_789'],
+                 '01_980_000_000_000_000_000', ['i64x2'] * 3],
+                [['0x0_90AB_cdef_8765_4321', '0x0_1234_5678_90AB_cdef'],
+                 '0x0_7e77_7776_f6b9_7532', ['i64x2'] * 3]
+            ],
+            'i64x2.mul': [
+                [['01_234_567_890_123_456_789', '01_234_567_890_123_456_789'],
+                 '09_710_478_858_155_731_897', ['i64x2'] * 3],
+                [['0x0_1234_5678_90AB_cdef', '0x0_90AB_cdef_8765_4321'],
+                 '0x0_602f_05e9_e556_18cf', ['i64x2'] * 3]
+            ]
+        }
+
+    @property
+    def i64x2_i8x16_test_data(self):
+        """This test data will be intepreted by the SIMD.v128_const() method in simd.py."""
+        return {
+            'i64x2.add': [
+                [['0x7fffffffffffffff', ['0', '0', '0', '0', '0', '0', '0', '0x80'] * 2], '-1',
+                 ['i64x2', 'i8x16', 'i64x2']],
+                [['1', '255'], '0', ['i64x2', 'i8x16', 'i64x2']]
+            ],
+            'i64x2.sub': [
+                [['0x7fffffffffffffff', ['0', '0', '0', '0', '0', '0', '0', '0x80'] * 2], '-1',
+                 ['i64x2', 'i8x16', 'i64x2']],
+                [['1', '255'], '2', ['i64x2', 'i8x16', 'i64x2']]
+            ],
+            'i64x2.mul': [
+                [['0x8000000000000000', '0x2'], '0', ['i64x2', 'i8x16', 'i64x2']],
+                [['0xffffffffffffffff', '255'], '1', ['i64x2', 'i8x16', 'i64x2']]
+            ]
+        }
+
+    @property
+    def i64x2_i16x8_test_data(self):
+        """This test data will be intepreted by the SIMD.v128_const() method in simd.py."""
+        return {
+            'i64x2.add': [
+                [['0x7fffffffffffffff', ['0', '0', '0', '0x8000'] * 2], '-1', ['i64x2', 'i16x8', 'i64x2']],
+                [['1', '0xffff'], '0', ['i64x2', 'i16x8', 'i64x2']]
+            ],
+            'i64x2.sub': [
+                [['0x7fffffffffffffff', ['0', '0', '0', '0x8000'] * 2], '-1', ['i64x2', 'i16x8', 'i64x2']],
+                [['1', '0xffff'], '2', ['i64x2', 'i16x8', 'i64x2']]
+            ],
+            'i64x2.mul': [
+                [['0x8000000000000000', ['0', '0', '0', '0x02'] * 4], '0', ['i64x2', 'i16x8', 'i64x2']],
+                [['0xffffffffffffffff', '0xffff'], '1', ['i64x2', 'i16x8', 'i64x2']]
+            ]
+        }
+
+    @property
+    def i64x2_i32x4_test_data(self):
+        """This test data will be intepreted by the SIMD.v128_const() method in simd.py."""
+        return {
+            'i64x2.add': [
+                [['0x7fffffffffffffff', ['0', '0x80000000'] * 2], '-1', ['i64x2', 'i32x4', 'i64x2']],
+                [['1', '0xffffffff'], '0', ['i64x2', 'i32x4', 'i64x2']]
+            ],
+            'i64x2.sub': [
+                [['0x7fffffffffffffff', ['0', '0x80000000'] * 2], '-1', ['i64x2', 'i32x4', 'i64x2']],
+                [['1', '0xffffffff'], '2', ['i64x2', 'i32x4', 'i64x2']]
+            ],
+            'i64x2.mul': [
+                [['0x8000000000000000', ['0', '0x02'] * 2], '0', ['i64x2', 'i32x4', 'i64x2']],
+                [['0xffffffffffffffff', '0xffffffff'], '1', ['i64x2', 'i32x4', 'i64x2']]
+            ]
+        }
+
+    @property
+    def i64x2_f64x2_test_data(self):
+        """This test data will be intepreted by the SIMD.v128_const() method in simd.py."""
+        return {
+            'i64x2.add': [
+                [['0x8000000000000000', '+0.0'], '0x8000000000000000', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x8000000000000000', '-0.0'], '0', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x8000000000000000', '1.0'], '0xbff0000000000000', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x8000000000000000', '-1.0'], '0x3ff0000000000000', ['i64x2', 'f64x2', 'i64x2']],
+                [['1', '+inf'], '0x7ff0000000000001', ['i64x2', 'f64x2', 'i64x2']],
+                [['1', '-inf'], '0xfff0000000000001', ['i64x2', 'f64x2', 'i64x2']],
+                [['1', 'nan'], '0x7ff8000000000001', ['i64x2', 'f64x2', 'i64x2']]
+            ],
+            'i64x2.sub': [
+                [['0x8000000000000000', '+0.0'], '0x8000000000000000', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x8000000000000000', '-0.0'], '0', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x8000000000000000', '1.0'], '0x4010000000000000', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x8000000000000000', '-1.0'], '0xc010000000000000', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x1', '+inf'], '0x8010000000000001', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x1', '-inf'], '0x0010000000000001', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x1', 'nan'], '0x8008000000000001', ['i64x2', 'f64x2', 'i64x2']]
+            ],
+            'i64x2.mul': [
+                [['0x80000000', '+0.0'], '0', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x80000000', '-0.0'], '0', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x80000000', '1.0'], '0', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x80000000', '-1.0'], '0', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x1', '+inf'], '0x7ff0000000000000', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x1', '-inf'], '0xfff0000000000000', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x1', 'nan'], '0x7ff8000000000000', ['i64x2', 'f64x2', 'i64x2']]
+            ]
+        }
+
+    @property
+    def combine_dec_hex_test_data(self):
+        """This test data will be intepreted by the SIMD.v128_const() method in simd.py."""
+        return {
+            'i64x2.add': [
+                [[['0', '1'], ['0', '0xffffffffffffffff']], ['0'] * 2, ['i64x2'] * 3]
+            ],
+            'i64x2.sub': [
+                [[['0', '1'], ['0', '0xffffffffffffffff']], ['0', '0x02'], ['i64x2'] * 3]
+            ],
+            'i64x2.mul': [
+                [[['0', '1'], ['0', '0xffffffffffffffff']], ['0', '0xffffffffffffffff'], ['i64x2'] * 3]
+            ]
+        }
+
+    @property
+    def range_test_data(self):
+        """This test data will be intepreted by the SIMD.v128_const() method in simd.py."""
+        return {
+            'i64x2.add': [
+                [[[str(i) for i in range(2)], [str(i * 2) for i in range(2)]],
+                 [str(i * 3) for i in range(2)], ['i64x2'] * 3]
+            ],
+            'i64x2.sub': [
+                [[[str(i) for i in range(2)], [str(i * 2) for i in range(2)]],
+                 [str(-i) for i in range(2)], ['i64x2'] * 3]
+            ],
+            'i64x2.mul': [
+                [[[str(i) for i in range(2)], [str(i * 2) for i in range(4)]],
+                 ['0', '0x02'], ['i64x2'] * 3]
+            ]
+        }
+
+    @property
+    def full_bin_test_data(self):
+        return [
+            self.i64x2_i8x16_test_data,
+            self.i64x2_i16x8_test_data,
+            self.i64x2_i32x4_test_data,
+            self.i64x2_f64x2_test_data,
+            self.combine_dec_hex_test_data,
+            self.range_test_data,
+            self.underscore_literal_test_data
+        ]
+
+
+def gen_test_cases():
+    simd_i64x2_arith = SimdI64x2ArithmeticCase()
+    simd_i64x2_arith.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
\ No newline at end of file
diff --git a/test/core/simd/meta/simd_i64x2_cmp.py b/test/core/simd/meta/simd_i64x2_cmp.py
new file mode 100644
index 000000000..35089efe1
--- /dev/null
+++ b/test/core/simd/meta/simd_i64x2_cmp.py
@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+
+from simd_compare import SimdCmpCase
+
+
+# Generate i64x2 test case
+class Simdi64x2CmpCase(SimdCmpCase):
+    LANE_TYPE = 'i64x2'
+
+    BINARY_OPS = ['eq', 'ne']
+
+    # Override this since i64x2 does not support as many comparison instructions.
+    CASE_TXT = """
+;; Test all the {lane_type} comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) ({lane_type}.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) ({lane_type}.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x v128) (param $y v128) (result v128) ({lane_type}.lt_s (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x v128) (param $y v128) (result v128) ({lane_type}.le_s (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x v128) (param $y v128) (result v128) ({lane_type}.gt_s (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x v128) (param $y v128) (result v128) ({lane_type}.ge_s (local.get $x) (local.get $y)))
+)
+
+{normal_case}
+
+;; Type check
+
+(assert_invalid (module (func (result v128) ({lane_type}.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+"""
+
+    def get_case_data(self):
+        forms = ['i64x2'] * 3
+        case_data = []
+
+        case_data.append(['#', 'eq'])
+        case_data.append(['#', 'i64x2.eq  (i64x2) (i64x2)'])
+        case_data.append(['eq', ['0xFFFFFFFFFFFFFFFF', '0xFFFFFFFFFFFFFFFF'], '-1', forms])
+        case_data.append(['eq', ['0x0000000000000000', '0x0000000000000000'], '-1', forms])
+        case_data.append(['eq', ['0xF0F0F0F0F0F0F0F0', '0xF0F0F0F0F0F0F0F0'], '-1', forms])
+        case_data.append(['eq', ['0x0F0F0F0F0F0F0F0F', '0x0F0F0F0F0F0F0F0F'], '-1', forms])
+        case_data.append(['eq', [['0xFFFFFFFFFFFFFFFF', '0x0000000000000000'], ['0xFFFFFFFFFFFFFFFF', '0x0000000000000000']], '-1', forms])
+        case_data.append(['eq', [['0x0000000000000000', '0xFFFFFFFFFFFFFFFF'], ['0x0000000000000000', '0xFFFFFFFFFFFFFFFF']], '-1', forms])
+        case_data.append(['eq', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '-1', forms])
+        case_data.append(['eq', ['0xFFFFFFFFFFFFFFFF', '0x0FFFFFFFFFFFFFFF'], '0', forms])
+        case_data.append(['eq', ['0x1', '0x2'], '0', forms])
+
+        case_data.append(['#', 'ne'])
+        case_data.append(['#', 'i64x2.ne  (i64x2) (i64x2)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ne', ['0xFFFFFFFFFFFFFFFF', '0xFFFFFFFFFFFFFFFF'], '0', forms])
+        case_data.append(['ne', ['0x0000000000000000', '0x0000000000000000'], '0', forms])
+        case_data.append(['ne', ['0xF0F0F0F0F0F0F0F0', '0xF0F0F0F0F0F0F0F0'], '0', forms])
+        case_data.append(['ne', ['0x0F0F0F0F0F0F0F0F', '0x0F0F0F0F0F0F0F0F'], '0', forms])
+        case_data.append(['ne', [['0xFFFFFFFFFFFFFFFF', '0x0000000000000000'], ['0xFFFFFFFFFFFFFFFF', '0x0000000000000000']], '0', forms])
+        case_data.append(['ne', [['0x0000000000000000', '0xFFFFFFFFFFFFFFFF'], ['0x0000000000000000', '0xFFFFFFFFFFFFFFFF']], '0', forms])
+        case_data.append(['ne', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '0', forms])
+
+        # lt_s
+        # i64x2.lt_s  (i64x2) (i64x2)
+        case_data.append(['#', 'lt_s'])
+        case_data.append(['#', 'i64x2.lt_s  (i64x2) (i64x2)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['lt_s', ['0xFFFFFFFFFFFFFFFF', '0xFFFFFFFFFFFFFFFF'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', ['0x0000000000000000', '0x0000000000000000'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', ['0xF0F0F0F0F0F0F0F0', '0xF0F0F0F0F0F0F0F0'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', ['0x0F0F0F0F0F0F0F0F', '0x0F0F0F0F0F0F0F0F'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', [['0xFFFFFFFFFFFFFFFF', '0x0000000000000000'], ['0xFFFFFFFFFFFFFFFF', '0x0000000000000000']], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', [['0x0000000000000000', '0xFFFFFFFFFFFFFFFF'], ['0x0000000000000000', '0xFFFFFFFFFFFFFFFF']], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', [['0x0302010011100904', '0x1A0B0A12FFABAA1B'],
+                          ['0x0302010011100904', '0x1A0B0A12FFABAA1B']], '0', ['i64x2', 'i64x2', 'i64x2']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['lt_s', ['0xFFFFFFFFFFFFFFFF', '18446744073709551615'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', ['0xFFFFFFFFFFFFFFFF', '-1'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', ['0x8080808080808080', '9259542123273814144'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', ['0x8080808080808080', '-9187201950435737472'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', [['0x8382818000FFFEFD', '0x7F020100FFFEFD80'],
+                          ['-8970465120996032771', '9151878496576798080']], '0', ['i64x2', 'i64x2', 'i64x2']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['lt_s', ['-1', '-1'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', ['0', '0'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', ['18446744073709551615', '18446744073709551615'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', ['18446744073709551615', '-1'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', [['18446744073709551615', '0'], ['18446744073709551615', '0']], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', [['0', '18446744073709551615'], ['0', '18446744073709551615']], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', [['-9223372036854775807', '18446744073709551615'],
+                          ['9223372036854775809', '-1']], '0', ['i64x2', 'i64x2', 'i64x2']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['lt_s', [['0xc060000000000000', '0xc05fc00000000000'],
+                          ['-128.0', '-127.0']], '0', ['i64x2', 'f64x2', 'i64x2']])
+        case_data.append(['lt_s', [['0x3ff0000000000000', '0x405fc00000000000'],
+                          ['1.0', '127.0']], '0', ['i64x2', 'f64x2', 'i64x2']])
+
+        # le_s
+        # i64x2.le_s  (i64x2) (i64x2)
+        case_data.append(['#', 'le_s'])
+        case_data.append(['#', 'i64x2.le_s  (i64x2) (i64x2)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['le_s', ['0xFFFFFFFFFFFFFFFF', '0xFFFFFFFFFFFFFFFF'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', ['0x0000000000000000', '0x0000000000000000'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', ['0xF0F0F0F0F0F0F0F0', '0xF0F0F0F0F0F0F0F0'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', ['0x0F0F0F0F0F0F0F0F', '0x0F0F0F0F0F0F0F0F'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', [['0xFFFFFFFFFFFFFFFF', '0x0000000000000000'], ['0xFFFFFFFFFFFFFFFF', '0x0000000000000000']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', [['0x0000000000000000', '0xFFFFFFFFFFFFFFFF'], ['0x0000000000000000', '0xFFFFFFFFFFFFFFFF']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', [['0x0302010011100904', '0x1A0B0A12FFABAA1B'],
+                          ['0x0302010011100904', '0x1A0B0A12FFABAA1B']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['le_s', ['0xFFFFFFFFFFFFFFFF', '18446744073709551615'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', ['0xFFFFFFFFFFFFFFFF', '-1'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', ['0x8080808080808080', '9259542123273814144'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', ['0x8080808080808080', '-9187201950435737472'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', [['0x8382818000FFFEFD', '0x7F020100FFFEFD80'],
+                          ['-8970465120996032771', '9151878496576798080']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['le_s', ['-1', '-1'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', [['0', '0'], ['0', '-1']], ['-1', '0'], ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', ['0', '0'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', ['18446744073709551615', '18446744073709551615'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', ['18446744073709551615', '-1'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', [['18446744073709551615', '0'], ['18446744073709551615', '0']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', [['0', '18446744073709551615'], ['0', '18446744073709551615']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', [['-9223372036854775807', '18446744073709551615'],
+                          ['9223372036854775809', '-1']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['le_s', [['0xc060000000000000', '0xc05fc00000000000'],
+                          ['-128.0', '-127.0']], '-1', ['i64x2', 'f64x2', 'i64x2']])
+        case_data.append(['le_s', [['0x3ff0000000000000', '0x405fc00000000000'],
+                          ['1.0', '127.0']], '-1', ['i64x2', 'f64x2', 'i64x2']])
+
+        # gt_s
+        # i64x2.gt_s  (i64x2) (i64x2)
+        case_data.append(['#', 'gt_s'])
+        case_data.append(['#', 'i64x2.gt_s  (i64x2) (i64x2)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['gt_s', ['0xFFFFFFFFFFFFFFFF', '0xFFFFFFFFFFFFFFFF'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', ['0x0000000000000000', '0x0000000000000000'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', ['0xF0F0F0F0F0F0F0F0', '0xF0F0F0F0F0F0F0F0'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', ['0x0F0F0F0F0F0F0F0F', '0x0F0F0F0F0F0F0F0F'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', [['0xFFFFFFFFFFFFFFFF', '0x0000000000000000'], ['0xFFFFFFFFFFFFFFFF', '0x0000000000000000']], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', [['0x0000000000000000', '0xFFFFFFFFFFFFFFFF'], ['0x0000000000000000', '0xFFFFFFFFFFFFFFFF']], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', [['0x0302010011100904', '0x1A0B0A12FFABAA1B'],
+                          ['0x0302010011100904', '0x1A0B0A12FFABAA1B']], '0', ['i64x2', 'i64x2', 'i64x2']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['gt_s', ['0xFFFFFFFFFFFFFFFF', '18446744073709551615'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', ['0xFFFFFFFFFFFFFFFF', '-1'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', ['0x8080808080808080', '9259542123273814144'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', ['0x8080808080808080', '-9187201950435737472'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', [['0x8382818000FFFEFD', '0x7F020100FFFEFD80'],
+                          ['-8970465120996032771', '9151878496576798080']], '0', ['i64x2', 'i64x2', 'i64x2']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['gt_s', ['-1', '-1'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', ['0', '0'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', ['18446744073709551615', '18446744073709551615'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', ['18446744073709551615', '-1'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', [['18446744073709551615', '0'], ['18446744073709551615', '0']], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', [['0', '18446744073709551615'], ['0', '18446744073709551615']], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', [['-9223372036854775807', '18446744073709551615'],
+                          ['9223372036854775809', '-1']], '0', ['i64x2', 'i64x2', 'i64x2']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['gt_s', [['0xc060000000000000', '0xc05fc00000000000'],
+                          ['-128.0', '-127.0']], '0', ['i64x2', 'f64x2', 'i64x2']])
+        case_data.append(['gt_s', [['0x3ff0000000000000', '0x405fc00000000000'],
+                          ['1.0', '127.0']], '0', ['i64x2', 'f64x2', 'i64x2']])
+
+        # ge_s
+        # i64x2.ge_s  (i64x2) (i64x2)
+        case_data.append(['#', 'ge_s'])
+        case_data.append(['#', 'i64x2.ge_s  (i64x2) (i64x2)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ge_s', ['0xFFFFFFFFFFFFFFFF', '0xFFFFFFFFFFFFFFFF'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', ['0x0000000000000000', '0x0000000000000000'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', ['0xF0F0F0F0F0F0F0F0', '0xF0F0F0F0F0F0F0F0'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', ['0x0F0F0F0F0F0F0F0F', '0x0F0F0F0F0F0F0F0F'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', [['0xFFFFFFFFFFFFFFFF', '0x0000000000000000'], ['0xFFFFFFFFFFFFFFFF', '0x0000000000000000']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', [['0x0000000000000000', '0xFFFFFFFFFFFFFFFF'], ['0x0000000000000000', '0xFFFFFFFFFFFFFFFF']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', [['0x0302010011100904', '0x1A0B0A12FFABAA1B'],
+                          ['0x0302010011100904', '0x1A0B0A12FFABAA1B']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['ge_s', ['0xFFFFFFFFFFFFFFFF', '18446744073709551615'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', ['0xFFFFFFFFFFFFFFFF', '-1'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', ['0x8080808080808080', '9259542123273814144'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', ['0x8080808080808080', '-9187201950435737472'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', [['0x8382818000FFFEFD', '0x7F020100FFFEFD80'],
+                          ['-8970465120996032771', '9151878496576798080']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['ge_s', ['-1', '-1'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', [['-1', '-1'], ['0', '-1']], ['0', '-1'], ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', ['0', '0'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', ['18446744073709551615', '18446744073709551615'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', ['18446744073709551615', '-1'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', [['18446744073709551615', '0'], ['18446744073709551615', '0']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', [['0', '18446744073709551615'], ['0', '18446744073709551615']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', [['-9223372036854775807', '18446744073709551615'],
+                          ['9223372036854775809', '-1']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['ge_s', [['0xc060000000000000', '0xc05fc00000000000'],
+                          ['-128.0', '-127.0']], '-1', ['i64x2', 'f64x2', 'i64x2']])
+        case_data.append(['ge_s', [['0x3ff0000000000000', '0x405fc00000000000'],
+                          ['1.0', '127.0']], '-1', ['i64x2', 'f64x2', 'i64x2']])
+
+        return case_data
+
+
+def gen_test_cases():
+    i64x2 = Simdi64x2CmpCase()
+    i64x2.gen_test_cases()
+
+
+if __name__ == '__main__':
+    i64x2 = Simdi64x2CmpCase()
+    i64x2.gen_test_cases()
diff --git a/test/core/simd/meta/simd_i8x16_arith.py b/test/core/simd/meta/simd_i8x16_arith.py
new file mode 100644
index 000000000..9639d04a8
--- /dev/null
+++ b/test/core/simd/meta/simd_i8x16_arith.py
@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+
+"""
+Generate i8x16 integer arithmetic operation cases.
+"""
+
+from simd_arithmetic import SimdArithmeticCase
+
+
+class SimdI8x16ArithmeticCase(SimdArithmeticCase):
+
+    LANE_LEN = 16
+    LANE_TYPE = 'i8x16'
+    BINARY_OPS = ('add', 'sub')
+
+    @property
+    def hex_binary_op_test_data(self):
+        return [
+            ('0x3f', '0x40'),
+            ('0x40', '0x40'),
+            ('-0x3f', '-0x40'),
+            ('-0x40', '-0x40'),
+            ('-0x40', '-0x41'),
+            ('0x7f', '0x7f'),
+            ('0x7f', '0x01'),
+            ('0x80', '-0x01'),
+            ('0x7f', '0x80'),
+            ('0x80', '0x80'),
+            ('0xff', '0x01'),
+            ('0xff', '0xff')
+        ]
+
+    @property
+    def hex_unary_op_test_data(self):
+        return ['0x01', '-0x01', '-0x80', '-0x7f', '0x7f', '0x80', '0xff']
+
+    @property
+    def i8x16_i16x8_test_data(self):
+        return {
+            'i8x16.add': [
+                [['0x7f', '0x8080'], '-1', ['i8x16', 'i16x8', 'i8x16']],
+                [['1', '65535'], '0', ['i8x16', 'i16x8', 'i8x16']]
+            ],
+            'i8x16.sub': [
+                [['0x7f', '0x8080'], '-1', ['i8x16', 'i16x8', 'i8x16']],
+                [['1', '65535'], '2', ['i8x16', 'i16x8', 'i8x16']]
+            ]
+        }
+
+    @property
+    def i8x16_i32x4_test_data(self):
+        return {
+            'i8x16.add': [
+                [['0x7f', '0x80808080'], '-1', ['i8x16', 'i32x4', 'i8x16']],
+                [['1', '0xffffffff'], '0', ['i8x16', 'i32x4', 'i8x16']]
+            ],
+            'i8x16.sub': [
+                [['0x7f', '0x80808080'], '-1', ['i8x16', 'i32x4', 'i8x16']],
+                [['1', '0xffffffff'], '2', ['i8x16', 'i32x4', 'i8x16']]
+            ]
+        }
+
+    @property
+    def i8x16_f32x4_test_data(self):
+        return {
+            'i8x16.add': [
+                [['0x80', '+0.0'], '0x80', ['i8x16', 'f32x4', 'i8x16']],
+                [['0x80', '-0.0'], ['0x80', '0x80', '0x80', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['0x80', '1.0'], ['0x80', '0x80', '0', '0xbf'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['0x80', '-1.0'], ['0x80', '0x80', '0', '0x3f'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '+inf'], ['0x01', '0x01', '0x81', '0x80'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '-inf'], ['0x01', '0x01', '0x81', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', 'nan'], ['0x01', '0x01', '0xc1', '0x80'] * 4, ['i8x16', 'f32x4', 'i8x16']]
+            ],
+            'i8x16.sub': [
+                [['0x80', '+0.0'], '0x80', ['i8x16', 'f32x4', 'i8x16']],
+                [['0x80', '-0.0'], ['0x80', '0x80', '0x80', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['0x80', '1.0'], ['0x80', '0x80', '0', '0x41'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['0x80', '-1.0'], ['0x80', '0x80', '0', '0xc1'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '+inf'], ['0x01', '0x01', '0x81', '0x82'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '-inf'], ['0x01', '0x01', '0x81', '0x02'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', 'nan'], ['0x01', '0x01', '0x41', '0x82'] * 4, ['i8x16', 'f32x4', 'i8x16']]
+            ]
+        }
+
+    @property
+    def combine_dec_hex_test_data(self):
+        return {
+            'i8x16.add': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15'],
+                  ['0', '0xff', '0xfe', '0xfd', '0xfc', '0xfb', '0xfa', '0xf9', '0xf8', '0xf7', '0xf6', '0xf5',
+                   '0xf4', '0xf3', '0xf2', '0xf1']],
+                 ['0'] * 16, ['i8x16', 'i8x16', 'i8x16']]
+            ],
+            'i8x16.sub': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15'],
+                  ['0', '0xff', '0xfe', '0xfd', '0xfc', '0xfb', '0xfa', '0xf9', '0xf8', '0xf7', '0xf6', '0xf5',
+                   '0xf4', '0xf3', '0xf2', '0xf1']],
+                 ['0', '0x02', '0x04', '0x06', '0x08', '0x0a', '0x0c', '0x0e', '0x10', '0x12', '0x14', '0x16',
+                  '0x18', '0x1a', '0x1c', '0x1e'],
+                 ['i8x16', 'i8x16', 'i8x16']]
+            ]
+        }
+
+    @property
+    def range_test_data(self):
+        return {
+            'i8x16.add': [
+                [[[str(i) for i in range(16)], [str(i * 2) for i in range(16)]],
+                 [str(i * 3) for i in range(16)], ['i8x16', 'i8x16', 'i8x16']]
+            ],
+            'i8x16.sub': [
+                [[[str(i) for i in range(16)], [str(i * 2) for i in range(16)]],
+                 [str(-i) for i in range(16)], ['i8x16', 'i8x16', 'i8x16']]
+            ]
+        }
+
+    @property
+    def combine_ternary_arith_test_data(self):
+        test_data = super().combine_ternary_arith_test_data
+        test_data.pop('mul-add')
+        test_data.pop('mul-sub')
+        return test_data
+
+    @property
+    def combine_binary_arith_test_data(self):
+        test_data = super().combine_binary_arith_test_data
+        test_data.pop('mul-neg')
+        return test_data
+
+    @property
+    def full_bin_test_data(self):
+        return [
+            self.i8x16_i16x8_test_data,
+            self.i8x16_i32x4_test_data,
+            self.i8x16_f32x4_test_data,
+            self.combine_dec_hex_test_data,
+            self.range_test_data
+        ]
+
+
+def gen_test_cases():
+    simd_i8x16_arith = SimdI8x16ArithmeticCase()
+    simd_i8x16_arith.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
\ No newline at end of file
diff --git a/test/core/simd/meta/simd_i8x16_cmp.py b/test/core/simd/meta/simd_i8x16_cmp.py
new file mode 100644
index 000000000..440d6087b
--- /dev/null
+++ b/test/core/simd/meta/simd_i8x16_cmp.py
@@ -0,0 +1,825 @@
+#!/usr/bin/env python3
+
+"""
+This file is used for generating i8x16 related test cases
+which inherites from the 'SimdCmpCase' class and overloads
+with the 'get_test_cases' method.
+"""
+
+from simd_compare import SimdCmpCase
+
+
+# Generate i8x16 test case
+class Simdi8x16CmpCase(SimdCmpCase):
+
+    # set lane type
+    LANE_TYPE = 'i8x16'
+
+    BINARY_OPS = ['eq', 'ne', 'lt_s', 'lt_u', 'le_s', 'le_u', 'gt_s', 'gt_u', 'ge_s', 'ge_u']
+
+    # Overload base class method and set test data for i32x4.
+    def get_case_data(self):
+
+        case_data = []
+
+        # i8x16.eq  (i8x16) (i8x16)
+        # hex vs hex
+        case_data.append(['#', 'eq'])
+        case_data.append(['#', 'i8x16.eq  (i8x16) (i8x16)'])
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['eq', ['0xFF', '0xFF'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', ['0x00', '0x00'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', ['0xF0', '0xF0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', ['0x0F', '0x0F'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['0xFF', '0x00'], ['0xFF', '0x00']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['0x00', '0xFF'], ['0x00', '0xFF']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['eq', ['0xFF', '255'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', ['0xFF', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', ['0x80', '128'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', ['0x80', '-128'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['eq', ['-1', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', ['0', '0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', ['255', '255'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', ['255', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['255', '0'], ['255', '0']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['0', '255'], ['0', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '-0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['eq', [['0x00', '0x00', '0x00', '0xc3', '0x00', '0x00', '0xfe', '0xc2', '0x00', '0x00', '0x80', '0xbf', '0x00', '0x00', '0x00', '0x00'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i8x16', 'f32x4', 'i8x16']])
+        case_data.append(['eq', [['0x00', '0x00', '0x80', '0x3f', '0x00', '0x00', '0xfe', '0x42', '0x00', '0x00', '0x00', '0x43', '0x00', '0x00', '0x7f', '0x43'],
+                          ['1.0', '127.0', '128.0', '255.0']], '-1', ['i8x16', 'f32x4', 'i8x16']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['eq', ['0x0F', '0xF0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['0x00', '0xFF'], ['0xFF', '0x00']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0xFF', '0xAB', '0xAA', '0x1B', '0x1A', '0x0B', '0x0A', '0x12', '0x11', '0x10', '0x09', '0x04', '0x03', '0x02', '0x01', '0x00']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['0', '0', '0', '0', '0', '0', '0', '-1', '-1', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '-0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['0', '0', '0', '0', '0', '0', '0', '-1', '-1', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+
+        # i8x16.eq  (i8x16) (i16x8)
+        case_data.append(['#', 'i8x16.eq  (i8x16) (i16x8)'])
+        case_data.append(['eq', ['0xFF', '0xFFFF'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['eq', ['255', '65535'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['eq', ['0', '0'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['eq', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['eq', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['eq', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'],
+                          ['-128', '-128', '0', '0', '1', '1', '255', '255']], ['-1', '0', '-1', '0', '-1', '-1', '-1', '-1', '-1', '0', '-1', '0', '-1', '0', '-1', '0'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['eq', ['0x55', '0xAAAA'], '0', ['i8x16', 'i16x8', 'i8x16']])
+
+        # i8x16.eq  (i8x16) (i32x4)
+        case_data.append(['#', 'i8x16.eq  (i8x16) (i32x4)'])
+        case_data.append(['eq', ['0xFF', '0xFFFFFFFF'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['eq', ['255', '4294967295'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['eq', ['0', '0'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['eq', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['eq', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['eq', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'],
+                          ['-128', '0', '1', '255']], ['-1', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '-1', '0', '0', '0'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['eq', ['0x55', '0xAAAAAAAA'], '0', ['i8x16', 'i32x4', 'i8x16']])
+
+        # ne
+        # i8x16.ne  (i8x16) (i8x16)
+        case_data.append(['#', 'ne'])
+        case_data.append(['#', 'i8x16.ne  (i8x16) (i8x16)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ne', ['0xFF', '0xFF'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', ['0x00', '0x00'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', ['0xF0', '0xF0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', ['0x0F', '0x0F'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['0xFF', '0x00'], ['0xFF', '0x00']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['0x00', '0xFF'], ['0x00', '0xFF']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['ne', ['0xFF', '255'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', ['0xFF', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', ['0x80', '128'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', ['0x80', '-128'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['ne', ['-1', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', ['0', '0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', ['255', '255'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', ['255', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['255', '0'], ['255', '0']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['0', '255'], ['0', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '-0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['ne', [['0x00', '0x00', '0x00', '0xc3', '0x00', '0x00', '0xfe', '0xc2', '0x00', '0x00', '0x80', '0xbf', '0x00', '0x00', '0x00', '0x00'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i8x16', 'f32x4', 'i8x16']])
+        case_data.append(['ne', [['0x00', '0x00', '0x80', '0x3f', '0x00', '0x00', '0xfe', '0x42', '0x00', '0x00', '0x00', '0x43', '0x00', '0x00', '0x7f', '0x43'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i8x16', 'f32x4', 'i8x16']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['ne', ['0x0F', '0xF0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['0x00', '0xFF'], ['0xFF', '0x00']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0xFF', '0xAB', '0xAA', '0x1B', '0x1A', '0x0B', '0x0A', '0x12', '0x11', '0x10', '0x09', '0x04', '0x03', '0x02', '0x01', '0x00']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '-0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+
+        # i8x16.ne  (i8x16) (i16x8)
+        case_data.append(['#', 'i8x16.ne (i8x16) (i16x8)'])
+        case_data.append(['ne', ['0xFF', '0xFFFF'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ne', ['255', '65535'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ne', ['0', '0'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ne', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ne', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ne', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'],
+                          ['-128', '-128', '0', '0', '1', '1', '255', '255']], ['0', '-1', '0', '-1', '0', '0', '0', '0', '0', '-1', '0', '-1', '0', '-1', '0', '-1'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ne', ['0x55', '0xAAAA'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+
+        # i8x16.ne  (i8x16) (i32x4)
+        case_data.append(['#', 'i8x16.ne  (i8x16) (i32x4)'])
+        case_data.append(['ne', ['0xFF', '0xFFFFFFFF'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ne', ['255', '4294967295'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ne', ['0', '0'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ne', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ne', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ne', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '0', '1', '255']],
+                          ['0', '-1', '-1', '-1', '0', '0', '0', '0', '0', '-1', '-1', '-1', '0', '-1', '-1', '-1'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ne', ['0x55', '0xAAAAAAAA'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+
+        # lt_s
+        case_data.append(['#', 'lt_s'])
+        case_data.append(['#', 'i8x16.lt_s  (i8x16) (i8x16)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['lt_s', ['0xFF', '0xFF'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', ['0x00', '0x00'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', ['0xF0', '0xF0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', ['0x0F', '0x0F'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['0xFF', '0x00'], ['0xFF', '0x00']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['0x00', '0xFF'], ['0x00', '0xFF']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['lt_s', ['0xFF', '255'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', ['0xFF', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', ['0x80', '128'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', ['0x80', '-128'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['lt_s', ['-1', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', ['0', '0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', ['255', '255'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', ['255', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['255', '0'], ['255', '0']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['0', '255'], ['0', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '-0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['lt_s', [['0x00', '0x00', '0x00', '0xc3', '0x00', '0x00', '0xfe', '0xc2', '0x00', '0x00', '0x80', '0xbf', '0x00', '0x00', '0x00', '0x00'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i8x16', 'f32x4', 'i8x16']])
+        case_data.append(['lt_s', [['0x00', '0x00', '0x80', '0x3f', '0x00', '0x00', '0xfe', '0x42', '0x00', '0x00', '0x00', '0x43', '0x00', '0x00', '0x7f', '0x43'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i8x16', 'f32x4', 'i8x16']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['lt_s', ['0x0F', '0xF0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['0x00', '0xFF'], ['0xFF', '0x00']], ['0', '0', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0xFF', '0xAB', '0xAA', '0x1B', '0x1A', '0x0B', '0x0A', '0x12', '0x11', '0x10', '0x09', '0x04', '0x03', '0x02', '0x01', '0x00']],
+                          ['0', '0', '0', '-1', '-1', '-1', '0', '-1', '0', '-1', '0', '0', '0', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['-1', '-1', '-1', '0', '-1', '-1', '-1', '0', '0', '0', '0', '0', '-1', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '-0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['-1', '-1', '-1', '0', '-1', '-1', '-1', '0', '0', '0', '0', '0', '-1', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['#', 'i8x16.lt_s  (i8x16) (i16x8)'])
+        case_data.append(['lt_s', ['0xFF', '0xFFFF'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_s', ['255', '65535'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_s', ['0', '0'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_s', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_s', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '-128', '0', '0', '1', '1', '255', '255']],
+                          ['0', '-1', '0', '-1', '0', '0', '0', '0', '0', '0', '0', '0', '0', '-1', '0', '-1'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_s', ['0x55', '0xAAAA'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['#', 'i8x16.lt_s  (i8x16) (i32x4)'])
+        case_data.append(['lt_s', ['0xFF', '0xFFFFFFFF'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_s', ['255', '4294967295'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_s', ['0', '0'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_s', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_s', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '0', '1', '255']],
+                          ['0', '-1', '-1', '-1', '0', '0', '0', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_s', ['0x55', '0xAAAAAAAA'], '0', ['i8x16', 'i32x4', 'i8x16']])
+
+        # lt_u
+        case_data.append(['#', 'lt_u'])
+        case_data.append(['#', 'i8x16.lt_u  (i8x16) (i8x16)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['lt_u', ['0xFF', '0xFF'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', ['0x00', '0x00'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', ['0xF0', '0xF0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', ['0x0F', '0x0F'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['0xFF', '0x00'], ['0xFF', '0x00']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['0x00', '0xFF'], ['0x00', '0xFF']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['lt_u', ['0xFF', '255'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', ['0xFF', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', ['0x80', '128'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', ['0x80', '-128'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['lt_u', ['-1', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', ['0', '0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', ['255', '255'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', ['255', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['255', '0'], ['255', '0']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['0', '255'], ['0', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '-0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['lt_u', [['0x00', '0x00', '0x00', '0xc3', '0x00', '0x00', '0xfe', '0xc2', '0x00', '0x00', '0x80', '0xbf', '0x00', '0x00', '0x00', '0x00'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i8x16', 'f32x4', 'i8x16']])
+        case_data.append(['lt_u', [['0x00', '0x00', '0x80', '0x3f', '0x00', '0x00', '0xfe', '0x42', '0x00', '0x00', '0x00', '0x43', '0x00', '0x00', '0x7f', '0x43'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i8x16', 'f32x4', 'i8x16']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['lt_u', ['0x0F', '0xF0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['0x00', '0xFF'], ['0xFF', '0x00']], ['-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0xFF', '0xAB', '0xAA', '0x1B', '0x1A', '0x0B', '0x0A', '0x12', '0x11', '0x10', '0x09', '0x04', '0x03', '0x02', '0x01', '0x00']],
+                          ['-1', '-1', '-1', '-1', '-1', '-1', '0', '-1', '0', '-1', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['-1', '-1', '-1', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1', '-1', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '-0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['-1', '-1', '-1', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1', '-1', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['#', 'i8x16.lt_u  (i8x16) (i16x8)'])
+        case_data.append(['lt_u', ['0xFF', '0xFFFF'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_u', ['255', '65535'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_u', ['0', '0'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_u', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_u', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'],
+                          ['-128', '-128', '0', '0', '1', '1', '255', '255']], ['0', '-1', '0', '-1', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_u', ['0x55', '0xAAAA'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['#', 'i8x16.lt_u  (i8x16) (i32x4)'])
+        case_data.append(['lt_u', ['0xFF', '0xFFFFFFFF'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_u', ['255', '4294967295'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_u', ['0', '0'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_u', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_u', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'],
+                          ['-128', '0', '1', '255']], ['0', '-1', '-1', '-1', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_u', ['0x55', '0xAAAAAAAA'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+
+        # le_s
+        case_data.append(['#', 'le_s'])
+        case_data.append(['#', 'i8x16.le_s  (i8x16) (i8x16)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['le_s', ['0xFF', '0xFF'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', ['0x00', '0x00'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', ['0xF0', '0xF0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', ['0x0F', '0x0F'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['0xFF', '0x00'], ['0xFF', '0x00']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['0x00', '0xFF'], ['0x00', '0xFF']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['le_s', ['0xFF', '255'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', ['0xFF', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', ['0x80', '128'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', ['0x80', '-128'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['le_s', ['-1', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', ['0', '0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', ['255', '255'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', ['255', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['255', '0'], ['255', '0']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['0', '255'], ['0', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '-0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['le_s', [['0x00', '0x00', '0x00', '0xc3', '0x00', '0x00', '0xfe', '0xc2', '0x00', '0x00', '0x80', '0xbf', '0x00', '0x00', '0x00', '0x00'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i8x16', 'f32x4', 'i8x16']])
+        case_data.append(['le_s', [['0x00', '0x00', '0x80', '0x3f', '0x00', '0x00', '0xfe', '0x42', '0x00', '0x00', '0x00', '0x43', '0x00', '0x00', '0x7f', '0x43'],
+                          ['1.0', '127.0', '128.0', '255.0']], '-1', ['i8x16', 'f32x4', 'i8x16']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['le_s', ['0x0F', '0xF0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['0x00', '0xFF'], ['0xFF', '0x00']], ['0', '0', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0xFF', '0xAB', '0xAA', '0x1B', '0x1A', '0x0B', '0x0A', '0x12', '0x11', '0x10', '0x09', '0x04', '0x03', '0x02', '0x01', '0x00']],
+                          ['0', '0', '0', '-1', '-1', '-1', '0', '-1', '0', '-1', '0', '0', '0', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['-1', '-1', '-1', '0', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '-1', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '-0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['-1', '-1', '-1', '0', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '-1', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['#', 'i8x16.le_s  (i8x16) (i16x8)'])
+        case_data.append(['le_s', ['0xFF', '0xFFFF'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_s', ['255', '65535'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_s', ['0', '0'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_s', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_s', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'],
+                          ['-128', '-128', '0', '0', '1', '1', '255', '255']],
+                          ['-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '-1', '0', '-1', '-1', '-1', '-1'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_s', ['0x55', '0xAAAA'], ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['#', 'i8x16.le_s  (i8x16) (i32x4)'])
+        case_data.append(['le_s', ['0xFF', '0xFFFFFFFF'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_s', ['255', '4294967295'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_s', ['0', '0'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_s', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_s', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '0', '1', '255']],
+                          ['-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '-1', '-1', '-1', '-1'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_s', ['0x55', '0xAAAAAAAA'], '0', ['i8x16', 'i32x4', 'i8x16']])
+
+        # le_u
+        case_data.append(['#', 'le_u'])
+        case_data.append(['#', 'i8x16.le_u  (i8x16) (i8x16)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['le_u', ['0xFF', '0xFF'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', ['0x00', '0x00'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', ['0xF0', '0xF0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', ['0x0F', '0x0F'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['0xFF', '0x00'], ['0xFF', '0x00']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['0x00', '0xFF'], ['0x00', '0xFF']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['le_u', ['0xFF', '255'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', ['0xFF', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', ['0x80', '128'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', ['0x80', '-128'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['le_u', ['-1', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', ['0', '0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', ['255', '255'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', ['255', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['255', '0'], ['255', '0']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['0', '255'], ['0', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '-0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['le_u', [['0x00', '0x00', '0x00', '0xc3', '0x00', '0x00', '0xfe', '0xc2', '0x00', '0x00', '0x80', '0xbf', '0x00', '0x00', '0x00', '0x00'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i8x16', 'f32x4', 'i8x16']])
+        case_data.append(['le_u', [['0x00', '0x00', '0x80', '0x3f', '0x00', '0x00', '0xfe', '0x42', '0x00', '0x00', '0x00', '0x43', '0x00', '0x00', '0x7f', '0x43'],
+                          ['1.0', '127.0', '128.0', '255.0']], '-1', ['i8x16', 'f32x4', 'i8x16']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['le_u', ['0x0F', '0xF0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['0x00', '0xFF'], ['0xFF', '0x00']], ['-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0xFF', '0xAB', '0xAA', '0x1B', '0x1A', '0x0B', '0x0A', '0x12', '0x11', '0x10', '0x09', '0x04', '0x03', '0x02', '0x01', '0x00']],
+                          ['-1', '-1', '-1', '-1', '-1', '-1', '0', '-1', '0', '-1', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['-1', '-1', '-1', '0', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '-0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['-1', '-1', '-1', '0', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['#', 'i8x16.le_u  (i8x16) (i16x8)'])
+        case_data.append(['le_u', ['0xFF', '0xFFFF'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_u', ['255', '65535'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_u', ['0', '0'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_u', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_u', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'],
+                          ['-128', '-128', '0', '0', '1', '1', '255', '255']], ['-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '-1', '0', '-1', '0', '-1', '0'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_u', ['0x55', '0xAAAA'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['#', 'i8x16.le_u  (i8x16) (i32x4)'])
+        case_data.append(['le_u', ['0xFF', '0xFFFFFFFF'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_u', ['255', '4294967295'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_u', ['0', '0'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_u', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_u', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '0', '1', '255']],
+                          ['-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '-1', '0', '0', '0'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_u', ['0x55', '0xAAAAAAAA'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+
+        # gt_s
+        case_data.append(['#', 'gt_s'])
+        case_data.append(['#', 'i8x16.gt_s  (i8x16) (i8x16)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['gt_s', ['0xFF', '0xFF'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', ['0x00', '0x00'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', ['0xF0', '0xF0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', ['0x0F', '0x0F'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['0xFF', '0x00'], ['0xFF', '0x00']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['0x00', '0xFF'], ['0x00', '0xFF']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['gt_s', ['0xFF', '255'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', ['0xFF', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', ['0x80', '128'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', ['0x80', '-128'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['gt_s', ['-1', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', ['0', '0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', ['255', '255'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', ['255', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['255', '0'], ['255', '0']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['0', '255'], ['0', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '-0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['gt_s', [['0x00', '0x00', '0x00', '0xc3', '0x00', '0x00', '0xfe', '0xc2', '0x00', '0x00', '0x80', '0xbf', '0x00', '0x00', '0x00', '0x00'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i8x16', 'f32x4', 'i8x16']])
+        case_data.append(['gt_s', [['0x00', '0x00', '0x80', '0x3f', '0x00', '0x00', '0xfe', '0x42', '0x00', '0x00', '0x00', '0x43', '0x00', '0x00', '0x7f', '0x43'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i8x16', 'f32x4', 'i8x16']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['gt_s', ['0x0F', '0xF0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['0x00', '0xFF'], ['0xFF', '0x00']], ['-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0xFF', '0xAB', '0xAA', '0x1B', '0x1A', '0x0B', '0x0A', '0x12', '0x11', '0x10', '0x09', '0x04', '0x03', '0x02', '0x01', '0x00']],
+                          ['-1', '-1', '-1', '0', '0', '0', '-1', '0', '-1', '0', '-1', '-1', '-1', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['0', '0', '0', '-1', '0', '0', '0', '0', '0', '-1', '-1', '-1', '0', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '-0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['0', '0', '0', '-1', '0', '0', '0', '0', '0', '-1', '-1', '-1', '0', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['#', 'i8x16.gt_s  (i8x16) (i16x8)'])
+        case_data.append(['gt_s', ['0xFF', '0xFFFF'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_s', ['255', '65535'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_s', ['0', '0'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_s', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_s', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '-128', '0', '0', '1', '1', '255', '255']],
+                          ['0', '0', '0', '0', '0', '0', '0', '0', '0', '-1', '0', '-1', '0', '0', '0', '0'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_s', ['0x55', '0xAAAA'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['#', 'i8x16.gt_s  (i8x16) (i32x4)'])
+        case_data.append(['gt_s', ['0xFF', '0xFFFFFFFF'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_s', ['255', '4294967295'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_s', ['0', '0'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_s', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'], ['2206368128', '16776957', '2130837760', '4294901120']],
+                          ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_s', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '0', '1', '255']],
+                          ['0', '0', '0', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1', '0', '0', '0', '0'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_s', ['0x55', '0xAAAAAAAA'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+
+        # gt_u
+        case_data.append(['#', 'gt_u'])
+        case_data.append(['#', 'i8x16.gt_u  (i8x16) (i8x16)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['gt_u', ['0xFF', '0xFF'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', ['0x00', '0x00'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', ['0xF0', '0xF0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', ['0x0F', '0x0F'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['0xFF', '0x00'], ['0xFF', '0x00']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['0x00', '0xFF'], ['0x00', '0xFF']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['gt_u', ['0xFF', '255'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', ['0xFF', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', ['0x80', '128'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', ['0x80', '-128'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['gt_u', ['-1', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', ['0', '0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', ['255', '255'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', ['255', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['255', '0'], ['255', '0']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['0', '255'], ['0', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '-0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['gt_u', [['0x00', '0x00', '0x00', '0xc3', '0x00', '0x00', '0xfe', '0xc2', '0x00', '0x00', '0x80', '0xbf', '0x00', '0x00', '0x00', '0x00'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i8x16', 'f32x4', 'i8x16']])
+        case_data.append(['gt_u', [['0x00', '0x00', '0x80', '0x3f', '0x00', '0x00', '0xfe', '0x42', '0x00', '0x00', '0x00', '0x43', '0x00', '0x00', '0x7f', '0x43'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i8x16', 'f32x4', 'i8x16']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['gt_u', ['0x0F', '0xF0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['0x00', '0xFF'], ['0xFF', '0x00']], ['0', '0', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0xFF', '0xAB', '0xAA', '0x1B', '0x1A', '0x0B', '0x0A', '0x12', '0x11', '0x10', '0x09', '0x04', '0x03', '0x02', '0x01', '0x00']],
+                          ['0', '0', '0', '0', '0', '0', '-1', '0', '-1', '0', '-1', '-1', '-1', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['0', '0', '0', '-1', '-1', '-1', '-1', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '-0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['0', '0', '0', '-1', '-1', '-1', '-1', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['#', 'i8x16.gt_u  (i8x16) (i16x8)'])
+        case_data.append(['gt_u', ['0xFF', '0xFFFF'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_u', ['255', '65535'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_u', ['0', '0'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_u', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_u', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '-128', '0', '0', '1', '1', '255', '255']],
+                          ['0', '0', '0', '0', '0', '0', '0', '0', '0', '-1', '0', '-1', '0', '-1', '0', '-1'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_u', ['0x55', '0xAAAA'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['#', 'i8x16.gt_u  (i8x16) (i32x4)'])
+        case_data.append(['gt_u', ['0xFF', '0xFFFFFFFF'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_u', ['255', '4294967295'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_u', ['0', '0'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_u', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'], ['2206368128', '16776957', '2130837760', '4294901120']],
+                          ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_u', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '0', '1', '255']],
+                          ['0', '0', '0', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1', '0', '-1', '-1', '-1'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_u', ['0x55', '0xAAAAAAAA'], ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i32x4', 'i8x16']])
+
+        # ge_s
+        case_data.append(['#', 'ge_s'])
+        case_data.append(['#', 'i8x16.ge_s  (i8x16) (i8x16)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ge_s', ['0xFF', '0xFF'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', ['0x00', '0x00'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', ['0xF0', '0xF0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', ['0x0F', '0x0F'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['0xFF', '0x00'], ['0xFF', '0x00']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['0x00', '0xFF'], ['0x00', '0xFF']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['ge_s', ['0xFF', '255'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', ['0xFF', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', ['0x80', '128'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', ['0x80', '-128'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['ge_s', ['-1', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', ['0', '0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', ['255', '255'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', ['255', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['255', '0'], ['255', '0']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['0', '255'], ['0', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '-0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['ge_s', [['0x00', '0x00', '0x00', '0xc3', '0x00', '0x00', '0xfe', '0xc2', '0x00', '0x00', '0x80', '0xbf', '0x00', '0x00', '0x00', '0x00'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i8x16', 'f32x4', 'i8x16']])
+        case_data.append(['ge_s', [['0x00', '0x00', '0x80', '0x3f', '0x00', '0x00', '0xfe', '0x42', '0x00', '0x00', '0x00', '0x43', '0x00', '0x00', '0x7f', '0x43'],
+                          ['1.0', '127.0', '128.0', '255.0']], '-1', ['i8x16', 'f32x4', 'i8x16']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['ge_s', ['0x0F', '0xF0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['0x00', '0xFF'], ['0xFF', '0x00']], ['-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0xFF', '0xAB', '0xAA', '0x1B', '0x1A', '0x0B', '0x0A', '0x12', '0x11', '0x10', '0x09', '0x04', '0x03', '0x02', '0x01', '0x00']],
+                          ['-1', '-1', '-1', '0', '0', '0', '-1', '0', '-1', '0', '-1', '-1', '-1', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['0', '0', '0', '-1', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '0', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '-0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['0', '0', '0', '-1', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '0', '-1', '-1', '-1'],
+                          ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['#', 'i8x16.ge_s  (i8x16) (i16x8)'])
+        case_data.append(['ge_s', ['0xFF', '0xFFFF'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_s', ['255', '65535'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_s', ['0', '0'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_s', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_s', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '-128', '0', '0', '1', '1', '255', '255']],
+                          ['-1', '0', '-1', '0', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '-1', '0'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_s', ['0x55', '0xAAAA'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['#', 'i8x16.ge_s  (i8x16) (i32x4)'])
+        case_data.append(['ge_s', ['0xFF', '0xFFFFFFFF'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_s', ['255', '4294967295'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_s', ['0', '0'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_s', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_s', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '0', '1', '255']],
+                          ['-1', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_s', ['0x55', '0xAAAAAAAA'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+
+        # ge_u
+        # i8x16.ge_u  (i8x16) (i8x16)
+        case_data.append(['#', 'ge_u'])
+        case_data.append(['#', 'i8x16.ge_u  (i8x16) (i8x16)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ge_u', ['0xFF', '0xFF'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', ['0x00', '0x00'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', ['0xF0', '0xF0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', ['0x0F', '0x0F'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['0xFF', '0x00'], ['0xFF', '0x00']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['0x00', '0xFF'], ['0x00', '0xFF']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['ge_u', ['0xFF', '255'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', ['0xFF', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', ['0x80', '128'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', ['0x80', '-128'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['ge_u', ['-1', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', ['0', '0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', ['255', '255'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', ['255', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['255', '0'], ['255', '0']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['0', '255'], ['0', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '-0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['ge_u', [['0x00', '0x00', '0x00', '0xc3', '0x00', '0x00', '0xfe', '0xc2', '0x00', '0x00', '0x80', '0xbf', '0x00', '0x00', '0x00', '0x00'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i8x16', 'f32x4', 'i8x16']])
+        case_data.append(['ge_u', [['0x00', '0x00', '0x80', '0x3f', '0x00', '0x00', '0xfe', '0x42', '0x00', '0x00', '0x00', '0x43', '0x00', '0x00', '0x7f', '0x43'],
+                          ['1.0', '127.0', '128.0', '255.0']], '-1', ['i8x16', 'f32x4', 'i8x16']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['ge_u', ['0x0F', '0xF0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['0x00', '0xFF'], ['0xFF', '0x00']], ['0', '0', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0xFF', '0xAB', '0xAA', '0x1B', '0x1A', '0x0B', '0x0A', '0x12', '0x11', '0x10', '0x09', '0x04', '0x03', '0x02', '0x01', '0x00']],
+                          ['0', '0', '0', '0', '0', '0', '-1', '0', '-1', '0', '-1', '-1', '-1', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['0', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '0', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '-0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['0', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '0', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+
+        # i8x16.ge_u (i8x16) (i16x8)
+        case_data.append(['#', 'i8x16.ge_u (i8x16) (i16x8)'])
+        case_data.append(['ge_u', ['0xFF', '0xFFFF'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_u', ['255', '65535'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_u', ['0', '0'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_u', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_u', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'],
+                          ['-128', '-128', '0', '0', '1', '1', '255', '255']], ['-1', '0', '-1', '0', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_u', ['0x55', '0xAAAA'], ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i16x8', 'i8x16']])
+
+        # i8x16.ge_u (i8x16) (i32x4)
+        case_data.append(['#', 'i8x16.ge_u (i8x16) (i32x4)'])
+        case_data.append(['ge_u', ['0xFF', '0xFFFFFFFF'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_u', ['255', '4294967295'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_u', ['0', '0'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_u', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_u', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'],
+                          ['-128', '0', '1', '255']], ['-1', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_u', ['0x55', '0xAAAAAAAA'], ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i32x4', 'i8x16']])
+
+        return case_data
+
+
+def gen_test_cases():
+    i8x16 = Simdi8x16CmpCase()
+    i8x16.gen_test_cases()
+
+
+if __name__ == '__main__':
+    i8x16 = Simdi8x16CmpCase()
+    i8x16.gen_test_cases()
diff --git a/test/core/simd/meta/simd_int_arith2.py b/test/core/simd/meta/simd_int_arith2.py
new file mode 100644
index 000000000..342aea854
--- /dev/null
+++ b/test/core/simd/meta/simd_int_arith2.py
@@ -0,0 +1,575 @@
+#!/usr/bin/env python3
+
+"""
+Generate [min_s, min_u, max_s, max_u] cases for i32x4, i16x8 and i8x16.
+"""
+
+from simd import SIMD
+from test_assert import AssertReturn, AssertInvalid, AssertMalformed
+from simd_lane_value import LaneValue
+from simd_integer_op import ArithmeticOp
+
+
+class SimdLaneWiseInteger:
+    LANE_TYPE = None
+
+    LANE_VALUE = None
+
+    BINARY_OPS = ('min_s', 'min_u', 'max_s', 'max_u',)
+
+    UNARY_OPS = ('abs',)
+
+    class_summary = """;; Tests for {lane_type} [min_s, min_u, max_s, max_u, avgr_u, abs] operations."""
+
+    def __init__(self):
+
+        self.LANE_VALUE = LaneValue(self.lane_width)
+
+    @property
+    def lane_count(self):
+        """count of lanes"""
+        return int(self.LANE_TYPE.split('x')[1])
+
+    @property
+    def lane_width(self):
+        """width of a single lane"""
+        return int(self.LANE_TYPE.replace('i', '').split('x')[0])
+
+    @property
+    def get_unary_complex_test_data(self):
+        """test const vs const and different lanes go through different if-then clauses for unary ops"""
+        case_data = [
+            [self.LANE_VALUE.min, self.LANE_VALUE.max, self.LANE_VALUE.quarter, self.LANE_VALUE.mask]
+        ]
+        case_data = [list(map(str, param)) for param in case_data]
+
+        return case_data
+
+    @property
+    def get_binary_test_data_with_const(self):
+        """test const vs const and param vs const for binary ops"""
+        case_data = [
+            [
+                [self.LANE_VALUE.min, self.LANE_VALUE.max, self.LANE_VALUE.quarter, self.LANE_VALUE.mask],
+                [self.LANE_VALUE.mask, self.LANE_VALUE.quarter, self.LANE_VALUE.max, self.LANE_VALUE.min]
+            ],
+            [
+                [0, 1, 2, 3],
+                [3, 2, 1, 0],
+            ]
+        ]
+        case_data = [[list(map(str, param_1)), list(map(str, param_2))] for param_1, param_2 in case_data]
+
+        return case_data
+
+    @property
+    def get_binary_test_data_go_through_if(self):
+        """test different lanes go through different if-then clauses"""
+        case_data = [
+            [
+                [self.LANE_VALUE.min, self.LANE_VALUE.max, self.LANE_VALUE.quarter, self.LANE_VALUE.mask],
+                [self.LANE_VALUE.mask, self.LANE_VALUE.quarter, self.LANE_VALUE.max, self.LANE_VALUE.min]
+            ],
+            [
+                [0, 1, 2, 128],
+                [0, 2, 1, 0x80],
+            ]
+        ]
+        case_data = [[list(map(str, param_1)), list(map(str, param_2))] for param_1, param_2 in case_data]
+
+        return case_data
+
+    @property
+    def get_unary_test_data_opposite_sign_zero(self):
+        """test opposite signs of zero for unary ops"""
+        case_data = [
+            ['-0', '-0', '+0', '+0'],
+            ['+0', '0', '-0', '0'],
+            ['-0', '-0', '-0', '-0'],
+            ['+0', '+0', '+0', '+0'],
+        ]
+
+        return case_data
+
+    @property
+    def get_binary_test_data_opposite_sign_zero(self):
+        """test opposite signs of zero for binary ops"""
+        case_data = [
+            [
+                ['-0', '-0', '+0', '+0'],
+                ['+0', '0', '-0', '0'],
+            ],
+            [
+                ['-0', '-0', '-0', '-0'],
+                ['+0', '+0', '+0', '+0'],
+            ]
+        ]
+
+        return case_data
+
+    @property
+    def get_unary_test_data(self):
+        """general unary case data"""
+
+        case_data = [
+
+            ['1'] * self.lane_count,
+            ['-1'] * self.lane_count,
+            [str(self.LANE_VALUE.mask)] * self.lane_count,
+            [hex(self.LANE_VALUE.mask)] * self.lane_count,
+            [str(-self.LANE_VALUE.min)] * self.lane_count,
+            [str(self.LANE_VALUE.min)] * self.lane_count,
+            [hex(self.LANE_VALUE.min)] * self.lane_count,
+            [hex(-self.LANE_VALUE.min)] * self.lane_count,
+            ['01_2_3'] * self.lane_count,
+            ['-01_2_3'] * self.lane_count,
+            ['0x80'] * self.lane_count,
+            ['-0x80'] * self.lane_count,
+            ['0x0_8_0'] * self.lane_count,
+            ['-0x0_8_0'] * self.lane_count
+
+        ]
+
+        return case_data
+
+    @property
+    def get_binary_test_data(self):
+        """general binary case data"""
+
+        case_data = [
+
+            [
+                ['0'] * self.lane_count,
+                ['0'] * self.lane_count,
+            ],
+            [
+                ['0'] * self.lane_count,
+                ['-1'] * self.lane_count,
+            ],
+            [
+                ['0', '0', '-1', '-1'],
+                ['0', '-1', '0', '-1'],
+            ],
+            [
+                ['0'] * self.lane_count,
+                [hex(self.LANE_VALUE.mask)] * self.lane_count,
+            ],
+
+            [
+                ['1'] * self.lane_count,
+                ['1'] * self.lane_count,
+            ],
+            [
+                [str(self.LANE_VALUE.mask)] * self.lane_count,
+                ['1'] * self.lane_count,
+            ],
+            [
+                [str(self.LANE_VALUE.mask)] * self.lane_count,
+                ['128'] * self.lane_count,
+            ],
+            [
+                [str(-self.LANE_VALUE.min)] * self.lane_count,
+                [str(self.LANE_VALUE.min)] * self.lane_count,
+            ],
+            [
+                [hex(-self.LANE_VALUE.min)] * self.lane_count,
+                [str(self.LANE_VALUE.min)] * self.lane_count,
+            ],
+            [
+                ['123'] * self.lane_count,
+                ['01_2_3'] * self.lane_count,
+            ],
+            [
+                ['0x80'] * self.lane_count,
+                ['0x0_8_0'] * self.lane_count,
+            ],
+
+        ]
+
+        return case_data
+
+    @property
+    def gen_funcs_normal(self):
+        """generate normal functions"""
+        binary_func_template = '\n  (func (export "{lane_type}.{op}") (param v128 v128) (result v128) ({lane_type}.{op} (local.get 0) (local.get 1)))'
+        unary_func_template = '\n  (func (export "{lane_type}.{op}") (param v128) (result v128) ({lane_type}.{op} (local.get 0)))'
+        funcs = ''
+        for op in self.BINARY_OPS:
+            funcs += binary_func_template.format(lane_type=self.LANE_TYPE, op=op)
+        for op in self.UNARY_OPS:
+            funcs += unary_func_template.format(lane_type=self.LANE_TYPE, op=op)
+        return funcs
+
+    @property
+    def gen_funcs_with_const(self):
+        """generate functions with const arguments"""
+        binary_func_with_const = '\n  (func (export "{lane_type}.{op}_with_const_{cnt}") (result v128) ({lane_type}.{op} {param_1} {param_2}))'
+        unary_func_with_const = '\n  (func (export "{lane_type}.{op}_with_const_{cnt}") (result v128) ({lane_type}.{op} {param}))'
+        binary_func_with_param_and_const = '\n  (func (export "{lane_type}.{op}_with_const_{cnt}") (param v128) (result v128) ({lane_type}.{op} (local.get 0) {param_1}))'
+        funcs = ''
+        cnt = 0
+        for op in self.BINARY_OPS:
+            for param_1, param_2 in self.get_binary_test_data_with_const:
+                funcs += binary_func_with_const.format(lane_type=self.LANE_TYPE,
+                                                op=op,
+                                                param_1=SIMD.v128_const(param_1, self.LANE_TYPE),
+                                                param_2=SIMD.v128_const(param_2, self.LANE_TYPE),
+                                                cnt=cnt)
+                cnt += 1
+        for op in self.UNARY_OPS:
+            for param in self.get_unary_complex_test_data:
+                funcs += unary_func_with_const.format(lane_type=self.LANE_TYPE,
+                                               op=op,
+                                               param=SIMD.v128_const(param, self.LANE_TYPE),
+                                               cnt=cnt)
+                cnt += 1
+        for op in self.BINARY_OPS:
+            for param_1, param_2 in self.get_binary_test_data_with_const:
+                funcs += binary_func_with_param_and_const.format(lane_type=self.LANE_TYPE,
+                                                          op=op,
+                                                          param_1=SIMD.v128_const(param_1, self.LANE_TYPE),
+                                                          cnt=cnt)
+                cnt += 1
+
+        return funcs
+
+    @property
+    def gen_test_case_with_const(self):
+        """generate tests calling function with const"""
+        cnt = 0
+        cases = '\n\n;; Const vs const'
+        for op in self.BINARY_OPS:
+            o = ArithmeticOp(op)
+            for param_1, param_2 in self.get_binary_test_data_with_const:
+                result = []
+                for idx in range(0, len(param_1)):
+                    result.append(o.binary_op(param_1[idx], param_2[idx], self.LANE_VALUE))
+                cases += '\n' + str(AssertReturn('{lane_type}.{op}_with_const_{cnt}'.format(lane_type=self.LANE_TYPE, op=op, cnt=cnt),
+                                                 [],
+                                                 SIMD.v128_const(result, self.LANE_TYPE)))
+                cnt += 1
+
+        for op in self.UNARY_OPS:
+            o = ArithmeticOp(op)
+            for param in self.get_unary_complex_test_data:
+                result = []
+                for idx in range(0, len(param)):
+                    result.append(o.unary_op(param[idx], self.LANE_VALUE))
+                cases += '\n' + str(AssertReturn('{lane_type}.{op}_with_const_{cnt}'.format(lane_type=self.LANE_TYPE, op=op, cnt=cnt),
+                                                 [],
+                                                 SIMD.v128_const(result, self.LANE_TYPE)))
+                cnt += 1
+
+        cases += '\n\n;; Param vs const'
+        for op in self.BINARY_OPS:
+            o = ArithmeticOp(op)
+            for param_1, param_2 in self.get_binary_test_data_with_const:
+                result = []
+                for idx in range(0, len(param_1)):
+                    result.append(o.binary_op(param_1[idx], param_2[idx], self.LANE_VALUE))
+                cases += '\n' + str(AssertReturn('{lane_type}.{op}_with_const_{cnt}'.format(lane_type=self.LANE_TYPE, op=op, cnt=cnt),
+                                                 [SIMD.v128_const(param_2, self.LANE_TYPE)],
+                                                 SIMD.v128_const(result, self.LANE_TYPE)))
+                cnt += 1
+
+        return cases
+
+    @property
+    def gen_test_case(self):
+        """generate binary test cases"""
+        cases = ''
+
+        def gen_binary(case_data):
+            cases = ''
+            for op in self.BINARY_OPS:
+                o = ArithmeticOp(op)
+                for param_1, param_2 in case_data:
+                    result = []
+                    for idx in range(0, len(param_1)):
+                        result.append(o.binary_op(param_1[idx], param_2[idx], self.LANE_VALUE))
+                    cases += '\n' + str(AssertReturn('{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op),
+                                                     [SIMD.v128_const(param_1, self.LANE_TYPE), SIMD.v128_const(param_2, self.LANE_TYPE)],
+                                                     SIMD.v128_const(result, self.LANE_TYPE)))
+            return cases
+
+        def gen_unary(case_data):
+            cases = ''
+            for op in self.UNARY_OPS:
+                o = ArithmeticOp(op)
+                for param in case_data:
+                    result = []
+                    for idx in range(0, len(param)):
+                        result.append(o.unary_op(param[idx], self.LANE_VALUE))
+                    cases += '\n' + str(AssertReturn('{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op),
+                                                     [SIMD.v128_const(param, self.LANE_TYPE)],
+                                                     SIMD.v128_const(result, self.LANE_TYPE)))
+            return cases
+
+        cases += gen_binary(self.get_binary_test_data)
+        cases += gen_unary(self.get_unary_test_data)
+
+        cases += self.gen_test_case_with_const
+
+        # test different lanes go through different if-then clauses
+        cases += '\n\n;; Test different lanes go through different if-then clauses'
+        cases += gen_binary(self.get_binary_test_data_go_through_if)
+        cases += gen_unary(self.get_unary_complex_test_data)
+
+        # test opposite signs of zero
+        cases += '\n\n;; Test opposite signs of zero'
+        cases += gen_binary(self.get_binary_test_data_opposite_sign_zero)
+        cases += gen_unary(self.get_unary_test_data_opposite_sign_zero)
+
+        # unknown operators test cases
+        cases += self.gen_test_case_unknown_operators
+
+        # type check test cases
+        cases += self.gen_test_case_type_check
+
+        # empty argument test cases
+        cases += self.gen_test_case_empty_argument
+
+        return cases
+
+    @property
+    def gen_test_case_unknown_operators(self):
+        """generate unknown operators test cases"""
+        cases = ['\n\n;; Unknown operators']
+
+        for op in self.UNKNOWN_BINARY_OPS:
+            cases.append(AssertMalformed.get_unknown_op_test(
+                op, 'v128',
+                SIMD.v128_const('0', self.LANE_TYPE),
+                SIMD.v128_const('1', self.LANE_TYPE)
+            ))
+        if hasattr(self, 'UNKNOWN_UNARY_OPS'):
+            for op in self.UNKNOWN_UNARY_OPS:
+                cases.append(AssertMalformed.get_unknown_op_test(
+                    op, 'v128',
+                    SIMD.v128_const('-1', self.LANE_TYPE)
+                ))
+        return '\n'.join(cases)
+
+    @property
+    def gen_test_case_type_check(self):
+        """generate type check test cases"""
+        cases = '\n\n;; Type check'
+        binary_assert_template = '(assert_invalid (module (func (result v128) ({lane_type}.{op} (i32.const 0) (f32.const 0.0)))) "type mismatch")'
+        unary_assert_template = '(assert_invalid (module (func (result v128) ({lane_type}.{op} (f32.const 0.0)))) "type mismatch")'
+        for op in self.BINARY_OPS:
+            cases += '\n' + binary_assert_template.format(lane_type=self.LANE_TYPE, op=op)
+        for op in self.UNARY_OPS:
+            cases += '\n' + unary_assert_template.format(lane_type=self.LANE_TYPE, op=op)
+
+        return cases
+
+    @property
+    def gen_funcs_combination(self):
+        """generate functions for combination test cases"""
+        funcs = '\n\n;; Combination'
+        funcs += '\n(module'
+
+        binary_vs_binary_assert_template = '  (func (export "{lane_type}.{op1}-{lane_type}.{op2}") (param v128 v128 v128) (result v128) ' \
+                          '({lane_type}.{op1} ({lane_type}.{op2} (local.get 0) (local.get 1))(local.get 2))' \
+                          ')'
+        binary_vs_unary_assert_template = '  (func (export "{lane_type}.{op1}-{lane_type}.{op2}") (param v128 v128) (result v128) ' \
+                          '({lane_type}.{op1} ({lane_type}.{op2} (local.get 0))(local.get 1))' \
+                          ')'
+        unary_vs_binary_assert_template = '  (func (export "{lane_type}.{op1}-{lane_type}.{op2}") (param v128 v128) (result v128) ' \
+                          '({lane_type}.{op1} ({lane_type}.{op2} (local.get 0) (local.get 1)))' \
+                          ')'
+        unary_vs_unary_assert_template = '  (func (export "{lane_type}.{op1}-{lane_type}.{op2}") (param v128) (result v128) ' \
+                          '({lane_type}.{op1} ({lane_type}.{op2} (local.get 0)))' \
+                          ')'
+
+        binary_ops = list(self.BINARY_OPS)
+        binary_ops.reverse()
+        unary_ops = list(self.UNARY_OPS)
+        unary_ops.reverse()
+        for op1 in self.BINARY_OPS:
+            for op2 in binary_ops:
+                funcs += '\n' + binary_vs_binary_assert_template.format(lane_type=self.LANE_TYPE, op1=op1, op2=op2)
+            for op2 in self.UNARY_OPS:
+                funcs += '\n' + binary_vs_unary_assert_template.format(lane_type=self.LANE_TYPE, op1=op1, op2=op2)
+                funcs += '\n' + unary_vs_binary_assert_template.format(lane_type=self.LANE_TYPE, op1=op2, op2=op1)
+        for op1 in self.UNARY_OPS:
+            for op2 in unary_ops:
+                funcs += '\n' + unary_vs_unary_assert_template.format(lane_type=self.LANE_TYPE, op1=op1, op2=op2)
+
+        funcs += '\n)'
+        return funcs
+
+    @property
+    def gen_test_case_combination(self):
+        """generate combination test cases"""
+
+        cases = '\n'
+
+        binary_ops = list(self.BINARY_OPS)
+        binary_ops.reverse()
+        unary_ops = list(self.UNARY_OPS)
+        unary_ops.reverse()
+        for op1 in self.BINARY_OPS:
+            """binary vs binary"""
+            o1 = ArithmeticOp(op1)
+            for op2 in binary_ops:
+                o2 = ArithmeticOp(op2)
+                result = []
+                ret = o2.binary_op('0', '1', self.LANE_VALUE)
+                ret = o1.binary_op(ret, '2', self.LANE_VALUE)
+                result.append(ret)
+
+                cases += '\n' + str(AssertReturn('{lane_type}.{op1}-{lane_type}.{op2}'.format(lane_type=self.LANE_TYPE, op1=op1, op2=op2),
+                                                 [SIMD.v128_const('0', self.LANE_TYPE),
+                                                  SIMD.v128_const('1', self.LANE_TYPE),
+                                                  SIMD.v128_const('2', self.LANE_TYPE)],
+                                                 SIMD.v128_const(result, self.LANE_TYPE)))
+            for op2 in self.UNARY_OPS:
+                """binary vs unary"""
+                o2 = ArithmeticOp(op2)
+                result1 = []
+                ret1 = o2.unary_op('-1', self.LANE_VALUE)
+                ret1 = o1.binary_op(ret1, '0', self.LANE_VALUE)
+                result1.append(ret1)
+                cases += '\n' + str(AssertReturn('{lane_type}.{op1}-{lane_type}.{op2}'.format(lane_type=self.LANE_TYPE, op1=op1, op2=op2),
+                                                 [SIMD.v128_const('-1', self.LANE_TYPE),
+                                                  SIMD.v128_const('0', self.LANE_TYPE)],
+                                                 SIMD.v128_const(result1, self.LANE_TYPE)))
+                """unary vs binary"""
+                result2 = []
+                ret2 = o1.binary_op('0', '-1', self.LANE_VALUE)
+                ret2 = o2.unary_op(ret2, self.LANE_VALUE)
+                result2.append(ret2)
+                cases += '\n' + str(AssertReturn('{lane_type}.{op1}-{lane_type}.{op2}'.format(lane_type=self.LANE_TYPE, op1=op2, op2=op1),
+                                                 [SIMD.v128_const('0', self.LANE_TYPE),
+                                                  SIMD.v128_const('-1', self.LANE_TYPE)],
+                                                 SIMD.v128_const(result2, self.LANE_TYPE)))
+        for op1 in self.UNARY_OPS:
+            """unary vs unary"""
+            o1 = ArithmeticOp(op1)
+            for op2 in unary_ops:
+                o2 = ArithmeticOp(op2)
+                result3 = []
+                ret3 = o2.unary_op('-1', self.LANE_VALUE)
+                ret3 = o1.unary_op(ret3, self.LANE_VALUE)
+                result3.append(ret3)
+                cases += '\n' + str(AssertReturn('{lane_type}.{op1}-{lane_type}.{op2}'.format(lane_type=self.LANE_TYPE, op1=op1, op2=op2),
+                                                 [SIMD.v128_const('-1', self.LANE_TYPE)],
+                                                 SIMD.v128_const(result3, self.LANE_TYPE)))
+
+        cases += '\n'
+        return cases
+
+    @property
+    def gen_test_case_empty_argument(self):
+        """generate empty argument test cases"""
+
+        cases = []
+
+        cases.append('\n\n;; Test operation with empty argument\n')
+
+        case_data = {
+            'op': '',
+            'extended_name': 'arg-empty',
+            'param_type': '',
+            'result_type': '(result v128)',
+            'params': '',
+        }
+
+        for op in self.BINARY_OPS:
+            case_data['op'] = '{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op)
+            case_data['extended_name'] = '1st-arg-empty'
+            case_data['params'] = SIMD.v128_const('0', self.LANE_TYPE)
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        for op in self.UNARY_OPS:
+            case_data['op'] = '{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op)
+
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        return '\n'.join(cases)
+
+    @property
+    def gen_funcs(self):
+        """generate functions"""
+        funcs = ''
+        funcs += '\n\n(module'
+        funcs += self.gen_funcs_normal
+        funcs += self.gen_funcs_with_const
+        funcs += '\n)\n'
+
+        return funcs
+
+    def get_all_cases(self):
+        """generate all test cases"""
+        cases = self.class_summary.format(lane_type=self.LANE_TYPE) \
+            + self.gen_funcs \
+            + self.gen_test_case \
+            + self.gen_funcs_combination \
+            + self.gen_test_case_combination
+
+        return cases
+
+    def gen_test_cases(self):
+        """generate case file"""
+        wast_filename = '../simd_{lane_type}_arith2.wast'.format(lane_type=self.LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            fp.write(self.get_all_cases())
+
+
+class Simdi64x2Case(SimdLaneWiseInteger):
+    LANE_TYPE = 'i64x2'
+    class_summary = """;; Tests for {lane_type} [abs] operations."""
+    BINARY_OPS = ()
+
+    UNKNOWN_BINARY_OPS = ()
+
+
+class Simdi32x4Case(SimdLaneWiseInteger):
+    LANE_TYPE = 'i32x4'
+    class_summary = """;; Tests for {lane_type} [min_s, min_u, max_s, max_u, abs] operations."""
+
+    UNKNOWN_BINARY_OPS = ('f32x4.min_s', 'f32x4.min_u', 'f32x4.max_s', 'f32x4.max_u',
+                   'i64x2.min_s', 'i64x2.min_u', 'i64x2.max_s', 'i64x2.max_u',
+                   'f64x2.min_s', 'f64x2.min_u', 'f64x2.max_s', 'f64x2.max_u')
+
+
+class Simdi16x8Case(SimdLaneWiseInteger):
+    LANE_TYPE = 'i16x8'
+
+    BINARY_OPS = ('min_s', 'min_u', 'max_s', 'max_u', 'avgr_u')
+    UNKNOWN_BINARY_OPS = ('i16x8.avgr', 'i16x8.avgr_s')
+
+
+class Simdi8x16Case(SimdLaneWiseInteger):
+    LANE_TYPE = 'i8x16'
+
+    UNARY_OPS = ('abs','popcnt')
+    BINARY_OPS = ('min_s', 'min_u', 'max_s', 'max_u', 'avgr_u')
+    UNKNOWN_BINARY_OPS = ('i32x4.avgr_u', 'f32x4.avgr_u',
+                   'i64x2.avgr_u', 'f64x2.avgr_u',
+                   'i8x16.avgr', 'i8x16.avgr_s')
+
+
+def gen_test_cases():
+    simd_i64x2_case = Simdi64x2Case()
+    simd_i64x2_case.gen_test_cases()
+
+    simd_i32x4_case = Simdi32x4Case()
+    simd_i32x4_case.gen_test_cases()
+
+    simd_i16x8_case = Simdi16x8Case()
+    simd_i16x8_case.gen_test_cases()
+
+    simd_i8x16_case = Simdi8x16Case()
+    simd_i8x16_case.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_int_to_int_extend.py b/test/core/simd/meta/simd_int_to_int_extend.py
new file mode 100644
index 000000000..b92b0d8e4
--- /dev/null
+++ b/test/core/simd/meta/simd_int_to_int_extend.py
@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+
+"""
+Generates all integer-to-integer extension test cases.
+"""
+
+from simd import SIMD
+from simd_arithmetic import SimdArithmeticCase
+from test_assert import AssertReturn, AssertInvalid
+
+
+class SimdIntToIntExtend(SimdArithmeticCase):
+    LANE_TYPE = ""  # unused, can be anything
+    BINARY_OPS = ()
+    UNARY_OPS = (
+        "i16x8.extend_high_i8x16_s",
+        "i16x8.extend_high_i8x16_u",
+        "i16x8.extend_low_i8x16_s",
+        "i16x8.extend_low_i8x16_u",
+        "i32x4.extend_high_i16x8_s",
+        "i32x4.extend_high_i16x8_u",
+        "i32x4.extend_low_i16x8_s",
+        "i32x4.extend_low_i16x8_u",
+        "i64x2.extend_high_i32x4_s",
+        "i64x2.extend_high_i32x4_u",
+        "i64x2.extend_low_i32x4_s",
+        "i64x2.extend_low_i32x4_u",
+    )
+
+    TEST_FUNC_TEMPLATE_HEADER = ";; Tests for int-to-int extension operations.\n"
+
+    def op_name(self, op):
+        # Override base class implementation, since the lane type is already
+        # part of the op name.
+        return "{op}".format(lane_type=self.LANE_TYPE, op=op)
+
+    def is_unsigned(self, op):
+        return op.endswith("_u")
+
+    def src_lane_type(self, op):
+        return op[-7:-2]
+
+    def dst_lane_type(self, op):
+        return op[0:5]
+
+    def get_test_cases(self, src_value):
+        return [
+            (0, 0),
+            (0, 1),
+            (0, -1),
+            (1, 0),
+            (-1, 0),
+            (1, -1),
+            ((-1, 1)),
+            ((src_value.max - 1), (src_value.max)),
+            ((src_value.max), (src_value.max - 1)),
+            ((src_value.max), (src_value.max)),
+            ((src_value.min), (src_value.min)),
+            ((src_value.max), (src_value.min)),
+            ((src_value.min), (src_value.max)),
+            ((src_value.max), -1),
+            (-1, (src_value.max)),
+            (((src_value.min + 1), (src_value.min))),
+            ((src_value.min), (src_value.min + 1)),
+            ((src_value.min), (-1)),
+            ((-1), (src_value.min)),
+        ]
+
+    def get_normal_case(self):
+        cases = []
+
+        for op in self.UNARY_OPS:
+            src_lane_type = self.src_lane_type(op)
+            src_value = self.LANE_VALUE[src_lane_type]
+            operands = self.get_test_cases(src_value)
+
+            for (low, high) in operands:
+                result = low if "low" in op else high
+
+                if self.is_unsigned(op):
+                    # Unsign-extend, mask top bits.
+                    result = result & src_value.mask
+
+                cases.append(
+                    str(
+                        AssertReturn(
+                            op,
+                            [SIMD.v128_const([str(low), str(high)], src_lane_type)],
+                            SIMD.v128_const(str(result), self.dst_lane_type(op)),
+                        )
+                    )
+                )
+
+            cases.append("")
+
+        return "\n".join(cases)
+
+    def gen_test_cases(self):
+        wast_filename = "../simd_int_to_int_extend.wast"
+        with open(wast_filename, "w") as fp:
+            fp.write(self.get_all_cases())
+
+    def get_combine_cases(self):
+        return ""
+
+
+def gen_test_cases():
+    simd_int_to_int_extend = SimdIntToIntExtend()
+    simd_int_to_int_extend.gen_test_cases()
+
+
+if __name__ == "__main__":
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_int_trunc_sat_float.py b/test/core/simd/meta/simd_int_trunc_sat_float.py
new file mode 100644
index 000000000..88048b6c9
--- /dev/null
+++ b/test/core/simd/meta/simd_int_trunc_sat_float.py
@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+
+"""Base class for generating SIMD <int>.trun_sat_<float> test cases.
+Subclasses should set:
+    - LANE_TYPE
+    - SRC_LANE_TYPE
+    - UNARY_OPS
+"""
+
+from abc import abstractmethod
+import struct
+from math import trunc
+from simd import SIMD
+from simd_arithmetic import SimdArithmeticCase
+from test_assert import AssertReturn
+from simd_float_op import FloatingPointOp, FloatingPointRoundingOp
+from simd_integer_op import ArithmeticOp
+
+
+class SimdConversionCase(SimdArithmeticCase):
+    BINARY_OPS = ()
+    TEST_FUNC_TEMPLATE_HEADER = ";; Tests for {} trunc sat conversions from float.\n"
+
+    def is_signed(self, op):
+        return op.endswith("_s") or op.endswith("_s_zero")
+
+    def get_test_data(self, lane):
+        return [
+            "0.0",
+            "-0.0",
+            "1.5",
+            "-1.5",
+            "1.9",
+            "2.0",
+            "-1.9",
+            "-2.0",
+            str(float(lane.max - 127)),
+            str(float(-(lane.max - 127))),
+            str(float(lane.max + 1)),
+            str(float(-(lane.max + 1))),
+            str(float(lane.max * 2)),
+            str(float(-(lane.max * 2))),
+            str(float(lane.max)),
+            str(float(-lane.max)),
+            str(float(lane.mask - 1)),
+            str(float(lane.mask)),
+            str(float(lane.mask + 1)),
+            "0x1p-149",
+            "-0x1p-149",
+            "0x1p-126",
+            "-0x1p-126",
+            "0x1p-1",
+            "-0x1p-1",
+            "0x1p+0",
+            "-0x1p+0",
+            "0x1.19999ap+0",
+            "-0x1.19999ap+0",
+            "0x1.921fb6p+2",
+            "-0x1.921fb6p+2",
+            "0x1.fffffep+127",
+            "-0x1.fffffep+127",
+            "0x1.ccccccp-1",
+            "-0x1.ccccccp-1",
+            "0x1.fffffep-1",
+            "-0x1.fffffep-1",
+            "0x1.921fb6p+2",
+            "-0x1.921fb6p+2",
+            "0x1.fffffep+127",
+            "-0x1.fffffep+127",
+            "+inf",
+            "-inf",
+            "+nan",
+            "-nan",
+            "nan:0x444444",
+            "-nan:0x444444",
+            "42",
+            "-42",
+            "0123456792.0",
+            "01234567890.0",
+        ]
+
+    def to_float_precision(self, value):
+        # Python supports double precision, so given an an input that cannot be
+        # precisely represented in f32, we need to round it.
+        return value
+
+    @abstractmethod
+    def to_results(self, result: str):
+        # Subclasses can override this to set the shape of the results. This is
+        # useful if instructions zero top lanes.
+        pass
+
+    def conversion_op(self, op, operand):
+        fop = FloatingPointRoundingOp()
+        signed = self.is_signed(op)
+        sat_op = ArithmeticOp("sat_s") if signed else ArithmeticOp("sat_u")
+        result = fop.unary_op("trunc", operand, hex_form=False)
+        if result == "nan":
+            return "0"
+        elif result == "+inf":
+            return str(str(self.lane.max) if signed else str(self.lane.mask))
+        elif result == "-inf":
+            return str(self.lane.min if signed else 0)
+        else:
+            float_result = self.to_float_precision(float(result))
+            trunced = int(trunc(float_result))
+            saturated = sat_op.unary_op(trunced, self.lane)
+            return str(saturated)
+
+    def get_case_data(self):
+        test_data = []
+        for op in self.UNARY_OPS:
+            op_name = "{}.{}".format(self.LANE_TYPE, op)
+            test_data.append(["#", op_name])
+
+            for operand in self.get_test_data(self.lane):
+                operand = str(operand)
+                if "nan" in operand:
+                    test_data.append(
+                        [op_name, [operand], "0", [self.SRC_LANE_TYPE, self.LANE_TYPE]]
+                    )
+                else:
+                    result = self.conversion_op(op_name, operand)
+                    results = self.to_results(result)
+                    assert "nan" not in result
+                    test_data.append(
+                        [
+                            op_name,
+                            [operand],
+                            results,
+                            [self.SRC_LANE_TYPE, self.LANE_TYPE],
+                        ]
+                    )
+
+        return test_data
+
+    def gen_test_cases(self):
+        wast_filename = "../simd_{}_trunc_sat_{}.wast".format(
+            self.LANE_TYPE, self.SRC_LANE_TYPE
+        )
+        with open(wast_filename, "w") as fp:
+            fp.write(self.get_all_cases())
+
+    def get_combine_cases(self):
+        return ""
+
+
+class SimdI32x4TruncSatF32x4Case(SimdConversionCase):
+    LANE_TYPE = "i32x4"
+    SRC_LANE_TYPE = "f32x4"
+    UNARY_OPS = ("trunc_sat_f32x4_s", "trunc_sat_f32x4_u")
+
+    def to_float_precision(self, value):
+        fop = FloatingPointOp()
+        return fop.to_single_precision(value)
+
+    def to_results(self, value: str):
+        return [value]
+
+
+class SimdI32x4TruncSatF64x2Case(SimdConversionCase):
+    LANE_TYPE = "i32x4"
+    SRC_LANE_TYPE = "f64x2"
+    UNARY_OPS = ("trunc_sat_f64x2_s_zero", "trunc_sat_f64x2_u_zero")
+
+    def to_results(self, value: str):
+        return [value, "0"]
+
+
+def gen_test_cases():
+    i32x4_trunc_sat = SimdI32x4TruncSatF32x4Case()
+    i32x4_trunc_sat.gen_test_cases()
+    i32x4_trunc_sat = SimdI32x4TruncSatF64x2Case()
+    i32x4_trunc_sat.gen_test_cases()
+
+
+if __name__ == "__main__":
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_integer_op.py b/test/core/simd/meta/simd_integer_op.py
new file mode 100644
index 000000000..69ed7235e
--- /dev/null
+++ b/test/core/simd/meta/simd_integer_op.py
@@ -0,0 +1,209 @@
+#!/usr/bin/env python3
+
+"""Common integer value operations"""
+
+from simd_lane_value import LaneValue
+
+
+class ArithmeticOp:
+    """This class provides methods to simulate integer arithmetic
+    and saturating integer arithmetic operations for the purpose of
+    getting corresponding expected results. One or more operands
+    may be required for the operations.
+    The following operators are covered:
+    add, sub, mul, neg,
+    add_sat_s, add_sat_u,
+    sub_sat_s, sub_sat_u,
+    min_s, min_u, max_s, max_u, avgr_u, abs
+    ext_mul_s, ext_mul_u
+    """
+    def __init__(self, op: str):
+        self.op = op
+
+    @staticmethod
+    def get_valid_value(value: int, lane: LaneValue, signed=True) -> int:
+        """Get the valid integer value in the scope of the specified lane size.
+
+        For a integer value, convert it to the valid value with the same bits
+        of the lane width. The value can be signed or unsigned, with the scope
+        of -0x80... to 0x7f... or 0 to 0xff...
+
+        :param value: the value of the integer
+        :param lane: the LaneValue instance of a lane in v128
+        :param signed: specify if the lane is interpreted as a signed or
+                        an unsigned number.
+        :return : the valid value in either signed or unsigned number
+        """
+        value &= lane.mask
+        if signed:
+            if value > lane.max:
+                return value - lane.mod
+            if value < lane.min:
+                return value + lane.mod
+        return value
+
+    def _saturate(self, operand1: int, operand2: int, lane: LaneValue) -> int:
+        """Get the result of saturating arithmetic operation on 2 operands.
+        The operands can be both signed or unsigned. The following ops
+        are covered:
+        add_sat_s, sub_sat_s, add_sat_u, sub_sat_u,
+
+        Saturating arithmetic can make sure:
+        When the operation result is less than the minimum, return the minimum.
+        When the operation result is greater than the maximum, return the maximum.
+        For other operation results, simply return themselves.
+        :param operand1: the integer operand 1
+        :param operand2: the integer operand 2
+        :param lane: the LaneValue instance of a lane in v128
+        :return: the result of the saturating arithmetic operation
+        """
+        if self.op.endswith('sat_s'):
+            if operand1 > lane.max:
+                operand1 -= lane.mod
+            if operand2 > lane.max:
+                operand2 -= lane.mod
+
+            if self.op.startswith('add'):
+                value = operand1 + operand2
+            if self.op.startswith('sub'):
+                value = operand1 - operand2
+
+            return lane.sat_s(value)
+
+        if self.op.endswith('sat_u'):
+            if operand1 < 0:
+                operand1 += lane.mod
+            if operand2 < 0:
+                operand2 += lane.mod
+            if self.op.startswith('add'):
+                value = operand1 + operand2
+            if self.op.startswith('sub'):
+                value = operand1 - operand2
+
+            return lane.sat_u(value)
+
+        return value
+
+    def unary_op(self, operand, lane):
+        """General integer arithmetic and saturating arithmetic operations
+        with only one operand.
+
+        Supported ops: neg, abs
+
+        :param operand: the operand, integer or literal string in hex or decimal format
+        :param lane: the LaneValue instance of a lane in v128
+        :return: the string of the result of <self.op p> in hex or decimal format
+        """
+        v = operand
+        base = 10
+        if isinstance(operand, str):
+            if '0x' in operand:
+                base = 16
+            v = int(operand, base)
+
+        if self.op == 'neg':
+            result = self.get_valid_value(-v, lane)
+        elif self.op == 'abs':
+            result = self.get_valid_value(v, lane)
+            if result >= 0:
+                return operand
+            else:
+                result = -result
+            if base == 16:
+                return hex(result)
+        elif self.op == 'popcnt':
+            result = self.get_valid_value(v, lane)
+            return str(bin(result % lane.mod).count('1'))
+        elif self.op == 'sat_s':
+            # Don't call get_valid_value, it will truncate results.
+            return lane.sat_s(v)
+        elif self.op == 'sat_u':
+            # Don't call get_valid_value, it will truncate results.
+            return lane.sat_u(v)
+        else:
+            raise Exception('Unknown unary operation')
+
+        return str(result)
+
+    def binary_op(self, operand1, operand2, src_lane, dst_lane=None):
+        """General integer arithmetic and saturating arithmetic operations
+        with 2 operands.
+
+        Supported ops:
+        add, sub, mul,
+        add_sat_s, add_sat_u,
+        sub_sat_s, sub_sat_u,
+        min_s, min_u, max_s, max_u, avgr_u,
+        ext_mul_s, ext_mul_u (same as mul),
+        q15mulr_sat_s
+
+        :param operand1: the operand 1, integer or literal string in hex or decimal format
+        :param operand2: the operand 2, integer or literal string in hex or decimal format
+        :param src_lane: the LaneValue instance of a lane in v128
+        :return: the string of the result of <p1 self.op p2> in hex or decimal format
+        """
+        if not dst_lane:
+            dst_lane = src_lane
+        v1 = operand1
+        v2 = operand2
+        base1 = base2 = 10
+        if isinstance(operand1, str):
+            if '0x' in operand1:
+                base1 = 16
+            v1 = int(operand1, base1)
+        if isinstance(operand2, str):
+            if '0x' in operand2:
+                base2 = 16
+            v2 = int(operand2, base2)
+
+        result_signed = True
+        if self.op == 'add':
+            value = v1 + v2
+        elif self.op == 'sub':
+            value = v1 - v2
+        elif self.op == 'mul':
+            value = v1 * v2
+        elif self.op.startswith('extmul_'):
+            if self.op.endswith('s'):
+                i1 = self.get_valid_value(v1, src_lane)
+                i2 = self.get_valid_value(v2, src_lane)
+            else:
+                i1 = self.get_valid_value(v1, src_lane, signed=False)
+                i2 = self.get_valid_value(v2, src_lane, signed=False)
+            value = i1 * i2
+        elif self.op == 'q15mulr_sat_s':
+            # This should be before 'sat' case.
+            i1 = ArithmeticOp.get_valid_value(v1, src_lane)
+            i2 = ArithmeticOp.get_valid_value(v2, src_lane)
+            return src_lane.sat_s((i1 * i2 + 0x4000) >> 15)
+        elif 'sat' in self.op:
+            value = self._saturate(v1, v2, src_lane)
+            if self.op.endswith('_u'):
+                result_signed = False
+        elif self.op in ['min_s', 'max_s']:
+            i1 = self.get_valid_value(v1, src_lane)
+            i2 = self.get_valid_value(v2, src_lane)
+            if self.op == 'min_s':
+                return operand1 if i1 <= i2 else operand2
+            else:
+                return operand1 if i1 >= i2 else operand2
+        elif self.op in ['min_u', 'max_u']:
+            i1 = self.get_valid_value(v1, src_lane, signed=False)
+            i2 = self.get_valid_value(v2, src_lane, signed=False)
+            if self.op == 'min_u':
+                return operand1 if i1 <= i2 else operand2
+            else:
+                return operand1 if i1 >= i2 else operand2
+        elif self.op == 'avgr_u':
+            i1 = self.get_valid_value(v1, src_lane, signed=False)
+            i2 = self.get_valid_value(v2, src_lane, signed=False)
+            result = (i1 + i2 + 1) // 2
+            if base1 == 16 or base2 == 16:
+                return hex(result)
+            else:
+                return str(result)
+        else:
+            raise Exception('Unknown binary operation')
+
+        result = self.get_valid_value(value, dst_lane, signed=result_signed)
+        return str(result)
diff --git a/test/core/simd/meta/simd_lane_value.py b/test/core/simd/meta/simd_lane_value.py
new file mode 100644
index 000000000..a280b0661
--- /dev/null
+++ b/test/core/simd/meta/simd_lane_value.py
@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+
+
+class LaneValue:
+    """This class stands for the value of signed integer represented by a lane in v128.
+    Suppose a bit number of the lane is n, then:
+    For signed integer:
+        minimum = -pow(2, n - 1), maximum = pow(2, n - 1) - 1
+    The bit number of the lane can be 8, 16, 32, 64"""
+    def __init__(self, lane_width):
+        """lane_width: bit number of each lane in SIMD v128"""
+        self.lane_width = lane_width
+
+    @property
+    def min(self):
+        return -pow(2, self.lane_width - 1)
+
+    @property
+    def max(self):
+        return pow(2, self.lane_width - 1) - 1
+
+    @property
+    def mask(self):
+        return pow(2, self.lane_width) - 1
+
+    @property
+    def mod(self):
+        return pow(2, self.lane_width)
+
+    @property
+    def quarter(self):
+        return pow(2, self.lane_width - 2)
+
+    def sat_s(self, v):
+        return max(self.min, min(v, self.max))
+
+    def sat_u(self, v):
+        return max(0, min(v, self.mask))
diff --git a/test/core/simd/meta/simd_load_lane.py b/test/core/simd/meta/simd_load_lane.py
new file mode 100644
index 000000000..2900e9850
--- /dev/null
+++ b/test/core/simd/meta/simd_load_lane.py
@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+
+from simd import SIMD
+from test_assert import AssertReturn, AssertInvalid
+
+def list_stringify(l):
+    return list(map(lambda x: str(x), l))
+
+"""Base class for generating SIMD load lane tests. Subclasses only to:
+    - define self.LANE_LEN, self.LANE_TYPE, self.NUM_LANES, self.MAX_ALIGN
+    - override get_normal_case to provide test data  (consult comments for details)
+
+It generates test cases that:
+    - load to all valid lane indices
+    - load using memarg offset
+    - load with memarg alignment
+    - load with invalid lane index
+    - load with invalid memarg alignment
+    - fails typecheck
+"""
+class SimdLoadLane:
+    def valid_alignments(self):
+        return [a for a in range(1, self.MAX_ALIGN+1) if a & (a-1) == 0]
+
+    def get_case_data(self):
+        # return value should be a list of tuples:
+        #   (address to load from : i32, initial value : v128, return value : v128)
+        # e.g. [(0, [0], [0x0100, 0, 0, 0, 0, 0, 0, 0]), ... ]
+        raise Exception("Subclasses should override this to provide test data")
+
+    def get_normal_case(self):
+        s = SIMD()
+        cases = []
+
+        # load using arg
+        for (addr, val, ret) in self.get_case_data():
+            i32_addr = s.const(addr, "i32")
+            v128_val = s.v128_const(list_stringify(val), self.LANE_TYPE)
+            v128_result = s.v128_const(list_stringify(ret), self.LANE_TYPE)
+            instr = "v128.load{lane_len}_lane_{idx}".format(lane_len=self.LANE_LEN, idx=addr)
+            cases.append(str(AssertReturn(instr, [i32_addr, v128_val], v128_result)))
+
+        # load using offset
+        for (addr, val, ret) in self.get_case_data():
+            v128_val = s.v128_const(list_stringify(val), self.LANE_TYPE)
+            v128_result = s.v128_const(list_stringify(ret), self.LANE_TYPE)
+            instr = "v128.load{lane_len}_lane_{idx}_offset_{idx}".format(lane_len=self.LANE_LEN, idx=addr)
+            cases.append(str(AssertReturn(instr, [v128_val], v128_result)))
+
+        # load using offset with alignment
+        for (addr, val, ret) in self.get_case_data():
+            for align in self.valid_alignments():
+                i32_addr = s.const(addr, "i32")
+                v128_val = s.v128_const(list_stringify(val), self.LANE_TYPE)
+                v128_result = s.v128_const(list_stringify(ret), self.LANE_TYPE)
+                instr = "v128.load{lane_len}_lane_{idx}_align_{align}".format(lane_len=self.LANE_LEN, idx=addr, align=align)
+                cases.append(str(AssertReturn(instr, [i32_addr, v128_val], v128_result)))
+
+        return '\n'.join(cases)
+
+    def gen_test_func_template(self):
+        template = [
+            ';; Tests for load lane operations.\n\n',
+            '(module',
+            '  (memory 1)',
+            '  (data (i32.const 0) "\\00\\01\\02\\03\\04\\05\\06\\07\\08\\09\\0A\\0B\\0C\\0D\\0E\\0F")',
+            ]
+
+        lane_indices = list(range(self.NUM_LANES))
+
+        # load using i32.const arg
+        for idx in lane_indices:
+            template.append(
+                '  (func (export "v128.load{lane_len}_lane_{idx}")\n'
+                '    (param $address i32) (param $x v128) (result v128)\n'
+                '    (v128.load{lane_len}_lane {idx} (local.get $address) (local.get $x)))'
+                .format(idx=idx, lane_len=self.LANE_LEN))
+
+        # load using memarg offset
+        for idx in lane_indices:
+            template.append(
+                '  (func (export "v128.load{lane_len}_lane_{idx}_offset_{idx}")\n'
+                '    (param $x v128) (result v128)\n'
+                '    (v128.load{lane_len}_lane offset={idx} {idx} (i32.const 0) (local.get $x)))'
+                .format(idx=idx, lane_len=self.LANE_LEN))
+
+        # with memarg aligment
+        for idx in lane_indices:
+            for align in self.valid_alignments():
+                template.append(
+                    '  (func (export "v128.load{lane_len}_lane_{idx}_align_{align}")\n'
+                    '    (param $address i32) (param $x v128) (result v128)\n'
+                    '    (v128.load{lane_len}_lane align={align} {idx} (local.get $address) (local.get $x)))'
+                    .format(idx=idx, lane_len=self.LANE_LEN, align=align))
+
+        template.append(')\n')
+        return template
+
+    def gen_test_template(self):
+        template = self.gen_test_func_template()
+
+        template.append('{normal_cases}')
+        template.append('\n{invalid_cases}')
+
+        return '\n'.join(template)
+
+    def get_invalid_cases(self):
+        invalid_cases = [';; type check']
+        invalid_cases.append(
+            '(assert_invalid'
+            '  (module (memory 1)\n'
+            '          (func (param $x v128) (result v128)\n'
+            '            (v128.load{lane_len}_lane 0 (local.get $x) (i32.const 0))))\n'
+            '  "type mismatch")'.format(lane_len=self.LANE_LEN))
+        invalid_cases.append('')
+
+        invalid_cases.append(';; invalid lane index')
+        invalid_cases.append(
+            '(assert_invalid'
+            '  (module (memory 1)\n'
+            '          (func (param $x v128) (result v128)\n'
+            '            (v128.load{lane_len}_lane {idx} (i32.const 0) (local.get $x))))\n'
+            '  "invalid lane index")'.format(idx=self.NUM_LANES, lane_len=self.LANE_LEN))
+
+        invalid_cases.append('')
+
+        invalid_cases.append(';; invalid memarg alignment')
+        invalid_cases.append(
+            '(assert_invalid\n'
+            '  (module (memory 1)\n'
+            '          (func (param $x v128) (result v128)\n'
+            '          (v128.load{lane_len}_lane align={align} 0 (i32.const 0) (local.get $x))))\n'
+            '  "alignment must not be larger than natural")'
+            .format(lane_len=self.LANE_LEN, align=self.MAX_ALIGN*2))
+        return '\n'.join(invalid_cases)
+
+    def get_all_cases(self):
+        case_data = {'lane_len': self.LANE_LEN,
+                     'normal_cases': self.get_normal_case(),
+                     'invalid_cases': self.get_invalid_cases(),
+                     }
+        return self.gen_test_template().format(**case_data)
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_load{lane_type}_lane.wast'.format(lane_type=self.LANE_LEN)
+        with open(wast_filename, 'w') as fp:
+            fp.write(self.get_all_cases())
+
+class SimdLoad8Lane(SimdLoadLane):
+    LANE_LEN = '8'
+    LANE_TYPE = 'i8x16'
+    NUM_LANES = 16
+    MAX_ALIGN = 1
+
+    def get_case_data(self):
+        return [
+            (0, [0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (1, [0], [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (2, [0], [0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (3, [0], [0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (4, [0], [0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (5, [0], [0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (6, [0], [0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (7, [0], [0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (8, [0], [0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0]),
+            (9, [0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0]),
+            (10, [0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0]),
+            (11, [0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0]),
+            (12, [0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0]),
+            (13, [0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0]),
+            (14, [0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0]),
+            (15, [0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15])]
+
+class SimdLoad16Lane(SimdLoadLane):
+    LANE_LEN = '16'
+    LANE_TYPE = 'i16x8'
+    NUM_LANES = 8
+    MAX_ALIGN = 2
+
+    def get_case_data(self):
+        return [
+            (0, [0], [0x0100, 0, 0, 0, 0, 0, 0, 0]),
+            (1, [0], [0, 0x0201, 0, 0, 0, 0, 0, 0]),
+            (2, [0], [0, 0, 0x0302, 0, 0, 0, 0, 0]),
+            (3, [0], [0, 0, 0, 0x0403, 0, 0, 0, 0]),
+            (4, [0], [0, 0, 0, 0, 0x0504, 0, 0, 0]),
+            (5, [0], [0, 0, 0, 0, 0, 0x0605, 0, 0]),
+            (6, [0], [0, 0, 0, 0, 0, 0, 0x0706, 0]),
+            (7, [0], [0, 0, 0, 0, 0, 0, 0, 0x0807])]
+
+class SimdLoad32Lane(SimdLoadLane):
+    LANE_LEN = '32'
+    LANE_TYPE = 'i32x4'
+    NUM_LANES = 4
+    MAX_ALIGN = 4
+
+    def get_case_data(self):
+        return [
+            (0, [0], [0x03020100, 0, 0, 0,]),
+            (1, [0], [0, 0x04030201, 0, 0,]),
+            (2, [0], [0, 0, 0x05040302, 0,]),
+            (3, [0], [0, 0, 0, 0x06050403,])]
+
+class SimdLoad64Lane(SimdLoadLane):
+    LANE_LEN = '64'
+    LANE_TYPE = 'i64x2'
+    NUM_LANES = 2
+    MAX_ALIGN = 8
+
+    def get_case_data(self):
+        return [
+            (0, [0], [0x0706050403020100, 0]),
+            (1, [0], [0, 0x0807060504030201])]
+
+def gen_test_cases():
+    simd_load8_lane = SimdLoad8Lane()
+    simd_load8_lane.gen_test_cases()
+    simd_load16_lane = SimdLoad16Lane()
+    simd_load16_lane.gen_test_cases()
+    simd_load32_lane = SimdLoad32Lane()
+    simd_load32_lane.gen_test_cases()
+    simd_load64_lane = SimdLoad64Lane()
+    simd_load64_lane.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_sat_arith.py b/test/core/simd/meta/simd_sat_arith.py
new file mode 100644
index 000000000..5831f5c76
--- /dev/null
+++ b/test/core/simd/meta/simd_sat_arith.py
@@ -0,0 +1,456 @@
+#!/usr/bin/env python3
+
+"""
+Generate saturating integer arithmetic operation cases.
+"""
+
+from simd_arithmetic import SimdArithmeticCase
+from test_assert import AssertReturn
+from simd import SIMD
+
+
+class SimdSaturateArithmeticCases(SimdArithmeticCase):
+    UNARY_OPS = ()
+    BINARY_OPS = ('add_sat_s', 'add_sat_u',
+                  'sub_sat_s', 'sub_sat_u')
+    malformed_template = '(assert_malformed (module quote\n    "(func (result v128) ' \
+                         '({lane_type}.{op} ({operand_1}) ({operand_2})))")\n    "unknown operator")'
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_{lane_type}_sat_arith.wast'.format(lane_type=self.LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            fp.write(self.get_all_cases())
+
+    def gen_test_template(self):
+        return super().gen_test_template().replace('{invalid_cases}',
+                                                   '{malformed_cases}\n\n{invalid_cases}')
+
+    def v128_const(self, lane, value, lane_len=None):
+        if not lane_len:
+            lane_len = self.LANE_LEN
+
+        return 'v128.const {lane_type} {value}'.format(lane_type=lane, value=' '.join([str(value)] * lane_len))
+
+    def get_malformed_cases(self):
+        malformed_cases = [';; Malformed cases: non-existent op names']
+        inst_ops = ['add', 'sub', 'mul', 'div']
+
+        # The op names should contain _s or _u suffixes, there is no mul or div
+        # for saturating integer arithmetic operation
+        for op in inst_ops:
+            malformed_cases.append(self.malformed_template.format(
+                lane_type=self.LANE_TYPE, op='_'.join([op, 'sat']),
+                operand_1=self.v128_const(self.LANE_TYPE, '1'), operand_2=self.v128_const(self.LANE_TYPE, '2')))
+
+        return '\n'.join(malformed_cases)
+
+    def argument_empty_cases(self):
+        """Test cases with empty argument.
+        """
+        cases = []
+
+        case_data = {
+            'op': '',
+            'extended_name': 'arg-empty',
+            'param_type': '',
+            'result_type': '(result v128)',
+            'params': '',
+        }
+
+        for op in self.BINARY_OPS:
+            case_data['op'] = '{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op)
+            case_data['extended_name'] = '1st-arg-empty'
+            case_data['params'] = SIMD.v128_const('0', self.LANE_TYPE)
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        return '\n'.join(cases)
+
+    def get_all_cases(self):
+        case_data = {'lane_type': self.LANE_TYPE,
+                     'normal_cases': self.get_normal_case(),
+                     'malformed_cases': self.get_malformed_cases(),
+                     'invalid_cases': self.get_invalid_cases(),
+                     'combine_cases': self.get_combine_cases()
+                     }
+        return self.gen_test_template().format(**case_data)
+
+    @property
+    def combine_ternary_arith_test_data(self):
+        return {
+            'sat-add_s-sub_s': [
+                [str(self.lane.quarter)] * self.LANE_LEN,
+                [str(self.lane.max)] * self.LANE_LEN,
+                [str(self.lane.min)] * self.LANE_LEN,
+                [str(self.lane.min)] * self.LANE_LEN
+            ],
+            'sat-add_s-sub_u': [
+                [str(self.lane.mask)] * self.LANE_LEN,
+                [str(self.lane.min)] * self.LANE_LEN,
+                [str(self.lane.min)] * self.LANE_LEN,
+                ['-1'] * self.LANE_LEN
+            ],
+            'sat-add_u-sub_s': [
+                [str(self.lane.max)] * self.LANE_LEN,
+                ['-1'] * self.LANE_LEN,
+                [str(self.lane.max)] * self.LANE_LEN,
+                [str(self.lane.mask - 1)] * self.LANE_LEN
+            ],
+            'sat-add_u-sub_u': [
+                [str(self.lane.mask)] * self.LANE_LEN,
+                ['0'] * self.LANE_LEN,
+                ['1'] * self.LANE_LEN,
+                [str(self.lane.mask)] * self.LANE_LEN
+            ]
+        }
+
+    @property
+    def combine_binary_arith_test_data(self):
+        return {
+            'sat-add_s-neg': [
+                [str(self.lane.min)] * self.LANE_LEN,
+                [str(self.lane.max)] * self.LANE_LEN,
+                ['-1'] * self.LANE_LEN
+            ],
+            'sat-add_u-neg': [
+                [str(self.lane.max)] * self.LANE_LEN,
+                [str(self.lane.min)] * self.LANE_LEN,
+                [str(self.lane.mask)] * self.LANE_LEN
+            ],
+            'sat-sub_s-neg': [
+                [str(self.lane.min)] * self.LANE_LEN,
+                [str(self.lane.max)] * self.LANE_LEN,
+                [str(self.lane.min)] * self.LANE_LEN
+            ],
+            'sat-sub_u-neg': [
+                [str(self.lane.max)] * self.LANE_LEN,
+                [str(self.lane.min)] * self.LANE_LEN,
+                ['1'] * self.LANE_LEN
+            ]
+        }
+
+    def get_combine_cases(self):
+        combine_cases = [';; combination\n(module']
+        ternary_func_template = '  (func (export "{func}") (param v128 v128 v128) (result v128)\n' \
+                              '    ({lane}.{op1} ({lane}.{op2} (local.get 0) (local.get 1))'\
+                              '(local.get 2)))'
+        for func in sorted(self.combine_ternary_arith_test_data):
+            func_parts = func.split('-')
+            op1 = func_parts[1].replace('_', '_sat_')
+            op2 = func_parts[2].replace('_', '_sat_')
+            combine_cases.append(ternary_func_template.format(func=func,
+                                                            lane=self.LANE_TYPE,
+                                                            op1=op1,
+                                                            op2=op2))
+        binary_func_template = '  (func (export "{func}") (param v128 v128) (result v128)\n'\
+                             '    ({lane}.{op1} ({lane}.{op2} (local.get 0)) (local.get 1)))'
+        for func in sorted(self.combine_binary_arith_test_data):
+            func_parts = func.split('-')
+            op1 = func_parts[1].replace('_', '_sat_')
+            combine_cases.append(binary_func_template.format(func=func,
+                                                           lane=self.LANE_TYPE,
+                                                           op1=op1,
+                                                           op2=func_parts[2]))
+        combine_cases.append(')\n')
+
+        for func, test in sorted(self.combine_ternary_arith_test_data.items()):
+            combine_cases.append(str(AssertReturn(func,
+                                 [SIMD.v128_const(elem, self.LANE_TYPE) for elem in test[:-1]],
+                                 SIMD.v128_const(test[-1], self.LANE_TYPE))))
+
+        for func, test in sorted(self.combine_binary_arith_test_data.items()):
+            combine_cases.append(str(AssertReturn(func,
+                                 [SIMD.v128_const(elem, self.LANE_TYPE) for elem in test[:-1]],
+                                 SIMD.v128_const(test[-1], self.LANE_TYPE))))
+
+        return '\n'.join(combine_cases)
+
+
+class SimdI8x16SaturateArithmeticCases(SimdSaturateArithmeticCases):
+    LANE_LEN = 16
+    LANE_TYPE = 'i8x16'
+
+    @property
+    def hex_binary_op_test_data(self):
+        return [
+            ('0x3f', '0x40'),
+            ('0x40', '0x40'),
+            ('-0x3f', '-0x40'),
+            ('-0x40', '-0x40'),
+            ('-0x40', '-0x41'),
+            ('0x7f', '0x7f'),
+            ('0x7f', '0x01'),
+            ('0x80', '-0x01'),
+            ('0x7f', '0x80'),
+            ('0x80', '0x80'),
+            ('0xff', '0x01'),
+            ('0xff', '0xff')
+        ]
+
+    @property
+    def hex_unary_op_test_data(self):
+        return ['0x01', '-0x01', '-0x80', '-0x7f', '0x7f', '0x80', '0xff']
+
+    @property
+    def i8x16_f32x4_test_data(self):
+        return {
+            'i8x16.add_sat_s': [
+                [['0x80', '-0.0'], '0x80', ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '+inf'], ['0x01', '0x01', '0x81', '0x7f'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '-inf'], ['0x01', '0x01', '0x81', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', 'nan'], ['0x01', '0x01', '0xc1', '0x7f'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '-nan'], ['0x01', '0x01', '0xc1', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']]
+            ],
+            'i8x16.add_sat_u': [
+                [['0x80', '-0.0'], ['0x80', '0x80', '0x80', '0xff'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '+inf'], ['0x01', '0x01', '0x81', '0x80'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '-inf'], ['0x01', '0x01', '0x81', '0xff'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', 'nan'], ['0x01', '0x01', '0xc1', '0x80'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '-nan'], ['0x01', '0x01', '0xc1', '0xff'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+            ],
+            'i8x16.sub_sat_s': [
+                [['0x80', '-0.0'], ['0x80', '0x80', '0x80', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '+inf'], ['0x01', '0x01', '0x7f', '0x82'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '-inf'], ['0x01', '0x01', '0x7f', '0x02'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', 'nan'], ['0x01', '0x01', '0x41', '0x82'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '-nan'], ['0x01', '0x01', '0x41', '0x02'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+            ],
+            'i8x16.sub_sat_u': [
+                [['0x80', '-0.0'], ['0x80', '0x80', '0x80', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '+inf'], ['0x01', '0x01', '0', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '-inf'], ['0x01', '0x01', '0', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', 'nan'], ['0x01', '0x01', '0', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '-nan'], ['0x01', '0x01', '0', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+            ]
+        }
+
+    @property
+    def combine_dec_hex_test_data(self):
+        return {
+            'i8x16.add_sat_s': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15'],
+                  ['0', '0xff', '0xfe', '0xfd', '0xfc', '0xfb', '0xfa', '0xf9', '0xf8', '0xf7', '0xf6', '0xf5',
+                   '0xf4', '0xf3', '0xf2', '0xf1']],
+                 ['0'] * 16, ['i8x16', 'i8x16', 'i8x16']]
+            ],
+            'i8x16.add_sat_u': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15'],
+                  ['0', '0xff', '0xfe', '0xfd', '0xfc', '0xfb', '0xfa', '0xf9', '0xf8', '0xf7', '0xf6', '0xf5',
+                   '0xf4', '0xf3', '0xf2', '0xf1']],
+                 ['0'] + ['0xff'] * 15, ['i8x16', 'i8x16', 'i8x16']]
+            ],
+            'i8x16.sub_sat_s': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15'],
+                  ['0', '0xff', '0xfe', '0xfd', '0xfc', '0xfb', '0xfa', '0xf9', '0xf8', '0xf7', '0xf6', '0xf5',
+                   '0xf4', '0xf3', '0xf2', '0xf1']],
+                 ['0', '0x02', '0x04', '0x06', '0x08', '0x0a', '0x0c', '0x0e', '0x10', '0x12', '0x14', '0x16',
+                  '0x18', '0x1a', '0x1c', '0x1e'],
+                 ['i8x16', 'i8x16', 'i8x16']]
+            ],
+            'i8x16.sub_sat_u': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15'],
+                  ['0', '0xff', '0xfe', '0xfd', '0xfc', '0xfb', '0xfa', '0xf9', '0xf8', '0xf7', '0xf6', '0xf5',
+                   '0xf4', '0xf3', '0xf2', '0xf1']],
+                 ['0'] * 16,
+                 ['i8x16', 'i8x16', 'i8x16']]
+            ],
+        }
+
+    @property
+    def range_test_data(self):
+        return {
+            'i8x16.add_sat_s': [
+                [[[str(i) for i in range(16)], [str(i * 2) for i in range(16)]],
+                 [str(i * 3) for i in range(16)], ['i8x16', 'i8x16', 'i8x16']]
+            ],
+            'i8x16.add_sat_u': [
+                [[[str(i) for i in range(16)], [str(i * 2) for i in range(16)]],
+                 [str(i * 3) for i in range(16)], ['i8x16', 'i8x16', 'i8x16']]
+            ],
+            'i8x16.sub_sat_s': [
+                [[[str(i) for i in range(16)], [str(i * 2) for i in range(16)]],
+                 [str(-i) for i in range(16)], ['i8x16', 'i8x16', 'i8x16']]
+            ],
+            'i8x16.sub_sat_u': [
+                [[[str(i) for i in range(16)], [str(i * 2) for i in range(16)]],
+                 ['0'] * 16, ['i8x16', 'i8x16', 'i8x16']]
+            ],
+        }
+
+    @property
+    def full_bin_test_data(self):
+        return [
+            self.i8x16_f32x4_test_data,
+            self.combine_dec_hex_test_data,
+            self.range_test_data
+        ]
+
+    def get_malformed_cases(self):
+        malformed_cases = []
+        # There is no saturating integer arithmetic operation for i32x4 or f32x4.
+        for prefix in ['i32x4', 'f32x4']:
+            for op in ['add', 'sub']:
+                for suffix in ['s', 'u']:
+                    malformed_cases.append(self.malformed_template.format(
+                        lane_type=prefix, op='_'.join([op, 'sat', suffix]),
+                        operand_1=self.v128_const(prefix, '0', lane_len=4),
+                        operand_2=self.v128_const(prefix, '0', lane_len=4)
+                    ))
+        return super().get_malformed_cases() + '\n' + '\n'.join(malformed_cases)
+
+
+class SimdI16x8SaturateArithmeticCases(SimdSaturateArithmeticCases):
+    LANE_LEN = 8
+    LANE_TYPE = 'i16x8'
+
+    @property
+    def hex_binary_op_test_data(self):
+        return [
+            ('0x3fff', '0x4000'),
+            ('0x4000', '0x4000'),
+            ('-0x3fff', '-0x4000'),
+            ('-0x4000', '-0x4000'),
+            ('-0x4000', '-0x4001'),
+            ('0x7fff', '0x7fff'),
+            ('0x7fff', '0x01'),
+            ('0x8000', '-0x01'),
+            ('0x7fff', '0x8000'),
+            ('0x8000', '0x8000'),
+            ('0xffff', '0x01'),
+            ('0xffff', '0xffff')
+        ]
+
+    @property
+    def hex_unary_op_test_data(self):
+        return ['0x01', '-0x01', '-0x8000', '-0x7fff', '0x7fff', '0x8000', '0xffff']
+
+    @property
+    def underscore_literal_test_data(self):
+        return {
+            'i16x8.add_sat_s': [
+                [['012_345', '032_123'], '032_767', ['i16x8'] * 3],
+                [['012_345', '056_789'], '03_598', ['i16x8'] * 3],
+                [['0x0_1234', '0x0_5678'], '0x0_68ac', ['i16x8'] * 3],
+                [['0x0_90AB', '0x0_cdef'], '-0x0_8000', ['i16x8'] * 3]
+            ],
+            'i16x8.add_sat_u': [
+                [['012_345', '056_789'], '065_535', ['i16x8'] * 3],
+                [['012_345', '-012_345'], '065_535', ['i16x8'] * 3],
+                [['0x0_1234', '0x0_5678'], '0x0_68ac', ['i16x8'] * 3],
+                [['0x0_90AB', '0x0_cdef'], '0x0_ffff', ['i16x8'] * 3]
+            ],
+            'i16x8.sub_sat_s': [
+                [['012_345', '056_789'], '021_092', ['i16x8'] * 3],
+                [['012_345', '-012_345'], '024_690', ['i16x8'] * 3],
+                [['0x0_1234', '0x0_5678'], '0x0_bbbc', ['i16x8'] * 3],
+                [['0x0_90AB', '-0x1234'], '0xa2df', ['i16x8'] * 3]
+            ],
+            'i16x8.sub_sat_u': [
+                [['012_345', '056_789'], '0', ['i16x8'] * 3],
+                [['056_789', '-12_345'], '03_598', ['i16x8'] * 3],
+                [['0x0_1234', '-0x0_5678'], '0', ['i16x8'] * 3],
+                [['0x0_cdef', '0x0_90AB'], '0x0_3d44', ['i16x8'] * 3]
+            ]
+        }
+
+    @property
+    def i16x8_f32x4_test_data(self):
+        return {
+            'i16x8.add_sat_s': [
+                [['0x8000', '-0.0'], '0x8000', ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '+inf'], ['0x01', '0x7f81'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '-inf'], ['0x01', '0xff81'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', 'nan'], ['0x01', '0x7fc1'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '-nan'], ['0x01', '0xffc1'] * 4, ['i16x8', 'f32x4', 'i16x8']]
+            ],
+            'i16x8.add_sat_u': [
+                [['0x8000', '-0.0'], ['0x8000', '0xffff'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '+inf'], ['0x01', '0x7f81'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '-inf'], ['0x01', '0xff81'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', 'nan'], ['0x01', '0x7fc1'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', 'nan'], ['0x01', '0x7fc1'] * 4, ['i16x8', 'f32x4', 'i16x8']]
+            ],
+            'i16x8.sub_sat_s': [
+                [['0x8000', '-0.0'], ['0x8000', '0'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '+inf'], ['0x01', '0x8081'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '-inf'], ['0x01', '0x81'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', 'nan'], ['0x01', '0x8041'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '-nan'], ['0x01', '0x41'] * 4, ['i16x8', 'f32x4', 'i16x8']]
+            ],
+            'i16x8.sub_sat_u': [
+                [['0x8000', '-0.0'], ['0x8000', '0'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '+inf'], ['0x01', '0'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '-inf'], ['0x01', '0'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', 'nan'], ['0x01', '0'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '-nan'], ['0x01', '0'] * 4, ['i16x8', 'f32x4', 'i16x8']]
+            ],
+        }
+
+    @property
+    def combine_dec_hex_test_data(self):
+        return {
+            'i16x8.add_sat_s': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7'],
+                  ['0', '0xffff', '0xfffe', '0xfffd', '0xfffc', '0xfffb', '0xfffa', '0xfff9']],
+                 ['0'] * 8, ['i16x8'] * 3]
+            ],
+            'i16x8.add_sat_u': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7'],
+                  ['0', '0xffff', '0xfffe', '0xfffd', '0xfffc', '0xfffb', '0xfffa', '0xfff9']],
+                 ['0'] + ['0xffff'] * 7, ['i16x8'] * 3]
+            ],
+            'i16x8.sub_sat_s': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7'],
+                  ['0', '0xffff', '0xfffe', '0xfffd', '0xfffc', '0xfffb', '0xfffa', '0xfff9']],
+                 ['0', '2', '4', '6', '8', '10', '12', '14'], ['i16x8'] * 3]
+            ],
+            'i16x8.sub_sat_u': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7'],
+                  ['0', '0xffff', '0xfffe', '0xfffd', '0xfffc', '0xfffb', '0xfffa', '0xfff9']],
+                 ['0'] * 8, ['i16x8'] * 3]
+            ]
+        }
+
+    @property
+    def range_test_data(self):
+        return {
+            'i16x8.add_sat_s': [
+                [[[str(i) for i in range(8)], [str(i * 2) for i in range(8)]],
+                 [str(i * 3) for i in range(8)], ['i16x8'] * 3]
+            ],
+            'i16x8.add_sat_u': [
+                [[[str(i) for i in range(8)], [str(i * 2) for i in range(8)]],
+                 [str(i * 3) for i in range(8)], ['i16x8'] * 3]
+            ],
+            'i16x8.sub_sat_s': [
+                [[[str(i) for i in range(8)], [str(i * 2) for i in range(8)]],
+                 [str(-i) for i in range(8)], ['i16x8'] * 3]
+            ],
+            'i16x8.sub_sat_u': [
+                [[[str(i) for i in range(8)], [str(i * 2) for i in range(8)]],
+                 ['0'] * 8, ['i16x8'] * 3]
+            ]
+        }
+
+    @property
+    def full_bin_test_data(self):
+        return [
+            self.i16x8_f32x4_test_data,
+            self.combine_dec_hex_test_data,
+            self.range_test_data,
+            self.underscore_literal_test_data
+        ]
+
+
+def gen_test_cases():
+    simd_i8x16_sat_arith = SimdI8x16SaturateArithmeticCases()
+    simd_i8x16_sat_arith.gen_test_cases()
+    simd_i16x8_sat_arith = SimdI16x8SaturateArithmeticCases()
+    simd_i16x8_sat_arith.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_store_lane.py b/test/core/simd/meta/simd_store_lane.py
new file mode 100644
index 000000000..f0a8e284f
--- /dev/null
+++ b/test/core/simd/meta/simd_store_lane.py
@@ -0,0 +1,237 @@
+#!/usr/bin/env python3
+
+from simd import SIMD
+from test_assert import AssertReturn, AssertInvalid
+
+def list_stringify(l):
+    return list(map(lambda x: str(x), l))
+
+"""Base class for generating SIMD store lane tests. Subclasses only to:
+    - define self.LANE_LEN, self.LANE_TYPE, self.NUM_LANES, self.MAX_ALIGN
+    - override get_normal_case to provide test data  (consult comments for details)
+
+It generates test cases that:
+    - store to all valid lane indices
+    - store using memarg offset
+    - store with memarg alignment
+    - store with invalid lane index
+    - store with invalid memarg alignment
+    - fails typecheck
+"""
+class SimdStoreLane:
+    def valid_alignments(self):
+        return [a for a in range(1, self.MAX_ALIGN+1) if a & (a-1) == 0]
+
+    def get_case_data(self):
+        # return value should be a list of tuples:
+        #   (address to store to : i32, v128, return value : v128)
+        # e.g. [(0, [0x0100, 0, 0, 0, 0, 0, 0, 0]), ... ]
+        # the expected result is return_value[address].
+        raise Exception("Subclasses should override this to provide test data")
+
+    def get_normal_case(self):
+        s = SIMD()
+        cases = []
+
+        # store using arg
+        for (addr, ret) in self.get_case_data():
+            i32_addr = s.const(addr, "i32")
+            v128_val = s.v128_const(list_stringify(ret), self.LANE_TYPE)
+            result = s.const(ret[addr], "i64")
+            instr = "v128.store{lane_len}_lane_{idx}".format(lane_len=self.LANE_LEN, idx=addr)
+            cases.append(str(AssertReturn(instr, [i32_addr, v128_val], result)))
+
+        # store using offset
+        for (addr, ret) in self.get_case_data():
+            v128_val = s.v128_const(list_stringify(ret), self.LANE_TYPE)
+            result = s.const(ret[addr], "i64")
+            instr = "v128.store{lane_len}_lane_{idx}_offset_{idx}".format(lane_len=self.LANE_LEN, idx=addr)
+            cases.append(str(AssertReturn(instr, [v128_val], result)))
+
+        # store using offset with alignment
+        for (addr, ret) in self.get_case_data():
+            for align in self.valid_alignments():
+                i32_addr = s.const(addr, "i32")
+                v128_val = s.v128_const(list_stringify(ret), self.LANE_TYPE)
+                result = s.const(ret[addr], "i64")
+                instr = "v128.store{lane_len}_lane_{idx}_align_{align}".format(lane_len=self.LANE_LEN, idx=addr, align=align)
+                cases.append(str(AssertReturn(instr, [i32_addr, v128_val], result)))
+
+        return '\n'.join(cases)
+
+    def gen_test_func_template(self):
+        template = [
+            ';; Tests for store lane operations.\n\n',
+            '(module',
+            '  (memory 1)',
+            '  (global $zero (mut v128) (v128.const i32x4 0 0 0 0))',
+            ]
+
+        lane_indices = list(range(self.NUM_LANES))
+
+        # store using i32.const arg
+        for idx in lane_indices:
+            template.append(
+                '  (func (export "v128.store{lane_len}_lane_{idx}")\n'
+                '    (param $address i32) (param $x v128) (result i64) (local $ret i64)\n'
+                '    (v128.store{lane_len}_lane {idx} (local.get $address) (local.get $x))\n'
+                '    (local.set $ret (i64.load (local.get $address)))\n'
+                '    (v128.store (local.get $address) (global.get $zero))'
+                '    (local.get $ret))'
+                .format(idx=idx, lane_len=self.LANE_LEN))
+
+        # store using memarg offset
+        for idx in lane_indices:
+            template.append(
+                '  (func (export "v128.store{lane_len}_lane_{idx}_offset_{idx}")\n'
+                '    (param $x v128) (result i64) (local $ret i64)\n'
+                '    (v128.store{lane_len}_lane offset={idx} {idx} (i32.const 0) (local.get $x))\n'
+                '    (local.set $ret (i64.load offset={idx} (i32.const 0)))\n'
+                '    (v128.store offset={idx} (i32.const 0) (global.get $zero))\n'
+                '    (local.get $ret))'
+                .format(idx=idx, lane_len=self.LANE_LEN))
+
+        # with memarg aligment
+        for idx in lane_indices:
+            for align in self.valid_alignments():
+                template.append(
+                    '  (func (export "v128.store{lane_len}_lane_{idx}_align_{align}")\n'
+                    '    (param $address i32) (param $x v128) (result i64) (local $ret i64)\n'
+                    '    (v128.store{lane_len}_lane align={align} {idx} (local.get $address) (local.get $x))\n'
+                    '    (local.set $ret (i64.load (local.get $address)))\n'
+                    '    (v128.store offset={idx} (i32.const 0) (global.get $zero))\n'
+                    '    (local.get $ret))'
+                    .format(idx=idx, lane_len=self.LANE_LEN, align=align))
+
+        template.append(')\n')
+        return template
+
+    def gen_test_template(self):
+        template = self.gen_test_func_template()
+
+        template.append('{normal_cases}')
+        template.append('\n{invalid_cases}')
+
+        return '\n'.join(template)
+
+    def get_invalid_cases(self):
+        invalid_cases = [';; type check']
+        invalid_cases.append(
+            '(assert_invalid'
+            '  (module (memory 1)\n'
+            '          (func (param $x v128) (result v128)\n'
+            '            (v128.store{lane_len}_lane 0 (local.get $x) (i32.const 0))))\n'
+            '  "type mismatch")'.format(lane_len=self.LANE_LEN))
+        invalid_cases.append('')
+
+        invalid_cases.append(';; invalid lane index')
+        invalid_cases.append(
+            '(assert_invalid'
+            '  (module (memory 1)\n'
+            '          (func (param $x v128) (result v128)\n'
+            '            (v128.store{lane_len}_lane {idx} (i32.const 0) (local.get $x))))\n'
+            '  "invalid lane index")'.format(idx=self.NUM_LANES, lane_len=self.LANE_LEN))
+
+        invalid_cases.append('')
+
+        invalid_cases.append(';; invalid memarg alignment')
+        invalid_cases.append(
+            '(assert_invalid\n'
+            '  (module (memory 1)\n'
+            '          (func (param $x v128) (result v128)\n'
+            '          (v128.store{lane_len}_lane align={align} 0 (i32.const 0) (local.get $x))))\n'
+            '  "alignment must not be larger than natural")'
+            .format(lane_len=self.LANE_LEN, align=self.MAX_ALIGN*2))
+        return '\n'.join(invalid_cases)
+
+    def get_all_cases(self):
+        case_data = {'lane_len': self.LANE_LEN,
+                     'normal_cases': self.get_normal_case(),
+                     'invalid_cases': self.get_invalid_cases(),
+                     }
+        return self.gen_test_template().format(**case_data)
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_store{lane_type}_lane.wast'.format(lane_type=self.LANE_LEN)
+        with open(wast_filename, 'w') as fp:
+            fp.write(self.get_all_cases())
+
+class SimdStore8Lane(SimdStoreLane):
+    LANE_LEN = '8'
+    LANE_TYPE = 'i8x16'
+    NUM_LANES = 16
+    MAX_ALIGN = 1
+
+    def get_case_data(self):
+        return [
+            (0, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (1, [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (2, [0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (3, [0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (4, [0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (5, [0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (6, [0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (7, [0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (8, [0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0]),
+            (9, [0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0]),
+            (10, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0]),
+            (11, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0]),
+            (12, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0]),
+            (13, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0]),
+            (14, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0]),
+            (15, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15])]
+
+class SimdStore16Lane(SimdStoreLane):
+    LANE_LEN = '16'
+    LANE_TYPE = 'i16x8'
+    NUM_LANES = 8
+    MAX_ALIGN = 2
+
+    def get_case_data(self):
+        return [
+            (0, [0x0100, 0, 0, 0, 0, 0, 0, 0]),
+            (1, [0, 0x0201, 0, 0, 0, 0, 0, 0]),
+            (2, [0, 0, 0x0302, 0, 0, 0, 0, 0]),
+            (3, [0, 0, 0, 0x0403, 0, 0, 0, 0]),
+            (4, [0, 0, 0, 0, 0x0504, 0, 0, 0]),
+            (5, [0, 0, 0, 0, 0, 0x0605, 0, 0]),
+            (6, [0, 0, 0, 0, 0, 0, 0x0706, 0]),
+            (7, [0, 0, 0, 0, 0, 0, 0, 0x0807])]
+
+class SimdStore32Lane(SimdStoreLane):
+    LANE_LEN = '32'
+    LANE_TYPE = 'i32x4'
+    NUM_LANES = 4
+    MAX_ALIGN = 4
+
+    def get_case_data(self):
+        return [
+            (0, [0x03020100, 0, 0, 0,]),
+            (1, [0, 0x04030201, 0, 0,]),
+            (2, [0, 0, 0x05040302, 0,]),
+            (3, [0, 0, 0, 0x06050403,])]
+
+class SimdStore64Lane(SimdStoreLane):
+    LANE_LEN = '64'
+    LANE_TYPE = 'i64x2'
+    NUM_LANES = 2
+    MAX_ALIGN = 8
+
+    def get_case_data(self):
+        return [
+            (0, [0x0706050403020100, 0]),
+            (1, [0, 0x0807060504030201])]
+
+def gen_test_cases():
+    simd_store8_lane = SimdStore8Lane()
+    simd_store8_lane.gen_test_cases()
+    simd_store16_lane = SimdStore16Lane()
+    simd_store16_lane.gen_test_cases()
+    simd_store32_lane = SimdStore32Lane()
+    simd_store32_lane.gen_test_cases()
+    simd_store64_lane = SimdStore64Lane()
+    simd_store64_lane.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/test_assert.py b/test/core/simd/meta/test_assert.py
new file mode 100644
index 000000000..1147ce07d
--- /dev/null
+++ b/test/core/simd/meta/test_assert.py
@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+This python file is a tool class for test generation.
+Currently only the 'AssertReturn' class that is used
+to generate the 'assert_return' assertion.
+TODO: Add more assertions
+"""
+
+
+# Generate assert_return to test
+class AssertReturn:
+
+    op = ''
+    params = ''
+    expected_result = ''
+
+    def __init__(self, op, params, expected_result):
+
+        # Convert to list if got str
+        if isinstance(params, str):
+            params = [params]
+        if isinstance(expected_result, str):
+            expected_result = [expected_result]
+
+        self.op = op
+        self.params = params
+        self.expected_result = expected_result
+
+    def __str__(self):
+        assert_return = '(assert_return (invoke "{}"'.format(self.op)
+
+        head_len = len(assert_return)
+
+        # Add write space to make the test case easier to read
+        params = []
+        for param in self.params:
+            white_space = ' '
+            if len(params) != 0:
+                white_space = '\n ' + ' ' * head_len
+            params.append(white_space + param)
+
+        results = []
+        for result in self.expected_result:
+            white_space = ' '
+            if len(params) != 0 or len(results) != 0:
+                white_space = '\n ' + ' ' * head_len
+            results.append(white_space + result)
+
+        return '{assert_head}{params}){expected_result})'.format(assert_head=assert_return, params=''.join(params), expected_result=''.join(results))
+
+
+# Generate assert_invalid to test
+class AssertInvalid:
+
+    @staticmethod
+    def get_arg_empty_test(op, extended_name, param_type, result_type, params):
+
+        arg_empty_test = '(assert_invalid' \
+                         '\n  (module' \
+                         '\n    (func ${op}-{extended_name}{param_type}{result_type}' \
+                         '\n      ({op}{params})' \
+                         '\n    )' \
+                         '\n  )' \
+                         '\n  "type mismatch"' \
+                         '\n)'
+
+        def str_with_space(input_str):
+            return (' ' if input_str else '') + input_str
+
+        param_map = {
+            'op': op,
+            'extended_name': extended_name,
+            'param_type': str_with_space(param_type),
+            'result_type': str_with_space(result_type),
+            'params': str_with_space(params),
+        }
+
+        return arg_empty_test.format(**param_map)
+
+
+class AssertMalformed:
+    """Generate an assert_malformed test"""
+
+    @staticmethod
+    def get_unknown_op_test(op, result_type, *params):
+        malformed_template = '(assert_malformed (module quote "(memory 1) (func (result {result_type}) ({operator} {param}))") "unknown operator")'
+        return malformed_template.format(
+            operator=op, result_type=result_type, param=' '.join(params)
+        )
\ No newline at end of file
diff --git a/test/core/simd/simd_address.wast b/test/core/simd/simd_address.wast
new file mode 100644
index 000000000..9e023008b
--- /dev/null
+++ b/test/core/simd/simd_address.wast
@@ -0,0 +1,157 @@
+;; Load/Store v128 data with different valid offset/alignment
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\10\11\12\13\14\15")
+  (data (offset (i32.const 65505)) "\16\17\18\19\20\21\22\23\24\25\26\27\28\29\30\31")
+
+  (func (export "load_data_1") (param $i i32) (result v128)
+    (v128.load offset=0 (local.get $i))                   ;; 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15
+  )
+  (func (export "load_data_2") (param $i i32) (result v128)
+    (v128.load align=1 (local.get $i))                    ;; 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15
+  )
+  (func (export "load_data_3") (param $i i32) (result v128)
+    (v128.load offset=1 align=1 (local.get $i))           ;; 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00
+  )
+  (func (export "load_data_4") (param $i i32) (result v128)
+    (v128.load offset=2 align=1 (local.get $i))           ;; 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00 0x00
+  )
+  (func (export "load_data_5") (param $i i32) (result v128)
+    (v128.load offset=15 align=1 (local.get $i))          ;; 0x15 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
+  )
+
+  (func (export "store_data_0") (result v128)
+    (v128.store offset=0 (i32.const 0) (v128.const f32x4 0 1 2 3))
+    (v128.load offset=0 (i32.const 0))
+  )
+  (func (export "store_data_1") (result v128)
+    (v128.store align=1 (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load align=1 (i32.const 0))
+  )
+  (func (export "store_data_2") (result v128)
+    (v128.store offset=1 align=1 (i32.const 0) (v128.const i16x8 0 1 2 3 4 5 6 7))
+    (v128.load offset=1 align=1 (i32.const 0))
+  )
+  (func (export "store_data_3") (result v128)
+    (v128.store offset=2 align=1 (i32.const 0) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+    (v128.load offset=2 align=1 (i32.const 0))
+  )
+  (func (export "store_data_4") (result v128)
+    (v128.store offset=15 align=1 (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load offset=15 (i32.const 0))
+  )
+  (func (export "store_data_5") (result v128)
+    (v128.store offset=65520 align=1 (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load offset=65520 (i32.const 0))
+  )
+  (func (export "store_data_6") (param $i i32)
+    (v128.store offset=1 align=1 (local.get $i) (v128.const i32x4 0 1 2 3))
+  )
+)
+
+(assert_return (invoke "load_data_1" (i32.const 0)) (v128.const i32x4 0x03020100 0x07060504 0x11100908 0x15141312))
+(assert_return (invoke "load_data_2" (i32.const 0)) (v128.const i32x4 0x03020100 0x07060504 0x11100908 0x15141312))
+(assert_return (invoke "load_data_3" (i32.const 0)) (v128.const i32x4 0x04030201 0x08070605 0x12111009 0x00151413))
+(assert_return (invoke "load_data_4" (i32.const 0)) (v128.const i32x4 0x05040302 0x09080706 0x13121110 0x00001514))
+(assert_return (invoke "load_data_5" (i32.const 0)) (v128.const i32x4 0x00000015 0x00000000 0x00000000 0x00000000))
+
+(assert_return (invoke "load_data_1" (i32.const 0)) (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x1110 0x1312 0x1514))
+(assert_return (invoke "load_data_2" (i32.const 0)) (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x1110 0x1312 0x1514))
+(assert_return (invoke "load_data_3" (i32.const 0)) (v128.const i16x8 0x0201 0x0403 0x0605 0x0807 0x1009 0x1211 0x1413 0x0015))
+(assert_return (invoke "load_data_4" (i32.const 0)) (v128.const i16x8 0x0302 0x0504 0x0706 0x0908 0x1110 0x1312 0x1514 0x0000))
+(assert_return (invoke "load_data_5" (i32.const 0)) (v128.const i16x8 0x0015 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+
+(assert_return (invoke "load_data_1" (i32.const 0)) (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15))
+(assert_return (invoke "load_data_2" (i32.const 0)) (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15))
+(assert_return (invoke "load_data_3" (i32.const 0)) (v128.const i8x16 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00))
+(assert_return (invoke "load_data_4" (i32.const 0)) (v128.const i8x16 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00 0x00))
+(assert_return (invoke "load_data_5" (i32.const 0)) (v128.const i8x16 0x15 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+
+(assert_return (invoke "load_data_1" (i32.const 65505)) (v128.const i32x4 0x19181716 0x23222120 0x27262524 0x31302928))
+(assert_return (invoke "load_data_2" (i32.const 65505)) (v128.const i32x4 0x19181716 0x23222120 0x27262524 0x31302928))
+(assert_return (invoke "load_data_3" (i32.const 65505)) (v128.const i32x4 0x20191817 0x24232221 0x28272625 0x00313029))
+(assert_return (invoke "load_data_4" (i32.const 65505)) (v128.const i32x4 0x21201918 0x25242322 0x29282726 0x00003130))
+(assert_return (invoke "load_data_5" (i32.const 65505)) (v128.const i32x4 0x00000031 0x00000000 0x00000000 0x00000000))
+
+(assert_return (invoke "load_data_1" (i32.const 65505)) (v128.const i16x8 0x1716 0x1918 0x2120 0x2322 0x2524 0x2726 0x2928 0x3130))
+(assert_return (invoke "load_data_2" (i32.const 65505)) (v128.const i16x8 0x1716 0x1918 0x2120 0x2322 0x2524 0x2726 0x2928 0x3130))
+(assert_return (invoke "load_data_3" (i32.const 65505)) (v128.const i16x8 0x1817 0x2019 0x2221 0x2423 0x2625 0x2827 0x3029 0x0031))
+(assert_return (invoke "load_data_4" (i32.const 65505)) (v128.const i16x8 0x1918 0x2120 0x2322 0x2524 0x2726 0x2928 0x3130 0x0000))
+(assert_return (invoke "load_data_5" (i32.const 65505)) (v128.const i16x8 0x0031 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+
+(assert_return (invoke "load_data_1" (i32.const 65505)) (v128.const i8x16 0x16 0x17 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31))
+(assert_return (invoke "load_data_2" (i32.const 65505)) (v128.const i8x16 0x16 0x17 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31))
+(assert_return (invoke "load_data_3" (i32.const 65505)) (v128.const i8x16 0x17 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31 0x00))
+(assert_return (invoke "load_data_4" (i32.const 65505)) (v128.const i8x16 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31 0x00 0x00))
+(assert_return (invoke "load_data_5" (i32.const 65505)) (v128.const i8x16 0x31 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+
+(assert_trap (invoke "load_data_3" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "load_data_5" (i32.const 65506)) "out of bounds memory access")
+
+(assert_return (invoke "store_data_0") (v128.const f32x4 0 1 2 3))
+(assert_return (invoke "store_data_1") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "store_data_2") (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "store_data_3") (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "store_data_4") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "store_data_5") (v128.const i32x4 0 1 2 3))
+
+(assert_trap (invoke "store_data_6" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "store_data_6" (i32.const 65535)) "out of bounds memory access")
+
+;; Load/Store v128 data with invalid offset
+
+(module
+  (memory 1)
+  (func (export "v128.load_offset_65521")
+    (drop (v128.load offset=65521 (i32.const 0)))
+  )
+)
+(assert_trap (invoke "v128.load_offset_65521") "out of bounds memory access")
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func"
+    "  (drop (v128.load offset=-1 (i32.const 0)))"
+    ")"
+  )
+  "unknown operator"
+)
+
+(module
+  (memory 1)
+  (func (export "v128.store_offset_65521")
+    (v128.store offset=65521 (i32.const 0) (v128.const i32x4 0 0 0 0))
+  )
+)
+(assert_trap (invoke "v128.store_offset_65521") "out of bounds memory access")
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func"
+    "  (v128.store offset=-1 (i32.const 0) (v128.const i32x4 0 0 0 0))"
+    ")"
+  )
+  "unknown operator"
+)
+
+
+;; Offset constant out of range
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (drop (v128.load offset=4294967296 (i32.const 0))))"
+  )
+  "i32 constant"
+)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store offset=4294967296 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "i32 constant"
+)
diff --git a/test/core/simd/simd_align.wast b/test/core/simd/simd_align.wast
new file mode 100644
index 000000000..ed91ed5c6
--- /dev/null
+++ b/test/core/simd/simd_align.wast
@@ -0,0 +1,355 @@
+;; Valid alignment
+
+(module (memory 1) (func (drop (v128.load align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load align=16 (i32.const 0)))))
+
+(module (memory 1) (func (v128.store align=1 (i32.const 0) (v128.const i32x4 0 1 2 3))))
+(module (memory 1) (func (v128.store align=2 (i32.const 0) (v128.const i32x4 0 1 2 3))))
+(module (memory 1) (func (v128.store align=4 (i32.const 0) (v128.const i32x4 0 1 2 3))))
+(module (memory 1) (func (v128.store align=8 (i32.const 0) (v128.const i32x4 0 1 2 3))))
+(module (memory 1) (func (v128.store align=16 (i32.const 0) (v128.const i32x4 0 1 2 3))))
+
+(module (memory 1) (func (drop (v128.load8x8_s align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_s align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_s align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_s align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_u align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_u align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_u align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_u align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_s align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_s align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_s align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_s align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_u align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_u align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_u align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_u align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_s align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_s align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_s align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_s align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_u align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_u align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_u align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_u align=8 (i32.const 0)))))
+
+(module (memory 1) (func (drop (v128.load8_splat align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16_splat align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16_splat align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32_splat align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32_splat align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32_splat align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load64_splat align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load64_splat align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load64_splat align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load64_splat align=8 (i32.const 0)))))
+
+;; Invalid alignment
+
+(assert_invalid
+  (module (memory 1) (func (drop (v128.load align=32 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func(v128.store align=32 (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load8x8_s align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load8x8_u align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load16x4_s align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load16x4_u align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load32x2_s align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load32x2_u align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load8_splat align=2 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load16_splat align=4 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load32_splat align=8 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load64_splat align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+
+;; Malformed alignment
+
+(assert_malformed
+  (module quote
+    "(memory 1) (func (drop (v128.load align=-1 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (drop (v128.load align=0 (i32.const 0))))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (drop (v128.load align=7 (i32.const 0))))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (v128.store align=-1 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 0) (func (v128.store align=0 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 0) (func (v128.store align=7 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_s align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_s align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_s align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_u align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_u align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_u align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_s align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_s align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_s align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_u align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_u align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_u align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_s align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_s align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_s align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_u align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_u align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_u align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8_splat align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8_splat align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16_splat align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16_splat align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32_splat align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32_splat align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32_splat align=3 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load64_splat align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load64_splat align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load64_splat align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+
+;; Test that misaligned SIMD loads/stores don't trap
+
+(module
+  (memory 1 1)
+  (func (export "v128.load align=16") (param $address i32) (result v128)
+    (v128.load align=16 (local.get $address))
+  )
+  (func (export "v128.store align=16") (param $address i32) (param $value v128)
+    (v128.store align=16 (local.get $address) (local.get $value))
+  )
+)
+
+(assert_return (invoke "v128.load align=16" (i32.const 0)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "v128.load align=16" (i32.const 1)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "v128.store align=16" (i32.const 1) (v128.const i8x16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)))
+(assert_return (invoke "v128.load align=16" (i32.const 0)) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+
+;; Test aligned and unaligned read/write
+
+(module
+  (memory 1)
+  (func (export "v128_unaligned_read_and_write") (result v128)
+    (local v128)
+    (v128.store (i32.const 0) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128_aligned_read_and_write") (result v128)
+    (local v128)
+    (v128.store align=2 (i32.const 0) (v128.const i16x8 0 1 2 3 4 5 6 7))
+    (v128.load align=2  (i32.const 0))
+  )
+  (func (export "v128_aligned_read_and_unaligned_write") (result v128)
+    (local v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load align=2 (i32.const 0))
+  )
+  (func (export "v128_unaligned_read_and_aligned_write") (result v128)
+    (local v128)
+    (v128.store align=2 (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load (i32.const 0))
+  )
+)
+
+(assert_return (invoke "v128_unaligned_read_and_write") (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "v128_aligned_read_and_write") (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "v128_aligned_read_and_unaligned_write") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "v128_unaligned_read_and_aligned_write") (v128.const i32x4 0 1 2 3))
diff --git a/test/core/simd/simd_bit_shift.wast b/test/core/simd/simd_bit_shift.wast
new file mode 100644
index 000000000..98e155651
--- /dev/null
+++ b/test/core/simd/simd_bit_shift.wast
@@ -0,0 +1,1104 @@
+;; Test all the bit shift operators on major boundary values and all special values.
+
+(module
+  (func (export "i8x16.shl") (param $0 v128) (param $1 i32) (result v128) (i8x16.shl (local.get $0) (local.get $1)))
+  (func (export "i8x16.shr_s") (param $0 v128) (param $1 i32) (result v128) (i8x16.shr_s (local.get $0) (local.get $1)))
+  (func (export "i8x16.shr_u") (param $0 v128) (param $1 i32) (result v128) (i8x16.shr_u (local.get $0) (local.get $1)))
+
+  (func (export "i16x8.shl") (param $0 v128) (param $1 i32) (result v128) (i16x8.shl (local.get $0) (local.get $1)))
+  (func (export "i16x8.shr_s") (param $0 v128) (param $1 i32) (result v128) (i16x8.shr_s (local.get $0) (local.get $1)))
+  (func (export "i16x8.shr_u") (param $0 v128) (param $1 i32) (result v128) (i16x8.shr_u (local.get $0) (local.get $1)))
+
+  (func (export "i32x4.shl") (param $0 v128) (param $1 i32) (result v128) (i32x4.shl (local.get $0) (local.get $1)))
+  (func (export "i32x4.shr_s") (param $0 v128) (param $1 i32) (result v128) (i32x4.shr_s (local.get $0) (local.get $1)))
+  (func (export "i32x4.shr_u") (param $0 v128) (param $1 i32) (result v128) (i32x4.shr_u (local.get $0) (local.get $1)))
+
+  (func (export "i64x2.shl") (param $0 v128) (param $1 i32) (result v128) (i64x2.shl (local.get $0) (local.get $1)))
+  (func (export "i64x2.shr_s") (param $0 v128) (param $1 i32) (result v128) (i64x2.shr_s (local.get $0) (local.get $1)))
+  (func (export "i64x2.shr_u") (param $0 v128) (param $1 i32) (result v128) (i64x2.shr_u (local.get $0) (local.get $1)))
+
+  ;; shifting by a constant amount
+  ;; i8x16
+  (func (export "i8x16.shl_1") (param $0 v128) (result v128) (i8x16.shl (local.get $0) (i32.const 1)))
+  (func (export "i8x16.shr_u_8") (param $0 v128) (result v128) (i8x16.shr_u (local.get $0) (i32.const 8)))
+  (func (export "i8x16.shr_s_9") (param $0 v128) (result v128) (i8x16.shr_s (local.get $0) (i32.const 9)))
+
+  ;; i16x8
+  (func (export "i16x8.shl_1") (param $0 v128) (result v128) (i16x8.shl (local.get $0) (i32.const 1)))
+  (func (export "i16x8.shr_u_16") (param $0 v128) (result v128) (i16x8.shr_u (local.get $0) (i32.const 16)))
+  (func (export "i16x8.shr_s_17") (param $0 v128) (result v128) (i16x8.shr_s (local.get $0) (i32.const 17)))
+
+  ;; i32x4
+  (func (export "i32x4.shl_1") (param $0 v128) (result v128) (i32x4.shl (local.get $0) (i32.const 1)))
+  (func (export "i32x4.shr_u_32") (param $0 v128) (result v128) (i32x4.shr_u (local.get $0) (i32.const 32)))
+  (func (export "i32x4.shr_s_33") (param $0 v128) (result v128) (i32x4.shr_s (local.get $0) (i32.const 33)))
+
+  ;; i64x2
+  (func (export "i64x2.shl_1") (param $0 v128) (result v128) (i64x2.shl (local.get $0) (i32.const 1)))
+  (func (export "i64x2.shr_u_64") (param $0 v128) (result v128) (i64x2.shr_u (local.get $0) (i32.const 64)))
+  (func (export "i64x2.shr_s_65") (param $0 v128) (result v128) (i64x2.shr_s (local.get $0) (i32.const 65)))
+)
+
+;; i8x16 shl
+;; amount less than lane width
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                   (i32.const 1))
+                                   (v128.const i8x16 0 -128 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0xAA 0xBB 0xCC 0xDD 0xEE 0xFF 0xA0 0xB0 0xC0 0xD0 0xE0 0xF0 0x0A 0x0B 0x0C 0x0D)
+                                   (i32.const 4))
+                                   (v128.const i8x16 0xA0 0xB0 0xC0 0xD0 0xE0 0xF0 0x00 0x00 0x00 0x00 0x00 0x00 0xA0 0xB0 0xC0 0xD0))
+;; amount is multiple of lane width
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 8))
+                                   (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 32))
+                                   (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 128))
+                                   (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 256))
+                                   (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                   (i32.const 9))
+                                   (v128.const i8x16 0 -128 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 9))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 17))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 33))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 129))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 257))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 513))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 514))
+                                   (v128.const i8x16 0 4 8 12 16 20 24 28 32 36 0x28 0x2C 0x30 0x34 0x38 0x3C))
+;; i8x16 shr_u
+;; amount less than lane width
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 1))
+                                     (v128.const i8x16 64 96 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0xAA 0xBB 0xCC 0xDD 0xEE 0xFF 0xA0 0xB0 0xC0 0xD0 0xE0 0xF0 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 4))
+                                     (v128.const i8x16 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F 0x00 0x00 0x00 0x00))
+;; amount is multiple of lane width
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 8))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 9))
+                                     (v128.const i8x16 64 96 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 9))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 17))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 33))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 0x02 0x02 0x03 0x03 0x03 0x03))
+;; i8x16 shr_s
+;; amount less than lane width
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 1))
+                                     (v128.const i8x16 192 224 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0xAA 0xBB 0xCC 0xDD 0xEE 0xFF 0xA0 0xB0 0xC0 0xD0 0xE0 0xF0 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 4))
+                                     (v128.const i8x16 0xFA 0xFB 0xFC 0xFD 0xFE 0xFF 0xFA 0xFB 0xFC 0xFD 0xFE 0xFF 0x00 0x00 0x00 0x00))
+;; amount is multiple of lane width
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 8))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 9))
+                                     (v128.const i8x16 192 224 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 9))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 17))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 33))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 0x02 0x02 0x03 0x03 0x03 0x03))
+;; shifting by a constant amount
+(assert_return (invoke "i8x16.shl_1" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+                                     (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shr_u_8" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+                                       (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_s_9" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+                                       (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+
+;; i16x8 shl
+;; amount less than lane width
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                   (i32.const 1))
+                                   (v128.const i16x8 65280 65408 0 2 4 6 8 10))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                   (i32.const 2))
+                                   (v128.const i16x8 49380 49380 49380 49380 49380 49380 49380 49380))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                   (i32.const 2))
+                                   (v128.const i16x8 0x48d0 0x48d0 0x48d0 0x48d0 0x48d0 0x48d0 0x48d0 0x48d0))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0xAABB 0xCCDD 0xEEFF 0xA0B0 0xC0D0 0xE0F0 0x0A0B 0x0C0D)
+                                   (i32.const 4))
+                                   (v128.const i16x8 0xABB0 0xCDD0 0xEFF0 0xB00 0xD00 0xF00 0xA0B0 0xC0D0))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 8))
+                                   (v128.const i16x8 0 256 512 768 1024 1280 1536 1792))
+;; amount is multiple of lane width
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 32))
+                                   (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 128))
+                                   (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 256))
+                                   (v128.const i16x8 0 1 2 3 4 5 6 7))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                   (i32.const 17))
+                                   (v128.const i16x8 65280 65408 0 2 4 6 8 10))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 17))
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 33))
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 129))
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 257))
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 513))
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 514))
+                                   (v128.const i16x8 0 4 8 12 16 20 24 28))
+
+;; i16x8 shr_u
+;; amount less than lane width
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                     (i32.const 1))
+                                     (v128.const i16x8 32704 32736 0 0 1 1 2 2))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                     (i32.const 2))
+                                     (v128.const i16x8 3086 3086 3086 3086 3086 3086 3086 3086))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                     (i32.const 2))
+                                     (v128.const i16x8 0x242a 0x242a 0x242a 0x242a 0x242a 0x242a 0x242a 0x242a))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0xAABB 0xCCDD 0xEEFF 0xA0B0 0xC0D0 0xE0F0 0x0A0B 0x0C0D)
+                                     (i32.const 4))
+                                     (v128.const i16x8 0xAAB 0xCCD 0xEEF 0xA0B 0xC0D 0xE0F 0x0A0 0x0C0))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 8))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+;; amount is multiple of lane width
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 32))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 128))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 256))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                     (i32.const 17))
+                                     (v128.const i16x8 32704 32736 0 0 1 1 2 2))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 17))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 33))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 129))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 257))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 513))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 514))
+                                     (v128.const i16x8 0 0 0 0 1 1 1 1))
+
+;; i16x8 shr_s
+;; amount less than lane width
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                     (i32.const 1))
+                                     (v128.const i16x8 65472 65504 0 0 1 1 2 2))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                     (i32.const 2))
+                                     (v128.const i16x8 3086 3086 3086 3086 3086 3086 3086 3086))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                     (i32.const 2))
+                                     (v128.const i16x8 0xe42a 0xe42a 0xe42a 0xe42a 0xe42a 0xe42a 0xe42a 0xe42a))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0xAABB 0xCCDD 0xEEFF 0xA0B0 0xC0D0 0xE0F0 0x0A0B 0x0C0D)
+                                     (i32.const 4))
+                                     (v128.const i16x8 0xFAAB 0xFCCD 0xFEEF 0xFA0B 0xFC0D 0xFE0F 0x00A0 0x00C0))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 8))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+;; amount is multiple of lane width
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 32))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 128))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 256))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                     (i32.const 17))
+                                     (v128.const i16x8 65472 65504 0 0 1 1 2 2))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 17))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 33))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 129))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 257))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 513))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 514))
+                                     (v128.const i16x8 0 0 0 0 1 1 1 1))
+
+;; shifting by a constant amount
+(assert_return (invoke "i16x8.shl_1" (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                     (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shr_u_16" (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                        (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shr_s_17" (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                        (v128.const i16x8 0 0 1 1 2 2 3 3))
+
+;; i32x4 shl
+;; amount less than lane width
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 -2147483648 -32768 0 0x0A0B0C0D)
+                                   (i32.const 1))
+                                   (v128.const i32x4 0 4294901760 0 0x1416181A))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                   (i32.const 2))
+                                   (v128.const i32x4 643304264 643304264 643304264 643304264))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                                   (i32.const 2))
+                                   (v128.const i32x4 0x48d159e0 0x48d159e0 0x48d159e0 0x48d159e0))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0xAABBCCDD 0xEEFFA0B0 0xC0D0E0F0 0x0A0B0C0D)
+                                   (i32.const 4))
+                                   (v128.const i32x4 0xABBCCDD0 0xEFFA0B00 0x0D0E0F00 0xA0B0C0D0))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 8))
+                                   (v128.const i32x4 0 256 0x00000E00 0x00000F00))
+;; amount is multiple of lane width
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 32))
+                                   (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 128))
+                                   (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 256))
+                                   (v128.const i32x4 0 1 0x0E 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 -2147483648 -32768 0 0x0A0B0C0D)
+                                   (i32.const 33))
+                                   (v128.const i32x4 0 4294901760 0 0x1416181A))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 33))
+                                   (v128.const i32x4 0 2 0x1C 0x1E))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 65))
+                                   (v128.const i32x4 0 2 0x1C 0x1E))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 129))
+                                   (v128.const i32x4 0 2 0x1C 0x1E))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 257))
+                                   (v128.const i32x4 0 2 0x1C 0x1E))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 513))
+                                   (v128.const i32x4 0 2 0x1C 0x1E))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 514))
+                                   (v128.const i32x4 0 4 0x38 0x3C))
+
+;; i32x4 shr_u
+;; amount less than lane width
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 -2147483648 -32768 0x0000000C 0x0000000D)
+                                     (i32.const 1))
+                                     (v128.const i32x4 1073741824 2147467264 0x00000006 0x00000006))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                     (i32.const 2))
+                                     (v128.const i32x4 308641972 308641972 308641972 308641972))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                     (i32.const 2))
+                                     (v128.const i32x4 0x242af37b 0x242af37b 0x242af37b 0x242af37b))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0xAABBCCDD 0xEEFFA0B0 0xC0D0E0F0 0x0A0B0C0D)
+                                     (i32.const 4))
+                                     (v128.const i32x4 0x0AABBCCD 0x0EEFFA0B 0x0C0D0E0F 0x00A0B0C0))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 8))
+                                     (v128.const i32x4 0 0 0x00000000 0x00000000))
+;; amount is multiple of lane width
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 -2147483648 -32768 0x0000000C 0x0000000D)
+                                     (i32.const 33))
+                                     (v128.const i32x4 1073741824 2147467264 0x00000006 0x00000006))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 33))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 65))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i32x4 0 0 0x03 0x03))
+
+;; i32x4 shr_s
+;; amount less than lane width
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 -2147483648 -32768 0x0C 0x0D)
+                                     (i32.const 1))
+                                     (v128.const i32x4 3221225472 4294950912 0x06 0x06))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                     (i32.const 2))
+                                     (v128.const i32x4 308641972 308641972 308641972 308641972))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                     (i32.const 2))
+                                     (v128.const i32x4 0xe42af37b 0xe42af37b 0xe42af37b 0xe42af37b))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0xAABBCCDD 0xEEFFA0B0 0xC0D0E0F0 0x0A0B0C0D)
+                                     (i32.const 4))
+                                     (v128.const i32x4 0xfaabbccd 0xFEEFFA0B 0xFC0D0E0F 0x00A0B0C0))
+;; amount is multiple of lane width
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 8))
+                                     (v128.const i32x4 0 0 0x00000000 0x00000000))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 -2147483648 -32768 0x0C 0x0D)
+                                     (i32.const 33))
+                                     (v128.const i32x4 3221225472 4294950912 0x06 0x06))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 33))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 65))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i32x4 0 0 0x03 0x03))
+
+;; shifting by a constant amount
+(assert_return (invoke "i32x4.shl_1" (v128.const i32x4 0 1 0x0E 0x0F))
+                                     (v128.const i32x4 0 2 28 30))
+(assert_return (invoke "i32x4.shr_u_32" (v128.const i32x4 0 1 0x0E 0x0F))
+                                        (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shr_s_33" (v128.const i32x4 0 1 0x0E 0x0F))
+                                        (v128.const i32x4 0 0 7 7))
+
+;; i64x2 shl
+;; amount less than lane width
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 -9223372036854775808 -2147483648)
+                                   (i32.const 1))
+                                   (v128.const i64x2 0 18446744069414584320))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)
+                                   (i32.const 2))
+                                   (v128.const i64x2 4938271560493827156 4938271560493827156))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef)
+                                   (i32.const 2))
+                                   (v128.const i64x2 0x48d159e242af37bc 0x48d159e242af37bc))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D)
+                                   (i32.const 4))
+                                   (v128.const i64x2 0xABBCCDDEEFFA0B00 0xD0E0F00A0B0C0D0))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D)
+                                   (i32.const 8))
+                                   (v128.const i64x2 0xBBCCDDEEFFA0B000 0xD0E0F00A0B0C0D00))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 16))
+                                   (v128.const i64x2 65536 0xF0000))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 32))
+                                   (v128.const i64x2 4294967296 0xF00000000))
+;; amount is multiple of lane width
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 128))
+                                   (v128.const i64x2 1 0x0F))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 256))
+                                   (v128.const i64x2 1 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 65))
+                                   (v128.const i64x2 2 0x1E))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 129))
+                                   (v128.const i64x2 2 0x1E))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 257))
+                                   (v128.const i64x2 2 0x1E))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 513))
+                                   (v128.const i64x2 2 0x1E))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 514))
+                                   (v128.const i64x2 4 0x3C))
+
+;; i64x2 shr_u
+;; amount less than lane width
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 -9223372036854775808 -2147483648)
+                                     (i32.const 1))
+                                     (v128.const i64x2 4611686018427387904 9223372035781033984))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)
+                                     (i32.const 2))
+                                     (v128.const i64x2 308641972530864197 308641972530864197))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 0x0_90AB_cdef_8765_4321 0x0_90AB_cdef_8765_4321)
+                                     (i32.const 2))
+                                     (v128.const i64x2 0x242af37be1d950c8 0x242af37be1d950c8))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D)
+                                     (i32.const 4))
+                                     (v128.const i64x2 0xAABBCCDDEEFFA0B 0xC0D0E0F00A0B0C0))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D)
+                                     (i32.const 8))
+                                     (v128.const i64x2 0xAABBCCDDEEFFA0 0xC0D0E0F00A0B0C))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 16))
+                                     (v128.const i64x2 0 0x00))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i64x2 0 0x00))
+;; amount is multiple of lane width
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i64x2 1 0x0F))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i64x2 1 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 65))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 0 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i64x2 0 0x03))
+
+;; i64x2 shr_s
+;; amount less than lane width
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 -9223372036854775808 -2147483648)
+                                     (i32.const 1))
+                                     (v128.const i64x2 13835058055282163712 18446744072635809792))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)
+                                     (i32.const 2))
+                                     (v128.const i64x2 308641972530864197 308641972530864197))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 0x0_90AB_cdef_8765_4321 0x0_90AB_cdef_8765_4321)
+                                     (i32.const 2))
+                                     (v128.const i64x2 0xe42af37be1d950c8 0xe42af37be1d950c8))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D)
+                                     (i32.const 4))
+                                     (v128.const i64x2 0xFAABBCCDDEEFFA0B 0xFC0D0E0F00A0B0C0))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 0xFFAABBCCDDEEFFA0 0xC0D0E0F00A0B0C0D)
+                                     (i32.const 8))
+                                     (v128.const i64x2 0xFFFFAABBCCDDEEFF 0xFFC0D0E0F00A0B0C))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 16))
+                                     (v128.const i64x2 0 0x00))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i64x2 0 0x00))
+;; amount is multiple of lane width
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i64x2 1 0x0F))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i64x2 1 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 -9223372036854775808 -2147483648)
+                                     (i32.const 65))
+                                     (v128.const i64x2 13835058055282163712 18446744072635809792))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 0x0C 0x0D)
+                                     (i32.const 65))
+                                     (v128.const i64x2 0x06 0x06))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i64x2 0 0x03))
+
+;; shifting by a constant amount
+(assert_return (invoke "i64x2.shl_1" (v128.const i64x2 1 0x0F))
+                                     (v128.const i64x2 2 0x1E))
+(assert_return (invoke "i64x2.shr_u_64" (v128.const i64x2 1 0x0F))
+                                        (v128.const i64x2 1 0x0F))
+(assert_return (invoke "i64x2.shr_s_65" (v128.const i64x2 1 0x0F))
+                                        (v128.const i64x2 0 0x07))
+
+;; Combination
+
+(module (memory 1)
+  (func (export "i8x16.shl-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.shl
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i8x16.shr_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.shr_s
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i8x16.shr_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.shr_u
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i16x8.shl-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.shl
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i16x8.shr_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.shr_s
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i16x8.shr_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.shr_u
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i32x4.shl-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.shl
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i32x4.shr_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.shr_s
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i32x4.shr_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.shr_u
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i64x2.shl-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i64x2.shl
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i64x2.shr_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i64x2.shr_s
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i64x2.shr_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i64x2.shr_u
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-i8x16.shl")
+    (drop
+      (i8x16.shl
+        (i8x16.shl
+          (i8x16.shl
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i8x16.shr_s")
+    (drop
+      (i8x16.shr_s
+        (i8x16.shr_s
+          (i8x16.shr_s
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i8x16.shr_u")
+    (drop
+      (i8x16.shr_u
+        (i8x16.shr_u
+          (i8x16.shr_u
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i16x8.shl")
+    (drop
+      (i16x8.shl
+        (i16x8.shl
+          (i16x8.shl
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i16x8.shr_s")
+    (drop
+      (i16x8.shr_s
+        (i16x8.shr_s
+          (i16x8.shr_s
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i16x8.shr_u")
+    (drop
+      (i16x8.shr_u
+        (i16x8.shr_u
+          (i16x8.shr_u
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i32x4.shl")
+    (drop
+      (i32x4.shl
+        (i32x4.shl
+          (i32x4.shl
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i32x4.shr_s")
+    (drop
+      (i32x4.shr_s
+        (i32x4.shr_s
+          (i32x4.shr_s
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i32x4.shr_u")
+    (drop
+      (i32x4.shr_u
+        (i32x4.shr_u
+          (i32x4.shr_u
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i64x2.shl")
+    (drop
+      (i64x2.shl
+        (i64x2.shl
+          (i64x2.shl
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i64x2.shr_s")
+    (drop
+      (i64x2.shr_s
+        (i64x2.shr_s
+          (i64x2.shr_s
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i64x2.shr_u")
+    (drop
+      (i64x2.shr_u
+        (i64x2.shr_u
+          (i64x2.shr_u
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+)
+
+(assert_return (invoke "i8x16.shl-in-block"))
+(assert_return (invoke "i8x16.shr_s-in-block"))
+(assert_return (invoke "i8x16.shr_u-in-block"))
+(assert_return (invoke "i16x8.shl-in-block"))
+(assert_return (invoke "i16x8.shr_s-in-block"))
+(assert_return (invoke "i16x8.shr_u-in-block"))
+(assert_return (invoke "i32x4.shl-in-block"))
+(assert_return (invoke "i32x4.shr_s-in-block"))
+(assert_return (invoke "i32x4.shr_u-in-block"))
+(assert_return (invoke "i64x2.shl-in-block"))
+(assert_return (invoke "i64x2.shr_s-in-block"))
+(assert_return (invoke "i64x2.shr_u-in-block"))
+(assert_return (invoke "nested-i8x16.shl"))
+(assert_return (invoke "nested-i8x16.shr_s"))
+(assert_return (invoke "nested-i8x16.shr_u"))
+(assert_return (invoke "nested-i16x8.shl"))
+(assert_return (invoke "nested-i16x8.shr_s"))
+(assert_return (invoke "nested-i16x8.shr_u"))
+(assert_return (invoke "nested-i32x4.shl"))
+(assert_return (invoke "nested-i32x4.shr_s"))
+(assert_return (invoke "nested-i32x4.shr_u"))
+(assert_return (invoke "nested-i64x2.shl"))
+(assert_return (invoke "nested-i64x2.shr_s"))
+(assert_return (invoke "nested-i64x2.shr_u"))
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (i8x16.shl   (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.shr_s (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.shr_u (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.shl   (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.shr_s (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.shr_u (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.shl   (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.shr_s (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.shr_u (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.shl   (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.shr_s (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.shr_u (i32.const 0) (i32.const 0)))) "type mismatch")
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.shl_s (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.shl_r (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.shr   (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.shl_s (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.shl_r (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.shr   (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.shl_s (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.shl_r (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.shr   (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.shl_s (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.shl_r (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.shr   (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.shl   (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.shr_s (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.shr_u (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.shl-1st-arg-empty (result v128)
+      (i8x16.shl (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.shl-last-arg-empty (result v128)
+      (i8x16.shl (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.shl-arg-empty (result v128)
+      (i8x16.shl)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.shr_u-1st-arg-empty (result v128)
+      (i16x8.shr_u (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.shr_u-last-arg-empty (result v128)
+      (i16x8.shr_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.shr_u-arg-empty (result v128)
+      (i16x8.shr_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.shr_s-1st-arg-empty (result v128)
+      (i32x4.shr_s (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.shr_s-last-arg-empty (result v128)
+      (i32x4.shr_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.shr_s-arg-empty (result v128)
+      (i32x4.shr_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.shl-1st-arg-empty (result v128)
+      (i64x2.shl (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.shr_u-last-arg-empty (result v128)
+      (i64x2.shr_u (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.shr_s-arg-empty (result v128)
+      (i64x2.shr_s)
+    )
+  )
+  "type mismatch"
+)
diff --git a/test/core/simd/simd_bitwise.wast b/test/core/simd/simd_bitwise.wast
new file mode 100644
index 000000000..f646bf61d
--- /dev/null
+++ b/test/core/simd/simd_bitwise.wast
@@ -0,0 +1,812 @@
+;; Test all the bitwise operators on major boundary values and all special values.
+
+(module
+  (func (export "not") (param $0 v128) (result v128) (v128.not (local.get $0)))
+  (func (export "and") (param $0 v128) (param $1 v128) (result v128) (v128.and (local.get $0) (local.get $1)))
+  (func (export "or") (param $0 v128) (param $1 v128) (result v128) (v128.or (local.get $0) (local.get $1)))
+  (func (export "xor") (param $0 v128) (param $1 v128) (result v128) (v128.xor (local.get $0) (local.get $1)))
+  (func (export "bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+    (v128.bitselect (local.get $0) (local.get $1) (local.get $2))
+  )
+  (func (export "andnot") (param $0 v128) (param $1 v128) (result v128) (v128.andnot (local.get $0) (local.get $1)))
+)
+
+;; i32x4
+(assert_return (invoke "not" (v128.const i32x4 0 0 0 0))
+                             (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "not" (v128.const i32x4 -1 -1 -1 -1))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "not" (v128.const i32x4 -1 0 -1 0))
+                             (v128.const i32x4 0 -1 0 -1))
+(assert_return (invoke "not" (v128.const i32x4 0 -1 0 -1))
+                             (v128.const i32x4 -1 0 -1 0))
+(assert_return (invoke "not" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+                             (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+(assert_return (invoke "not" (v128.const i32x4 3435973836 3435973836 3435973836 3435973836))
+                             (v128.const i32x4 858993459 858993459 858993459 858993459))
+(assert_return (invoke "not" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                             (v128.const i32x4 3060399405 3060399405 3060399405 3060399405))
+(assert_return (invoke "not" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                             (v128.const i32x4 0xedcba987 0xedcba987 0xedcba987 0xedcba987))
+(assert_return (invoke "and" (v128.const i32x4 0 0 -1 -1)
+                             (v128.const i32x4 0 -1 0 -1))
+                             (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "and" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 0 0 0 0))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "and" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 -1 -1 -1 -1))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "and" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "and" (v128.const i32x4 1 1 1 1)
+                             (v128.const i32x4 1 1 1 1))
+                             (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "and" (v128.const i32x4 255 255 255 255)
+                             (v128.const i32x4 85 85 85 85))
+                             (v128.const i32x4 85 85 85 85))
+(assert_return (invoke "and" (v128.const i32x4 255 255 255 255)
+                             (v128.const i32x4 128 128 128 128))
+                             (v128.const i32x4 128 128 128 128))
+(assert_return (invoke "and" (v128.const i32x4 2863311530 2863311530 2863311530 2863311530)
+                             (v128.const i32x4 10 128 5 165))
+                             (v128.const i32x4 10 128 0 160))
+(assert_return (invoke "and" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+                             (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+(assert_return (invoke "and" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                             (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+(assert_return (invoke "and" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0x0 0x0 0x0 0x0))
+                             (v128.const i32x4 0x0 0x0 0x0 0x0))
+(assert_return (invoke "and" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                             (v128.const i32x4 0x5555 0xFFFF 0x55FF 0x5FFF))
+                             (v128.const i32x4 0x5555 0x5555 0x5555 0x5555))
+(assert_return (invoke "and" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                             (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                             (v128.const i32x4 1234567890 1234567890 1234567890 1234567890))
+(assert_return (invoke "and" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                             (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                             (v128.const i32x4 0x10204468 0x10204468 0x10204468 0x10204468))
+(assert_return (invoke "or" (v128.const i32x4 0 0 -1 -1)
+                            (v128.const i32x4 0 -1 0 -1))
+                            (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "or" (v128.const i32x4 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "or" (v128.const i32x4 0 0 0 0)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "or" (v128.const i32x4 0 0 0 0)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "or" (v128.const i32x4 1 1 1 1)
+                            (v128.const i32x4 1 1 1 1))
+                            (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "or" (v128.const i32x4 255 255 255 255)
+                            (v128.const i32x4 85 85 85 85))
+                            (v128.const i32x4 255 255 255 255))
+(assert_return (invoke "or" (v128.const i32x4 255 255 255 255)
+                            (v128.const i32x4 128 128 128 128))
+                            (v128.const i32x4 255 255 255 255))
+(assert_return (invoke "or" (v128.const i32x4 2863311530 2863311530 2863311530 2863311530)
+                            (v128.const i32x4 10 128 5 165))
+                            (v128.const i32x4 2863311530 2863311530 2863311535 2863311535))
+(assert_return (invoke "or" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "or" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "or" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0x0 0x0 0x0 0x0))
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "or" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                            (v128.const i32x4 0x5555 0xFFFF 0x55FF 0x5FFF))
+                            (v128.const i32x4 0x55555555 0x5555ffff 0x555555ff 0x55555fff))
+(assert_return (invoke "or" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                            (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                            (v128.const i32x4 1234567890 1234567890 1234567890 1234567890))
+(assert_return (invoke "or" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                            (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                            (v128.const i32x4 0x92bfdfff 0x92bfdfff 0x92bfdfff 0x92bfdfff))
+(assert_return (invoke "xor" (v128.const i32x4 0 0 -1 -1)
+                             (v128.const i32x4 0 -1 0 -1))
+                             (v128.const i32x4 0 -1 -1 0))
+(assert_return (invoke "xor" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 0 0 0 0))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 -1 -1 -1 -1))
+                             (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "xor" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                             (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "xor" (v128.const i32x4 1 1 1 1)
+                             (v128.const i32x4 1 1 1 1))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const i32x4 255 255 255 255)
+                             (v128.const i32x4 85 85 85 85))
+                             (v128.const i32x4 170 170 170 170))
+(assert_return (invoke "xor" (v128.const i32x4 255 255 255 255)
+                             (v128.const i32x4 128 128 128 128))
+                             (v128.const i32x4 127 127 127 127))
+(assert_return (invoke "xor" (v128.const i32x4 2863311530 2863311530 2863311530 2863311530)
+                             (v128.const i32x4 10 128 5 165))
+                             (v128.const i32x4 2863311520 2863311402 2863311535 2863311375))
+(assert_return (invoke "xor" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+                             (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+(assert_return (invoke "xor" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                             (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+(assert_return (invoke "xor" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0x0 0x0 0x0 0x0))
+                             (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "xor" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                             (v128.const i32x4 0x5555 0xFFFF 0x55FF 0x5FFF))
+                             (v128.const i32x4 0x55550000 0x5555AAAA 0x555500AA 0x55550AAA))
+(assert_return (invoke "xor" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                             (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                             (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                             (v128.const i32x4 0x829f9b97 0x829f9b97 0x829f9b97 0x829f9b97))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB)
+                                   (v128.const i32x4 0x00112345 0xF00FFFFF 0x10112021 0xBBAABBAA))
+                                   (v128.const i32x4 0xBBAABABA 0xABBAAAAA 0xABAABBBA 0xAABBAABB))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB)
+                                   (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                                   (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB)
+                                   (v128.const i32x4 0x11111111 0x11111111 0x11111111 0x11111111))
+                                   (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB)
+                                   (v128.const i32x4 0x01234567 0x89ABCDEF 0xFEDCBA98 0x76543210))
+                                   (v128.const i32x4 0xBABABABA 0xBABABABA 0xABABABAB 0xABABABAB))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                                   (v128.const i32x4 0x01234567 0x89ABCDEF 0xFEDCBA98 0x76543210))
+                                   (v128.const i32x4 0x54761032 0xDCFE98BA 0xAB89EFCD 0x23016745))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                                   (v128.const i32x4 0x55555555 0xAAAAAAAA 0x00000000 0xFFFFFFFF))
+                                   (v128.const i32x4 0x00000000 0xFFFFFFFF 0x55555555 0xAAAAAAAA))
+(assert_return (invoke "bitselect" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                   (v128.const i32x4 03_060_399_406 03_060_399_406 03_060_399_406 03_060_399_406)
+                                   (v128.const i32x4 0xcdefcdef 0xcdefcdef 0xcdefcdef 0xcdefcdef))
+                                   (v128.const i32x4 2072391874 2072391874 2072391874 2072391874))
+(assert_return (invoke "bitselect" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                                   (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                   (v128.const i32x4 0xcdefcdef 0xcdefcdef 0xcdefcdef 0xcdefcdef))
+                                   (v128.const i32x4 0x10244468 0x10244468 0x10244468 0x10244468))
+(assert_return (invoke "andnot" (v128.const i32x4 0 0 -1 -1)
+                                (v128.const i32x4 0 -1 0 -1))
+                                (v128.const i32x4 0 0 -1 0))
+(assert_return (invoke "andnot" (v128.const i32x4 0 0 0 0)
+                                (v128.const i32x4 0 0 0 0))
+                                (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "andnot" (v128.const i32x4 0 0 0 0)
+                                (v128.const i32x4 -1 -1 -1 -1))
+                                (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "andnot" (v128.const i32x4 0 0 0 0)
+                                (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                                (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "andnot" (v128.const i32x4 1 1 1 1)
+                                (v128.const i32x4 1 1 1 1))
+                                (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "andnot" (v128.const i32x4 255 255 255 255)
+                                (v128.const i32x4 85 85 85 85))
+                                (v128.const i32x4 170 170 170 170))
+(assert_return (invoke "andnot" (v128.const i32x4 255 255 255 255)
+                                (v128.const i32x4 128 128 128 128))
+                                (v128.const i32x4 127 127 127 127))
+(assert_return (invoke "andnot" (v128.const i32x4 2863311530 2863311530 2863311530 2863311530)
+                                (v128.const i32x4 10 128 5 165))
+                                (v128.const i32x4 2863311520 2863311402 2863311530 2863311370))
+(assert_return (invoke "andnot" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                                (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+                                (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+(assert_return (invoke "andnot" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                                (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                                (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+(assert_return (invoke "andnot" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                                (v128.const i32x4 0x0 0x0 0x0 0x0))
+                                (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "andnot" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                                (v128.const i32x4 0x5555 0xFFFF 0x55FF 0x5FFF))
+                                (v128.const i32x4 0x55550000 0x55550000 0x55550000 0x55550000))
+(assert_return (invoke "andnot" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "andnot" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                                (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                                (v128.const i32x4 0x02141210 0x02141210 0x02141210 0x02141210))
+
+;; for float special data [e.g. -nan nan -inf inf]
+(assert_return (invoke "not" (v128.const f32x4 -nan -nan -nan -nan))
+                             (v128.const f32x4 5.87747e-39 5.87747e-39 5.87747e-39 5.87747e-39))
+(assert_return (invoke "not" (v128.const f32x4 nan nan nan nan))
+                             (v128.const f32x4 -5.87747e-39 -5.87747e-39 -5.87747e-39 -5.87747e-39))
+(assert_return (invoke "not" (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const i32x4 0x007fffff 0x007fffff 0x007fffff 0x007fffff))
+(assert_return (invoke "not" (v128.const f32x4 inf inf inf inf))
+                             (v128.const i32x4 0x807fffff 0x807fffff 0x807fffff 0x807fffff))
+(assert_return (invoke "and" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 -nan -nan -nan -nan))
+                             (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "and" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 nan nan nan nan))
+                             (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "and" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "and" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "and" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 nan nan nan nan))
+                             (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "and" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "and" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "and" (v128.const f32x4 -inf -inf -inf -inf)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "and" (v128.const f32x4 -inf -inf -inf -inf)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "and" (v128.const f32x4 inf inf inf inf)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "or" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "or" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "or" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "or" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "or" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "or" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "or" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "or" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "or" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "or" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "xor" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 -nan -nan -nan -nan))
+                             (v128.const f32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 nan nan nan nan))
+                             (v128.const f32x4 -0 -0 -0 -0))
+(assert_return (invoke "xor" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000))
+(assert_return (invoke "xor" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const i32x4 0x80400000 0x80400000 0x80400000 0x80400000))
+(assert_return (invoke "xor" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 nan nan nan nan))
+                             (v128.const f32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const i32x4 0x80400000 0x80400000 0x80400000 0x80400000))
+(assert_return (invoke "xor" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000))
+(assert_return (invoke "xor" (v128.const f32x4 -inf -inf -inf -inf)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const f32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const f32x4 -inf -inf -inf -inf)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "xor" (v128.const f32x4 inf inf inf inf)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const f32x4 0 0 0 0))
+(assert_return (invoke "bitselect" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "bitselect" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "bitselect" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "bitselect" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "andnot" (v128.const f32x4 -nan -nan -nan -nan)
+                                (v128.const f32x4 -nan -nan -nan -nan))
+                                (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "andnot" (v128.const f32x4 -nan -nan -nan -nan)
+                                (v128.const f32x4 nan nan nan nan))
+                                (v128.const f32x4 -0 -0 -0 -0))
+(assert_return (invoke "andnot" (v128.const f32x4 -nan -nan -nan -nan)
+                                (v128.const f32x4 -inf -inf -inf -inf))
+                                (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000))
+(assert_return (invoke "andnot" (v128.const f32x4 -nan -nan -nan -nan)
+                                (v128.const f32x4 inf inf inf inf))
+                                (v128.const i32x4 0x80400000 0x80400000 0x80400000 0x80400000))
+(assert_return (invoke "andnot" (v128.const f32x4 nan nan nan nan)
+                                (v128.const f32x4 nan nan nan nan))
+                                (v128.const f32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "andnot" (v128.const f32x4 nan nan nan nan)
+                                (v128.const f32x4 -inf -inf -inf -inf))
+                                (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000))
+(assert_return (invoke "andnot" (v128.const f32x4 nan nan nan nan)
+                                (v128.const f32x4 inf inf inf inf))
+                                (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000))
+(assert_return (invoke "andnot" (v128.const f32x4 -inf -inf -inf -inf)
+                                (v128.const f32x4 -inf -inf -inf -inf))
+                                (v128.const f32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "andnot" (v128.const f32x4 -inf -inf -inf -inf)
+                                (v128.const f32x4 inf inf inf inf))
+                                (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "andnot" (v128.const f32x4 inf inf inf inf)
+                                (v128.const f32x4 inf inf inf inf))
+                                (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+
+;; Type check
+
+;; not
+(assert_invalid (module (func (result v128) (v128.not (i32.const 0)))) "type mismatch")
+;; and
+(assert_invalid (module (func (result v128) (v128.and (i32.const 0) (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.and (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.and (i32.const 0) (i32.const 0)))) "type mismatch")
+;; or
+(assert_invalid (module (func (result v128) (v128.or (i32.const 0) (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.or (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.or (i32.const 0) (i32.const 0)))) "type mismatch")
+;; xor
+(assert_invalid (module (func (result v128) (v128.xor (i32.const 0) (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.xor (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.xor (i32.const 0) (i32.const 0)))) "type mismatch")
+;; bitselect
+(assert_invalid (module (func (result v128) (v128.bitselect (i32.const 0) (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.bitselect (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.bitselect (i32.const 0) (i32.const 0) (i32.const 0)))) "type mismatch")
+;; andnot
+(assert_invalid (module (func (result v128) (v128.andnot (i32.const 0) (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.andnot (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.andnot (i32.const 0) (i32.const 0)))) "type mismatch")
+
+;; Combination
+
+(module (memory 1)
+  (func (export "v128.not-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.not
+            (block (result v128) (v128.load (i32.const 0)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "v128.and-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.and
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "v128.or-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.or
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "v128.xor-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.xor
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "v128.bitselect-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.bitselect
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+            (block (result v128) (v128.load (i32.const 2)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "v128.andnot-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.andnot
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.not")
+    (drop
+      (v128.not
+        (v128.not
+          (v128.not
+            (v128.load (i32.const 0))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.and")
+    (drop
+      (v128.and
+        (v128.and
+          (v128.and
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.and
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+        (v128.and
+          (v128.and
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.and
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.or")
+    (drop
+      (v128.or
+        (v128.or
+          (v128.or
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.or
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+        (v128.or
+          (v128.or
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.or
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.xor")
+    (drop
+      (v128.xor
+        (v128.xor
+          (v128.xor
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.xor
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+        (v128.xor
+          (v128.xor
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.xor
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.bitselect")
+    (drop
+      (v128.bitselect
+        (v128.bitselect
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+        )
+        (v128.bitselect
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+        )
+        (v128.bitselect
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.andnot")
+    (drop
+      (v128.andnot
+        (v128.andnot
+          (v128.andnot
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.andnot
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+        (v128.andnot
+          (v128.andnot
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.andnot
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (v128.or
+        (v128.and
+          (v128.not
+            (v128.load (i32.const 0))
+          )
+          (v128.not
+            (v128.load (i32.const 1))
+          )
+        )
+        (v128.xor
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.andnot
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "v128.not-in-block"))
+(assert_return (invoke "v128.and-in-block"))
+(assert_return (invoke "v128.or-in-block"))
+(assert_return (invoke "v128.xor-in-block"))
+(assert_return (invoke "v128.bitselect-in-block"))
+(assert_return (invoke "v128.andnot-in-block"))
+(assert_return (invoke "nested-v128.not"))
+(assert_return (invoke "nested-v128.and"))
+(assert_return (invoke "nested-v128.or"))
+(assert_return (invoke "nested-v128.xor"))
+(assert_return (invoke "nested-v128.bitselect"))
+(assert_return (invoke "nested-v128.andnot"))
+(assert_return (invoke "as-param"))
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $v128.not-arg-empty (result v128)
+      (v128.not)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.and-1st-arg-empty (result v128)
+      (v128.and (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.and-arg-empty (result v128)
+      (v128.and)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.or-1st-arg-empty (result v128)
+      (v128.or (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.or-arg-empty (result v128)
+      (v128.or)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.xor-1st-arg-empty (result v128)
+      (v128.xor (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.xor-arg-empty (result v128)
+      (v128.xor)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.andnot-1st-arg-empty (result v128)
+      (v128.andnot (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.andnot-arg-empty (result v128)
+      (v128.andnot)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.bitselect-1st-arg-empty (result v128)
+      (v128.bitselect (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.bitselect-two-args-empty (result v128)
+      (v128.bitselect (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.bitselect-arg-empty (result v128)
+      (v128.bitselect)
+    )
+  )
+  "type mismatch"
+)
diff --git a/test/core/simd/simd_boolean.wast b/test/core/simd/simd_boolean.wast
new file mode 100644
index 000000000..6ab330fe5
--- /dev/null
+++ b/test/core/simd/simd_boolean.wast
@@ -0,0 +1,1058 @@
+;; Test all the boolean operators on major boundary values and all special values.
+
+(module
+  (func (export "i8x16.any_true") (param $0 v128) (result i32) (v128.any_true (local.get $0)))
+  (func (export "i8x16.all_true") (param $0 v128) (result i32) (i8x16.all_true (local.get $0)))
+  (func (export "i8x16.bitmask") (param $0 v128) (result i32) (i8x16.bitmask (local.get $0)))
+
+  (func (export "i16x8.any_true") (param $0 v128) (result i32) (v128.any_true (local.get $0)))
+  (func (export "i16x8.all_true") (param $0 v128) (result i32) (i16x8.all_true (local.get $0)))
+  (func (export "i16x8.bitmask") (param $0 v128) (result i32) (i16x8.bitmask (local.get $0)))
+
+  (func (export "i32x4.any_true") (param $0 v128) (result i32) (v128.any_true (local.get $0)))
+  (func (export "i32x4.all_true") (param $0 v128) (result i32) (i32x4.all_true (local.get $0)))
+  (func (export "i32x4.bitmask") (param $0 v128) (result i32) (i32x4.bitmask (local.get $0)))
+
+  (func (export "i64x2.all_true") (param $0 v128) (result i32) (i64x2.all_true (local.get $0)))
+  (func (export "i64x2.bitmask") (param $0 v128) (result i32) (i64x2.bitmask (local.get $0)))
+)
+
+;; i8x16
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 -1 0 1 2 3 4 5 6 7 8 9 0xA 0xB 0xC 0xD 0xF))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 -1 0 1 2 3 4 5 6 7 8 9 0xA 0xB 0xC 0xD 0xF))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.bitmask" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 0x0000FFFF))
+(assert_return (invoke "i8x16.bitmask" (v128.const i8x16 -1 0 1 2 3 4 5 6 7 8 9 0xA 0xB 0xC 0xD 0xF))
+                                        (i32.const 0x00000001))
+
+;; i16x8
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 -1 0 1 2 0xB 0xC 0xD 0xF))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 -1 0 1 2 0xB 0xC 0xD 0xF))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.bitmask" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                                        (i32.const 0x000000FF))
+(assert_return (invoke "i16x8.bitmask" (v128.const i16x8 -1 0 1 2 0xB 0xC 0xD 0xF))
+                                        (i32.const 0x00000001))
+
+;; i32x4
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0 0 1 0))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 1 1 0 1))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 -1 0 1 0xF))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0 0 1 0))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 1 1 0 1))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 -1 0 1 0xF))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.bitmask" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                                        (i32.const 0x0000000F))
+(assert_return (invoke "i32x4.bitmask" (v128.const i32x4 -1 0 1 0xF))
+                                        (i32.const 0x00000001))
+
+;; i64x2
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0 1))
+                                        (i32.const 0))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 1 0))
+                                        (i32.const 0))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 -1 0))
+                                        (i32.const 0))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i64x2.bitmask" (v128.const i64x2 0xFFFFFFFF_FFFFFFFF 0xFFFFFFFF_FFFFFFFF))
+                                        (i32.const 0x00000003))
+(assert_return (invoke "i64x2.bitmask" (v128.const i64x2 -1 0xF))
+                                        (i32.const 0x00000001))
+
+;; Combination
+
+(module (memory 1)
+    ;; as if condition
+    (func (export "i8x16_any_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (v128.any_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    (func (export "i16x8_any_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (v128.any_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    (func (export "i32x4_any_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (v128.any_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    (func (export "i8x16_all_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (i8x16.all_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    (func (export "i16x8_all_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (i16x8.all_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    (func (export "i32x4_all_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (i32x4.all_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    ;; any_true as select condition
+    (func (export "i8x16_any_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (v128.any_true (local.get 0)))
+    )
+    (func (export "i16x8_any_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (v128.any_true (local.get 0)))
+    )
+    (func (export "i32x4_any_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (v128.any_true (local.get 0)))
+    )
+    ;; all_true as select condition
+    (func (export "i8x16_all_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (i8x16.all_true (local.get 0)))
+    )
+    (func (export "i16x8_all_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (i16x8.all_true (local.get 0)))
+    )
+    (func (export "i32x4_all_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (i32x4.all_true (local.get 0)))
+    )
+    ;; any_true as br_if condition
+    (func (export "i8x16_any_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (v128.any_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    (func (export "i16x8_any_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (v128.any_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    (func (export "i32x4_any_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (v128.any_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    ;; all_true as br_if condition
+    (func (export "i8x16_all_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (i8x16.all_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    (func (export "i16x8_all_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (i16x8.all_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    (func (export "i32x4_all_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (i32x4.all_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    ;; any_true as i32.and operand
+    (func (export "i8x16_any_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i16x8_any_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i32x4_any_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+     ;; any_true as i32.or operand
+    (func (export "i8x16_any_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i16x8_any_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i32x4_any_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+     ;; any_true as i32.xor operand
+    (func (export "i8x16_any_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i16x8_any_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i32x4_any_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+     ;; all_true as i32.and operand
+    (func (export "i8x16_all_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (i8x16.all_true (local.get $0)) (i8x16.all_true (local.get $1)))
+    )
+    (func (export "i16x8_all_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (i16x8.all_true (local.get $0)) (i16x8.all_true (local.get $1)))
+    )
+    (func (export "i32x4_all_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (i32x4.all_true (local.get $0)) (i32x4.all_true (local.get $1)))
+    )
+     ;; all_true as i32.or operand
+    (func (export "i8x16_all_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (i8x16.all_true (local.get $0)) (i8x16.all_true (local.get $1)))
+    )
+    (func (export "i16x8_all_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (i16x8.all_true (local.get $0)) (i16x8.all_true (local.get $1)))
+    )
+    (func (export "i32x4_all_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (i32x4.all_true (local.get $0)) (i32x4.all_true (local.get $1)))
+    )
+     ;; all_true as i32.xor operand
+    (func (export "i8x16_all_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (i8x16.all_true (local.get $0)) (i8x16.all_true (local.get $1)))
+    )
+    (func (export "i16x8_all_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (i16x8.all_true (local.get $0)) (i16x8.all_true (local.get $1)))
+    )
+    (func (export "i32x4_all_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (i32x4.all_true (local.get $0)) (i32x4.all_true (local.get $1)))
+    )
+    ;; any_true with v128.not
+    (func (export "i8x16_any_true_with_v128.not") (param $0 v128) (result i32)
+       (v128.any_true (v128.not (local.get $0)))
+    )
+    (func (export "i16x8_any_true_with_v128.not") (param $0 v128) (result i32)
+       (v128.any_true (v128.not (local.get $0)))
+    )
+    (func (export "i32x4_any_true_with_v128.not") (param $0 v128) (result i32)
+       (v128.any_true (v128.not (local.get $0)))
+    )
+    ;; any_true with v128.and
+    (func (export "i8x16_any_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.and (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_any_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.and (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_any_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.and (local.get $0) (local.get $1)))
+    )
+    ;; any_true with v128.or
+    (func (export "i8x16_any_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.or (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_any_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.or (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_any_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.or (local.get $0) (local.get $1)))
+    )
+    ;; any_true with v128.xor
+    (func (export "i8x16_any_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_any_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_any_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    ;; any_true with v128.bitselect
+    (func (export "i8x16_any_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (v128.any_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+    (func (export "i16x8_any_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (v128.any_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+    (func (export "i32x4_any_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (v128.any_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+    ;; all_true with v128.not
+    (func (export "i8x16_all_true_with_v128.not") (param $0 v128) (result i32)
+       (i8x16.all_true (v128.not (local.get $0)))
+    )
+    (func (export "i16x8_all_true_with_v128.not") (param $0 v128) (result i32)
+       (i16x8.all_true (v128.not (local.get $0)))
+    )
+    (func (export "i32x4_all_true_with_v128.not") (param $0 v128) (result i32)
+       (i32x4.all_true (v128.not (local.get $0)))
+    )
+    ;; all_true with v128.and
+    (func (export "i8x16_all_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (i8x16.all_true (v128.and (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_all_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (i16x8.all_true (v128.and (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_all_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (i32x4.all_true (v128.and (local.get $0) (local.get $1)))
+    )
+    ;; all_true with v128.or
+    (func (export "i8x16_all_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (i8x16.all_true (v128.or (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_all_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (i16x8.all_true (v128.or (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_all_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (i32x4.all_true (v128.or (local.get $0) (local.get $1)))
+    )
+    ;; all_true with v128.xor
+    (func (export "i8x16_all_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (i8x16.all_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_all_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (i16x8.all_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_all_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (i32x4.all_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    ;; all_true with v128.bitselect
+    (func (export "i8x16_all_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (i8x16.all_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+    (func (export "i16x8_all_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (i16x8.all_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+    (func (export "i32x4_all_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (i32x4.all_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+)
+
+;; 'any_true' as 'if' condition
+;; i8x16
+(assert_return (invoke "i8x16_any_true_as_if_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_if_cond" (v128.const i8x16 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0))
+                                                   (i32.const 1))
+(assert_return (invoke "i8x16_any_true_as_if_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (i32.const 1))
+;; i16x8
+(assert_return (invoke "i16x8_any_true_as_if_cond" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_if_cond" (v128.const i16x8 0 0 1 0 0 0 1 0))
+                                                   (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_if_cond" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (i32.const 1))
+;; i32x4
+(assert_return (invoke "i32x4_any_true_as_if_cond" (v128.const i32x4 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_if_cond" (v128.const i32x4 0 0 1 0))
+                                                   (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_if_cond" (v128.const i32x4 1 1 1 1))
+                                                   (i32.const 1))
+
+;; 'all_true' as 'if' condition
+;; i8x16
+(assert_return (invoke "i8x16_all_true_as_if_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i8x16_all_true_as_if_cond" (v128.const i8x16 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i8x16_all_true_as_if_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (i32.const 1))
+;; i16x8
+(assert_return (invoke "i16x8_all_true_as_if_cond" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_if_cond" (v128.const i16x8 1 1 1 0 1 1 1 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_if_cond" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (i32.const 1))
+;; i32x4
+(assert_return (invoke "i32x4_all_true_as_if_cond" (v128.const i32x4 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_if_cond" (v128.const i32x4 1 1 1 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_if_cond" (v128.const i32x4 1 1 1 1))
+                                                   (i32.const 1))
+
+;; any_true as select condition
+(assert_return (invoke "i8x16_any_true_as_select_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                       (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_select_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                       (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_select_cond" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                       (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_select_cond" (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                       (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_select_cond" (v128.const i32x4 0 0 0 0))
+                                                       (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_select_cond" (v128.const i32x4 0 0 1 0))
+                                                       (i32.const 1))
+;; all_true as select condition
+(assert_return (invoke "i8x16_all_true_as_select_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                       (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_select_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                                       (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_select_cond" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                       (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_select_cond" (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                                       (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_select_cond" (v128.const i32x4 1 1 1 1))
+                                                       (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_select_cond" (v128.const i32x4 1 1 0 1))
+                                                       (i32.const 0))
+;; any_true as br_if condition
+(assert_return (invoke "i8x16_any_true_as_br_if_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_br_if_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_br_if_cond" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_br_if_cond" (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_br_if_cond" (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_br_if_cond" (v128.const i32x4 0 0 1 0))
+                                                      (i32.const 1))
+;; all_true as br_if condition
+(assert_return (invoke "i8x16_all_true_as_br_if_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                      (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_br_if_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_br_if_cond" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_br_if_cond" (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_br_if_cond" (v128.const i32x4 1 1 1 1))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_br_if_cond" (v128.const i32x4 1 1 0 1))
+                                                      (i32.const 0))
+;; any_true as and operand
+(assert_return (invoke "i8x16_any_true_as_i32.and_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_i32.and_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_i32.and_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                           (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_i32.and_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_i32.and_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_i32.and_operand" (v128.const i16x8 0 0 0 0 0 0 1 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                           (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_i32.and_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_i32.and_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_i32.and_operand" (v128.const i32x4 0 0 1 0)
+                                                           (v128.const i32x4 0 0 1 0))
+                                                           (i32.const 1))
+;; any_true as or operand
+(assert_return (invoke "i8x16_any_true_as_i32.or_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                          (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                          (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_i32.or_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                          (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                          (i32.const 1))
+(assert_return (invoke "i8x16_any_true_as_i32.or_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)
+                                                          (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                          (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_i32.or_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                          (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                          (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_i32.or_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                          (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                          (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_i32.or_operand" (v128.const i16x8 0 0 0 0 0 0 1 0)
+                                                          (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                          (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_i32.or_operand" (v128.const i32x4 0 0 0 0)
+                                                          (v128.const i32x4 0 0 0 0))
+                                                          (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_i32.or_operand" (v128.const i32x4 0 0 0 0)
+                                                          (v128.const i32x4 0 0 1 0))
+                                                          (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_i32.or_operand" (v128.const i32x4 0 0 1 0)
+                                                          (v128.const i32x4 0 0 1 0))
+                                                          (i32.const 1))
+;; any_true as xor operand
+(assert_return (invoke "i8x16_any_true_as_i32.xor_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_i32.xor_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                           (i32.const 1))
+(assert_return (invoke "i8x16_any_true_as_i32.xor_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_i32.xor_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_i32.xor_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                           (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_i32.xor_operand" (v128.const i16x8 0 0 0 0 0 0 1 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_i32.xor_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_i32.xor_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 1 0))
+                                                           (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_i32.xor_operand" (v128.const i32x4 0 0 1 0)
+                                                           (v128.const i32x4 0 0 1 0))
+                                                           (i32.const 0))
+;; all_true as and operand
+(assert_return (invoke "i8x16_all_true_as_i32.and_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                           (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_i32.and_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                           (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i8x16_all_true_as_i32.and_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_i32.and_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_i32.and_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                           (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_i32.and_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_i32.and_operand" (v128.const i32x4 1 1 1 1)
+                                                           (v128.const i32x4 1 1 1 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_i32.and_operand" (v128.const i32x4 1 1 1 1)
+                                                           (v128.const i32x4 1 1 0 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_i32.and_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 1 0))
+                                                           (i32.const 0))
+;; all_true as or operand
+(assert_return (invoke "i8x16_all_true_as_i32.or_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                          (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_i32.or_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                          (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_i32.or_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                          (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                          (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_i32.or_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                          (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_i32.or_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                          (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_i32.or_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                          (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                          (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_i32.or_operand" (v128.const i32x4 1 1 1 1)
+                                                          (v128.const i32x4 1 1 1 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_i32.or_operand" (v128.const i32x4 1 1 1 1)
+                                                          (v128.const i32x4 1 1 0 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_i32.or_operand" (v128.const i32x4 0 0 0 0)
+                                                          (v128.const i32x4 0 0 0 0))
+                                                          (i32.const 0))
+;; all_true as xor operand
+(assert_return (invoke "i8x16_all_true_as_i32.xor_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                           (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i8x16_all_true_as_i32.xor_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                           (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_i32.xor_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_i32.xor_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_i32.xor_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                           (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_i32.xor_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_i32.xor_operand" (v128.const i32x4 1 1 1 1)
+                                                           (v128.const i32x4 1 1 1 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_i32.xor_operand" (v128.const i32x4 1 1 1 1)
+                                                           (v128.const i32x4 1 1 0 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_i32.xor_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 0 0))
+                                                           (i32.const 0))
+;; any_true with v128.not
+(assert_return (invoke "i8x16_any_true_with_v128.not" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i8x16_any_true_with_v128.not" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.not" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.not" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.not" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.not" (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.not" (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.not" (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.not" (v128.const i32x4 0 0 -1 0))
+                                                      (i32.const 1))
+;; any_true with v128.and
+(assert_return (invoke "i8x16_any_true_with_v128.and" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.and" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i8x16_any_true_with_v128.and" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.and" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.and" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.and" (v128.const i16x8 0 0 0 0 0 0 -1 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.and" (v128.const i32x4 0 0 0 0)
+                                                      (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.and" (v128.const i32x4 -1 -1 -1 -1)
+                                                      (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.and" (v128.const i32x4 0 0 -1 0)
+                                                      (v128.const i32x4 0 0 -1 0))
+                                                      (i32.const 1))
+;; any_true with v128.or
+(assert_return (invoke "i8x16_any_true_with_v128.or" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.or" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i8x16_any_true_with_v128.or" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                     (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.or" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.or" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.or" (v128.const i16x8 0 0 0 0 0 0 -1 0)
+                                                     (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                     (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.or" (v128.const i32x4 0 0 0 0)
+                                                     (v128.const i32x4 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.or" (v128.const i32x4 -1 -1 -1 -1)
+                                                     (v128.const i32x4 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.or" (v128.const i32x4 0 0 -1 0)
+                                                     (v128.const i32x4 0 0 -1 0))
+                                                     (i32.const 1))
+;; any_true with v128.xor
+(assert_return (invoke "i8x16_any_true_with_v128.xor" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.xor" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.xor" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.xor" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.xor" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.xor" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.xor" (v128.const i32x4 0 0 0 0)
+                                                      (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.xor" (v128.const i32x4 -1 -1 -1 -1)
+                                                      (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.xor" (v128.const i32x4 0 0 0 0)
+                                                      (v128.const i32x4 0 0 -1 0))
+                                                      (i32.const 1))
+;; any_true with v128.bitselect
+(assert_return (invoke "i8x16_any_true_with_v128.bitselect" (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.bitselect" (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0xFF 0x55))
+                                                            (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.bitselect" (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.bitselect" (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0xFF 0x55))
+                                                            (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.bitselect" (v128.const i32x4 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.bitselect" (v128.const i32x4 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55)
+                                                            (v128.const i32x4 0x55 0x55 0xFF 0x55))
+                                                            (i32.const 1))
+;; all_true with v128.not
+(assert_return (invoke "i8x16_all_true_with_v128.not" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i8x16_all_true_with_v128.not" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.not" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.not" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_all_true_with_v128.not" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.not" (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.not" (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_all_true_with_v128.not" (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.not" (v128.const i32x4 0 0 -1 0))
+                                                      (i32.const 0))
+;; all_true with v128.and
+(assert_return (invoke "i8x16_all_true_with_v128.and" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.and" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i8x16_all_true_with_v128.and" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.and" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.and" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_all_true_with_v128.and" (v128.const i16x8 0 0 0 0 0 0 -1 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.and" (v128.const i32x4 0 0 0 0)
+                                                      (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.and" (v128.const i32x4 -1 -1 -1 -1)
+                                                      (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_all_true_with_v128.and" (v128.const i32x4 0 0 -1 0)
+                                                      (v128.const i32x4 0 0 -1 0))
+                                                      (i32.const 0))
+;; all_true with v128.or
+(assert_return (invoke "i8x16_all_true_with_v128.or" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.or" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i8x16_all_true_with_v128.or" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.or" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.or" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i16x8_all_true_with_v128.or" (v128.const i16x8 0 0 0 0 0 0 -1 0)
+                                                     (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.or" (v128.const i32x4 0 0 0 0)
+                                                     (v128.const i32x4 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.or" (v128.const i32x4 -1 -1 -1 -1)
+                                                     (v128.const i32x4 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i32x4_all_true_with_v128.or" (v128.const i32x4 0 0 -1 0)
+                                                     (v128.const i32x4 0 0 -1 0))
+                                                     (i32.const 0))
+;; all_true with v128.xor
+(assert_return (invoke "i8x16_all_true_with_v128.xor" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.xor" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.xor" (v128.const i8x16 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1)
+                                                      (v128.const i8x16 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_all_true_with_v128.xor" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.xor" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.xor" (v128.const i16x8 0 -1 0 -1 0 -1 0 -1)
+                                                      (v128.const i16x8 -1 0 -1 0 -1 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_all_true_with_v128.xor" (v128.const i32x4 0 0 0 0)
+                                                      (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.xor" (v128.const i32x4 -1 -1 -1 -1)
+                                                      (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.xor" (v128.const i32x4 0 -1 0 -1)
+                                                      (v128.const i32x4 -1 0 -1 0))
+                                                      (i32.const 1))
+;; all_true with v128.bitselect
+(assert_return (invoke "i8x16_all_true_with_v128.bitselect" (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.bitselect" (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                                                            (i32.const 1))
+(assert_return (invoke "i16x8_all_true_with_v128.bitselect" (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.bitselect" (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                                                            (i32.const 1))
+(assert_return (invoke "i32x4_all_true_with_v128.bitselect" (v128.const i32x4 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.bitselect" (v128.const i32x4 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55)
+                                                            (v128.const i32x4 0xAA 0xAA 0xAA 0xAA))
+                                                            (i32.const 1))
+
+;; Type check
+
+(assert_invalid (module (func (result i32) (v128.any_true (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i8x16.all_true (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (v128.any_true (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i16x8.all_true (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (v128.any_true (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32x4.all_true (i32.const 0)))) "type mismatch")
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result i32) (f32x4.any_true (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result i32) (f32x4.all_true (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result i32) (f64x2.any_true (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result i32) (f64x2.all_true (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $v128.any_true-arg-empty (result v128)
+      (v128.any_true)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.all_true-arg-empty (result v128)
+      (i8x16.all_true)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.any_true-arg-empty (result v128)
+      (v128.any_true)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.all_true-arg-empty (result v128)
+      (i16x8.all_true)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.any_true-arg-empty (result v128)
+      (v128.any_true)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.all_true-arg-empty (result v128)
+      (i32x4.all_true)
+    )
+  )
+  "type mismatch"
+)
diff --git a/test/core/simd/simd_const.wast b/test/core/simd/simd_const.wast
new file mode 100644
index 000000000..8080cfb0f
--- /dev/null
+++ b/test/core/simd/simd_const.wast
@@ -0,0 +1,1664 @@
+;; v128.const normal parameter (e.g. (i8x16, i16x8 i32x4, f32x4))
+
+(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF) drop))
+(module (func (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) drop))
+(module (func (v128.const i8x16  255  255  255  255  255  255  255  255  255  255  255  255  255  255  255  255) drop))
+(module (func (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) drop))
+(module (func (v128.const i16x8  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF) drop))
+(module (func (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000) drop))
+(module (func (v128.const i16x8  65535  65535  65535  65535  65535  65535  65535  65535) drop))
+(module (func (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) drop))
+(module (func (v128.const i16x8  65_535  65_535  65_535  65_535  65_535  65_535  65_535  65_535) drop))
+(module (func (v128.const i16x8 -32_768 -32_768 -32_768 -32_768 -32_768 -32_768 -32_768 -32_768) drop))
+(module (func (v128.const i16x8  0_123_45 0_123_45 0_123_45 0_123_45 0_123_45 0_123_45 0_123_45 0_123_45) drop))
+(module (func (v128.const i16x8  0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) drop))
+(module (func (v128.const i32x4  0xffffffff  0xffffffff  0xffffffff  0xffffffff) drop))
+(module (func (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000) drop))
+(module (func (v128.const i32x4  4294967295  4294967295  4294967295  4294967295) drop))
+(module (func (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) drop))
+(module (func (v128.const i32x4  0xffff_ffff  0xffff_ffff  0xffff_ffff  0xffff_ffff) drop))
+(module (func (v128.const i32x4 -0x8000_0000 -0x8000_0000 -0x8000_0000 -0x8000_0000) drop))
+(module (func (v128.const i32x4 4_294_967_295  4_294_967_295  4_294_967_295  4_294_967_295) drop))
+(module (func (v128.const i32x4 -2_147_483_648 -2_147_483_648 -2_147_483_648 -2_147_483_648) drop))
+(module (func (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789) drop))
+(module (func (v128.const i32x4 0x0_9acf_fBDF 0x0_9acf_fBDF 0x0_9acf_fBDF 0x0_9acf_fBDF) drop))
+(module (func (v128.const i64x2  0xffffffffffffffff  0xffffffffffffffff) drop))
+(module (func (v128.const i64x2 -0x8000000000000000 -0x8000000000000000) drop))
+(module (func (v128.const i64x2  18446744073709551615 18446744073709551615) drop))
+(module (func (v128.const i64x2 -9223372036854775808 -9223372036854775808) drop))
+(module (func (v128.const i64x2  0xffff_ffff_ffff_ffff  0xffff_ffff_ffff_ffff) drop))
+(module (func (v128.const i64x2 -0x8000_0000_0000_0000 -0x8000_0000_0000_0000) drop))
+(module (func (v128.const i64x2  18_446_744_073_709_551_615 18_446_744_073_709_551_615) drop))
+(module (func (v128.const i64x2 -9_223_372_036_854_775_808 -9_223_372_036_854_775_808) drop))
+(module (func (v128.const i64x2  0_123_456_789 0_123_456_789) drop))
+(module (func (v128.const i64x2  0x0125_6789_ADEF_bcef 0x0125_6789_ADEF_bcef) drop))
+(module (func (v128.const f32x4  0x1p127  0x1p127  0x1p127  0x1p127) drop))
+(module (func (v128.const f32x4 -0x1p127 -0x1p127 -0x1p127 -0x1p127) drop))
+(module (func (v128.const f32x4  1e38  1e38  1e38  1e38) drop))
+(module (func (v128.const f32x4 -1e38 -1e38 -1e38 -1e38) drop))
+(module (func (v128.const f32x4  340282356779733623858607532500980858880 340282356779733623858607532500980858880
+                                 340282356779733623858607532500980858880 340282356779733623858607532500980858880) drop))
+(module (func (v128.const f32x4 -340282356779733623858607532500980858880 -340282356779733623858607532500980858880
+                                -340282356779733623858607532500980858880 -340282356779733623858607532500980858880) drop))
+(module (func (v128.const f32x4 nan:0x1 nan:0x1 nan:0x1 nan:0x1) drop))
+(module (func (v128.const f32x4 nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff) drop))
+(module (func (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) drop))
+(module (func (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) drop))
+(module (func (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) drop))
+(module (func (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) drop))
+(module (func (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) drop))
+(module (func (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) drop))
+(module (func (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) drop))
+(module (func (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) drop))
+(module (func (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) drop))
+(module (func (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) drop))
+(module (func (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) drop))
+(module (func (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) drop))
+(module (func (v128.const f64x2  0x1p1023  0x1p1023) drop))
+(module (func (v128.const f64x2 -0x1p1023 -0x1p1023) drop))
+(module (func (v128.const f64x2  1e308  1e308) drop))
+(module (func (v128.const f64x2 -1e308 -1e308) drop))
+(module (func (v128.const f64x2  179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368
+                                 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop))
+(module (func (v128.const f64x2 -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368
+                                -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop))
+(module (func (v128.const f64x2 nan:0x1 nan:0x1) drop))
+(module (func (v128.const f64x2 nan:0xf_ffff_ffff_ffff nan:0xf_ffff_ffff_ffff) drop))
+(module (func (v128.const f64x2 0123456789 0123456789) drop))
+(module (func (v128.const f64x2 0123456789e019 0123456789e019) drop))
+(module (func (v128.const f64x2 0123456789e+019 0123456789e+019) drop))
+(module (func (v128.const f64x2 0123456789e-019 0123456789e-019) drop))
+(module (func (v128.const f64x2 0123456789. 0123456789.) drop))
+(module (func (v128.const f64x2 0123456789.e019 0123456789.e019) drop))
+(module (func (v128.const f64x2 0123456789.e+019 0123456789.e+019) drop))
+(module (func (v128.const f64x2 0123456789.e-019 0123456789.e-019) drop))
+(module (func (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) drop))
+(module (func (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) drop))
+(module (func (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) drop))
+(module (func (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) drop))
+
+;; Non-splat cases
+
+(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF
+                                -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) drop))
+(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF   255   255   255   255
+                                -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) drop))
+(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF   255   255   255   255
+                                -0x80 -0x80 -0x80 -0x80  -128  -128  -128  -128) drop))
+(module (func (v128.const i16x8 0xFF 0xFF  0xFF  0xFF -0x8000 -0x8000 -0x8000 -0x8000) drop))
+(module (func (v128.const i16x8 0xFF 0xFF 65535 65535 -0x8000 -0x8000 -0x8000 -0x8000) drop))
+(module (func (v128.const i16x8 0xFF 0xFF 65535 65535 -0x8000 -0x8000  -32768  -32768) drop))
+(module (func (v128.const i32x4 0xffffffff 0xffffffff -0x80000000 -0x80000000) drop))
+(module (func (v128.const i32x4 0xffffffff 4294967295 -0x80000000 -0x80000000) drop))
+(module (func (v128.const i32x4 0xffffffff 4294967295 -0x80000000 -2147483648) drop))
+(module (func (v128.const f32x4 0x1p127 0x1p127 -0x1p127 -1e38) drop))
+(module (func (v128.const f32x4 0x1p127 340282356779733623858607532500980858880 -1e38 -340282356779733623858607532500980858880) drop))
+(module (func (v128.const f32x4 nan -nan inf -inf) drop))
+(module (func (v128.const i64x2 0xffffffffffffffff 0x8000000000000000) drop))
+(module (func (v128.const i64x2 0xffffffffffffffff -9223372036854775808) drop))
+(module (func (v128.const f64x2 0x1p1023 -1e308) drop))
+(module (func (v128.const f64x2 nan -inf) drop))
+
+;; Constant out of range (int literal is too large)
+
+(module (memory 1))
+(assert_malformed
+  (module quote "(func (v128.const i8x16 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 0x10000 0x10000 0x10000 0x10000 0x10000 0x10000 0x10000 0x10000) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 65536 65536 65536 65536 65536 65536 65536 65536) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 -32769 -32769 -32769 -32769 -32769 -32769 -32769 -32769) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4  0x100000000  0x100000000  0x100000000  0x100000000) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 -0x80000001 -0x80000001 -0x80000001 -0x80000001) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4  4294967296  4294967296  4294967296  4294967296) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 -2147483649 -2147483649 -2147483649 -2147483649) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4  0x1p128  0x1p128  0x1p128  0x1p128) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 -0x1p128 -0x1p128 -0x1p128 -0x1p128) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4  1e39  1e39  1e39  1e39) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 -1e39 -1e39 -1e39 -1e39) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4  340282356779733661637539395458142568448 340282356779733661637539395458142568448"
+                "                         340282356779733661637539395458142568448 340282356779733661637539395458142568448) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 -340282356779733661637539395458142568448 -340282356779733661637539395458142568448"
+                "                        -340282356779733661637539395458142568448 -340282356779733661637539395458142568448) drop)")
+  "constant out of range"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f32x4 nan:0x80_0000 nan:0x80_0000 nan:0x80_0000 nan:0x80_0000) drop)")
+  "constant out of range"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f64x2  269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552"
+                "                         269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 -269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552"
+                "                        -269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop)")
+  "constant out of range"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f64x2 nan:0x10_0000_0000_0000 nan:0x10_0000_0000_0000) drop)")
+  "constant out of range"
+)
+
+;; More malformed v128.const forms
+(assert_malformed
+  (module quote "(func (v128.const) drop)")
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const 0 0 0 0) drop)")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg) drop)")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const i16x8) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 0x 0x 0x 0x 0x 0x 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 1x 1x 1x 1x 1x 1x 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg) drop)")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const i32x4) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 0x 0x 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 1x 1x 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 0xg 0xg 0xg 0xg) drop)")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const i64x2) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const i64x2 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0xg 0xg) drop)")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f32x4) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 .0 .0 .0 .0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 .0e0 .0e0 .0e0 .0e0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0e 0e 0e 0e) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0e+ 0e+ 0e+ 0e+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0.0e 0.0e 0.0e 0.0e) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0.0e- 0.0e- 0.0e- 0.0e-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x 0x 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 1x 1x 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0xg 0xg 0xg 0xg) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x. 0x. 0x. 0x.) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0.g 0x0.g 0x0.g 0x0.g) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0p 0x0p 0x0p 0x0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0p+ 0x0p+ 0x0p+ 0x0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0p- 0x0p- 0x0p- 0x0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0.0p 0x0.0p 0x0.0p 0x0.0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0.0p+ 0x0.0p+ 0x0.0p+ 0x0.0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0.0p- 0x0.0p- 0x0.0p- 0x0.0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0pA 0x0pA 0x0pA 0x0pA) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 nan:1 nan:1 nan:1 nan:1) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 nan:0x0 nan:0x0 nan:0x0 nan:0x0) drop)")
+  "constant out of range"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f64x2) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 .0 .0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 .0e0 .0e0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0e 0e) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0e+ 0e+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0.0e+ 0.0e+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0.0e- 0.0e-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0xg 0xg) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x. 0x.) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0.g 0x0.g) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0p 0x0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0p+ 0x0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0p- 0x0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0.0p 0x0.0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0.0p+ 0x0.0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0.0p- 0x0.0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0pA 0x0pA) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 nan:1 nan:1) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 nan:0x0 nan:0x0) drop)")
+  "constant out of range"
+)
+
+;; too little arguments
+
+(assert_malformed
+  (module quote "(func (v128.const i32x4 0x10000000000000000 0x10000000000000000) drop)")
+  "wrong number of lane literals"
+)
+
+;; too many arguments
+(assert_malformed
+  (module quote "(func (v128.const i32x4 0x1 0x1 0x1 0x1 0x1) drop)")
+  "wrong number of lane literals"
+)
+
+;; Rounding behaviour
+
+;; f32x4, small exponent
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000100000000000p-50 +0x1.00000100000000000p-50 +0x1.00000100000000000p-50 +0x1.00000100000000000p-50)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000100000000000p-50 -0x1.00000100000000000p-50 -0x1.00000100000000000p-50 -0x1.00000100000000000p-50)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000500000000001p-50 +0x1.00000500000000001p-50 +0x1.00000500000000001p-50 +0x1.00000500000000001p-50)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000500000000001p-50 -0x1.00000500000000001p-50 -0x1.00000500000000001p-50 -0x1.00000500000000001p-50)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50))
+
+(module (func (export "f") (result v128) (v128.const f32x4 +0x4000.004000000p-64 +0x4000.004000000p-64 +0x4000.004000000p-64 +0x4000.004000000p-64)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x4000.004000000p-64 -0x4000.004000000p-64 -0x4000.004000000p-64 -0x4000.004000000p-64)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x4000.014000001p-64 +0x4000.014000001p-64 +0x4000.014000001p-64 +0x4000.014000001p-64)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x4000.014000001p-64 -0x4000.014000001p-64 -0x4000.014000001p-64 -0x4000.014000001p-64)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50))
+
+(module (func (export "f") (result v128) (v128.const f32x4 +8.8817847263968443573e-16 +8.8817847263968443573e-16 +8.8817847263968443573e-16 +8.8817847263968443573e-16)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -8.8817847263968443573e-16 -8.8817847263968443573e-16 -8.8817847263968443573e-16 -8.8817847263968443573e-16)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 +8.8817857851880284253e-16 +8.8817857851880284253e-16 +8.8817857851880284253e-16 +8.8817857851880284253e-16)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000004p-50 +0x1.000004p-50 +0x1.000004p-50 +0x1.000004p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -8.8817857851880284253e-16 -8.8817857851880284253e-16 -8.8817857851880284253e-16 -8.8817857851880284253e-16)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000004p-50 -0x1.000004p-50 -0x1.000004p-50 -0x1.000004p-50))
+
+;; f32x4, large exponent
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000100000000000p+50 +0x1.00000100000000000p+50 +0x1.00000100000000000p+50 +0x1.00000100000000000p+50)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000100000000000p+50 -0x1.00000100000000000p+50 -0x1.00000100000000000p+50 -0x1.00000100000000000p+50)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000500000000001p+50 +0x1.00000500000000001p+50 +0x1.00000500000000001p+50 +0x1.00000500000000001p+50)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000006p+50 +0x1.000006p+50 +0x1.000006p+50 +0x1.000006p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000500000000001p+50 -0x1.00000500000000001p+50 -0x1.00000500000000001p+50 -0x1.00000500000000001p+50)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000006p+50 -0x1.000006p+50 -0x1.000006p+50 -0x1.000006p+50))
+
+(module (func (export "f") (result v128) (v128.const f32x4 +0x4000004000000 +0x4000004000000 +0x4000004000000 +0x4000004000000)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x4000004000000 -0x4000004000000 -0x4000004000000 -0x4000004000000)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x400000c000000 +0x400000c000000 +0x400000c000000 +0x400000c000000)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x400000c000000 -0x400000c000000 -0x400000c000000 -0x400000c000000)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50))
+
+(module (func (export "f") (result v128) (v128.const f32x4 +1125899973951488 +1125899973951488 +1125899973951488 +1125899973951488)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -1125899973951488 -1125899973951488 -1125899973951488 -1125899973951488)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 +1125900108169216 +1125900108169216 +1125900108169216 +1125900108169216)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -1125900108169216 -1125900108169216 -1125900108169216 -1125900108169216)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50))
+
+;; f32x4, subnormal
+(module (func (export "f") (result v128) (v128.const f32x4 +0x0.00000100000000000p-126 +0x0.00000100000000000p-126 +0x0.00000100000000000p-126 +0x0.00000100000000000p-126)))
+(assert_return (invoke "f") (v128.const f32x4 +0x0.000000p-126 +0x0.000000p-126 +0x0.000000p-126 +0x0.000000p-126))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126)))
+(assert_return (invoke "f") (v128.const f32x4 -0x0.000000p-126 -0x0.000000p-126 -0x0.000000p-126 -0x0.000000p-126))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126)))
+(assert_return (invoke "f") (v128.const f32x4 +0x0.000006p-126 +0x0.000006p-126 +0x0.000006p-126 +0x0.000006p-126))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x0.00000500000000001p-126 -0x0.00000500000000001p-126 -0x0.00000500000000001p-126 -0x0.00000500000000001p-126)))
+(assert_return (invoke "f") (v128.const f32x4 -0x0.000006p-126 -0x0.000006p-126 -0x0.000006p-126 -0x0.000006p-126))
+
+;; f32x4, round down at limit to infinity
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.fffffe8p127 +0x1.fffffe8p127 +0x1.fffffe8p127 +0x1.fffffe8p127)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.fffffe8p127 -0x1.fffffe8p127 -0x1.fffffe8p127 -0x1.fffffe8p127)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.fffffefffffffffffp127 +0x1.fffffefffffffffffp127 +0x1.fffffefffffffffffp127 +0x1.fffffefffffffffffp127)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.fffffefffffffffffp127 -0x1.fffffefffffffffffp127 -0x1.fffffefffffffffffp127 -0x1.fffffefffffffffffp127)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127))
+
+;; f64x2, small exponent
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.0000000000000fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.0000000000000fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.00000000000017ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.00000000000017ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.0000000000001fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.0000000000001fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.00000000000027ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.00000000000027ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.0000007fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.0000007fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000bfffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000bfffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000ffffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000ffffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.0000013fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.0000013fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000001400000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000001400000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313371995e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000000p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313371995e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000000p+999))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313371996e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313371996e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313383891e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313383891e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313383892e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313383892e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p+999))
+
+;; f64, large exponent
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000080000000000p+600 +0x1.000000000000080000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000000p+600 +0x1.0000000000000p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000080000000000p+600 -0x1.000000000000080000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000000p+600 -0x1.0000000000000p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000080000000001p+600 +0x1.000000000000080000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000080000000001p+600 -0x1.000000000000080000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.0000000000000fffffffffffp+600 +0x1.0000000000000fffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.0000000000000fffffffffffp+600 -0x1.0000000000000fffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000100000000000p+600 +0x1.000000000000100000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000100000000000p+600 -0x1.000000000000100000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000100000000001p+600 +0x1.000000000000100000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000100000000001p+600 -0x1.000000000000100000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.00000000000017ffffffffffp+600 +0x1.00000000000017ffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.00000000000017ffffffffffp+600 -0x1.00000000000017ffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000180000000000p+600 +0x1.000000000000180000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000180000000000p+600 -0x1.000000000000180000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000180000000001p+600 +0x1.000000000000180000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000180000000001p+600 -0x1.000000000000180000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.0000000000001fffffffffffp+600 +0x1.0000000000001fffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.0000000000001fffffffffffp+600 -0x1.0000000000001fffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000200000000000p+600 +0x1.000000000000200000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000200000000000p+600 -0x1.000000000000200000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000200000000001p+600 +0x1.000000000000200000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000200000000001p+600 -0x1.000000000000200000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.00000000000027ffffffffffp+600 +0x1.00000000000027ffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.00000000000027ffffffffffp+600 -0x1.00000000000027ffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000280000000000p+600 +0x1.000000000000280000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000280000000000p+600 -0x1.000000000000280000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000280000000001p+600 +0x1.000000000000280000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000003p+600 +0x1.0000000000003p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000280000000001p+600 -0x1.000000000000280000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000003p+600 -0x1.0000000000003p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000100000000000 +0x2000000000000100000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000000p+97 +0x1.0000000000000p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000100000000000 -0x2000000000000100000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000000p+97 -0x1.0000000000000p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000100000000001 +0x2000000000000100000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000100000000001 -0x2000000000000100000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000001fffffffffff +0x20000000000001fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000001fffffffffff -0x20000000000001fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000200000000000 +0x2000000000000200000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000200000000000 -0x2000000000000200000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000200000000001 +0x2000000000000200000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000200000000001 -0x2000000000000200000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000002fffffffffff +0x20000000000002fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000002fffffffffff -0x20000000000002fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000300000000000 +0x2000000000000300000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000300000000000 -0x2000000000000300000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000300000000001 +0x2000000000000300000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000300000000001 -0x2000000000000300000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000003fffffffffff +0x20000000000003fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000003fffffffffff -0x20000000000003fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000400000000000 +0x2000000000000400000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000400000000000 -0x2000000000000400000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000400000000001 +0x2000000000000400000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000400000000001 -0x2000000000000400000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000004fffffffffff +0x20000000000004fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000004fffffffffff -0x20000000000004fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000500000000000 +0x2000000000000500000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000500000000000 -0x2000000000000500000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000500000000001 +0x2000000000000500000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000003p+97 +0x1.0000000000003p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000500000000001 -0x2000000000000500000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000003p+97 -0x1.0000000000003p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847104 +1152921504606847104)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000000p+60 +0x1.0000000000000p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847104 -1152921504606847104)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000000p+60 -0x1.0000000000000p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847105 +1152921504606847105)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+60 +0x1.0000000000001p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847105 -1152921504606847105)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+60 -0x1.0000000000001p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847359 +1152921504606847359)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+60 +0x1.0000000000001p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847359 -1152921504606847359)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+60 -0x1.0000000000001p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847360 +1152921504606847360)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+60 +0x1.0000000000002p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847360 -1152921504606847360)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+60 -0x1.0000000000002p+60))
+
+;; f64x2, subnormal
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000080000000000p-1022 +0x0.000000000000080000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000000p-1022 +0x0.0000000000000p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000080000000000p-1022 -0x0.000000000000080000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000000p-1022 -0x0.0000000000000p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000080000000001p-1022 +0x0.000000000000080000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000080000000001p-1022 -0x0.000000000000080000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.0000000000000fffffffffffp-1022 +0x0.0000000000000fffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.0000000000000fffffffffffp-1022 -0x0.0000000000000fffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000100000000000p-1022 +0x0.000000000000100000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000100000000000p-1022 -0x0.000000000000100000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000100000000001p-1022 +0x0.000000000000100000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000100000000001p-1022 -0x0.000000000000100000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.00000000000017ffffffffffp-1022 +0x0.00000000000017ffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.00000000000017ffffffffffp-1022 -0x0.00000000000017ffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000180000000000p-1022 +0x0.000000000000180000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000180000000000p-1022 -0x0.000000000000180000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000180000000001p-1022 +0x0.000000000000180000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000180000000001p-1022 -0x0.000000000000180000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.0000000000001fffffffffffp-1022 +0x0.0000000000001fffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.0000000000001fffffffffffp-1022 -0x0.0000000000001fffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000200000000000p-1022 +0x0.000000000000200000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000200000000000p-1022 -0x0.000000000000200000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000200000000001p-1022 +0x0.000000000000200000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000200000000001p-1022 -0x0.000000000000200000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.00000000000027ffffffffffp-1022 +0x0.00000000000027ffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.00000000000027ffffffffffp-1022 -0x0.00000000000027ffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000280000000000p-1022 +0x0.000000000000280000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000280000000000p-1022 -0x0.000000000000280000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000280000000001p-1022 +0x1.000000000000280000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000003p-1022 +0x1.0000000000003p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000280000000001p-1022 -0x1.000000000000280000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000003p-1022 -0x1.0000000000003p-1022))
+
+;; f64x2, round down at limit to infinity
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.fffffffffffff4p1023 +0x1.fffffffffffff4p1023)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.fffffffffffffp1023 +0x1.fffffffffffffp1023))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.fffffffffffff4p1023 -0x1.fffffffffffff4p1023)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.fffffffffffffp1023 -0x1.fffffffffffffp1023))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.fffffffffffff7ffffffp1023 +0x1.fffffffffffff7ffffffp1023)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.fffffffffffffp1023 +0x1.fffffffffffffp1023))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.fffffffffffff7ffffffp1023 -0x1.fffffffffffff7ffffffp1023)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.fffffffffffffp1023 -0x1.fffffffffffffp1023))
+
+;; As parameters of control constructs
+
+(module (memory 1)
+  (func (export "as-br-retval") (result v128)
+    (block (result v128) (br 0 (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c)))
+  )
+  (func (export "as-br_if-retval") (result v128)
+    (block (result v128)
+      (br_if 0 (v128.const i32x4 0 1 2 3) (i32.const 1))
+    )
+  )
+  (func (export "as-return-retval") (result v128)
+    (return (v128.const i32x4 0 1 2 3))
+  )
+  (func (export "as-if-then-retval") (result v128)
+    (if (result v128) (i32.const 1)
+      (then (v128.const i32x4 0 1 2 3)) (else (v128.const i32x4 3 2 1 0))
+    )
+  )
+  (func (export "as-if-else-retval") (result v128)
+    (if (result v128) (i32.const 0)
+      (then (v128.const i32x4 0 1 2 3)) (else (v128.const i32x4 3 2 1 0))
+    )
+  )
+  (func $f (param v128 v128 v128) (result v128) (v128.const i32x4 0 1 2 3))
+  (func (export "as-call-param") (result v128)
+    (call $f (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3))
+  )
+  (func (export "as-block-retval") (result v128)
+    (block (result v128) (v128.const i32x4 0 1 2 3))
+  )
+  (func (export "as-loop-retval") (result v128)
+    (loop (result v128) (v128.const i32x4 0 1 2 3))
+  )
+  (func (export "as-drop-operand")
+    (drop (v128.const i32x4 0 1 2 3))
+  )
+
+  (func (export "as-br-retval2") (result v128)
+    (block (result v128) (br 0 (v128.const i64x2 0x0302010007060504 0x0b0a09080f0e0d0c)))
+  )
+  (func (export "as-br_if-retval2") (result v128)
+    (block (result v128)
+      (br_if 0 (v128.const i64x2 0 1) (i32.const 1))
+    )
+  )
+  (func (export "as-return-retval2") (result v128)
+    (return (v128.const i64x2 0 1))
+  )
+  (func (export "as-if-then-retval2") (result v128)
+    (if (result v128) (i32.const 1)
+      (then (v128.const i64x2 0 1)) (else (v128.const i64x2 1 0))
+    )
+  )
+  (func (export "as-if-else-retval2") (result v128)
+    (if (result v128) (i32.const 0)
+      (then (v128.const i64x2 0 1)) (else (v128.const i64x2 1 0))
+    )
+  )
+  (func $f2 (param v128 v128 v128) (result v128) (v128.const i64x2 0 1))
+  (func (export "as-call-param2") (result v128)
+    (call $f2 (v128.const i64x2 0 1) (v128.const i64x2 0 1) (v128.const i64x2 0 1))
+  )
+
+  (type $sig (func (param v128 v128 v128) (result v128)))
+  (table funcref (elem $f $f2))
+  (func (export "as-call_indirect-param") (result v128)
+    (call_indirect (type $sig)
+      (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-param2") (result v128)
+    (call_indirect (type $sig)
+      (v128.const i64x2 0 1) (v128.const i64x2 0 1) (v128.const i64x2 0 1) (i32.const 1)
+    )
+  )
+  (func (export "as-block-retval2") (result v128)
+    (block (result v128) (v128.const i64x2 0 1))
+  )
+  (func (export "as-loop-retval2") (result v128)
+    (loop (result v128) (v128.const i64x2 0 1))
+  )
+  (func (export "as-drop-operand2")
+    (drop (v128.const i64x2 0 1))
+  )
+)
+
+(assert_return (invoke "as-br-retval") (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c))
+(assert_return (invoke "as-br_if-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-return-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-if-then-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-if-else-retval") (v128.const i32x4 3 2 1 0))
+(assert_return (invoke "as-call-param") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-call_indirect-param") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-block-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-loop-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-drop-operand"))
+
+(assert_return (invoke "as-br-retval2") (v128.const i64x2 0x0302010007060504 0x0b0a09080f0e0d0c))
+(assert_return (invoke "as-br_if-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-return-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-if-then-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-if-else-retval2") (v128.const i64x2 1 0))
+(assert_return (invoke "as-call-param2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-call_indirect-param2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-block-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-loop-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-drop-operand2"))
+
+;; v128 locals
+
+(module (memory 1)
+  (func (export "as-local.set/get-value_0_0") (param $0 v128) (result v128)
+    (local v128 v128 v128 v128)
+    (local.set 0 (local.get $0))
+    (local.get 0)
+  )
+  (func (export "as-local.set/get-value_0_1") (param $0 v128) (result v128)
+    (local v128 v128 v128 v128)
+    (local.set 0 (local.get $0))
+    (local.set 1 (local.get 0))
+    (local.set 2 (local.get 1))
+    (local.set 3 (local.get 2))
+    (local.get 0)
+  )
+  (func (export "as-local.set/get-value_3_0") (param $0 v128) (result v128)
+    (local v128 v128 v128 v128)
+    (local.set 0 (local.get $0))
+    (local.set 1 (local.get 0))
+    (local.set 2 (local.get 1))
+    (local.set 3 (local.get 2))
+    (local.get 3)
+  )
+  (func (export "as-local.tee-value") (result v128)
+    (local v128)
+    (local.tee 0 (v128.const i32x4 0 1 2 3))
+  )
+)
+
+(assert_return (invoke "as-local.set/get-value_0_0" (v128.const i32x4 0 0 0 0)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "as-local.set/get-value_0_1" (v128.const i32x4 1 1 1 1)) (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "as-local.set/get-value_3_0" (v128.const i32x4 2 2 2 2)) (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "as-local.tee-value") (v128.const i32x4 0 1 2 3))
+
+
+;; v128 globals
+
+(module (memory 1)
+  (global $g0 (mut v128) (v128.const i32x4 0 1 2 3))
+  (global $g1 (mut v128) (v128.const i32x4 4 5 6 7))
+  (global $g2 (mut v128) (v128.const i32x4 8 9 10 11))
+  (global $g3 (mut v128) (v128.const i32x4 12 13 14 15))
+  (global $g4 (mut v128) (v128.const i32x4 16 17 18 19))
+
+  (func $set_g0 (export "as-global.set_value_$g0") (param $0 v128)
+    (global.set $g0 (local.get $0))
+  )
+  (func $set_g1_g2 (export "as-global.set_value_$g1_$g2") (param $0 v128) (param $1 v128)
+    (global.set $g1 (local.get $0))
+    (global.set $g2 (local.get $1))
+  )
+  (func $set_g0_g1_g2_g3 (export "as-global.set_value_$g0_$g1_$g2_$g3") (param $0 v128) (param $1 v128) (param $2 v128) (param $3 v128)
+    (call $set_g0 (local.get $0))
+    (call $set_g1_g2 (local.get $1) (local.get $2))
+    (global.set $g3 (local.get $3))
+  )
+  (func (export "global.get_g0") (result v128)
+    (global.get $g0)
+  )
+  (func (export "global.get_g1") (result v128)
+    (global.get $g1)
+  )
+  (func (export "global.get_g2") (result v128)
+    (global.get $g2)
+  )
+  (func (export "global.get_g3") (result v128)
+    (global.get $g3)
+  )
+)
+
+(assert_return (invoke "as-global.set_value_$g0_$g1_$g2_$g3" (v128.const i32x4 1 1 1 1)
+                                                             (v128.const i32x4 2 2 2 2)
+                                                             (v128.const i32x4 3 3 3 3)
+                                                             (v128.const i32x4 4 4 4 4)))
+(assert_return (invoke "global.get_g0") (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "global.get_g1") (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "global.get_g2") (v128.const i32x4 3 3 3 3))
+(assert_return (invoke "global.get_g3") (v128.const i32x4 4 4 4 4))
+
+
+;; Test integer literal parsing.
+
+(module
+  (func (export "i32x4.test") (result v128) (return (v128.const i32x4 0x0bAdD00D 0x0bAdD00D 0x0bAdD00D 0x0bAdD00D)))
+  (func (export "i32x4.smax") (result v128) (return (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)))
+  (func (export "i32x4.neg_smax") (result v128) (return (v128.const i32x4 -0x7fffffff -0x7fffffff -0x7fffffff -0x7fffffff)))
+  (func (export "i32x4.inc_smin") (result v128) (return (i32x4.add (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000) (v128.const i32x4 1 1 1 1))))
+  (func (export "i32x4.neg_zero") (result v128) (return (v128.const i32x4 -0x0 -0x0 -0x0 -0x0)))
+  (func (export "i32x4.not_octal") (result v128) (return (v128.const i32x4 010 010 010 010)))
+  (func (export "i32x4.plus_sign") (result v128) (return (v128.const i32x4 +42 +42 +42 +42)))
+
+  (func (export "i32x4-dec-sep1") (result v128) (v128.const i32x4 1_000_000 1_000_000 1_000_000 1_000_000))
+  (func (export "i32x4-dec-sep2") (result v128) (v128.const i32x4 1_0_0_0 1_0_0_0 1_0_0_0 1_0_0_0))
+  (func (export "i32x4-hex-sep1") (result v128) (v128.const i32x4 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99))
+  (func (export "i32x4-hex-sep2") (result v128) (v128.const i32x4 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f))
+
+  (func (export "i64x2.test") (result v128) (return (v128.const i64x2 0x0bAdD00D0bAdD00D 0x0bAdD00D0bAdD00D)))
+  (func (export "i64x2.smax") (result v128) (return (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)))
+  (func (export "i64x2.neg_smax") (result v128) (return (v128.const i64x2 -0x7fffffffffffffff -0x7fffffffffffffff)))
+  (func (export "i64x2.inc_smin") (result v128) (return (i64x2.add (v128.const i64x2 -0x8000000000000000 -0x8000000000000000) (v128.const i64x2 1 1))))
+  (func (export "i64x2.neg_zero") (result v128) (return (v128.const i64x2 -0x0 -0x0)))
+  (func (export "i64x2.not_octal") (result v128) (return (v128.const i64x2 010010 010010)))
+  (func (export "i64x2.plus_sign") (result v128) (return (v128.const i64x2 +42 +42)))
+
+  (func (export "i64x2-dec-sep1") (result v128) (v128.const i64x2 10_000_000_000_000 10_000_000_000_000))
+  (func (export "i64x2-dec-sep2") (result v128) (v128.const i64x2 1_0_0_0_0_0_0_0 1_0_0_0_0_0_0_0))
+  (func (export "i64x2-hex-sep1") (result v128) (v128.const i64x2 0xa_0f_00_99_0a_0f_00_99 0xa_0f_00_99_0a_0f_00_99))
+  (func (export "i64x2-hex-sep2") (result v128) (v128.const i64x2 0x1_a_A_0_f_1_a_A_0_f 0x1_a_A_0_f_1_a_A_0_f))
+)
+
+(assert_return (invoke "i32x4.test") (v128.const i32x4 195940365 195940365 195940365 195940365))
+(assert_return (invoke "i32x4.smax") (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.neg_smax") (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.inc_smin") (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.neg_zero") (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.not_octal") (v128.const i32x4 10 10 10 10))
+(assert_return (invoke "i32x4.plus_sign") (v128.const i32x4 42 42 42 42))
+
+(assert_return (invoke "i32x4-dec-sep1") (v128.const i32x4 1000000 1000000 1000000 1000000))
+(assert_return (invoke "i32x4-dec-sep2") (v128.const i32x4 1000 1000 1000 1000))
+(assert_return (invoke "i32x4-hex-sep1") (v128.const i32x4 0xa0f0099 0xa0f0099 0xa0f0099 0xa0f0099))
+(assert_return (invoke "i32x4-hex-sep2") (v128.const i32x4 0x1aa0f 0x1aa0f 0x1aa0f 0x1aa0f))
+
+(assert_return (invoke "i64x2.test") (v128.const i64x2 841557459837243405 841557459837243405))
+(assert_return (invoke "i64x2.smax") (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.neg_smax") (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.inc_smin") (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.neg_zero") (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.not_octal") (v128.const i64x2 10010 10010))
+(assert_return (invoke "i64x2.plus_sign") (v128.const i64x2 42 42))
+
+(assert_return (invoke "i64x2-dec-sep1") (v128.const i64x2 10000000000000 10000000000000))
+(assert_return (invoke "i64x2-dec-sep2") (v128.const i64x2 10000000 10000000))
+(assert_return (invoke "i64x2-hex-sep1") (v128.const i64x2 0xa0f00990a0f0099 0xa0f00990a0f0099))
+(assert_return (invoke "i64x2-hex-sep2") (v128.const i64x2 0x1aa0f1aa0f 0x1aa0f1aa0f))
+
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 _100 _100 _100 _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 +_100 +_100 +_100 +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 -_100 -_100 -_100 -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 99_ 99_ 99_ 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 1__000 1__000 1__000 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 _0x100 _0x100 _0x100 _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 0_x100 0_x100 0_x100 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 0x_100 0x_100 0x_100 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 0x00_ 0x00_ 0x00_ 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 0xff__ffff 0xff__ffff 0xff__ffff 0xff__ffff))")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 _100_100 _100_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 +_100_100 +_100_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 -_100_100 -_100_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 99_99_ 99_99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 1__000_000 1__000_000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 _0x100000 _0x100000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 0_x100000 0_x100000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 0x_100000 0x_100000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 0x00_ 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 0xff__ffff_ffff_ffff 0xff__ffff_ffff_ffff))")
+  "unknown operator"
+)
+
+;; Test floating-point literal parsing.
+
+(module
+  (func (export "f32-dec-sep1") (result v128) (v128.const f32x4 1_000_000 1_000_000 1_000_000 1_000_000))
+  (func (export "f32-dec-sep2") (result v128) (v128.const f32x4 1_0_0_0 1_0_0_0 1_0_0_0 1_0_0_0))
+  (func (export "f32-dec-sep3") (result v128) (v128.const f32x4 100_3.141_592 100_3.141_592 100_3.141_592 100_3.141_592))
+  (func (export "f32-dec-sep4") (result v128) (v128.const f32x4 99e+1_3 99e+1_3 99e+1_3 99e+1_3))
+  (func (export "f32-dec-sep5") (result v128) (v128.const f32x4 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3))
+  (func (export "f32-hex-sep1") (result v128) (v128.const f32x4 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99))
+  (func (export "f32-hex-sep2") (result v128) (v128.const f32x4 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f))
+  (func (export "f32-hex-sep3") (result v128) (v128.const f32x4 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a))
+  (func (export "f32-hex-sep4") (result v128) (v128.const f32x4 0xf0P+1_3 0xf0P+1_3 0xf0P+1_3 0xf0P+1_3))
+  (func (export "f32-hex-sep5") (result v128) (v128.const f32x4 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3))
+  (func (export "f64-dec-sep1") (result v128) (v128.const f64x2 1_000_000 1_000_000))
+  (func (export "f64-dec-sep2") (result v128) (v128.const f64x2 1_0_0_0 1_0_0_0))
+  (func (export "f64-dec-sep3") (result v128) (v128.const f64x2 100_3.141_592 100_3.141_592))
+  (func (export "f64-dec-sep4") (result v128) (v128.const f64x2 99e+1_3 99e+1_3))
+  (func (export "f64-dec-sep5") (result v128) (v128.const f64x2 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3))
+  (func (export "f64-hex-sep1") (result v128) (v128.const f64x2 0xa_0f_00_99 0xa_0f_00_99))
+  (func (export "f64-hex-sep2") (result v128) (v128.const f64x2 0x1_a_A_0_f 0x1_a_A_0_f))
+  (func (export "f64-hex-sep3") (result v128) (v128.const f64x2 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a))
+  (func (export "f64-hex-sep4") (result v128) (v128.const f64x2 0xf0P+1_3 0xf0P+1_3))
+  (func (export "f64-hex-sep5") (result v128) (v128.const f64x2 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3))
+)
+
+(assert_return (invoke "f32-dec-sep1") (v128.const f32x4 1000000 1000000 1000000 1000000))
+(assert_return (invoke "f32-dec-sep2") (v128.const f32x4 1000 1000 1000 1000))
+(assert_return (invoke "f32-dec-sep3") (v128.const f32x4 1003.141592 1003.141592 1003.141592 1003.141592))
+(assert_return (invoke "f32-dec-sep4") (v128.const f32x4 99e+13 99e+13 99e+13 99e+13))
+(assert_return (invoke "f32-dec-sep5") (v128.const f32x4 122000.11354e23 122000.11354e23 122000.11354e23 122000.11354e23))
+(assert_return (invoke "f32-hex-sep1") (v128.const f32x4 0xa0f0099 0xa0f0099 0xa0f0099 0xa0f0099))
+(assert_return (invoke "f32-hex-sep2") (v128.const f32x4 0x1aa0f 0x1aa0f 0x1aa0f 0x1aa0f))
+(assert_return (invoke "f32-hex-sep3") (v128.const f32x4 0xa0ff.f141a59a 0xa0ff.f141a59a 0xa0ff.f141a59a 0xa0ff.f141a59a))
+(assert_return (invoke "f32-hex-sep4") (v128.const f32x4 0xf0P+13 0xf0P+13 0xf0P+13 0xf0P+13))
+(assert_return (invoke "f32-hex-sep5") (v128.const f32x4 0x2af00a.1f3eep23 0x2af00a.1f3eep23 0x2af00a.1f3eep23 0x2af00a.1f3eep23))
+(assert_return (invoke "f64-dec-sep1") (v128.const f64x2 1000000 1000000))
+(assert_return (invoke "f64-dec-sep2") (v128.const f64x2 1000 1000))
+(assert_return (invoke "f64-dec-sep3") (v128.const f64x2 1003.141592 1003.141592))
+(assert_return (invoke "f64-dec-sep4") (v128.const f64x2 99e+13 99e+13))
+(assert_return (invoke "f64-dec-sep5") (v128.const f64x2 122000.11354e23 122000.11354e23))
+(assert_return (invoke "f64-hex-sep1") (v128.const f64x2 0xa0f0099 0xa0f0099))
+(assert_return (invoke "f64-hex-sep2") (v128.const f64x2 0x1aa0f 0x1aa0f))
+(assert_return (invoke "f64-hex-sep3") (v128.const f64x2 0xa0ff.f141a59a 0xa0ff.f141a59a))
+(assert_return (invoke "f64-hex-sep4") (v128.const f64x2 0xf0P+13 0xf0P+13))
+(assert_return (invoke "f64-hex-sep5") (v128.const f64x2 0x2af00a.1f3eep23 0x2af00a.1f3eep23))
+
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _100 _100 _100 _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 +_100 +_100 +_100 +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 -_100 -_100 -_100 -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 99_ 99_ 99_ 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1__000 1__000 1__000 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _1.0 _1.0 _1.0 _1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0_ 1.0_ 1.0_ 1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1_.0 1_.0 1_.0 1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1._0 1._0 1._0 1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _1e1 _1e1 _1e1 _1e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1e1_ 1e1_ 1e1_ 1e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1_e1 1_e1 1_e1 1_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1e_1 1e_1 1e_1 1e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _1.0e1 _1.0e1 _1.0e1 _1.0e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0e1_ 1.0e1_ 1.0e1_ 1.0e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0_e1 1.0_e1 1.0_e1 1.0_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0e_1 1.0e_1 1.0e_1 1.0e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0e+_1 1.0e+_1 1.0e+_1 1.0e+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0e_+1 1.0e_+1 1.0e_+1 1.0e_+1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _0x100 _0x100 _0x100 _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0_x100 0_x100 0_x100 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x_100 0x_100 0x_100 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x00_ 0x00_ 0x00_ 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0xff__ffff 0xff__ffff 0xff__ffff 0xff__ffff))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x_1.0 0x_1.0 0x_1.0 0x_1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0_ 0x1.0_ 0x1.0_ 0x1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1_.0 0x1_.0 0x1_.0 0x1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1._0 0x1._0 0x1._0 0x1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x_1p1 0x_1p1 0x_1p1 0x_1p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1p1_ 0x1p1_ 0x1p1_ 0x1p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1_p1 0x1_p1 0x1_p1 0x1_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1p_1 0x1p_1 0x1p_1 0x1p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x_1.0p1 0x_1.0p1 0x_1.0p1 0x_1.0p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0p1_ 0x1.0p1_ 0x1.0p1_ 0x1.0p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0_p1 0x1.0_p1 0x1.0_p1 0x1.0_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0p_1 0x1.0p_1 0x1.0p_1 0x1.0p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0p+_1 0x1.0p+_1 0x1.0p+_1 0x1.0p+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0p_+1 0x1.0p_+1 0x1.0p_+1 0x1.0p_+1))")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _100 _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 +_100 +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 -_100 -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 99_ 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1__000 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _1.0 _1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0_ 1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1_.0 1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1._0 1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _1e1 _1e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1e1_ 1e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1_e1 1_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1e_1 1e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _1.0e1 _1.0e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0e1_ 1.0e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0_e1 1.0_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0e_1 1.0e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0e+_1 1.0e+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0e_+1 1.0e_+1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _0x100 _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0_x100 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x_100 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x00_ 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0xff__ffff 0xff__ffff))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x_1.0 0x_1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0_ 0x1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1_.0 0x1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1._0 0x1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x_1p1 0x_1p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1p1_ 0x1p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1_p1 0x1_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1p_1 0x1p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x_1.0p1 0x_1.0p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0p1_ 0x1.0p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0_p1 0x1.0_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0p_1 0x1.0p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0p+_1 0x1.0p+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0p_+1 0x1.0p_+1))")
+  "unknown operator"
+)
+
+;; Test parsing an integer from binary
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\69\38\78\31\36\00\00"  ;; export name (parse_i8x16)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\00\00\00\00"                             ;; data lane 0~3   (0,    0,    0,    0)
+  "\80\80\80\80"                             ;; data lane 4~7   (-128, -128, -128, -128)
+  "\ff\ff\ff\ff"                             ;; data lane 8~11  (0xff, 0xff, 0xff, 0xff)
+  "\ff\ff\ff\ff"                             ;; data lane 12~15 (255,  255,  255,  255)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_i8x16") (v128.const i8x16 0 0 0 0 -128 -128 -128 -128 0xff 0xff 0xff 0xff 255 255 255 255))
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\69\31\36\78\38\00\00"  ;; export name (parse_i16x8)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\00\00\00\00"                             ;; data lane 0, 1 (0,      0)
+  "\00\80\00\80"                             ;; data lane 2, 3 (-32768, -32768)
+  "\ff\ff\ff\ff"                             ;; data lane 4, 5 (65535,  65535)
+  "\ff\ff\ff\ff"                             ;; data lane 6, 7 (0xffff, 0xffff)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_i16x8") (v128.const i16x8 0 0 -32768 -32768 65535 65535 0xffff 0xffff))
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\69\33\32\78\34\00\00"  ;; export name (parse_i32x4)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\d1\ff\ff\ff"                             ;; data lane 0 (4294967249)
+  "\d1\ff\ff\ff"                             ;; data lane 1 (4294967249)
+  "\d1\ff\ff\ff"                             ;; data lane 2 (4294967249)
+  "\d1\ff\ff\ff"                             ;; data lane 3 (4294967249)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_i32x4") (v128.const i32x4 4294967249 4294967249 4294967249 4294967249))
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\69\36\34\78\32\00\00"  ;; export name (parse_i64x2)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\ff\ff\ff\ff\ff\ff\ff\7f"                 ;; data lane 0 (9223372036854775807)
+  "\ff\ff\ff\ff\ff\ff\ff\7f"                 ;; data lane 1 (9223372036854775807)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_i64x2") (v128.const i64x2 9223372036854775807 9223372036854775807))
+
+;; Test parsing a float from binary
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\66\33\32\78\34\00\00"  ;; export name (parse_f32x4)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\00\00\80\4f"                             ;; data lane 0 (4294967249)
+  "\00\00\80\4f"                             ;; data lane 1 (4294967249)
+  "\00\00\80\4f"                             ;; data lane 2 (4294967249)
+  "\00\00\80\4f"                             ;; data lane 3 (4294967249)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_f32x4") (v128.const f32x4 4294967249 4294967249 4294967249 4294967249))
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\66\36\34\78\32\00\00"  ;; export name (parse_f64x2)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\ff\ff\ff\ff\ff\ff\ef\7f"                 ;; data lane 0 (0x1.fffffffffffffp+1023)
+  "\ff\ff\ff\ff\ff\ff\ef\7f"                 ;; data lane 1 (0x1.fffffffffffffp+1023)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_f64x2") (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
diff --git a/test/core/simd/simd_conversions.wast b/test/core/simd/simd_conversions.wast
new file mode 100644
index 000000000..552e94361
--- /dev/null
+++ b/test/core/simd/simd_conversions.wast
@@ -0,0 +1,899 @@
+;; Web Assembly SIMD-related type conversion tests
+
+(module
+  ;; Integer to floating point
+  (func (export "f32x4.convert_i32x4_s") (param v128) (result v128)
+    (f32x4.convert_i32x4_s (local.get 0)))
+  (func (export "f32x4.convert_i32x4_u") (param v128) (result v128)
+    (f32x4.convert_i32x4_u (local.get 0)))
+
+  (func (export "f64x2.convert_low_i32x4_s") (param v128) (result v128)
+    (f64x2.convert_low_i32x4_s (local.get 0)))
+  (func (export "f64x2.convert_low_i32x4_u") (param v128) (result v128)
+    (f64x2.convert_low_i32x4_u (local.get 0)))
+
+  ;; Integer to integer narrowing
+  (func (export "i8x16.narrow_i16x8_s") (param v128 v128) (result v128)
+    (i8x16.narrow_i16x8_s (local.get 0) (local.get 1)))
+  (func (export "i8x16.narrow_i16x8_u") (param v128 v128) (result v128)
+    (i8x16.narrow_i16x8_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.narrow_i32x4_s") (param v128 v128) (result v128)
+    (i16x8.narrow_i32x4_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.narrow_i32x4_u") (param v128 v128) (result v128)
+    (i16x8.narrow_i32x4_u (local.get 0)(local.get 1)))
+
+  ;; Float to float promote/demote
+  (func (export "f64x2.promote_low_f32x4") (param v128) (result v128)
+    (f64x2.promote_low_f32x4 (local.get 0)))
+  (func (export "f32x4.demote_f64x2_zero") (param v128) (result v128)
+    (f32x4.demote_f64x2_zero (local.get 0)))
+)
+
+;; f64x2.promote_low_f32x4
+;; Float constants copied from test/core/conversions.wast.
+
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0.0 0.0 0.0 0.0))
+                                                 (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                                 (v128.const f64x2 -0.0 -0.0))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                                 (v128.const f64x2 0x1p-149 0x1p-149))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                                 (v128.const f64x2 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                                 (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                                 (v128.const f64x2 -1.0 -1.0))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+;; Generated randomly by picking a random int and reinterpret it to float.
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0x1p-119 0x1p-119 0x1p-119 0x1p-119))
+                                                 (v128.const f64x2 0x1p-119 0x1p-119))
+;; Generated randomly by picking a random float.
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0x1.8f867ep+125 0x1.8f867ep+125 0x1.8f867ep+125 0x1.8f867ep+125))
+                                                 (v128.const f64x2 6.6382536710104395e+37 6.6382536710104395e+37))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 inf inf inf inf))
+                                                 (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -inf -inf -inf -inf))
+                                                 (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 nan nan nan nan))
+                                                 (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                                 (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -nan -nan -nan -nan))
+                                                 (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                                 (v128.const f64x2 nan:arithmetic nan:arithmetic))
+
+;; f32x4.demote_f64x2_zero
+;; Float constants copied from test/core/conversions.wast.
+
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0.0 0.0))
+                                                 (v128.const f32x4 0.0 0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0.0 -0.0))
+                                                 (v128.const f32x4 -0.0 -0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                                 (v128.const f32x4 0.0 0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+                                                 (v128.const f32x4 -0.0 -0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 1.0 1.0))
+                                                 (v128.const f32x4 1.0 1.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -1.0 -1.0))
+                                                 (v128.const f32x4 -1.0 -1.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffe0000000p-127 0x1.fffffe0000000p-127))
+                                                 (v128.const f32x4 0x1p-126 0x1p-126 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffe0000000p-127 -0x1.fffffe0000000p-127))
+                                                 (v128.const f32x4 -0x1p-126 -0x1p-126 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffdfffffffp-127 0x1.fffffdfffffffp-127))
+                                                 (v128.const f32x4 0x1.fffffcp-127 0x1.fffffcp-127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffdfffffffp-127 -0x1.fffffdfffffffp-127))
+                                                 (v128.const f32x4 -0x1.fffffcp-127 -0x1.fffffcp-127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1p-149 0x1p-149))
+                                                 (v128.const f32x4 0x1p-149 0x1p-149 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1p-149 -0x1p-149))
+                                                 (v128.const f32x4 -0x1p-149 -0x1p-149 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffd0000000p+127 0x1.fffffd0000000p+127))
+                                                 (v128.const f32x4 0x1.fffffcp+127 0x1.fffffcp+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffd0000000p+127 -0x1.fffffd0000000p+127))
+                                                 (v128.const f32x4 -0x1.fffffcp+127 -0x1.fffffcp+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffd0000001p+127 0x1.fffffd0000001p+127))
+                                                 (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffd0000001p+127 -0x1.fffffd0000001p+127))
+                                                 (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffefffffffp+127 0x1.fffffefffffffp+127))
+                                                 (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffefffffffp+127 -0x1.fffffefffffffp+127))
+                                                 (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.ffffffp+127 0x1.ffffffp+127))
+                                                 (v128.const f32x4 inf inf 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.ffffffp+127 -0x1.ffffffp+127))
+                                                 (v128.const f32x4 -inf -inf 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1p-119 0x1p-119))
+                                                 (v128.const f32x4 0x1p-119 0x1p-119 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.8f867ep+125 0x1.8f867ep+125))
+                                                 (v128.const f32x4 0x1.8f867ep+125 0x1.8f867ep+125 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 inf inf))
+                                                 (v128.const f32x4 inf inf 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -inf -inf))
+                                                 (v128.const f32x4 -inf -inf 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000000000001p+0 0x1.0000000000001p+0))
+                                                 (v128.const f32x4 1.0 1.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffffffffffp-1 0x1.fffffffffffffp-1))
+                                                 (v128.const f32x4 1.0 1.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000010000000p+0 0x1.0000010000000p+0))
+                                                 (v128.const f32x4 0x1.000000p+0 0x1.000000p+0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000010000001p+0 0x1.0000010000001p+0))
+                                                 (v128.const f32x4 0x1.000002p+0 0x1.000002p+0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.000002fffffffp+0 0x1.000002fffffffp+0))
+                                                 (v128.const f32x4 0x1.000002p+0 0x1.000002p+0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000030000000p+0 0x1.0000030000000p+0))
+                                                 (v128.const f32x4 0x1.000004p+0 0x1.000004p+0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000050000000p+0 0x1.0000050000000p+0))
+                                                 (v128.const f32x4 0x1.000004p+0 0x1.000004p+0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000010000000p+24 0x1.0000010000000p+24))
+                                                 (v128.const f32x4 0x1.0p+24 0x1.0p+24 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000010000001p+24 0x1.0000010000001p+24))
+                                                 (v128.const f32x4 0x1.000002p+24 0x1.000002p+24 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.000002fffffffp+24 0x1.000002fffffffp+24))
+                                                 (v128.const f32x4 0x1.000002p+24 0x1.000002p+24 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000030000000p+24 0x1.0000030000000p+24))
+                                                 (v128.const f32x4 0x1.000004p+24 0x1.000004p+24 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.4eae4f7024c7p+108 0x1.4eae4f7024c7p+108))
+                                                 (v128.const f32x4 0x1.4eae5p+108 0x1.4eae5p+108 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.a12e71e358685p-113 0x1.a12e71e358685p-113))
+                                                 (v128.const f32x4 0x1.a12e72p-113 0x1.a12e72p-113 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.cb98354d521ffp-127 0x1.cb98354d521ffp-127))
+                                                 (v128.const f32x4 0x1.cb9834p-127 0x1.cb9834p-127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.6972b30cfb562p+1 -0x1.6972b30cfb562p+1))
+                                                 (v128.const f32x4 -0x1.6972b4p+1 -0x1.6972b4p+1 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.bedbe4819d4c4p+112 -0x1.bedbe4819d4c4p+112))
+                                                 (v128.const f32x4 -0x1.bedbe4p+112 -0x1.bedbe4p+112 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 nan nan))
+                                                 (v128.const f32x4 nan:canonical nan:canonical 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                                 (v128.const f32x4 nan:arithmetic nan:arithmetic 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -nan -nan))
+                                                 (v128.const f32x4 nan:canonical nan:canonical 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                                 (v128.const f32x4 nan:arithmetic nan:arithmetic 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                                 (v128.const f32x4 0.0 0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                                 (v128.const f32x4 -0.0 -0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0p-150 0x1.0p-150))
+                                                 (v128.const f32x4 0.0 0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.0p-150 -0x1.0p-150))
+                                                 (v128.const f32x4 -0.0 -0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000000000001p-150 0x1.0000000000001p-150))
+                                                 (v128.const f32x4 0x1p-149 0x1p-149 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.0000000000001p-150 -0x1.0000000000001p-150))
+                                                 (v128.const f32x4 -0x1p-149 -0x1p-149 0 0))
+
+
+;; Integer to floating point
+;; f32x4.convert_i32x4_s
+
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 0 0 0 0))
+                                               (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 1 1 1 1))
+                                               (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                               (v128.const f32x4 2147483647.0 2147483647.0 2147483647.0 2147483647.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                               (v128.const f32x4 -2147483648.0 -2147483648.0 -2147483648.0 -2147483648.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 1234567890 1234567890 1234567890 1234567890))
+                                               (v128.const f32x4 0x1.26580cp+30 0x1.26580cp+30 0x1.26580cp+30 0x1.26580cp+30))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 0_123_456_792 0_123_456_792 0_123_456_792 0_123_456_792))
+                                               (v128.const f32x4 123456792.0 123456792.0 123456792.0 123456792.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 0x0_1234_5680 0x0_1234_5680 0x0_1234_5680 0x0_1234_5680))
+                                               (v128.const f32x4 305419904.0 305419904.0 305419904.0 305419904.0))
+;; Test rounding directions.
+
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 16777217 16777217 16777217 16777217))
+                                               (v128.const f32x4 16777216.0 16777216.0 16777216.0 16777216.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 -16777217 -16777217 -16777217 -16777217))
+                                               (v128.const f32x4 -16777216.0 -16777216.0 -16777216.0 -16777216.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 16777219 16777219 16777219 16777219))
+                                               (v128.const f32x4 16777220.0 16777220.0 16777220.0 16777220.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 -16777219 -16777219 -16777219 -16777219))
+                                               (v128.const f32x4 -16777220.0 -16777220.0 -16777220.0 -16777220.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 0 -1 0x7fffffff 0x80000000))
+                                               (v128.const f32x4 0.0 -1.0 2147483647.0 -2147483648.0))
+
+;; f32x4.convert_i32x4_u
+
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0 0 0 0))
+                                               (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 1 1 1 1))
+                                               (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const f32x4 4294967295.0 4294967295.0 4294967295.0 4294967295.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                               (v128.const f32x4 2147483648.0 2147483648.0 2147483648.0 2147483648.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                               (v128.const f32x4 2147483648.0 2147483648.0 2147483648.0 2147483648.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                                               (v128.const f32x4 0x1.234568p+28 0x1.234568p+28 0x1.234568p+28 0x1.234568p+28))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x80000080 0x80000080 0x80000080 0x80000080))
+                                               (v128.const f32x4 0x1.000000p+31 0x1.000000p+31 0x1.000000p+31 0x1.000000p+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x80000081 0x80000081 0x80000081 0x80000081))
+                                               (v128.const f32x4 0x1.000002p+31 0x1.000002p+31 0x1.000002p+31 0x1.000002p+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x80000082 0x80000082 0x80000082 0x80000082))
+                                               (v128.const f32x4 0x1.000002p+31 0x1.000002p+31 0x1.000002p+31 0x1.000002p+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0xfffffe80 0xfffffe80 0xfffffe80 0xfffffe80))
+                                               (v128.const f32x4 0x1.fffffcp+31 0x1.fffffcp+31 0x1.fffffcp+31 0x1.fffffcp+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0xfffffe81 0xfffffe81 0xfffffe81 0xfffffe81))
+                                               (v128.const f32x4 0x1.fffffep+31 0x1.fffffep+31 0x1.fffffep+31 0x1.fffffep+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0xfffffe82 0xfffffe82 0xfffffe82 0xfffffe82))
+                                               (v128.const f32x4 0x1.fffffep+31 0x1.fffffep+31 0x1.fffffep+31 0x1.fffffep+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0_123_456_792 0_123_456_792 0_123_456_792 0_123_456_792))
+                                               (v128.const f32x4 123456792.0 123456792.0 123456792.0 123456792.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                                               (v128.const f32x4 2427178496.0 2427178496.0 2427178496.0 2427178496.0))
+;; Test rounding directions.
+
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 16777217 16777217 16777217 16777217))
+                                               (v128.const f32x4 16777216.0 16777216.0 16777216.0 16777216.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 16777219 16777219 16777219 16777219))
+                                               (v128.const f32x4 16777220.0 16777220.0 16777220.0 16777220.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0 -1 0x7fffffff 0x80000000))
+                                               (v128.const f32x4 0.0 4294967295.0 2147483647.0 2147483648.0))
+
+;; f64x2.convert_i32x4_s
+;; constants copied from test/core/conversions.wast.
+
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 1 1 0 0))
+                                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 -1 -1 0 0))
+                                                   (v128.const f64x2 -1.0 -1.0))
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 0 0 0 0))
+                                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 0 0))
+                                                   (v128.const f64x2 2147483647 2147483647))
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 0 0))
+                                                   (v128.const f64x2 -2147483648 -2147483648))
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 987654321 987654321 0 0))
+                                                   (v128.const f64x2 987654321 987654321))
+
+;; f64x2.convert_i32x4_u
+;; constants copied from test/core/conversions.wast.
+
+(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 1 1 0 0))
+                                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 0 0 0 0))
+                                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 0 0))
+                                                   (v128.const f64x2 2147483647 2147483647))
+(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 0 0))
+                                                   (v128.const f64x2 2147483648 2147483648))
+(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 0xffffffff 0xffffffff 0 0))
+                                                   (v128.const f64x2 4294967295.0 4294967295.0))
+
+;; Integer to integer narrowing
+;; i8x16.narrow_i16x8_s
+
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                              (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                              (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f)
+                                              (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                              (v128.const i8x16 0x81 0x81 0x81 0x81 0x81 0x81 0x81 0x81 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x81 0x81 0x81 0x81 0x81 0x81 0x81 0x81))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81)
+                                              (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81)
+                                              (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81)
+                                              (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                              (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                              (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+;; i8x16.narrow_i16x8_u
+
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                              (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                              (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                              (v128.const i16x8 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe))
+                                              (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100)
+                                              (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+                                              (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                              (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+                                              (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789)
+                                              (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                              (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+;; i16x8.narrow_i32x4_s
+
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 1 1 1 1))
+                                              (v128.const i16x8 0 0 0 0 1 1 1 1))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 -1 -1 -1 -1))
+                                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                              (v128.const i32x4 -1 -1 -1 -1))
+                                              (v128.const i16x8 1 1 1 1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 1 1 1 1))
+                                              (v128.const i16x8 -1 -1 -1 -1 1 1 1 1))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7ffe 0x7ffe 0x7ffe 0x7ffe)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x7ffe 0x7ffe 0x7ffe 0x7ffe 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)
+                                              (v128.const i32x4 0x7ffe 0x7ffe 0x7ffe 0x7ffe))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7ffe 0x7ffe 0x7ffe 0x7ffe))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                              (v128.const i32x4 0x8000 0x8000 0x8000 0x8000))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)
+                                              (v128.const i32x4 0x8000 0x8000 0x8000 0x8000))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x7fff -0x7fff -0x7fff -0x7fff)
+                                              (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000))
+                                              (v128.const i16x8 0x8001 0x8001 0x8001 0x8001 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 -0x7fff -0x7fff -0x7fff -0x7fff))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8001 0x8001 0x8001 0x8001))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001)
+                                              (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001)
+                                              (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 0x8000 0x8000 0x8000 0x8000))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001)
+                                              (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000000 -0x8000000 -0x8000000 -0x8000000)
+                                              (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                                              (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                              (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+;; i16x8.narrow_i32x4_u
+
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 1 1 1 1))
+                                              (v128.const i16x8 0 0 0 0 1 1 1 1))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 -1 -1 -1 -1))
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                              (v128.const i32x4 -1 -1 -1 -1))
+                                              (v128.const i16x8 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 1 1 1 1))
+                                              (v128.const i16x8 0 0 0 0 1 1 1 1))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0xfffe 0xfffe 0xfffe 0xfffe)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0xfffe 0xfffe 0xfffe 0xfffe 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)
+                                              (v128.const i32x4 0xfffe 0xfffe 0xfffe 0xfffe))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xfffe 0xfffe 0xfffe 0xfffe))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0x10000 0x10000 0x10000 0x10000)
+                                              (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)
+                                              (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0x10000 0x10000 0x10000 0x10000)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+                                              (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+                                              (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000)
+                                              (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                                              (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                              (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                                              (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff))
+
+
+;; Unknown operator
+
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.trunc_sat_f32x4 (v128.const f32x4 0.0 0.0 0.0 0.0)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.trunc_s_sat_f32x4 (v128.const f32x4 -2.0 -1.0 1.0 2.0)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.trunc_u_sat_f32x4 (v128.const f32x4 -2.0 -1.0 1.0 2.0)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.convert_f32x4 (v128.const f32x4 -1 0 1 2)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.convert_s_f32x4 (v128.const f32x4 -1 0 1 2)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.convert_u_f32x4 (v128.const f32x4 -1 0 1 2)))")
+  "unknown operator")
+
+(assert_malformed (module quote
+  "(func (result v128) (i64x2.trunc_sat_f64x2_s (v128.const f64x2 0.0 0.0)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i64x2.trunc_sat_f64x2_u (v128.const f64x2 -2.0 -1.0)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (f64x2.convert_i64x2_s (v128.const i64x2 1 2)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (f64x2.convert_i64x2_u (v128.const i64x2 1 2)))")
+  "unknown operator")
+
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.narrow_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.narrow_i8x16 (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.narrow_i8x16_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.narrow_i8x16_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.narrow_i32x4 (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.narrow_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.narrow_i16x8_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.narrow_i16x8_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_low_i8x16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.extend_low_i16x8_s (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.extend_low_i16x8_u (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_high_i8x16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.extend_high_i16x8_s (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.extend_high_i16x8_u (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.extend_low_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_low_i32x4_s (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_low_i32x4_u (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.extend_high_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_high_i32x4_s (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_high_i32x4_u (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+
+
+;; Type mismatch
+
+(assert_invalid (module (func (result v128) (f32x4.convert_i32x4_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.convert_i32x4_s (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.convert_i32x4_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.convert_i32x4_u (i64.const 0)))) "type mismatch")
+
+(assert_invalid (module (func (result v128) (i8x16.narrow_i16x8_s (i32.const 0) (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.narrow_i16x8_u (i32.const 0) (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.narrow_i32x4_s (f32.const 0.0) (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.narrow_i32x4_s (f32.const 0.0) (f64.const 0.0)))) "type mismatch")
+
+
+;; Combinations
+
+(module
+  (func (export "f32x4_convert_i32x4_s_add") (param v128 v128) (result v128)
+    (f32x4.convert_i32x4_s (i32x4.add (local.get 0) (local.get 1))))
+  (func (export "f32x4_convert_i32x4_s_sub") (param  v128 v128) (result v128)
+    (f32x4.convert_i32x4_s (i32x4.sub (local.get 0) (local.get 1))))
+  (func (export "f32x4_convert_i32x4_u_mul") (param  v128 v128) (result v128)
+    (f32x4.convert_i32x4_u (i32x4.mul (local.get 0) (local.get 1))))
+
+  (func (export "i16x8_low_extend_narrow_ss") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_s (i8x16.narrow_i16x8_s (local.get 0) (local.get 1))))
+  (func (export "i16x8_low_extend_narrow_su") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_s (i8x16.narrow_i16x8_u (local.get 0) (local.get 1))))
+  (func (export "i16x8_high_extend_narrow_ss") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_s (i8x16.narrow_i16x8_s (local.get 0) (local.get 1))))
+  (func (export "i16x8_high_extend_narrow_su") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_s (i8x16.narrow_i16x8_u (local.get 0) (local.get 1))))
+  (func (export "i16x8_low_extend_narrow_uu") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_u (i8x16.narrow_i16x8_u (local.get 0) (local.get 1))))
+  (func (export "i16x8_low_extend_narrow_us") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_u (i8x16.narrow_i16x8_s (local.get 0) (local.get 1))))
+  (func (export "i16x8_high_extend_narrow_uu") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_u (i8x16.narrow_i16x8_u (local.get 0) (local.get 1))))
+  (func (export "i16x8_high_extend_narrow_us") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_u (i8x16.narrow_i16x8_s (local.get 0) (local.get 1))))
+
+  (func (export "i32x4_low_extend_narrow_ss") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_s (i16x8.narrow_i32x4_s (local.get 0) (local.get 1))))
+  (func (export "i32x4_low_extend_narrow_su") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_s (i16x8.narrow_i32x4_u (local.get 0) (local.get 1))))
+  (func (export "i32x4_high_extend_narrow_ss") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_s (i16x8.narrow_i32x4_s (local.get 0) (local.get 1))))
+  (func (export "i32x4_high_extend_narrow_su") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_s (i16x8.narrow_i32x4_u (local.get 0) (local.get 1))))
+  (func (export "i32x4_low_extend_narrow_uu") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_u (i16x8.narrow_i32x4_u (local.get 0) (local.get 1))))
+  (func (export "i32x4_low_extend_narrow_us") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_u (i16x8.narrow_i32x4_s (local.get 0) (local.get 1))))
+  (func (export "i32x4_high_extend_narrow_uu") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_u (i16x8.narrow_i32x4_u (local.get 0) (local.get 1))))
+  (func (export "i32x4_high_extend_narrow_us") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_u (i16x8.narrow_i32x4_s (local.get 0) (local.get 1))))
+)
+
+(assert_return (invoke "f32x4_convert_i32x4_s_add" (v128.const i32x4 1 2 3 4)
+                                                   (v128.const i32x4 2 3 4 5))
+                                                   (v128.const f32x4 3.0 5.0 7.0 9.0))
+(assert_return (invoke "f32x4_convert_i32x4_s_sub" (v128.const i32x4 0 1 2 3)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const f32x4 -1.0 0.0 1.0 2.0))
+(assert_return (invoke "f32x4_convert_i32x4_u_mul" (v128.const i32x4 1 2 3 4)
+                                                   (v128.const i32x4 1 2 3 4))
+                                                   (v128.const f32x4 1.0 4.0 9.0 16.0))
+
+(assert_return (invoke "i16x8_low_extend_narrow_ss" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000)
+                                                    (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000))
+                                                    (v128.const i16x8 0xff80 0xff80 0x7f 0xff80 0xff80 0xff80 0x7f 0xff80))
+(assert_return (invoke "i16x8_low_extend_narrow_su" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff)
+                                                    (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff))
+                                                    (v128.const i16x8 0 0 0xffff 0 0 0 0xffff 0))
+(assert_return (invoke "i16x8_high_extend_narrow_ss" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000)
+                                                     (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000))
+                                                     (v128.const i16x8 0xff80 0xff80 0x7f 0xff80 0xff80 0xff80 0x7f 0xff80))
+(assert_return (invoke "i16x8_high_extend_narrow_su" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff)
+                                                     (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff))
+                                                     (v128.const i16x8 0 0 0xffff 0 0 0 0xffff 0))
+(assert_return (invoke "i16x8_low_extend_narrow_uu" (v128.const i16x8 -0x8000 -0x7fff 0x8000 0xffff -0x8000 -0x7fff 0x8000 0xffff)
+                                                    (v128.const i16x8 -0x8000 -0x7fff 0x8000 0xffff -0x8000 -0x7fff 0x8000 0xffff))
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_low_extend_narrow_us" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000)
+                                                    (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000))
+                                                    (v128.const i16x8 0x80 0x80 0x7f 0x80 0x80 0x80 0x7f 0x80))
+(assert_return (invoke "i16x8_high_extend_narrow_uu" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff)
+                                                     (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff))
+                                                     (v128.const i16x8 0 0 0xff 0 0 0 0xff 0))
+(assert_return (invoke "i16x8_high_extend_narrow_us" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000)
+                                                     (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000))
+                                                     (v128.const i16x8 0x80 0x80 0x7f 0x80 0x80 0x80 0x7f 0x80))
+
+(assert_return (invoke "i32x4_low_extend_narrow_ss" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000)
+                                                    (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000))
+                                                    (v128.const i32x4 0xffff8000 0xffff8000 0x7fff 0x7fff))
+(assert_return (invoke "i32x4_low_extend_narrow_su" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff)
+                                                    (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff))
+                                                    (v128.const i32x4 0 0 0xffffffff 0))
+(assert_return (invoke "i32x4_high_extend_narrow_ss" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000)
+                                                     (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000))
+                                                     (v128.const i32x4 0xffff8000 0xffff8000 0x7fff 0x7fff))
+(assert_return (invoke "i32x4_high_extend_narrow_su" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff)
+                                                     (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff))
+                                                     (v128.const i32x4 0 0 0xffffffff 0))
+(assert_return (invoke "i32x4_low_extend_narrow_uu" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff)
+                                                    (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff))
+                                                    (v128.const i32x4 0 0 0xffff 0))
+(assert_return (invoke "i32x4_low_extend_narrow_us" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000)
+                                                    (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000))
+                                                    (v128.const i32x4 0x8000 0x8000 0x7fff 0x7fff))
+(assert_return (invoke "i32x4_high_extend_narrow_uu" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff)
+                                                     (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff))
+                                                     (v128.const i32x4 0 0 0xffff 0))
+(assert_return (invoke "i32x4_high_extend_narrow_us" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000)
+                                                     (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000))
+                                                     (v128.const i32x4 0x8000 0x8000 0x7fff 0x7fff))
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.convert_i32x4_s-arg-empty (result v128)
+      (f32x4.convert_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.convert_i32x4_u-arg-empty (result v128)
+      (f32x4.convert_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.narrow_i16x8_s-1st-arg-empty (result v128)
+      (i8x16.narrow_i16x8_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.narrow_i16x8_s-arg-empty (result v128)
+      (i8x16.narrow_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.narrow_i16x8_u-1st-arg-empty (result v128)
+      (i8x16.narrow_i16x8_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.narrow_i16x8_u-arg-empty (result v128)
+      (i8x16.narrow_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.narrow_i32x4_s-1st-arg-empty (result v128)
+      (i16x8.narrow_i32x4_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.narrow_i32x4_s-arg-empty (result v128)
+      (i16x8.narrow_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.narrow_i32x4_u-1st-arg-empty (result v128)
+      (i16x8.narrow_i32x4_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.narrow_i32x4_u-arg-empty (result v128)
+      (i16x8.narrow_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
diff --git a/test/core/simd/simd_f32x4.wast b/test/core/simd/simd_f32x4.wast
new file mode 100644
index 000000000..819db8cfd
--- /dev/null
+++ b/test/core/simd/simd_f32x4.wast
@@ -0,0 +1,2407 @@
+;; Tests for f32x4 [abs, min, max] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f32x4.min") (param v128 v128) (result v128) (f32x4.min (local.get 0) (local.get 1)))
+  (func (export "f32x4.max") (param v128 v128) (result v128) (f32x4.max (local.get 0) (local.get 1)))
+  (func (export "f32x4.abs") (param v128) (result v128) (f32x4.abs (local.get 0)))
+  ;; f32x4.min const vs const
+  (func (export "f32x4.min_with_const_0") (result v128) (f32x4.min (v128.const f32x4 0 1 2 -3) (v128.const f32x4 0 2 1 3)))
+  (func (export "f32x4.min_with_const_1") (result v128) (f32x4.min (v128.const f32x4 0 1 2 3) (v128.const f32x4 0 1 2 3)))
+  (func (export "f32x4.min_with_const_2") (result v128) (f32x4.min (v128.const f32x4 0x00 0x01 0x02 0x80000000) (v128.const f32x4 0x00 0x02 0x01 2147483648)))
+  (func (export "f32x4.min_with_const_3") (result v128) (f32x4.min (v128.const f32x4 0x00 0x01 0x02 0x80000000) (v128.const f32x4 0x00 0x01 0x02 0x80000000)))
+  ;; f32x4.min param vs const
+  (func (export "f32x4.min_with_const_5")(param v128) (result v128) (f32x4.min (local.get 0) (v128.const f32x4 0 1 2 -3)))
+  (func (export "f32x4.min_with_const_6")(param v128) (result v128) (f32x4.min (v128.const f32x4 0 1 2 3) (local.get 0)))
+  (func (export "f32x4.min_with_const_7")(param v128) (result v128) (f32x4.min (v128.const f32x4 0x00 0x01 0x02 0x80000000) (local.get 0)))
+  (func (export "f32x4.min_with_const_8")(param v128) (result v128) (f32x4.min (local.get 0) (v128.const f32x4 0x00 0x01 0x02 0x80000000)))
+  ;; f32x4.max const vs const
+  (func (export "f32x4.max_with_const_10") (result v128) (f32x4.max (v128.const f32x4 0 1 2 -3) (v128.const f32x4 0 2 1 3)))
+  (func (export "f32x4.max_with_const_11") (result v128) (f32x4.max (v128.const f32x4 0 1 2 3) (v128.const f32x4 0 1 2 3)))
+  (func (export "f32x4.max_with_const_12") (result v128) (f32x4.max (v128.const f32x4 0x00 0x01 0x02 0x80000000) (v128.const f32x4 0x00 0x02 0x01 2147483648)))
+  (func (export "f32x4.max_with_const_13") (result v128) (f32x4.max (v128.const f32x4 0x00 0x01 0x02 0x80000000) (v128.const f32x4 0x00 0x01 0x02 0x80000000)))
+  ;; f32x4.max param vs const
+  (func (export "f32x4.max_with_const_15")(param v128) (result v128) (f32x4.max (local.get 0) (v128.const f32x4 0 1 2 -3)))
+  (func (export "f32x4.max_with_const_16")(param v128) (result v128) (f32x4.max (v128.const f32x4 0 1 2 3) (local.get 0)))
+  (func (export "f32x4.max_with_const_17")(param v128) (result v128) (f32x4.max (v128.const f32x4 0x00 0x01 0x02 0x80000000) (local.get 0)))
+  (func (export "f32x4.max_with_const_18")(param v128) (result v128) (f32x4.max (local.get 0) (v128.const f32x4 0x00 0x01 0x02 0x80000000)))
+
+  (func (export "f32x4.abs_with_const") (result v128) (f32x4.abs (v128.const f32x4 -0 -1 -2 -3)))
+)
+
+;; f32x4.min const vs const
+(assert_return (invoke "f32x4.min_with_const_0") (v128.const f32x4 0 1 1 -3))
+(assert_return (invoke "f32x4.min_with_const_1") (v128.const f32x4 0 1 2 3))
+(assert_return (invoke "f32x4.min_with_const_2") (v128.const f32x4 0x00 0x01 0x01 0x80000000))
+(assert_return (invoke "f32x4.min_with_const_3") (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+;; f32x4.min param vs const
+(assert_return (invoke "f32x4.min_with_const_5" (v128.const f32x4 0 2 1 3))
+                                                (v128.const f32x4 0 1 1 -3))
+(assert_return (invoke "f32x4.min_with_const_6" (v128.const f32x4 0 1 2 3))
+                                                (v128.const f32x4 0 1 2 3))
+(assert_return (invoke "f32x4.min_with_const_7" (v128.const f32x4 0x00 0x02 0x01 2147483648))
+                                                (v128.const f32x4 0x00 0x01 0x01 0x80000000))
+(assert_return (invoke "f32x4.min_with_const_8" (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+                                                (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+;; f32x4.max const vs const
+(assert_return (invoke "f32x4.max_with_const_10") (v128.const f32x4 0 2 2 3))
+(assert_return (invoke "f32x4.max_with_const_11") (v128.const f32x4 0 1 2 3))
+(assert_return (invoke "f32x4.max_with_const_12") (v128.const f32x4 0x00 0x02 0x02 2147483648))
+(assert_return (invoke "f32x4.max_with_const_13") (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+;; f32x4.max param vs const
+(assert_return (invoke "f32x4.max_with_const_15" (v128.const f32x4 0 2 1 3))
+                                                 (v128.const f32x4 0 2 2 3))
+(assert_return (invoke "f32x4.max_with_const_16" (v128.const f32x4 0 1 2 3))
+                                                 (v128.const f32x4 0 1 2 3))
+(assert_return (invoke "f32x4.max_with_const_17" (v128.const f32x4 0x00 0x02 0x01 2147483648))
+                                                 (v128.const f32x4 0x00 0x02 0x02 2147483648))
+(assert_return (invoke "f32x4.max_with_const_18" (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+                                                 (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+
+(assert_return (invoke "f32x4.abs_with_const") (v128.const f32x4 0 1 2 3))
+
+;; Test different lanes go through different if-then clauses
+;; f32x4.min
+(assert_return
+  (invoke "f32x4.min"
+    (v128.const f32x4 nan 0 0 1)
+    (v128.const f32x4 0 -nan 1 0)
+  )
+  (v128.const f32x4 nan:canonical nan:canonical 0 0)
+)
+;; f32x4.min
+(assert_return
+  (invoke "f32x4.min"
+    (v128.const f32x4 nan 0 0 0)
+    (v128.const f32x4 0 -nan 1 0)
+  )
+  (v128.const f32x4 nan:canonical nan:canonical 0 0)
+)
+;; f32x4.max
+(assert_return
+  (invoke "f32x4.max"
+    (v128.const f32x4 nan 0 0 1)
+    (v128.const f32x4 0 -nan 1 0)
+  )
+  (v128.const f32x4 nan:canonical nan:canonical 1 1)
+)
+;; f32x4.max
+(assert_return
+  (invoke "f32x4.max"
+    (v128.const f32x4 nan 0 0 0)
+    (v128.const f32x4 0 -nan 1 0)
+  )
+  (v128.const f32x4 nan:canonical nan:canonical 1 0)
+)
+
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+
+;; Test opposite signs of zero
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0 0 -0 +0)
+                                   (v128.const f32x4 +0 -0 +0 -0))
+                                   (v128.const f32x4 0 -0 -0 -0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0 -0 -0 -0)
+                                   (v128.const f32x4 +0 +0 +0 +0))
+                                   (v128.const f32x4 -0 -0 -0 -0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0 0 -0 +0)
+                                   (v128.const f32x4 +0 -0 +0 -0))
+                                   (v128.const f32x4 0 0 0 0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0 -0 -0 -0)
+                                   (v128.const f32x4 +0 +0 +0 +0))
+                                   (v128.const f32x4 +0 +0 +0 +0))
+
+
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f32x4.abs (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.min (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.max (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.abs-arg-empty (result v128)
+      (f32x4.abs)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.min-1st-arg-empty (result v128)
+      (f32x4.min (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.min-arg-empty (result v128)
+      (f32x4.min)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.max-1st-arg-empty (result v128)
+      (f32x4.max (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.max-arg-empty (result v128)
+      (f32x4.max)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "max-min") (param v128 v128 v128) (result v128)
+    (f32x4.max (f32x4.min (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "min-max") (param v128 v128 v128) (result v128)
+    (f32x4.min (f32x4.max (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "max-abs") (param v128 v128) (result v128)
+    (f32x4.max (f32x4.abs (local.get 0)) (local.get 1)))
+  (func (export "min-abs") (param v128 v128) (result v128)
+    (f32x4.min (f32x4.abs (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "max-min" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+(assert_return (invoke "min-max" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+(assert_return (invoke "max-abs" (v128.const f32x4 -1.125 -1.125 -1.125 -1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 1.125 1.125 1.125 1.125))
+(assert_return (invoke "min-abs" (v128.const f32x4 -1.125 -1.125 -1.125 -1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
\ No newline at end of file
diff --git a/test/core/simd/simd_f32x4_arith.wast b/test/core/simd/simd_f32x4_arith.wast
new file mode 100644
index 000000000..56f80f547
--- /dev/null
+++ b/test/core/simd/simd_f32x4_arith.wast
@@ -0,0 +1,5476 @@
+;; Tests for f32x4 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f32x4.add") (param v128 v128) (result v128) (f32x4.add (local.get 0) (local.get 1)))
+  (func (export "f32x4.sub") (param v128 v128) (result v128) (f32x4.sub (local.get 0) (local.get 1)))
+  (func (export "f32x4.mul") (param v128 v128) (result v128) (f32x4.mul (local.get 0) (local.get 1)))
+  (func (export "f32x4.div") (param v128 v128) (result v128) (f32x4.div (local.get 0) (local.get 1)))
+  (func (export "f32x4.neg") (param v128) (result v128) (f32x4.neg (local.get 0)))
+  (func (export "f32x4.sqrt") (param v128) (result v128) (f32x4.sqrt (local.get 0)))
+)
+
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                   (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                   (v128.const f32x4 246913578.0 246913578.0 246913578.0 246913578.0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 2.46913578e+27 2.46913578e+27 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                   (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                   (v128.const f32x4 2.46913578e+27 2.46913578e+27 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 2.46913578e-11 2.46913578e-11 2.46913578e-11 2.46913578e-11))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                   (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                   (v128.const f32x4 246913578.0 246913578.0 246913578.0 246913578.0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 2.46913578e+27 2.46913578e+27 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 2.46913578e+27 2.46913578e+27 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f32x4 2.46913578e-11 2.46913578e-11 2.46913578e-11 2.46913578e-11))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f32x4 246913578.02469134 246913578.02469134 246913578.02469134 246913578.02469134))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f32x4 2.4691357802469137e+27 2.4691357802469137e+27 2.4691357802469137e+27 2.4691357802469137e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f32x4 2.4691357802469137e+27 2.4691357802469137e+27 2.4691357802469137e+27 2.4691357802469137e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f32x4 2.4691357802469137e-11 2.4691357802469137e-11 2.4691357802469137e-11 2.4691357802469137e-11))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                   (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                   (v128.const f32x4 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                   (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                   (v128.const f32x4 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                   (v128.const f32x4 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                   (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                   (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                   (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                   (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                   (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-298 0x1.0000000000000p-298 0x1.0000000000000p-298 0x1.0000000000000p-298))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-298 -0x1.0000000000000p-298 -0x1.0000000000000p-298 -0x1.0000000000000p-298))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-298 -0x1.0000000000000p-298 -0x1.0000000000000p-298 -0x1.0000000000000p-298))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-298 0x1.0000000000000p-298 0x1.0000000000000p-298 0x1.0000000000000p-298))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-252 0x1.0000000000000p-252 0x1.0000000000000p-252 0x1.0000000000000p-252))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-252 -0x1.0000000000000p-252 -0x1.0000000000000p-252 -0x1.0000000000000p-252))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-252 -0x1.0000000000000p-252 -0x1.0000000000000p-252 -0x1.0000000000000p-252))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-252 0x1.0000000000000p-252 0x1.0000000000000p-252 0x1.0000000000000p-252))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-2 0x1.0000000000000p-2 0x1.0000000000000p-2 0x1.0000000000000p-2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-2 -0x1.0000000000000p-2 -0x1.0000000000000p-2 -0x1.0000000000000p-2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-2 -0x1.0000000000000p-2 -0x1.0000000000000p-2 -0x1.0000000000000p-2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-2 0x1.0000000000000p-2 0x1.0000000000000p-2 0x1.0000000000000p-2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                   (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                   (v128.const f32x4 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                   (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                   (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                   (v128.const f32x4 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f32x4 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f32x4 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f32x4 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                   (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                   (v128.const f32x4 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                   (v128.const f32x4 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                   (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                   (v128.const f32x4 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                   (v128.const f32x4 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                   (v128.const f32x4 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                   (v128.const f32x4 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-23 0x1.0000000000000p-23 0x1.0000000000000p-23 0x1.0000000000000p-23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-23 -0x1.0000000000000p-23 -0x1.0000000000000p-23 -0x1.0000000000000p-23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-277 0x1.0000010000010p-277 0x1.0000010000010p-277 0x1.0000010000010p-277))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-277 -0x1.0000010000010p-277 -0x1.0000010000010p-277 -0x1.0000010000010p-277))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-23 -0x1.0000000000000p-23 -0x1.0000000000000p-23 -0x1.0000000000000p-23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-23 0x1.0000000000000p-23 0x1.0000000000000p-23 0x1.0000000000000p-23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-277 -0x1.0000010000010p-277 -0x1.0000010000010p-277 -0x1.0000010000010p-277))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-277 0x1.0000010000010p-277 0x1.0000010000010p-277 0x1.0000010000010p-277))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+23 0x1.0000000000000p+23 0x1.0000000000000p+23 0x1.0000000000000p+23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+23 -0x1.0000000000000p+23 -0x1.0000000000000p+23 -0x1.0000000000000p+23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-254 0x1.0000010000010p-254 0x1.0000010000010p-254 0x1.0000010000010p-254))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-254 -0x1.0000010000010p-254 -0x1.0000010000010p-254 -0x1.0000010000010p-254))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+23 -0x1.0000000000000p+23 -0x1.0000000000000p+23 -0x1.0000000000000p+23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+23 0x1.0000000000000p+23 0x1.0000000000000p+23 0x1.0000000000000p+23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-254 -0x1.0000010000010p-254 -0x1.0000010000010p-254 -0x1.0000010000010p-254))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-254 0x1.0000010000010p-254 0x1.0000010000010p-254 0x1.0000010000010p-254))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+125 0x1.0000000000000p+125 0x1.0000000000000p+125 0x1.0000000000000p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+125 -0x1.0000000000000p+125 -0x1.0000000000000p+125 -0x1.0000000000000p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-129 0x1.0000010000010p-129 0x1.0000010000010p-129 0x1.0000010000010p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-129 -0x1.0000010000010p-129 -0x1.0000010000010p-129 -0x1.0000010000010p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+125 -0x1.0000000000000p+125 -0x1.0000000000000p+125 -0x1.0000000000000p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+125 0x1.0000000000000p+125 0x1.0000000000000p+125 0x1.0000000000000p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-129 -0x1.0000010000010p-129 -0x1.0000010000010p-129 -0x1.0000010000010p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-129 0x1.0000010000010p-129 0x1.0000010000010p-129 0x1.0000010000010p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+126 0x1.0000000000000p+126 0x1.0000000000000p+126 0x1.0000000000000p+126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+126 -0x1.0000000000000p+126 -0x1.0000000000000p+126 -0x1.0000000000000p+126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-128 0x1.0000010000010p-128 0x1.0000010000010p-128 0x1.0000010000010p-128))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-128 -0x1.0000010000010p-128 -0x1.0000010000010p-128 -0x1.0000010000010p-128))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+126 -0x1.0000000000000p+126 -0x1.0000000000000p+126 -0x1.0000000000000p+126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+126 0x1.0000000000000p+126 0x1.0000000000000p+126 0x1.0000000000000p+126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-128 -0x1.0000010000010p-128 -0x1.0000010000010p-128 -0x1.0000010000010p-128))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-128 0x1.0000010000010p-128 0x1.0000010000010p-128 0x1.0000010000010p-128))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                   (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                   (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                   (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                   (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                   (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.6a09e667f3bcdp-75 0x1.6a09e667f3bcdp-75 0x1.6a09e667f3bcdp-75 0x1.6a09e667f3bcdp-75))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-63 0x1.0000000000000p-63 0x1.0000000000000p-63 0x1.0000000000000p-63))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.6a09e667f3bcdp-1 0x1.6a09e667f3bcdp-1 0x1.6a09e667f3bcdp-1 0x1.6a09e667f3bcdp-1))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.40d9324a48138p+1 0x1.40d9324a48138p+1 0x1.40d9324a48138p+1 0x1.40d9324a48138p+1))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffeffffffcp+63 0x1.fffffeffffffcp+63 0x1.fffffeffffffcp+63 0x1.fffffeffffffcp+63))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 11111.111060555555 11111.111060555555 11111.111060555555 11111.111060555555))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 35136418286444.62 35136418286444.62 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 35136418286444.62 35136418286444.62 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 3.5136418286444623e-06 3.5136418286444623e-06 3.5136418286444623e-06 3.5136418286444623e-06))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 11111.111060555555 11111.111060555555 11111.111060555555 11111.111060555555))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 35136418286444.62 35136418286444.62 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 35136418286444.62 35136418286444.62 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 3.5136418286444623e-06 3.5136418286444623e-06 3.5136418286444623e-06 3.5136418286444623e-06))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 11111.11106111111 11111.11106111111 11111.11106111111 11111.11106111111))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 35136418288201.445 35136418288201.445 35136418288201.445 35136418288201.445))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 35136418288201.445 35136418288201.445 35136418288201.445 35136418288201.445))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 3.513641828820144e-06 3.513641828820144e-06 3.513641828820144e-06 3.513641828820144e-06))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                   (v128.const f32x4 -123456789.0 -123456789.0 -123456789.0 -123456789.0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                   (v128.const f32x4 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 -1.23456789e-11 -1.23456789e-11 -1.23456789e-11 -1.23456789e-11))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                   (v128.const f32x4 -123456789.0 -123456789.0 -123456789.0 -123456789.0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f32x4 -1.23456789e-11 -1.23456789e-11 -1.23456789e-11 -1.23456789e-11))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f32x4 -123456789.01234567 -123456789.01234567 -123456789.01234567 -123456789.01234567))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f32x4 -1.2345678901234569e+27 -1.2345678901234569e+27 -1.2345678901234569e+27 -1.2345678901234569e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f32x4 -1.2345678901234569e+27 -1.2345678901234569e+27 -1.2345678901234569e+27 -1.2345678901234569e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f32x4 -1.2345678901234568e-11 -1.2345678901234568e-11 -1.2345678901234568e-11 -1.2345678901234568e-11))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37))
+
+
+;; Mixed f32x4 tests when some lanes are NaNs
+(module
+
+  (func (export "f32x4_sqrt_arith") (result v128)
+    (f32x4.sqrt (v128.const f32x4 nan:0x200000 -nan:0x200000 16.0 25.0)))
+  (func (export "f32x4_sqrt_canon") (result v128)
+    (f32x4.sqrt (v128.const f32x4 -1.0 nan 4.0 9.0)))
+  (func (export "f32x4_sqrt_mixed") (result v128)
+    (f32x4.sqrt (v128.const f32x4 -inf nan:0x200000 36.0 49.0)))
+)
+
+(assert_return (invoke "f32x4_sqrt_arith") (v128.const f32x4 nan:arithmetic nan:arithmetic 4.0 5.0))
+(assert_return (invoke "f32x4_sqrt_canon") (v128.const f32x4 nan:canonical nan:canonical 2.0 3.0))
+(assert_return (invoke "f32x4_sqrt_mixed") (v128.const f32x4 nan:canonical nan:arithmetic 6.0 7.0))
+
+;; type check
+(assert_invalid (module (func (result v128) (f32x4.neg (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.sqrt (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.add (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.sub (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.mul (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.div (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.neg-arg-empty (result v128)
+      (f32x4.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.sqrt-arg-empty (result v128)
+      (f32x4.sqrt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.add-1st-arg-empty (result v128)
+      (f32x4.add (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.add-arg-empty (result v128)
+      (f32x4.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.sub-1st-arg-empty (result v128)
+      (f32x4.sub (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.sub-arg-empty (result v128)
+      (f32x4.sub)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.mul-1st-arg-empty (result v128)
+      (f32x4.mul (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.mul-arg-empty (result v128)
+      (f32x4.mul)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.div-1st-arg-empty (result v128)
+      (f32x4.div (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.div-arg-empty (result v128)
+      (f32x4.div)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (f32x4.add (f32x4.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-add") (param v128 v128 v128) (result v128)
+    (f32x4.div (f32x4.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-mul") (param v128 v128 v128) (result v128)
+    (f32x4.div (f32x4.mul (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-sub") (param v128 v128 v128) (result v128)
+    (f32x4.div (f32x4.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-add") (param v128 v128 v128) (result v128)
+    (f32x4.mul (f32x4.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-div") (param v128 v128 v128) (result v128)
+    (f32x4.mul (f32x4.div (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-sub") (param v128 v128 v128) (result v128)
+    (f32x4.mul (f32x4.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (f32x4.sub (f32x4.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (f32x4.add (f32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "add-sqrt") (param v128 v128) (result v128)
+    (f32x4.add (f32x4.sqrt (local.get 0)) (local.get 1)))
+  (func (export "div-neg") (param v128 v128) (result v128)
+    (f32x4.div (f32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "div-sqrt") (param v128 v128) (result v128)
+    (f32x4.div (f32x4.sqrt (local.get 0)) (local.get 1)))
+  (func (export "mul-neg") (param v128 v128) (result v128)
+    (f32x4.mul (f32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "mul-sqrt") (param v128 v128) (result v128)
+    (f32x4.mul (f32x4.sqrt (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (f32x4.sub (f32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-sqrt") (param v128 v128) (result v128)
+    (f32x4.sub (f32x4.sqrt (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "div-add" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 5.0 5.0 5.0 5.0))
+(assert_return (invoke "div-mul" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 4 4 4 4)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 18.0 18.0 18.0 18.0))
+(assert_return (invoke "div-sub" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 4.0 4.0 4.0 4.0))
+(assert_return (invoke "mul-add" (v128.const f32x4 1.25 1.25 1.25 1.25)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 0.375 0.375 0.375 0.375))
+(assert_return (invoke "mul-div" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 2.25 2.25 2.25 2.25))
+(assert_return (invoke "mul-sub" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+(assert_return (invoke "sub-add" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 1.25 1.25 1.25 1.25))
+(assert_return (invoke "add-neg" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+(assert_return (invoke "add-sqrt" (v128.const f32x4 2.25 2.25 2.25 2.25)
+                                  (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                  (v128.const f32x4 1.75 1.75 1.75 1.75))
+(assert_return (invoke "div-neg" (v128.const f32x4 1.5 1.5 1.5 1.5)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 -6 -6 -6 -6))
+(assert_return (invoke "div-sqrt" (v128.const f32x4 2.25 2.25 2.25 2.25)
+                                  (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                  (v128.const f32x4 6 6 6 6))
+(assert_return (invoke "mul-neg" (v128.const f32x4 1.5 1.5 1.5 1.5)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 -0.375 -0.375 -0.375 -0.375))
+(assert_return (invoke "mul-sqrt" (v128.const f32x4 2.25 2.25 2.25 2.25)
+                                  (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                  (v128.const f32x4 0.375 0.375 0.375 0.375))
+(assert_return (invoke "sub-neg" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 -1.25 -1.25 -1.25 -1.25))
+(assert_return (invoke "sub-sqrt" (v128.const f32x4 2.25 2.25 2.25 2.25)
+                                  (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                  (v128.const f32x4 1.25 1.25 1.25 1.25))
\ No newline at end of file
diff --git a/test/core/simd/simd_f32x4_cmp.wast b/test/core/simd/simd_f32x4_cmp.wast
new file mode 100644
index 000000000..9e9a8735b
--- /dev/null
+++ b/test/core/simd/simd_f32x4_cmp.wast
@@ -0,0 +1,8167 @@
+;; Test all the f32x4 comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (f32x4.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (f32x4.ne (local.get $x) (local.get $y)))
+  (func (export "lt") (param $x v128) (param $y v128) (result v128) (f32x4.lt (local.get $x) (local.get $y)))
+  (func (export "le") (param $x v128) (param $y v128) (result v128) (f32x4.le (local.get $x) (local.get $y)))
+  (func (export "gt") (param $x v128) (param $y v128) (result v128) (f32x4.gt (local.get $x) (local.get $y)))
+  (func (export "ge") (param $x v128) (param $y v128) (result v128) (f32x4.ge (local.get $x) (local.get $y)))
+)
+
+;; eq
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; ne
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+
+;; lt
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+
+;; le
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; gt
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+
+;; ge
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; eq
+
+;; f32x4.eq  (f32x4) (i8x16)
+(assert_return (invoke "eq" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 0 -1 0 0))
+
+;; f32x4.eq  (f32x4) (i16x8)
+(assert_return (invoke "eq" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 0 -1 0 0))
+
+;; f32x4.eq  (f32x4) (i32x4)
+(assert_return (invoke "eq" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 -1 -1 0 0 ))
+
+;; ne
+
+;; f32x4.ne  (f32x4) (i8x16)
+(assert_return (invoke "ne" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 -1 0 -1 -1))
+
+;; f32x4.ne  (f32x4) (i16x8)
+(assert_return (invoke "ne" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 -1 0 -1 -1))
+
+;; f32x4.ne  (f32x4) (i32x4)
+(assert_return (invoke "ne" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 0 0 -1 -1))
+
+;; lt
+
+;; f32x4.lt  (f32x4) (i8x16)
+(assert_return (invoke "lt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 0 0 0 0))
+
+;; f32x4.lt  (f32x4) (i16x8)
+(assert_return (invoke "lt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 0 0 0 0))
+
+;; f32x4.lt  (f32x4) (i32x4)
+(assert_return (invoke "lt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 0 0 0 0))
+
+;; le
+
+;; f32x4.le  (f32x4) (i8x16)
+(assert_return (invoke "le" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 0 -1 0 0))
+
+;; f32x4.le  (f32x4) (i16x8)
+(assert_return (invoke "le" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 0 -1 0 0))
+
+;; f32x4.le  (f32x4) (i32x4)
+(assert_return (invoke "le" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 -1 -1 0 0))
+
+;; gt
+
+;; f32x4.gt  (f32x4) (i8x16)
+(assert_return (invoke "gt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 0 0 -1 -1))
+
+;; f32x4.gt  (f32x4) (i16x8)
+(assert_return (invoke "gt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 0 0 -1 -1))
+
+;; f32x4.gt  (f32x4) (i32x4)
+(assert_return (invoke "gt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 0 0 -1 -1))
+
+;; ge
+
+;; f32x4.ge  (f32x4) (i8x16)
+(assert_return (invoke "ge" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 0 -1 -1 -1))
+
+;; f32x4.ge  (f32x4) (i16x8)
+(assert_return (invoke "ge" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 0 -1 -1 -1))
+
+;; f32x4.ge  (f32x4) (i32x4)
+(assert_return (invoke "ge" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (f32x4.eq (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.ge (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.gt (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.le (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.lt (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.ne (i64.const 0) (f64.const 0)))) "type mismatch")
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.eq (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.ge (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.gt (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.le (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.lt (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.ne (local.get $x) (local.get $y)))") "unknown operator")
+
+
+;; Combination
+
+(module (memory 1)
+  (func (export "eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "lt-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.lt
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "le-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.le
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "gt-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.gt
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ge-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.ge
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-eq")
+    (drop
+      (f32x4.eq
+        (f32x4.eq
+          (f32x4.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.eq
+          (f32x4.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ne")
+    (drop
+      (f32x4.ne
+        (f32x4.ne
+          (f32x4.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.ne
+          (f32x4.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-lt")
+    (drop
+      (f32x4.lt
+        (f32x4.lt
+          (f32x4.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.lt
+          (f32x4.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-le")
+    (drop
+      (f32x4.le
+        (f32x4.le
+          (f32x4.le
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.le
+          (f32x4.le
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-gt")
+    (drop
+      (f32x4.gt
+        (f32x4.gt
+          (f32x4.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.gt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.gt
+          (f32x4.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.gt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ge")
+    (drop
+      (f32x4.ge
+        (f32x4.ge
+          (f32x4.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ge
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.ge
+          (f32x4.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ge
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (f32x4.ge
+        (f32x4.eq
+          (f32x4.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.ne
+          (f32x4.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+
+(assert_return (invoke "eq-in-block"))
+(assert_return (invoke "ne-in-block"))
+(assert_return (invoke "lt-in-block"))
+(assert_return (invoke "le-in-block"))
+(assert_return (invoke "gt-in-block"))
+(assert_return (invoke "ge-in-block"))
+(assert_return (invoke "nested-eq"))
+(assert_return (invoke "nested-ne"))
+(assert_return (invoke "nested-lt"))
+(assert_return (invoke "nested-le"))
+(assert_return (invoke "nested-gt"))
+(assert_return (invoke "nested-ge"))
+(assert_return (invoke "as-param"))
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.eq-1st-arg-empty (result v128)
+      (f32x4.eq (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.eq-arg-empty (result v128)
+      (f32x4.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.ne-1st-arg-empty (result v128)
+      (f32x4.ne (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.ne-arg-empty (result v128)
+      (f32x4.ne)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.lt-1st-arg-empty (result v128)
+      (f32x4.lt (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.lt-arg-empty (result v128)
+      (f32x4.lt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.le-1st-arg-empty (result v128)
+      (f32x4.le (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.le-arg-empty (result v128)
+      (f32x4.le)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.gt-1st-arg-empty (result v128)
+      (f32x4.gt (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.gt-arg-empty (result v128)
+      (f32x4.gt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.ge-1st-arg-empty (result v128)
+      (f32x4.ge (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.ge-arg-empty (result v128)
+      (f32x4.ge)
+    )
+  )
+  "type mismatch"
+)
\ No newline at end of file
diff --git a/test/core/simd/simd_f32x4_pmin_pmax.wast b/test/core/simd/simd_f32x4_pmin_pmax.wast
new file mode 100644
index 000000000..b0f47b380
--- /dev/null
+++ b/test/core/simd/simd_f32x4_pmin_pmax.wast
@@ -0,0 +1,11676 @@
+;; Tests for f32x4 [pmin, pmax] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f32x4.pmin") (param v128 v128) (result v128) (f32x4.pmin (local.get 0) (local.get 1)))
+  (func (export "f32x4.pmax") (param v128 v128) (result v128) (f32x4.pmax (local.get 0) (local.get 1)))
+)
+
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f32x4.pmin (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.pmax (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.pmin-1st-arg-empty (result v128)
+      (f32x4.pmin (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.pmin-arg-empty (result v128)
+      (f32x4.pmin)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.pmax-1st-arg-empty (result v128)
+      (f32x4.pmax (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.pmax-arg-empty (result v128)
+      (f32x4.pmax)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_f32x4_rounding.wast b/test/core/simd/simd_f32x4_rounding.wast
new file mode 100644
index 000000000..e59f99a77
--- /dev/null
+++ b/test/core/simd/simd_f32x4_rounding.wast
@@ -0,0 +1,424 @@
+;; Tests for f32x4 [ceil, floor, trunc, nearest] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f32x4.ceil") (param v128) (result v128) (f32x4.ceil (local.get 0)))
+  (func (export "f32x4.floor") (param v128) (result v128) (f32x4.floor (local.get 0)))
+  (func (export "f32x4.trunc") (param v128) (result v128) (f32x4.trunc (local.get 0)))
+  (func (export "f32x4.nearest") (param v128) (result v128) (f32x4.nearest (local.get 0)))
+)
+
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.c000000000000p+2 0x1.c000000000000p+2 0x1.c000000000000p+2 0x1.c000000000000p+2))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 123456790.0 123456790.0 123456790.0 123456790.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 156374987062.0 156374987062.0 156374987062.0 156374987062.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 156374987062.0 156374987062.0 156374987062.0 156374987062.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 156374987062.0 156374987062.0 156374987062.0 156374987062.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                     (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                     (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                     (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                     (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                     (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                     (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                     (v128.const f32x4 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                     (v128.const f32x4 -0x1.c000000000000p+2 -0x1.c000000000000p+2 -0x1.c000000000000p+2 -0x1.c000000000000p+2))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                     (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                     (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 inf inf inf inf))
+                                     (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -inf -inf -inf -inf))
+                                     (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                     (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                     (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 nan nan nan nan))
+                                     (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -nan -nan -nan -nan))
+                                     (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                     (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                     (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                     (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                     (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                     (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                     (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                     (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                     (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                     (v128.const f32x4 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                     (v128.const f32x4 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                     (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                     (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 inf inf inf inf))
+                                     (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -inf -inf -inf -inf))
+                                     (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                     (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                     (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 nan nan nan nan))
+                                     (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -nan -nan -nan -nan))
+                                     (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                     (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                     (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                       (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                       (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                       (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                       (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                       (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                       (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                       (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                       (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                       (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                       (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                       (v128.const f32x4 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                       (v128.const f32x4 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                       (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                       (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 inf inf inf inf))
+                                       (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -inf -inf -inf -inf))
+                                       (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                       (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                       (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                       (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                       (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                       (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                       (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                       (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                       (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                       (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                       (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                       (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                       (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                       (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                       (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                       (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                       (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                       (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                       (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 nan nan nan nan))
+                                       (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -nan -nan -nan -nan))
+                                       (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                       (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                       (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f32x4.ceil (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.floor (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.trunc (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.nearest (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.ceil-arg-empty (result v128)
+      (f32x4.ceil)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.floor-arg-empty (result v128)
+      (f32x4.floor)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.trunc-arg-empty (result v128)
+      (f32x4.trunc)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.nearest-arg-empty (result v128)
+      (f32x4.nearest)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_f64x2.wast b/test/core/simd/simd_f64x2.wast
new file mode 100644
index 000000000..8ebd33b36
--- /dev/null
+++ b/test/core/simd/simd_f64x2.wast
@@ -0,0 +1,2459 @@
+;; Tests for f64x2 [abs, min, max] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f64x2.min") (param v128 v128) (result v128) (f64x2.min (local.get 0) (local.get 1)))
+  (func (export "f64x2.max") (param v128 v128) (result v128) (f64x2.max (local.get 0) (local.get 1)))
+  (func (export "f64x2.abs") (param v128) (result v128) (f64x2.abs (local.get 0)))
+  ;; f64x2.min const vs const
+  (func (export "f64x2.min_with_const_0") (result v128) (f64x2.min (v128.const f64x2 0 1) (v128.const f64x2 0 2)))
+  (func (export "f64x2.min_with_const_1") (result v128) (f64x2.min (v128.const f64x2 2 -3) (v128.const f64x2 1 3)))
+  (func (export "f64x2.min_with_const_2") (result v128) (f64x2.min (v128.const f64x2 0 1) (v128.const f64x2 0 1)))
+  (func (export "f64x2.min_with_const_3") (result v128) (f64x2.min (v128.const f64x2 2 3) (v128.const f64x2 2 3)))
+  (func (export "f64x2.min_with_const_4") (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x02)))
+  (func (export "f64x2.min_with_const_5") (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x01 2147483648)))
+  (func (export "f64x2.min_with_const_6") (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x01)))
+  (func (export "f64x2.min_with_const_7") (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x02 0x80000000)))
+  ;; f64x2.min param vs const
+  (func (export "f64x2.min_with_const_9") (param v128) (result v128) (f64x2.min (local.get 0) (v128.const f64x2 0 1)))
+  (func (export "f64x2.min_with_const_10") (param v128) (result v128) (f64x2.min (v128.const f64x2 2 -3) (local.get 0)))
+  (func (export "f64x2.min_with_const_11") (param v128) (result v128) (f64x2.min (v128.const f64x2 0 1) (local.get 0)))
+  (func (export "f64x2.min_with_const_12") (param v128) (result v128) (f64x2.min (local.get 0) (v128.const f64x2 2 3)))
+  (func (export "f64x2.min_with_const_13") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.min_with_const_14") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+  (func (export "f64x2.min_with_const_15") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.min_with_const_16") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+  ;; f64x2.max const vs const
+  (func (export "f64x2.max_with_const_18") (result v128) (f64x2.max (v128.const f64x2 0 1) (v128.const f64x2 0 2)))
+  (func (export "f64x2.max_with_const_19") (result v128) (f64x2.max (v128.const f64x2 2 -3) (v128.const f64x2 1 3)))
+  (func (export "f64x2.max_with_const_20") (result v128) (f64x2.max (v128.const f64x2 0 1) (v128.const f64x2 0 1)))
+  (func (export "f64x2.max_with_const_21") (result v128) (f64x2.max (v128.const f64x2 2 3) (v128.const f64x2 2 3)))
+  (func (export "f64x2.max_with_const_22") (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x02)))
+  (func (export "f64x2.max_with_const_23") (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x01 2147483648)))
+  (func (export "f64x2.max_with_const_24") (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x01)))
+  (func (export "f64x2.max_with_const_25") (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x02 0x80000000)))
+  ;; f64x2.max param vs const
+  (func (export "f64x2.max_with_const_27") (param v128) (result v128) (f64x2.max (local.get 0) (v128.const f64x2 0 1)))
+  (func (export "f64x2.max_with_const_28") (param v128) (result v128) (f64x2.max (v128.const f64x2 2 -3) (local.get 0)))
+  (func (export "f64x2.max_with_const_29") (param v128) (result v128) (f64x2.max (v128.const f64x2 0 1) (local.get 0)))
+  (func (export "f64x2.max_with_const_30") (param v128) (result v128) (f64x2.max (local.get 0) (v128.const f64x2 2 3)))
+  (func (export "f64x2.max_with_const_31") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.max_with_const_32") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+  (func (export "f64x2.max_with_const_33") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.max_with_const_34") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+
+  (func (export "f64x2.abs_with_const_35") (result v128) (f64x2.abs (v128.const f64x2 -0 -1)))
+  (func (export "f64x2.abs_with_const_36") (result v128) (f64x2.abs (v128.const f64x2 -2 -3)))
+)
+
+;; f64x2.min const vs const
+(assert_return (invoke "f64x2.min_with_const_0") (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.min_with_const_1") (v128.const f64x2 1 -3))
+(assert_return (invoke "f64x2.min_with_const_2") (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.min_with_const_3") (v128.const f64x2 2 3))
+;; f64x2.min param vs const
+(assert_return (invoke "f64x2.min_with_const_4") (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.min_with_const_5") (v128.const f64x2 0x01 0x80000000))
+(assert_return (invoke "f64x2.min_with_const_6") (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.min_with_const_7") (v128.const f64x2 0x02 0x80000000))
+(assert_return (invoke "f64x2.min_with_const_9" (v128.const f64x2 0 2))
+                                                (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.min_with_const_10" (v128.const f64x2 1 3))
+                                                 (v128.const f64x2 1 -3))
+(assert_return (invoke "f64x2.min_with_const_11" (v128.const f64x2 0 1))
+                                                 (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.min_with_const_12" (v128.const f64x2 2 3))
+                                                 (v128.const f64x2 2 3))
+(assert_return (invoke "f64x2.min_with_const_13" (v128.const f64x2 0x00 0x02))
+                                                 (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.min_with_const_14" (v128.const f64x2 0x01 2147483648))
+                                                 (v128.const f64x2 0x01 0x80000000))
+(assert_return (invoke "f64x2.min_with_const_15" (v128.const f64x2 0x00 0x01))
+                                                 (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.min_with_const_16" (v128.const f64x2 0x02 0x80000000))
+                                                 (v128.const f64x2 0x02 0x80000000))
+;; f64x2.max const vs const
+(assert_return (invoke "f64x2.max_with_const_18") (v128.const f64x2 0 2))
+(assert_return (invoke "f64x2.max_with_const_19") (v128.const f64x2 2 3))
+(assert_return (invoke "f64x2.max_with_const_20") (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.max_with_const_21") (v128.const f64x2 2 3))
+;; f64x2.max param vs const
+(assert_return (invoke "f64x2.max_with_const_22") (v128.const f64x2 0x00 0x02))
+(assert_return (invoke "f64x2.max_with_const_23") (v128.const f64x2 0x02 2147483648))
+(assert_return (invoke "f64x2.max_with_const_24") (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.max_with_const_25") (v128.const f64x2 0x02 0x80000000))
+(assert_return (invoke "f64x2.max_with_const_27" (v128.const f64x2 0 2))
+                                                 (v128.const f64x2 0 2))
+(assert_return (invoke "f64x2.max_with_const_28" (v128.const f64x2 1 3))
+                                                 (v128.const f64x2 2 3))
+(assert_return (invoke "f64x2.max_with_const_29" (v128.const f64x2 0 1))
+                                                 (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.max_with_const_30" (v128.const f64x2 2 3))
+                                                 (v128.const f64x2 2 3))
+(assert_return (invoke "f64x2.max_with_const_31" (v128.const f64x2 0x00 0x02))
+                                                 (v128.const f64x2 0x00 0x02))
+(assert_return (invoke "f64x2.max_with_const_32" (v128.const f64x2 0x01 2147483648))
+                                                 (v128.const f64x2 0x02 2147483648))
+(assert_return (invoke "f64x2.max_with_const_33" (v128.const f64x2 0x00 0x01))
+                                                 (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.max_with_const_34" (v128.const f64x2 0x02 0x80000000))
+                                                 (v128.const f64x2 0x02 0x80000000))
+
+(assert_return (invoke "f64x2.abs_with_const_35") (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.abs_with_const_36") (v128.const f64x2 2 3))
+
+;; Test different lanes go through different if-then clauses
+;; f64x2.min
+(assert_return
+  (invoke "f64x2.min"
+    (v128.const f64x2 nan 0)
+    (v128.const f64x2 0 1)
+  )
+  (v128.const f64x2 nan:canonical 0)
+)
+;; f64x2.min
+(assert_return
+  (invoke "f64x2.min"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 0)
+  )
+  (v128.const f64x2 nan:canonical 0)
+)
+;; f64x2.min
+(assert_return
+  (invoke "f64x2.min"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 1)
+  )
+  (v128.const f64x2 nan:canonical 1)
+)
+;; f64x2.max
+(assert_return
+  (invoke "f64x2.max"
+    (v128.const f64x2 nan 0)
+    (v128.const f64x2 0 1)
+  )
+  (v128.const f64x2 nan:canonical 1)
+)
+;; f64x2.max
+(assert_return
+  (invoke "f64x2.max"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 0)
+  )
+  (v128.const f64x2 nan:canonical 1)
+)
+;; f64x2.max
+(assert_return
+  (invoke "f64x2.max"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 1)
+  )
+  (v128.const f64x2 nan:canonical 1)
+)
+
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+
+;; Test opposite signs of zero
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0 0)
+                                   (v128.const f64x2 +0 -0))
+                                   (v128.const f64x2 0 -0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0 +0)
+                                   (v128.const f64x2 +0 -0))
+                                   (v128.const f64x2 -0 -0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0 -0)
+                                   (v128.const f64x2 +0 +0))
+                                   (v128.const f64x2 -0 -0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0 0)
+                                   (v128.const f64x2 +0 -0))
+                                   (v128.const f64x2 0 0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0 +0)
+                                   (v128.const f64x2 +0 -0))
+                                   (v128.const f64x2 0 0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0 -0)
+                                   (v128.const f64x2 +0 +0))
+                                   (v128.const f64x2 +0 +0))
+
+
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+
+;; type check
+(assert_invalid (module (func (result v128) (f64x2.abs (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.min (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.max (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f64x2.abs-arg-empty (result v128)
+      (f64x2.abs)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.min-1st-arg-empty (result v128)
+      (f64x2.min (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.min-arg-empty (result v128)
+      (f64x2.min)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.max-1st-arg-empty (result v128)
+      (f64x2.max (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.max-arg-empty (result v128)
+      (f64x2.max)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "max-min") (param v128 v128 v128) (result v128)
+    (f64x2.max (f64x2.min (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "min-max") (param v128 v128 v128) (result v128)
+    (f64x2.min (f64x2.max (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "max-abs") (param v128 v128) (result v128)
+    (f64x2.max (f64x2.abs (local.get 0)) (local.get 1)))
+  (func (export "min-abs") (param v128 v128) (result v128)
+    (f64x2.min (f64x2.abs (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "max-min" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 0.25 0.25))
+(assert_return (invoke "min-max" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 0.125 0.125))
+(assert_return (invoke "max-abs" (v128.const f64x2 -1.125 -1.125)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 1.125 1.125))
+(assert_return (invoke "min-abs" (v128.const f64x2 -1.125 -1.125)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 0.125 0.125))
\ No newline at end of file
diff --git a/test/core/simd/simd_f64x2_arith.wast b/test/core/simd/simd_f64x2_arith.wast
new file mode 100644
index 000000000..4ab3b01e9
--- /dev/null
+++ b/test/core/simd/simd_f64x2_arith.wast
@@ -0,0 +1,5483 @@
+;; Tests for f64x2 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f64x2.add") (param v128 v128) (result v128) (f64x2.add (local.get 0) (local.get 1)))
+  (func (export "f64x2.sub") (param v128 v128) (result v128) (f64x2.sub (local.get 0) (local.get 1)))
+  (func (export "f64x2.mul") (param v128 v128) (result v128) (f64x2.mul (local.get 0) (local.get 1)))
+  (func (export "f64x2.div") (param v128 v128) (result v128) (f64x2.div (local.get 0) (local.get 1)))
+  (func (export "f64x2.neg") (param v128) (result v128) (f64x2.neg (local.get 0)))
+  (func (export "f64x2.sqrt") (param v128) (result v128) (f64x2.sqrt (local.get 0)))
+)
+
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1021 0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1021 -0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.b21fb54442d18p+2 0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.721fb54442d18p+2 -0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.721fb54442d18p+2 0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.b21fb54442d18p+2 -0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.d21fb54442d18p+2 0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.521fb54442d18p+2 -0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.521fb54442d18p+2 0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.d21fb54442d18p+2 -0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.b21fb54442d18p+2 0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.721fb54442d18p+2 0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.d21fb54442d18p+2 0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.521fb54442d18p+2 0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+3 0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.721fb54442d18p+2 -0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.b21fb54442d18p+2 -0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.521fb54442d18p+2 -0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.d21fb54442d18p+2 -0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+3 -0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789 0123456789)
+                                   (v128.const f64x2 0123456789 0123456789))
+                                   (v128.const f64x2 246913578.0 246913578.0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789e019 0123456789e019)
+                                   (v128.const f64x2 0123456789e019 0123456789e019))
+                                   (v128.const f64x2 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                   (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                   (v128.const f64x2 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                   (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                   (v128.const f64x2 2.46913578e-11 2.46913578e-11))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789. 0123456789.)
+                                   (v128.const f64x2 0123456789. 0123456789.))
+                                   (v128.const f64x2 246913578.0 246913578.0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                   (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                   (v128.const f64x2 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f64x2 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f64x2 2.46913578e-11 2.46913578e-11))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f64x2 246913578.02469134 246913578.02469134))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f64x2 2.4691357802469137e+27 2.4691357802469137e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f64x2 2.4691357802469137e+27 2.4691357802469137e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f64x2 2.4691357802469137e-11 2.4691357802469137e-11))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.23456789abcdfp+81 0x1.23456789abcdfp+81))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+62 0x1.23456789abcdfp+62))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                   (v128.const f64x2 0x1.23456789abcdfp+81 0x1.23456789abcdfp+81))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+62 0x1.23456789abcdfp+62))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.23456789abcdfp+81 0x1.23456789abcdfp+81))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+62 0x1.23456789abcdfp+62))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1021 0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.fffffffffffffp-1022 0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.fffffffffffffp-1022 0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1021 -0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000001p-1022 -0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000001p-1022 -0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.721fb54442d18p+2 -0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.b21fb54442d18p+2 0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.b21fb54442d18p+2 -0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.721fb54442d18p+2 0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.521fb54442d18p+2 -0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.d21fb54442d18p+2 0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.d21fb54442d18p+2 -0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.521fb54442d18p+2 0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.721fb54442d18p+2 0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.b21fb54442d18p+2 0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.521fb54442d18p+2 0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.d21fb54442d18p+2 0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+3 0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.b21fb54442d18p+2 -0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.721fb54442d18p+2 -0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.d21fb54442d18p+2 -0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.521fb54442d18p+2 -0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+3 -0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789 0123456789)
+                                   (v128.const f64x2 0123456789 0123456789))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789e019 0123456789e019)
+                                   (v128.const f64x2 0123456789e019 0123456789e019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                   (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                   (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789. 0123456789.)
+                                   (v128.const f64x2 0123456789. 0123456789.))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                   (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.8000000000000p-1022 0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.8000000000000p-1022 -0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p-1020 0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p-1020 -0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1 0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1 -0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.8000000000000p-1022 -0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.8000000000000p-1022 0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p-1020 -0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p-1020 0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1 -0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1 0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.8000000000000p-1022 0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.8000000000000p-1022 -0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-2 0x1.0000000000000p-2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-2 -0x1.0000000000000p-2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+1 0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+1 -0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1022 0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1022 -0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.8000000000000p-1022 -0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.8000000000000p-1022 0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-2 -0x1.0000000000000p-2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-2 0x1.0000000000000p-2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+1 -0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+1 0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1022 -0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1022 0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p-1020 0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p-1020 -0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+1 0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+1 -0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.3bd3cc9be45dep+5 0x1.3bd3cc9be45dep+5))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.3bd3cc9be45dep+5 -0x1.3bd3cc9be45dep+5))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000006p-1022 0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000006p-1022 0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p-1020 -0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p-1020 0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+1 -0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+1 0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.3bd3cc9be45dep+5 -0x1.3bd3cc9be45dep+5))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.3bd3cc9be45dep+5 0x1.3bd3cc9be45dep+5))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000006p-1022 -0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000006p-1022 -0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1 0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1 -0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1022 0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1022 -0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp-51 0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp-51 0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1 -0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1 0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1022 -0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1022 0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp-51 -0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp-51 -0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0000000000006p-1022 0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0000000000006p-1022 -0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp-51 0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp-51 -0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0000000000006p-1022 0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0000000000006p-1022 -0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp-51 0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp-51 -0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789 0123456789)
+                                   (v128.const f64x2 0123456789 0123456789))
+                                   (v128.const f64x2 1.524157875019052e+16 1.524157875019052e+16))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789e019 0123456789e019)
+                                   (v128.const f64x2 0123456789e019 0123456789e019))
+                                   (v128.const f64x2 1.524157875019052e+54 1.524157875019052e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                   (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                   (v128.const f64x2 1.524157875019052e+54 1.524157875019052e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                   (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                   (v128.const f64x2 1.524157875019052e-22 1.524157875019052e-22))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789. 0123456789.)
+                                   (v128.const f64x2 0123456789. 0123456789.))
+                                   (v128.const f64x2 1.524157875019052e+16 1.524157875019052e+16))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                   (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                   (v128.const f64x2 1.524157875019052e+54 1.524157875019052e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f64x2 1.524157875019052e+54 1.524157875019052e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f64x2 1.524157875019052e-22 1.524157875019052e-22))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f64x2 1.5241578753238834e+16 1.5241578753238834e+16))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f64x2 1.5241578753238838e+54 1.5241578753238838e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f64x2 1.5241578753238838e+54 1.5241578753238838e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f64x2 1.524157875323884e-22 1.524157875323884e-22))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+160 0x1.4b66dc33f6acep+160))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+122 0x1.4b66dc33f6acep+122))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+160 0x1.4b66dc33f6acep+160))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+122 0x1.4b66dc33f6acep+122))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+160 0x1.4b66dc33f6acep+160))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+122 0x1.4b66dc33f6acep+122))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1021 0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1021 -0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.28be60db93910p-1022 0x0.28be60db93910p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.28be60db93910p-1022 -0x0.28be60db93910p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+52 0x1.0000000000000p+52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+52 0x1.0000000000000p+52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1021 -0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1021 0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.28be60db93910p-1022 -0x0.28be60db93910p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.28be60db93910p-1022 0x0.28be60db93910p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+52 -0x1.0000000000000p+52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+52 -0x1.0000000000000p+52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+1021 0x1.0000000000000p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+1021 -0x1.0000000000000p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c883p-4 0x1.45f306dc9c883p-4))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c883p-4 -0x1.45f306dc9c883p-4))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.2000000000000p-1022 0x0.2000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.2000000000000p-1022 -0x0.2000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+1021 -0x1.0000000000000p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+1021 0x1.0000000000000p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c883p-4 -0x1.45f306dc9c883p-4))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c883p-4 0x1.45f306dc9c883p-4))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.2000000000000p-1022 -0x0.2000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.2000000000000p-1022 0x0.2000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+1022 0x1.0000000000000p+1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+1022 -0x1.0000000000000p+1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c883p-3 0x1.45f306dc9c883p-3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c883p-3 -0x1.45f306dc9c883p-3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.4000000000000p-1022 0x0.4000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.4000000000000p-1022 -0x0.4000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+1022 -0x1.0000000000000p+1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+1022 0x1.0000000000000p+1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c883p-3 -0x1.45f306dc9c883p-3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c883p-3 0x1.45f306dc9c883p-3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.4000000000000p-1022 -0x0.4000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.4000000000000p-1022 0x0.4000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+3 0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+3 -0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.921fb54442d19p-1022 0x1.921fb54442d19p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.921fb54442d19p-1022 -0x1.921fb54442d19p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+3 -0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+3 0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.921fb54442d19p-1022 -0x1.921fb54442d19p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.921fb54442d19p-1022 0x1.921fb54442d19p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c882p+1021 0x1.45f306dc9c882p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c882p+1021 -0x1.45f306dc9c882p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c882p+1021 -0x1.45f306dc9c882p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c882p+1021 0x1.45f306dc9c882p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-52 0x1.0000000000000p-52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-52 -0x1.0000000000000p-52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-52 0x1.0000000000000p-52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-52 -0x1.0000000000000p-52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789 0123456789)
+                                   (v128.const f64x2 0123456789 0123456789))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789e019 0123456789e019)
+                                   (v128.const f64x2 0123456789e019 0123456789e019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                   (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                   (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789. 0123456789.)
+                                   (v128.const f64x2 0123456789. 0123456789.))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                   (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-511 0x1.0000000000000p-511))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.6a09e667f3bcdp-1 0x1.6a09e667f3bcdp-1))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.40d931ff62705p+1 0x1.40d931ff62705p+1))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+511 0x1.fffffffffffffp+511))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-537 0x1.0000000000000p-537))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-537 0x1.0000000000000p-537))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 11111.111060555555 11111.111060555555))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 3.5136418286444623e-06 3.5136418286444623e-06))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 11111.111060555555 11111.111060555555))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 3.5136418286444623e-06 3.5136418286444623e-06))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 11111.11106111111 11111.11106111111))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 35136418288201.445 35136418288201.445))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 35136418288201.445 35136418288201.445))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 3.513641828820144e-06 3.513641828820144e-06))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.1111111111111p+40 0x1.1111111111111p+40))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+30 0x1.822cb17ff2eb8p+30))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.1111111111111p+40 0x1.1111111111111p+40))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+30 0x1.822cb17ff2eb8p+30))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.1111111111111p+40 0x1.1111111111111p+40))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+30 0x1.822cb17ff2eb8p+30))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789 0123456789))
+                                   (v128.const f64x2 -123456789.0 -123456789.0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789e019 0123456789e019))
+                                   (v128.const f64x2 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                   (v128.const f64x2 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                   (v128.const f64x2 -1.23456789e-11 -1.23456789e-11))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789. 0123456789.))
+                                   (v128.const f64x2 -123456789.0 -123456789.0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                   (v128.const f64x2 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f64x2 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f64x2 -1.23456789e-11 -1.23456789e-11))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f64x2 -123456789.01234567 -123456789.01234567))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f64x2 -1.2345678901234569e+27 -1.2345678901234569e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f64x2 -1.2345678901234569e+27 -1.2345678901234569e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f64x2 -1.2345678901234568e-11 -1.2345678901234568e-11))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+80 -0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+61 -0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+80 -0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+61 -0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+80 -0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+61 -0x1.23456789abcdfp+61))
+
+;; Mixed f64x2 tests when some lanes are NaNs
+(module
+  (func (export "f64x2_add_arith") (result v128)
+    (f64x2.add (v128.const f64x2 nan:0x8000000000000 1.0) (v128.const f64x2 nan 1.0)))
+  (func (export "f64x2_div_mixed") (result v128)
+    (f64x2.div (v128.const f64x2 nan 1.0) (v128.const f64x2 2.0 -nan:0x8000000000000)))
+  (func (export "f64x2_mul_mixed") (result v128)
+    (f64x2.mul (v128.const f64x2 nan:0x8000000000000 1.0) (v128.const f64x2 2.0 nan)))
+  (func (export "f64x2_neg_canon") (result v128)
+    (f64x2.neg (v128.const f64x2 nan 1.0)))
+  (func (export "f64x2_sqrt_canon") (result v128)
+    (f64x2.sqrt (v128.const f64x2 4.0 -nan)))
+  (func (export "f64x2_sub_arith") (result v128)
+    (f64x2.sub (v128.const f64x2 1.0 -1.0) (v128.const f64x2 -nan 1.0)))
+)
+
+(assert_return (invoke "f64x2_add_arith") (v128.const f64x2 nan:arithmetic 2.0))
+(assert_return (invoke "f64x2_div_mixed") (v128.const f64x2 nan:canonical nan:arithmetic))
+(assert_return (invoke "f64x2_mul_mixed") (v128.const f64x2 nan:arithmetic nan:canonical))
+(assert_return (invoke "f64x2_neg_canon") (v128.const f64x2 nan:canonical -1.0))
+(assert_return (invoke "f64x2_sqrt_canon") (v128.const f64x2 2.0 nan:canonical))
+(assert_return (invoke "f64x2_sub_arith") (v128.const f64x2 nan:canonical -2.0))
+
+;; type check
+(assert_invalid (module (func (result v128) (f64x2.neg (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.sqrt (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.add (i64.const 0) (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.sub (i64.const 0) (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.mul (i64.const 0) (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.div (i64.const 0) (f64.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f64x2.neg-arg-empty (result v128)
+      (f64x2.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.sqrt-arg-empty (result v128)
+      (f64x2.sqrt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.add-1st-arg-empty (result v128)
+      (f64x2.add (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.add-arg-empty (result v128)
+      (f64x2.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.sub-1st-arg-empty (result v128)
+      (f64x2.sub (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.sub-arg-empty (result v128)
+      (f64x2.sub)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.mul-1st-arg-empty (result v128)
+      (f64x2.mul (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.mul-arg-empty (result v128)
+      (f64x2.mul)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.div-1st-arg-empty (result v128)
+      (f64x2.div (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.div-arg-empty (result v128)
+      (f64x2.div)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (f64x2.add (f64x2.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-add") (param v128 v128 v128) (result v128)
+    (f64x2.div (f64x2.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-mul") (param v128 v128 v128) (result v128)
+    (f64x2.div (f64x2.mul (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-sub") (param v128 v128 v128) (result v128)
+    (f64x2.div (f64x2.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-add") (param v128 v128 v128) (result v128)
+    (f64x2.mul (f64x2.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-div") (param v128 v128 v128) (result v128)
+    (f64x2.mul (f64x2.div (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-sub") (param v128 v128 v128) (result v128)
+    (f64x2.mul (f64x2.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (f64x2.sub (f64x2.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (f64x2.add (f64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "add-sqrt") (param v128 v128) (result v128)
+    (f64x2.add (f64x2.sqrt (local.get 0)) (local.get 1)))
+  (func (export "div-neg") (param v128 v128) (result v128)
+    (f64x2.div (f64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "div-sqrt") (param v128 v128) (result v128)
+    (f64x2.div (f64x2.sqrt (local.get 0)) (local.get 1)))
+  (func (export "mul-neg") (param v128 v128) (result v128)
+    (f64x2.mul (f64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "mul-sqrt") (param v128 v128) (result v128)
+    (f64x2.mul (f64x2.sqrt (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (f64x2.sub (f64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-sqrt") (param v128 v128) (result v128)
+    (f64x2.sub (f64x2.sqrt (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "div-add" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 5.0 5.0))
+(assert_return (invoke "div-mul" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 4 4)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 18.0 18.0))
+(assert_return (invoke "div-sub" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 4.0 4.0))
+(assert_return (invoke "mul-add" (v128.const f64x2 1.25 1.25)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 0.375 0.375))
+(assert_return (invoke "mul-div" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 2.25 2.25))
+(assert_return (invoke "mul-sub" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 0.25 0.25))
+(assert_return (invoke "sub-add" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 1.25 1.25))
+(assert_return (invoke "add-neg" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 -1.0 -1.0))
+(assert_return (invoke "add-sqrt" (v128.const f64x2 2.25 2.25)
+                                  (v128.const f64x2 0.25 0.25))
+                                  (v128.const f64x2 1.75 1.75))
+(assert_return (invoke "div-neg" (v128.const f64x2 1.5 1.5)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 -6 -6))
+(assert_return (invoke "div-sqrt" (v128.const f64x2 2.25 2.25)
+                                  (v128.const f64x2 0.25 0.25))
+                                  (v128.const f64x2 6 6))
+(assert_return (invoke "mul-neg" (v128.const f64x2 1.5 1.5)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 -0.375 -0.375))
+(assert_return (invoke "mul-sqrt" (v128.const f64x2 2.25 2.25)
+                                  (v128.const f64x2 0.25 0.25))
+                                  (v128.const f64x2 0.375 0.375))
+(assert_return (invoke "sub-neg" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 -1.25 -1.25))
+(assert_return (invoke "sub-sqrt" (v128.const f64x2 2.25 2.25)
+                                  (v128.const f64x2 0.25 0.25))
+                                  (v128.const f64x2 1.25 1.25))
\ No newline at end of file
diff --git a/test/core/simd/simd_f64x2_cmp.wast b/test/core/simd/simd_f64x2_cmp.wast
new file mode 100644
index 000000000..cab815ea5
--- /dev/null
+++ b/test/core/simd/simd_f64x2_cmp.wast
@@ -0,0 +1,8337 @@
+;; Tests for f64x2 comparison operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f64x2.eq") (param v128 v128) (result v128) (f64x2.eq (local.get 0) (local.get 1)))
+  (func (export "f64x2.ne") (param v128 v128) (result v128) (f64x2.ne (local.get 0) (local.get 1)))
+  (func (export "f64x2.lt") (param v128 v128) (result v128) (f64x2.lt (local.get 0) (local.get 1)))
+  (func (export "f64x2.le") (param v128 v128) (result v128) (f64x2.le (local.get 0) (local.get 1)))
+  (func (export "f64x2.gt") (param v128 v128) (result v128) (f64x2.gt (local.get 0) (local.get 1)))
+  (func (export "f64x2.ge") (param v128 v128) (result v128) (f64x2.ge (local.get 0) (local.get 1)))
+)
+
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+
+
+;; unknown operators
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.eq (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.ne (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.lt (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.le (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.gt (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.ge (local.get $x) (local.get $y)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f64x2.eq (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.ne (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.lt (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.le (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.gt (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.ge (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f64x2.eq-1st-arg-empty (result v128)
+      (f64x2.eq (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.eq-arg-empty (result v128)
+      (f64x2.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.ne-1st-arg-empty (result v128)
+      (f64x2.ne (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.ne-arg-empty (result v128)
+      (f64x2.ne)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.lt-1st-arg-empty (result v128)
+      (f64x2.lt (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.lt-arg-empty (result v128)
+      (f64x2.lt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.le-1st-arg-empty (result v128)
+      (f64x2.le (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.le-arg-empty (result v128)
+      (f64x2.le)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.gt-1st-arg-empty (result v128)
+      (f64x2.gt (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.gt-arg-empty (result v128)
+      (f64x2.gt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.ge-1st-arg-empty (result v128)
+      (f64x2.ge (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.ge-arg-empty (result v128)
+      (f64x2.ge)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module (memory 1)
+  (func (export "f64x2.eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "f64x2.ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "f64x2.lt-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.lt
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "f64x2.le-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.le
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "f64x2.gt-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.gt
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "f64x2.ge-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.ge
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.eq")
+    (drop
+      (f64x2.eq
+        (f64x2.eq
+          (f64x2.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.eq
+          (f64x2.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.ne")
+    (drop
+      (f64x2.ne
+        (f64x2.ne
+          (f64x2.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.ne
+          (f64x2.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.lt")
+    (drop
+      (f64x2.lt
+        (f64x2.lt
+          (f64x2.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.lt
+          (f64x2.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.le")
+    (drop
+      (f64x2.le
+        (f64x2.le
+          (f64x2.le
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.le
+          (f64x2.le
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.gt")
+    (drop
+      (f64x2.gt
+        (f64x2.gt
+          (f64x2.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.gt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.gt
+          (f64x2.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.gt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.ge")
+    (drop
+      (f64x2.ge
+        (f64x2.ge
+          (f64x2.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.ge
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.ge
+          (f64x2.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.ge
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (f64x2.eq
+        (f64x2.ne
+          (f64x2.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.gt
+          (f64x2.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "f64x2.eq-in-block"))
+(assert_return (invoke "f64x2.ne-in-block"))
+(assert_return (invoke "f64x2.lt-in-block"))
+(assert_return (invoke "f64x2.le-in-block"))
+(assert_return (invoke "f64x2.gt-in-block"))
+(assert_return (invoke "f64x2.ge-in-block"))
+(assert_return (invoke "nested-f64x2.eq"))
+(assert_return (invoke "nested-f64x2.ne"))
+(assert_return (invoke "nested-f64x2.lt"))
+(assert_return (invoke "nested-f64x2.le"))
+(assert_return (invoke "nested-f64x2.gt"))
+(assert_return (invoke "nested-f64x2.ge"))
+(assert_return (invoke "as-param"))
diff --git a/test/core/simd/simd_f64x2_pmin_pmax.wast b/test/core/simd/simd_f64x2_pmin_pmax.wast
new file mode 100644
index 000000000..e8167b0e5
--- /dev/null
+++ b/test/core/simd/simd_f64x2_pmin_pmax.wast
@@ -0,0 +1,11676 @@
+;; Tests for f64x2 [pmin, pmax] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f64x2.pmin") (param v128 v128) (result v128) (f64x2.pmin (local.get 0) (local.get 1)))
+  (func (export "f64x2.pmax") (param v128 v128) (result v128) (f64x2.pmax (local.get 0) (local.get 1)))
+)
+
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f64x2.pmin (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.pmax (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f64x2.pmin-1st-arg-empty (result v128)
+      (f64x2.pmin (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.pmin-arg-empty (result v128)
+      (f64x2.pmin)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.pmax-1st-arg-empty (result v128)
+      (f64x2.pmax (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.pmax-arg-empty (result v128)
+      (f64x2.pmax)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_f64x2_rounding.wast b/test/core/simd/simd_f64x2_rounding.wast
new file mode 100644
index 000000000..f82c6d294
--- /dev/null
+++ b/test/core/simd/simd_f64x2_rounding.wast
@@ -0,0 +1,424 @@
+;; Tests for f64x2 [ceil, floor, trunc, nearest] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f64x2.ceil") (param v128) (result v128) (f64x2.ceil (local.get 0)))
+  (func (export "f64x2.floor") (param v128) (result v128) (f64x2.floor (local.get 0)))
+  (func (export "f64x2.trunc") (param v128) (result v128) (f64x2.trunc (local.get 0)))
+  (func (export "f64x2.nearest") (param v128) (result v128) (f64x2.nearest (local.get 0)))
+)
+
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.c000000000000p+2 0x1.c000000000000p+2))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 123456790.0 123456790.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0p+0 0x0p+0))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                     (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                     (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1p-1 0x1p-1))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                     (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1p+0 0x1p+0))
+                                     (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                     (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                     (v128.const f64x2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                     (v128.const f64x2 -0x1.c000000000000p+2 -0x1.c000000000000p+2))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                     (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                     (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 inf inf))
+                                     (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -inf -inf))
+                                     (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789 0123456789))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789e019 0123456789e019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789. 0123456789.))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                     (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                     (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 nan nan))
+                                     (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -nan -nan))
+                                     (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                     (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                     (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0p+0 0x0p+0))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                     (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                     (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1p-1 0x1p-1))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                     (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1p+0 0x1p+0))
+                                     (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                     (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                     (v128.const f64x2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                     (v128.const f64x2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                     (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                     (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 inf inf))
+                                     (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -inf -inf))
+                                     (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789 0123456789))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789e019 0123456789e019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789. 0123456789.))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                     (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                     (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 nan nan))
+                                     (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -nan -nan))
+                                     (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                     (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                     (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0p+0 0x0p+0))
+                                       (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                       (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                       (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                       (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1p-1 0x1p-1))
+                                       (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                       (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1p+0 0x1p+0))
+                                       (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                       (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                       (v128.const f64x2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                       (v128.const f64x2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                       (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                       (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                       (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                       (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 inf inf))
+                                       (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -inf -inf))
+                                       (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789 0123456789))
+                                       (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789e019 0123456789e019))
+                                       (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                       (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                       (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789. 0123456789.))
+                                       (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                       (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                       (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                       (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                       (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                       (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                       (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                       (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                       (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                       (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                       (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                       (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                       (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                       (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 nan nan))
+                                       (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -nan -nan))
+                                       (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                       (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                       (v128.const f64x2 nan:arithmetic nan:arithmetic))
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f64x2.ceil (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.floor (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.trunc (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.nearest (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f64x2.ceil-arg-empty (result v128)
+      (f64x2.ceil)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.floor-arg-empty (result v128)
+      (f64x2.floor)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.trunc-arg-empty (result v128)
+      (f64x2.trunc)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.nearest-arg-empty (result v128)
+      (f64x2.nearest)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_i16x8_arith.wast b/test/core/simd/simd_i16x8_arith.wast
new file mode 100644
index 000000000..3dc4d5ed7
--- /dev/null
+++ b/test/core/simd/simd_i16x8_arith.wast
@@ -0,0 +1,634 @@
+;; Tests for i16x8 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i16x8.add") (param v128 v128) (result v128) (i16x8.add (local.get 0) (local.get 1)))
+  (func (export "i16x8.sub") (param v128 v128) (result v128) (i16x8.sub (local.get 0) (local.get 1)))
+  (func (export "i16x8.mul") (param v128 v128) (result v128) (i16x8.mul (local.get 0) (local.get 1)))
+  (func (export "i16x8.neg") (param v128) (result v128) (i16x8.neg (local.get 0)))
+)
+
+
+;; i16x8.add
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i8x16 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i32x4 0x80008000 0x80008000 0x80008000 0x80008000))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i16x8 0x8000 0 0x8000 0 0x8000 0 0x8000 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i16x8 0x8000 0xbf80 0x8000 0xbf80 0x8000 0xbf80 0x8000 0xbf80))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i16x8 0x8000 0x3f80 0x8000 0x3f80 0x8000 0x3f80 0x8000 0x3f80))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i16x8 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i16x8 0x01 0xff81 0x01 0xff81 0x01 0xff81 0x01 0xff81))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i16x8 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                   (v128.const i16x8 0 3 6 9 12 15 18 21))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                   (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                   (v128.const i16x8 03_598 03_598 03_598 03_598 03_598 03_598 03_598 03_598))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                   (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678))
+                                   (v128.const i16x8 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac))
+
+;; i16x8.sub
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32764 32764 32764 32764 32764 32764 32764 32764))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32765 -32765 -32765 -32765 -32765 -32765 -32765 -32765))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i8x16 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i16x8 0x02 0x02 0x02 0x02 0x02 0x02 0x02 0x02))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i32x4 0x80008000 0x80008000 0x80008000 0x80008000))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i16x8 0x02 0x02 0x02 0x02 0x02 0x02 0x02 0x02))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i16x8 0x8000 0 0x8000 0 0x8000 0 0x8000 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i16x8 0x8000 0x4080 0x8000 0x4080 0x8000 0x4080 0x8000 0x4080))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i16x8 0x8000 0xc080 0x8000 0xc080 0x8000 0xc080 0x8000 0xc080))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i16x8 0x01 0x8081 0x01 0x8081 0x01 0x8081 0x01 0x8081))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i16x8 0x01 0x81 0x01 0x81 0x01 0x81 0x01 0x81))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i16x8 0x01 0x8041 0x01 0x8041 0x01 0x8041 0x01 0x8041))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                   (v128.const i16x8 0 0x02 0x04 0x06 0x08 0x0a 0x0c 0x0e))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                   (v128.const i16x8 0 -1 -2 -3 -4 -5 -6 -7))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789)
+                                   (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+                                   (v128.const i16x8 044_444 044_444 044_444 044_444 044_444 044_444 044_444 044_444))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678)
+                                   (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+                                   (v128.const i16x8 0x0_4444 0x0_4444 0x0_4444 0x0_4444 0x0_4444 0x0_4444 0x0_4444 0x0_4444))
+
+;; i16x8.mul
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x1000 0x1000 0x1000 0x1000 0x1000 0x1000 0x1000 0x1000)
+                                   (v128.const i8x16 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i32x4 0x00020002 0x00020002 0x00020002 0x00020002))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i16x8 0 0x7f80 0 0x7f80 0 0x7f80 0 0x7f80))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i16x8 0 0xff80 0 0xff80 0 0xff80 0 0xff80))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i16x8 0 0x7fc0 0 0x7fc0 0 0x7fc0 0 0x7fc0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                   (v128.const i16x8 0 0xffff 0xfffc 0xfff7 0xfff0 0xffe7 0xffdc 0xffcf))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                   (v128.const i16x8 0 0x02 0x08 0x12 0x20 0x32 0x48 0x62))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                   (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                   (v128.const i16x8 021_613 021_613 021_613 021_613 021_613 021_613 021_613 021_613))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                   (v128.const i16x8 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef))
+                                   (v128.const i16x8 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c))
+
+;; i16x8.neg
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+                                   (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -0x7fff -0x7fff -0x7fff -0x7fff -0x7fff -0x7fff -0x7fff -0x7fff))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.neg (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.add (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.sub (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.mul (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.neg-arg-empty (result v128)
+      (i16x8.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.add-1st-arg-empty (result v128)
+      (i16x8.add (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.add-arg-empty (result v128)
+      (i16x8.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub-1st-arg-empty (result v128)
+      (i16x8.sub (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub-arg-empty (result v128)
+      (i16x8.sub)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.mul-1st-arg-empty (result v128)
+      (i16x8.mul (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.mul-arg-empty (result v128)
+      (i16x8.mul)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (i16x8.add (i16x8.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-add") (param v128 v128 v128) (result v128)
+    (i16x8.mul (i16x8.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-sub") (param v128 v128 v128) (result v128)
+    (i16x8.mul (i16x8.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (i16x8.sub (i16x8.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (i16x8.add (i16x8.neg (local.get 0)) (local.get 1)))
+  (func (export "mul-neg") (param v128 v128) (result v128)
+    (i16x8.mul (i16x8.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (i16x8.sub (i16x8.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 2 4 6 8 10 12 14)
+                                 (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "mul-add" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                 (v128.const i16x8 0 4 8 12 16 20 24 28))
+(assert_return (invoke "mul-sub" (v128.const i16x8 0 2 4 6 8 10 12 14)
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                 (v128.const i16x8 0 1 4 9 16 25 36 49))
+(assert_return (invoke "sub-add" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 2 4 6 8 10 12 14)
+                                 (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "add-neg" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                 (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "mul-neg" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                 (v128.const i16x8 0 -2 -4 -6 -8 -10 -12 -14))
+(assert_return (invoke "sub-neg" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                 (v128.const i16x8 0 -2 -4 -6 -8 -10 -12 -14))
\ No newline at end of file
diff --git a/test/core/simd/simd_i16x8_arith2.wast b/test/core/simd/simd_i16x8_arith2.wast
new file mode 100644
index 000000000..454f598df
--- /dev/null
+++ b/test/core/simd/simd_i16x8_arith2.wast
@@ -0,0 +1,610 @@
+;; Tests for i16x8 [min_s, min_u, max_s, max_u, avgr_u, abs] operations.
+
+(module
+  (func (export "i16x8.min_s") (param v128 v128) (result v128) (i16x8.min_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.min_u") (param v128 v128) (result v128) (i16x8.min_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.max_s") (param v128 v128) (result v128) (i16x8.max_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.max_u") (param v128 v128) (result v128) (i16x8.max_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.avgr_u") (param v128 v128) (result v128) (i16x8.avgr_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.abs") (param v128) (result v128) (i16x8.abs (local.get 0)))
+  (func (export "i16x8.min_s_with_const_0") (result v128) (i16x8.min_s (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)))
+  (func (export "i16x8.min_s_with_const_1") (result v128) (i16x8.min_s (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0)))
+  (func (export "i16x8.min_u_with_const_2") (result v128) (i16x8.min_u (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)))
+  (func (export "i16x8.min_u_with_const_3") (result v128) (i16x8.min_u (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0)))
+  (func (export "i16x8.max_s_with_const_4") (result v128) (i16x8.max_s (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)))
+  (func (export "i16x8.max_s_with_const_5") (result v128) (i16x8.max_s (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0)))
+  (func (export "i16x8.max_u_with_const_6") (result v128) (i16x8.max_u (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)))
+  (func (export "i16x8.max_u_with_const_7") (result v128) (i16x8.max_u (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0)))
+  (func (export "i16x8.avgr_u_with_const_8") (result v128) (i16x8.avgr_u (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)))
+  (func (export "i16x8.avgr_u_with_const_9") (result v128) (i16x8.avgr_u (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0)))
+  (func (export "i16x8.abs_with_const_10") (result v128) (i16x8.abs (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.min_s_with_const_11") (param v128) (result v128) (i16x8.min_s (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.min_s_with_const_12") (param v128) (result v128) (i16x8.min_s (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3)))
+  (func (export "i16x8.min_u_with_const_13") (param v128) (result v128) (i16x8.min_u (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.min_u_with_const_14") (param v128) (result v128) (i16x8.min_u (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3)))
+  (func (export "i16x8.max_s_with_const_15") (param v128) (result v128) (i16x8.max_s (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.max_s_with_const_16") (param v128) (result v128) (i16x8.max_s (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3)))
+  (func (export "i16x8.max_u_with_const_17") (param v128) (result v128) (i16x8.max_u (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.max_u_with_const_18") (param v128) (result v128) (i16x8.max_u (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3)))
+  (func (export "i16x8.avgr_u_with_const_19") (param v128) (result v128) (i16x8.avgr_u (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.avgr_u_with_const_20") (param v128) (result v128) (i16x8.avgr_u (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3)))
+)
+
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)
+                                     (v128.const i16x8 0 0 -1 -1 0 0 -1 -1))
+                                     (v128.const i16x8 0 0 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+                                     (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 123 123 123 123 123 123 123 123)
+                                     (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)
+                                     (v128.const i16x8 0 0 -1 -1 0 0 -1 -1))
+                                     (v128.const i16x8 0 0 0 0 0 0 -1 -1))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 123 123 123 123 123 123 123 123)
+                                     (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)
+                                     (v128.const i16x8 0 0 -1 -1 0 0 -1 -1))
+                                     (v128.const i16x8 0 0 0 0 0 0 -1 -1))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 123 123 123 123 123 123 123 123)
+                                     (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)
+                                     (v128.const i16x8 0 0 -1 -1 0 0 -1 -1))
+                                     (v128.const i16x8 0 0 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+                                     (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 123 123 123 123 123 123 123 123)
+                                     (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                      (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                      (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)
+                                      (v128.const i16x8 0 0 -1 -1 0 0 -1 -1))
+                                      (v128.const i16x8 0 0 32768 32768 32768 32768 65535 65535))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                      (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                      (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                      (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                      (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                      (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                      (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                      (v128.const i16x8 128 128 128 128 128 128 128 128))
+                                      (v128.const i16x8 32832 32832 32832 32832 32832 32832 32832 32832))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                      (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                      (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                      (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                      (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 123 123 123 123 123 123 123 123)
+                                      (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                      (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                      (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                      (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i16x8 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+                                   (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000))
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                   (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3))
+                                   (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                   (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                   (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0))
+                                   (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+
+;; Const vs const
+(assert_return (invoke "i16x8.min_s_with_const_0") (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_s_with_const_1") (v128.const i16x8 0 0 1 1 1 1 0 0))
+(assert_return (invoke "i16x8.min_u_with_const_2") (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_u_with_const_3") (v128.const i16x8 0 0 1 1 1 1 0 0))
+(assert_return (invoke "i16x8.max_s_with_const_4") (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_s_with_const_5") (v128.const i16x8 3 3 2 2 2 2 3 3))
+(assert_return (invoke "i16x8.max_u_with_const_6") (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_u_with_const_7") (v128.const i16x8 3 3 2 2 2 2 3 3))
+(assert_return (invoke "i16x8.avgr_u_with_const_8") (v128.const i16x8 49152 49152 24576 24576 24576 24576 49152 49152))
+(assert_return (invoke "i16x8.avgr_u_with_const_9") (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.abs_with_const_10") (v128.const i16x8 32768 32768 32767 32767 16384 16384 1 1))
+
+;; Param vs const
+(assert_return (invoke "i16x8.min_s_with_const_11" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                                   (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_s_with_const_12" (v128.const i16x8 3 3 2 2 1 1 0 0))
+                                                   (v128.const i16x8 0 0 1 1 1 1 0 0))
+(assert_return (invoke "i16x8.min_u_with_const_13" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                                   (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_u_with_const_14" (v128.const i16x8 3 3 2 2 1 1 0 0))
+                                                   (v128.const i16x8 0 0 1 1 1 1 0 0))
+(assert_return (invoke "i16x8.max_s_with_const_15" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                                   (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_s_with_const_16" (v128.const i16x8 3 3 2 2 1 1 0 0))
+                                                   (v128.const i16x8 3 3 2 2 2 2 3 3))
+(assert_return (invoke "i16x8.max_u_with_const_17" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                                   (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_u_with_const_18" (v128.const i16x8 3 3 2 2 1 1 0 0))
+                                                   (v128.const i16x8 3 3 2 2 2 2 3 3))
+(assert_return (invoke "i16x8.avgr_u_with_const_19" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                                    (v128.const i16x8 49152 49152 24576 24576 24576 24576 49152 49152))
+(assert_return (invoke "i16x8.avgr_u_with_const_20" (v128.const i16x8 3 3 2 2 1 1 0 0))
+                                                    (v128.const i16x8 2 2 2 2 2 2 2 2))
+
+;; Test different lanes go through different if-then clauses
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)
+                                     (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                     (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 1 1 2 2 128 128)
+                                     (v128.const i16x8 0 0 2 2 1 1 128 128))
+                                     (v128.const i16x8 0 0 1 1 1 1 128 128))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)
+                                     (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                     (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 1 1 2 2 128 128)
+                                     (v128.const i16x8 0 0 2 2 1 1 128 128))
+                                     (v128.const i16x8 0 0 1 1 1 1 128 128))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)
+                                     (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                     (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 1 1 2 2 128 128)
+                                     (v128.const i16x8 0 0 2 2 1 1 128 128))
+                                     (v128.const i16x8 0 0 2 2 2 2 128 128))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)
+                                     (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                     (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 1 1 2 2 128 128)
+                                     (v128.const i16x8 0 0 2 2 1 1 128 128))
+                                     (v128.const i16x8 0 0 2 2 2 2 128 128))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)
+                                      (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                      (v128.const i16x8 49152 49152 24576 24576 24576 24576 49152 49152))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 1 1 2 2 128 128)
+                                      (v128.const i16x8 0 0 2 2 1 1 128 128))
+                                      (v128.const i16x8 0 0 2 2 2 2 128 128))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535))
+                                   (v128.const i16x8 32768 32768 32767 32767 16384 16384 1 1))
+
+;; Test opposite signs of zero
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)
+                                     (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                     (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)
+                                     (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                     (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)
+                                     (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                     (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)
+                                     (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                     (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)
+                                      (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)
+                                      (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+                                   (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                   (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+                                   (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                   (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+
+;; Unknown operators
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.avgr (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.avgr_s (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 1 1 1 1 1 1 1 1)))") "unknown operator")
+
+;; Type check
+(assert_invalid (module (func (result v128) (i16x8.min_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.min_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.max_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.max_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.avgr_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.abs (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.min_s-1st-arg-empty (result v128)
+      (i16x8.min_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.min_s-arg-empty (result v128)
+      (i16x8.min_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.min_u-1st-arg-empty (result v128)
+      (i16x8.min_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.min_u-arg-empty (result v128)
+      (i16x8.min_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.max_s-1st-arg-empty (result v128)
+      (i16x8.max_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.max_s-arg-empty (result v128)
+      (i16x8.max_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.max_u-1st-arg-empty (result v128)
+      (i16x8.max_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.max_u-arg-empty (result v128)
+      (i16x8.max_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.avgr_u-1st-arg-empty (result v128)
+      (i16x8.avgr_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.avgr_u-arg-empty (result v128)
+      (i16x8.avgr_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.abs-arg-empty (result v128)
+      (i16x8.abs)
+    )
+  )
+  "type mismatch"
+)
+
+;; Combination
+(module
+  (func (export "i16x8.min_s-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_s-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_s-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_s-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_s-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_s-i16x8.abs") (param v128 v128) (result v128) (i16x8.min_s (i16x8.abs (local.get 0))(local.get 1)))
+  (func (export "i16x8.abs-i16x8.min_s") (param v128 v128) (result v128) (i16x8.abs (i16x8.min_s (local.get 0) (local.get 1))))
+  (func (export "i16x8.min_u-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_u-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_u-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_u-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_u-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_u-i16x8.abs") (param v128 v128) (result v128) (i16x8.min_u (i16x8.abs (local.get 0))(local.get 1)))
+  (func (export "i16x8.abs-i16x8.min_u") (param v128 v128) (result v128) (i16x8.abs (i16x8.min_u (local.get 0) (local.get 1))))
+  (func (export "i16x8.max_s-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_s-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_s-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_s-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_s-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_s-i16x8.abs") (param v128 v128) (result v128) (i16x8.max_s (i16x8.abs (local.get 0))(local.get 1)))
+  (func (export "i16x8.abs-i16x8.max_s") (param v128 v128) (result v128) (i16x8.abs (i16x8.max_s (local.get 0) (local.get 1))))
+  (func (export "i16x8.max_u-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_u-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_u-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_u-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_u-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_u-i16x8.abs") (param v128 v128) (result v128) (i16x8.max_u (i16x8.abs (local.get 0))(local.get 1)))
+  (func (export "i16x8.abs-i16x8.max_u") (param v128 v128) (result v128) (i16x8.abs (i16x8.max_u (local.get 0) (local.get 1))))
+  (func (export "i16x8.avgr_u-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.avgr_u-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.avgr_u-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.avgr_u-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.avgr_u-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.avgr_u-i16x8.abs") (param v128 v128) (result v128) (i16x8.avgr_u (i16x8.abs (local.get 0))(local.get 1)))
+  (func (export "i16x8.abs-i16x8.avgr_u") (param v128 v128) (result v128) (i16x8.abs (i16x8.avgr_u (local.get 0) (local.get 1))))
+  (func (export "i16x8.abs-i16x8.abs") (param v128) (result v128) (i16x8.abs (i16x8.abs (local.get 0))))
+)
+
+(assert_return (invoke "i16x8.min_s-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_s-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_s-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_s-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_s-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_s-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.abs-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                               (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_u-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_u-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.abs-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                               (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_s-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_s-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_s-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_s-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_s-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_s-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                               (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                               (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_u-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_u-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_u-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_u-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_u-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_u-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                               (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                               (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.avgr_u-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                   (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                   (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.avgr_u-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.avgr_u-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.avgr_u-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.avgr_u-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.avgr_u-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.abs-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
diff --git a/test/core/simd/simd_i16x8_cmp.wast b/test/core/simd/simd_i16x8_cmp.wast
new file mode 100644
index 000000000..24068ce32
--- /dev/null
+++ b/test/core/simd/simd_i16x8_cmp.wast
@@ -0,0 +1,1901 @@
+
+;; Test all the i16x8 comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (i16x8.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (i16x8.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x v128) (param $y v128) (result v128) (i16x8.lt_s (local.get $x) (local.get $y)))
+  (func (export "lt_u") (param $x v128) (param $y v128) (result v128) (i16x8.lt_u (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x v128) (param $y v128) (result v128) (i16x8.le_s (local.get $x) (local.get $y)))
+  (func (export "le_u") (param $x v128) (param $y v128) (result v128) (i16x8.le_u (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x v128) (param $y v128) (result v128) (i16x8.gt_s (local.get $x) (local.get $y)))
+  (func (export "gt_u") (param $x v128) (param $y v128) (result v128) (i16x8.gt_u (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x v128) (param $y v128) (result v128) (i16x8.ge_s (local.get $x) (local.get $y)))
+  (func (export "ge_u") (param $x v128) (param $y v128) (result v128) (i16x8.ge_u (local.get $x) (local.get $y)))
+)
+
+
+;; eq
+
+;; i16x8.eq  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                            (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                            (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                            (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                            (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                            (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                            (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "eq" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                            (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                            (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                            (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "eq" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "eq" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                            (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                            (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                            (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                            (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                            (v128.const i16x8 -1 -1 0 0 0 0 -1 -1))
+
+;; i16x8.eq  (i16x8) (i8x16)
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                            (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                            (v128.const i16x8 0 0 -1 -1 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                            (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; i16x8.eq  (i16x8) (i32x4)
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                            (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 0 0 1 1 32768 32768)
+                            (v128.const i32x4 65535 0 1 32768))
+                            (v128.const i16x8 -1 0 -1 -1 -1 0 -1 0))
+(assert_return (invoke "eq" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                            (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                            (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                            (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; ne
+
+;; i16x8.ne  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                            (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                            (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                            (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                            (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                            (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                            (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "ne" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 255 255 255 255 255 255 255 255)
+                            (v128.const i16x8 255 255 255 255 255 255 255 255))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 255 255 255 255 0 0 0 0)
+                            (v128.const i16x8 255 255 255 255 0 0 0 0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0 0 0 0 255 255 255 255)
+                            (v128.const i16x8 0 0 0 0 255 255 255 255))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 255 32767 -0 0 1 2 65534 65535)
+                            (v128.const i16x8 255 32767 0 0 1 2 -2 -1))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "ne" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "ne" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                            (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                            (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 0x8081 0x8283 0xFDFE 0xFF00 0x0001 0x027F 0x80FD 0xFEFF)
+                            (v128.const i16x8 65279 33021 639 1 65280 65022 33411 32897))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 128 129 130 131 -0 255 32766 32767)
+                            (v128.const i16x8 32767 32766 255 -0 131 130 129 28))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.ne  (i16x8) (i8x16)
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                            (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                            (v128.const i16x8 -1 -1 0 0 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                            (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.ne  (i16x8) (i32x4)
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                            (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                            (v128.const i32x4 -128 0 1 255))
+                            (v128.const i16x8 0 -1 0 0 0 -1 0 -1))
+(assert_return (invoke "ne" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                            (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                            (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                            (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; lt_s
+
+;; i16x8.lt_s  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 255 255 255 255 0 0 0 0)
+                              (v128.const i16x8 255 255 255 255 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0 0 0 0 255 255 255 255)
+                              (v128.const i16x8 0 0 0 0 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 255 32767 -0 0 1 2 65534 65535)
+                              (v128.const i16x8 255 32767 0 0 1 2 -2 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 0 0 -1 0 0 0 0 -1))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x8081 0x8283 0xFDFE 0xFF00 0x0001 0x027F 0x80FD 0xFEFF)
+                              (v128.const i16x8 65279 33021 639 1 65280 65022 33411 32897))
+                              (v128.const i16x8 -1 0 -1 -1 0 0 -1 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 128 129 130 131 -0 255 32766 32767)
+                              (v128.const i16x8 32767 32766 255 -0 131 130 129 28))
+                              (v128.const i16x8 -1 -1 -1 0 -1 0 0 0))
+
+;; i16x8.lt_s  (i16x8) (i8x16)
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 -1 -1 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; i16x8.lt_s  (i16x8) (i32x4)
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 0 -1 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; lt_u
+
+;; i16x8.lt_u  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 255 255 255 255 0 0 0 0)
+                              (v128.const i16x8 255 255 255 255 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0 0 0 0 255 255 255 255)
+                              (v128.const i16x8 0 0 0 0 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 255 32767 -0 0 1 2 65534 65535)
+                              (v128.const i16x8 255 32767 0 0 1 2 -2 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 -1 -1 -1 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x8081 0x8283 0xFDFE 0xFF00 0x0001 0x027F 0x80FD 0xFEFF)
+                              (v128.const i16x8 65279 33021 639 1 65280 65022 33411 32897))
+                              (v128.const i16x8 -1 0 0 0 -1 -1 -1 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 128 129 130 131 -0 255 32766 32767)
+                              (v128.const i16x8 32767 32766 255 -0 131 130 129 28))
+                              (v128.const i16x8 -1 -1 -1 0 -1 0 0 0))
+
+;; i16x8.lt_u  (i16x8) (i8x16)
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.lt_u  (i16x8) (i32x4)
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 0 -1 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; le_s
+
+;; i16x8.le_s  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                              (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                              (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                              (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 0 0 -1 0 0 0 0 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "le_s" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 -1 -1))
+
+;; i16x8.le_s  (i16x8) (i8x16)
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 0 0 -1 -1 -1 -1 0 0))
+(assert_return (invoke "le_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; i16x8.le_s  (i16x8) (i32x4)
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 0 -1 0))
+(assert_return (invoke "le_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "le_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; le_u
+
+;; i16x8.le_u  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                              (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                              (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                              (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 -1 -1 -1 0 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 -1 -1 -1 0 -1 0 -1 -1))
+
+;; i16x8.le_u  (i16x8) (i8x16)
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 0 0 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.le_u  (i16x8) (i32x4)
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 0 -1 0))
+(assert_return (invoke "le_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb)
+                              (v128.const i16x8 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; gt_s
+
+;; i16x8.gt_s  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                              (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                              (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                              (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 -1 -1 0 -1 -1 -1 -1 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 0 0 0 0 -1 -1 0 0))
+
+;; i16x8.gt_s  (i16x8) (i8x16)
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 -1 -1 0 0 0 0 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.gt_s  (i16x8) (i32x4)
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 0 0 1 1 32768 32768)
+                              (v128.const i32x4 65535 0 1 32768))
+                              (v128.const i16x8 0 0 0 0 0 -1 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; gt_u
+
+;; i16x8.gt_u  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "eq" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                            (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                            (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                            (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 0 0 0 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 0 0 0 -1 0 -1 0 0))
+
+;; i16x8.gt_u  (i16x8) (i8x16)
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 -1 -1 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; i16x8.gt_u  (i16x8) (i32x4)
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 0 0 0 0 0 -1 0 -1))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; ge_s
+
+;; i16x8.ge_s  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                              (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                              (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                              (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 -1 -1 0 -1 -1 -1 -1 0))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 -1 -1 0 0 -1 -1 -1 -1))
+
+;; i16x8.ge_s  (i16x8) (i8x16)
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA)
+                              (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; i16x8.ge_s  (i16x8) (i32x4)
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 0 0 1 1 32768 32768)
+                              (v128.const i32x4 65535 0 1 32768))
+                              (v128.const i16x8 -1 0 -1 -1 -1 -1 -1 0))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; ge_u
+
+;; i16x8.ge_u  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                              (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                              (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                              (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 0 0 0 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 -1 -1 0 -1 0 -1 -1 -1))
+
+;; i16x8.ge_u  (i16x8) (i8x16)
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "ge_u" (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA)
+                              (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.ge_u  (i16x8) (i32x4)
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 0 0 1 1 32768 32768)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ge_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (i16x8.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.ge_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.gt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.le_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.lt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+
+
+;; combination
+
+(module (memory 1)
+  (func (export "eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "lt_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.lt_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "le_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.le_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "gt_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.gt_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ge_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.ge_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-eq")
+    (drop
+      (i16x8.eq
+        (i16x8.eq
+          (i16x8.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.eq
+          (i16x8.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ne")
+    (drop
+      (i16x8.ne
+        (i16x8.ne
+          (i16x8.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.ne
+          (i16x8.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-lt_s")
+    (drop
+      (i16x8.lt_s
+        (i16x8.lt_s
+          (i16x8.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.lt_s
+          (i16x8.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-le_u")
+    (drop
+      (i16x8.le_u
+        (i16x8.le_u
+          (i16x8.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.le_u
+          (i16x8.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-gt_u")
+    (drop
+      (i16x8.gt_u
+        (i16x8.gt_u
+          (i16x8.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.gt_u
+          (i16x8.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ge_s")
+    (drop
+      (i16x8.ge_s
+        (i16x8.ge_s
+          (i16x8.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.ge_s
+          (i16x8.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (i16x8.ge_u
+        (i16x8.eq
+          (i16x8.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.ne
+          (i16x8.gt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.lt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "eq-in-block"))
+(assert_return (invoke "ne-in-block"))
+(assert_return (invoke "lt_s-in-block"))
+(assert_return (invoke "le_u-in-block"))
+(assert_return (invoke "gt_u-in-block"))
+(assert_return (invoke "ge_s-in-block"))
+(assert_return (invoke "nested-eq"))
+(assert_return (invoke "nested-ne"))
+(assert_return (invoke "nested-lt_s"))
+(assert_return (invoke "nested-le_u"))
+(assert_return (invoke "nested-gt_u"))
+(assert_return (invoke "nested-ge_s"))
+(assert_return (invoke "as-param"))
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.eq-1st-arg-empty (result v128)
+      (i16x8.eq (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.eq-arg-empty (result v128)
+      (i16x8.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ne-1st-arg-empty (result v128)
+      (i16x8.ne (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ne-arg-empty (result v128)
+      (i16x8.ne)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.lt_s-1st-arg-empty (result v128)
+      (i16x8.lt_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.lt_s-arg-empty (result v128)
+      (i16x8.lt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.lt_u-1st-arg-empty (result v128)
+      (i16x8.lt_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.lt_u-arg-empty (result v128)
+      (i16x8.lt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.le_s-1st-arg-empty (result v128)
+      (i16x8.le_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.le_s-arg-empty (result v128)
+      (i16x8.le_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.le_u-1st-arg-empty (result v128)
+      (i16x8.le_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.le_u-arg-empty (result v128)
+      (i16x8.le_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.gt_s-1st-arg-empty (result v128)
+      (i16x8.gt_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.gt_s-arg-empty (result v128)
+      (i16x8.gt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.gt_u-1st-arg-empty (result v128)
+      (i16x8.gt_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.gt_u-arg-empty (result v128)
+      (i16x8.gt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ge_s-1st-arg-empty (result v128)
+      (i16x8.ge_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ge_s-arg-empty (result v128)
+      (i16x8.ge_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ge_u-1st-arg-empty (result v128)
+      (i16x8.ge_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ge_u-arg-empty (result v128)
+      (i16x8.ge_u)
+    )
+  )
+  "type mismatch"
+)
\ No newline at end of file
diff --git a/test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast b/test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast
new file mode 100644
index 000000000..c2267de9c
--- /dev/null
+++ b/test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast
@@ -0,0 +1,68 @@
+;; Tests for i16x8 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i16x8.extadd_pairwise_i8x16_s") (param v128) (result v128) (i16x8.extadd_pairwise_i8x16_s (local.get 0)))
+  (func (export "i16x8.extadd_pairwise_i8x16_u") (param v128) (result v128) (i16x8.extadd_pairwise_i8x16_u (local.get 0)))
+)
+
+
+;; i16x8.extadd_pairwise_i8x16_s
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                       (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                       (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                       (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+                                                       (v128.const i16x8 252 252 252 252 252 252 252 252))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                       (v128.const i16x8 -254 -254 -254 -254 -254 -254 -254 -254))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                       (v128.const i16x8 -256 -256 -256 -256 -256 -256 -256 -256))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                       (v128.const i16x8 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                       (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+
+;; i16x8.extadd_pairwise_i8x16_u
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                       (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                       (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                       (v128.const i16x8 510 510 510 510 510 510 510 510))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+                                                       (v128.const i16x8 252 252 252 252 252 252 252 252))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                       (v128.const i16x8 258 258 258 258 258 258 258 258))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                       (v128.const i16x8 256 256 256 256 256 256 256 256))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                       (v128.const i16x8 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                       (v128.const i16x8 510 510 510 510 510 510 510 510))
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.extadd_pairwise_i8x16_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extadd_pairwise_i8x16_u (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.extadd_pairwise_i8x16_s-arg-empty (result v128)
+      (i16x8.extadd_pairwise_i8x16_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extadd_pairwise_i8x16_u-arg-empty (result v128)
+      (i16x8.extadd_pairwise_i8x16_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_i16x8_extmul_i8x16.wast b/test/core/simd/simd_i16x8_extmul_i8x16.wast
new file mode 100644
index 000000000..cc8cf8f40
--- /dev/null
+++ b/test/core/simd/simd_i16x8_extmul_i8x16.wast
@@ -0,0 +1,404 @@
+;; Tests for i16x8 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i16x8.extmul_low_i8x16_s") (param v128 v128) (result v128) (i16x8.extmul_low_i8x16_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.extmul_high_i8x16_s") (param v128 v128) (result v128) (i16x8.extmul_high_i8x16_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.extmul_low_i8x16_u") (param v128 v128) (result v128) (i16x8.extmul_low_i8x16_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.extmul_high_i8x16_u") (param v128 v128) (result v128) (i16x8.extmul_high_i8x16_u (local.get 0) (local.get 1)))
+)
+
+
+;; i16x8.extmul_low_i8x16_s
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                                  (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                  (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                                  (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                  (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 4160 4160 4160 4160 4160 4160 4160 4160))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                                  (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 16129 16129 16129 16129 16129 16129 16129 16129))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                  (v128.const i16x8 16256 16256 16256 16256 16256 16256 16256 16256))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+
+;; i16x8.extmul_high_i8x16_s
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                   (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                   (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 4160 4160 4160 4160 4160 4160 4160 4160))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 16129 16129 16129 16129 16129 16129 16129 16129))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                   (v128.const i16x8 16256 16256 16256 16256 16256 16256 16256 16256))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+
+;; i16x8.extmul_low_i8x16_u
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                                  (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                  (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                                  (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                  (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 -28480 -28480 -28480 -28480 -28480 -28480 -28480 -28480))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 -28672 -28672 -28672 -28672 -28672 -28672 -28672 -28672))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 -28864 -28864 -28864 -28864 -28864 -28864 -28864 -28864))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -32386 -32386 -32386 -32386 -32386 -32386 -32386 -32386))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -32641 -32641 -32641 -32641 -32641 -32641 -32641 -32641))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 32640 32640 32640 32640 32640 32640 32640 32640))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                                  (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 16129 16129 16129 16129 16129 16129 16129 16129))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                  (v128.const i16x8 16512 16512 16512 16512 16512 16512 16512 16512))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 32385 32385 32385 32385 32385 32385 32385 32385))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 32640 32640 32640 32640 32640 32640 32640 32640))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                  (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+
+;; i16x8.extmul_high_i8x16_u
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                   (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                   (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 -28480 -28480 -28480 -28480 -28480 -28480 -28480 -28480))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 -28672 -28672 -28672 -28672 -28672 -28672 -28672 -28672))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 -28864 -28864 -28864 -28864 -28864 -28864 -28864 -28864))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -32386 -32386 -32386 -32386 -32386 -32386 -32386 -32386))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -32641 -32641 -32641 -32641 -32641 -32641 -32641 -32641))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 32640 32640 32640 32640 32640 32640 32640 32640))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 16129 16129 16129 16129 16129 16129 16129 16129))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                   (v128.const i16x8 16512 16512 16512 16512 16512 16512 16512 16512))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 32385 32385 32385 32385 32385 32385 32385 32385))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 32640 32640 32640 32640 32640 32640 32640 32640))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                   (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.extmul_low_i8x16_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extmul_high_i8x16_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extmul_low_i8x16_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extmul_high_i8x16_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.extmul_low_i8x16_s-1st-arg-empty (result v128)
+      (i16x8.extmul_low_i8x16_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_low_i8x16_s-arg-empty (result v128)
+      (i16x8.extmul_low_i8x16_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_high_i8x16_s-1st-arg-empty (result v128)
+      (i16x8.extmul_high_i8x16_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_high_i8x16_s-arg-empty (result v128)
+      (i16x8.extmul_high_i8x16_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_low_i8x16_u-1st-arg-empty (result v128)
+      (i16x8.extmul_low_i8x16_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_low_i8x16_u-arg-empty (result v128)
+      (i16x8.extmul_low_i8x16_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_high_i8x16_u-1st-arg-empty (result v128)
+      (i16x8.extmul_high_i8x16_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_high_i8x16_u-arg-empty (result v128)
+      (i16x8.extmul_high_i8x16_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_i16x8_q15mulr_sat_s.wast b/test/core/simd/simd_i16x8_q15mulr_sat_s.wast
new file mode 100644
index 000000000..2cea8cc74
--- /dev/null
+++ b/test/core/simd/simd_i16x8_q15mulr_sat_s.wast
@@ -0,0 +1,110 @@
+;; Tests for i16x8 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i16x8.q15mulr_sat_s") (param v128 v128) (result v128) (i16x8.q15mulr_sat_s (local.get 0) (local.get 1)))
+)
+
+
+;; i16x8.q15mulr_sat_s
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                             (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                             (v128.const i16x8 8192 8192 8192 8192 8192 8192 8192 8192))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                             (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                             (v128.const i16x8 8192 8192 8192 8192 8192 8192 8192 8192))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                             (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                             (v128.const i16x8 8192 8192 8192 8192 8192 8192 8192 8192))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                             (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                             (v128.const i16x8 8192 8192 8192 8192 8192 8192 8192 8192))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                             (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                             (v128.const i16x8 8193 8193 8193 8193 8193 8193 8193 8193))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                             (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                             (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                             (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                             (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                             (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                             (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.q15mulr_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.q15mulr_sat_s-1st-arg-empty (result v128)
+      (i16x8.q15mulr_sat_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.q15mulr_sat_s-arg-empty (result v128)
+      (i16x8.q15mulr_sat_s)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_i16x8_sat_arith.wast b/test/core/simd/simd_i16x8_sat_arith.wast
new file mode 100644
index 000000000..cea4ebbc7
--- /dev/null
+++ b/test/core/simd/simd_i16x8_sat_arith.wast
@@ -0,0 +1,742 @@
+;; Tests for i16x8 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i16x8.add_sat_s") (param v128 v128) (result v128) (i16x8.add_sat_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.add_sat_u") (param v128 v128) (result v128) (i16x8.add_sat_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.sub_sat_s") (param v128 v128) (result v128) (i16x8.sub_sat_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.sub_sat_u") (param v128 v128) (result v128) (i16x8.sub_sat_u (local.get 0) (local.get 1)))
+)
+
+
+;; i16x8.add_sat_s
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i16x8 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i16x8 0x01 0xff81 0x01 0xff81 0x01 0xff81 0x01 0xff81))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i16x8 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i16x8 0x01 0xffc1 0x01 0xffc1 0x01 0xffc1 0x01 0xffc1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                         (v128.const i16x8 0 3 6 9 12 15 18 21))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 032_123 032_123 032_123 032_123 032_123 032_123 032_123 032_123))
+                                         (v128.const i16x8 032_767 032_767 032_767 032_767 032_767 032_767 032_767 032_767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                         (v128.const i16x8 03_598 03_598 03_598 03_598 03_598 03_598 03_598 03_598))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                         (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678))
+                                         (v128.const i16x8 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                         (v128.const i16x8 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef))
+                                         (v128.const i16x8 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000))
+
+;; i16x8.add_sat_u
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32769 32769 32769 32769 32769 32769 32769 32769))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                         (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i16x8 0x8000 0xffff 0x8000 0xffff 0x8000 0xffff 0x8000 0xffff))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i16x8 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i16x8 0x01 0xff81 0x01 0xff81 0x01 0xff81 0x01 0xff81))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i16x8 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i16x8 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                         (v128.const i16x8 0 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                         (v128.const i16x8 0 3 6 9 12 15 18 21))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                         (v128.const i16x8 065_535 065_535 065_535 065_535 065_535 065_535 065_535 065_535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345))
+                                         (v128.const i16x8 065_535 065_535 065_535 065_535 065_535 065_535 065_535 065_535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                         (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678))
+                                         (v128.const i16x8 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                         (v128.const i16x8 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef))
+                                         (v128.const i16x8 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff))
+
+;; i16x8.sub_sat_s
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32764 32764 32764 32764 32764 32764 32764 32764))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32765 -32765 -32765 -32765 -32765 -32765 -32765 -32765))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i16x8 0x8000 0 0x8000 0 0x8000 0 0x8000 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i16x8 0x01 0x8081 0x01 0x8081 0x01 0x8081 0x01 0x8081))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i16x8 0x01 0x81 0x01 0x81 0x01 0x81 0x01 0x81))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i16x8 0x01 0x8041 0x01 0x8041 0x01 0x8041 0x01 0x8041))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i16x8 0x01 0x41 0x01 0x41 0x01 0x41 0x01 0x41))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                         (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                         (v128.const i16x8 0 -1 -2 -3 -4 -5 -6 -7))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                         (v128.const i16x8 021_092 021_092 021_092 021_092 021_092 021_092 021_092 021_092))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345))
+                                         (v128.const i16x8 024_690 024_690 024_690 024_690 024_690 024_690 024_690 024_690))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                         (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678))
+                                         (v128.const i16x8 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                         (v128.const i16x8 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234))
+                                         (v128.const i16x8 0xa2df 0xa2df 0xa2df 0xa2df 0xa2df 0xa2df 0xa2df 0xa2df))
+
+;; i16x8.sub_sat_u
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32764 32764 32764 32764 32764 32764 32764 32764))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i16x8 0x8000 0 0x8000 0 0x8000 0 0x8000 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i16x8 0x01 0 0x01 0 0x01 0 0x01 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i16x8 0x01 0 0x01 0 0x01 0 0x01 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i16x8 0x01 0 0x01 0 0x01 0 0x01 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i16x8 0x01 0 0x01 0 0x01 0 0x01 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789)
+                                         (v128.const i16x8 -12_345 -12_345 -12_345 -12_345 -12_345 -12_345 -12_345 -12_345))
+                                         (v128.const i16x8 03_598 03_598 03_598 03_598 03_598 03_598 03_598 03_598))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                         (v128.const i16x8 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef)
+                                         (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB))
+                                         (v128.const i16x8 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44))
+
+;; Malformed cases: non-existent op names
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.add_sat (v128.const i16x8 1 1 1 1 1 1 1 1) (v128.const i16x8 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.sub_sat (v128.const i16x8 1 1 1 1 1 1 1 1) (v128.const i16x8 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.mul_sat (v128.const i16x8 1 1 1 1 1 1 1 1) (v128.const i16x8 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.div_sat (v128.const i16x8 1 1 1 1 1 1 1 1) (v128.const i16x8 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.add_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.add_sat_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.sub_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.sub_sat_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.add_sat_s-1st-arg-empty (result v128)
+      (i16x8.add_sat_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.add_sat_s-arg-empty (result v128)
+      (i16x8.add_sat_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.add_sat_u-1st-arg-empty (result v128)
+      (i16x8.add_sat_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.add_sat_u-arg-empty (result v128)
+      (i16x8.add_sat_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub_sat_s-1st-arg-empty (result v128)
+      (i16x8.sub_sat_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub_sat_s-arg-empty (result v128)
+      (i16x8.sub_sat_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub_sat_u-1st-arg-empty (result v128)
+      (i16x8.sub_sat_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub_sat_u-arg-empty (result v128)
+      (i16x8.sub_sat_u)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "sat-add_s-sub_s") (param v128 v128 v128) (result v128)
+    (i16x8.add_sat_s (i16x8.sub_sat_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_s-sub_u") (param v128 v128 v128) (result v128)
+    (i16x8.add_sat_s (i16x8.sub_sat_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_u-sub_s") (param v128 v128 v128) (result v128)
+    (i16x8.add_sat_u (i16x8.sub_sat_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_u-sub_u") (param v128 v128 v128) (result v128)
+    (i16x8.add_sat_u (i16x8.sub_sat_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_s-neg") (param v128 v128) (result v128)
+    (i16x8.add_sat_s (i16x8.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-add_u-neg") (param v128 v128) (result v128)
+    (i16x8.add_sat_u (i16x8.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-sub_s-neg") (param v128 v128) (result v128)
+    (i16x8.sub_sat_s (i16x8.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-sub_u-neg") (param v128 v128) (result v128)
+    (i16x8.sub_sat_u (i16x8.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "sat-add_s-sub_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "sat-add_s-sub_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "sat-add_u-sub_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534))
+(assert_return (invoke "sat-add_u-sub_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "sat-add_s-neg" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                       (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                       (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "sat-add_u-neg" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                       (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                       (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "sat-sub_s-neg" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                       (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                       (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "sat-sub_u-neg" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                       (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                       (v128.const i16x8 1 1 1 1 1 1 1 1))
\ No newline at end of file
diff --git a/test/core/simd/simd_i32x4_arith.wast b/test/core/simd/simd_i32x4_arith.wast
new file mode 100644
index 000000000..f0e09b8bf
--- /dev/null
+++ b/test/core/simd/simd_i32x4_arith.wast
@@ -0,0 +1,634 @@
+;; Tests for i32x4 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i32x4.add") (param v128 v128) (result v128) (i32x4.add (local.get 0) (local.get 1)))
+  (func (export "i32x4.sub") (param v128 v128) (result v128) (i32x4.sub (local.get 0) (local.get 1)))
+  (func (export "i32x4.mul") (param v128 v128) (result v128) (i32x4.mul (local.get 0) (local.get 1)))
+  (func (export "i32x4.neg") (param v128) (result v128) (i32x4.neg (local.get 0)))
+)
+
+
+;; i32x4.add
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -1 -1 -1 -1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x3fffffff 0x3fffffff 0x3fffffff 0x3fffffff)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -0x3fffffff -0x3fffffff -0x3fffffff -0x3fffffff)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000001 -0x40000001 -0x40000001 -0x40000001))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i8x16 0 0 0 0x80 0 0 0 0x80 0 0 0 0x80 0 0 0 0x80))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i16x8 0 0x8000 0 0x8000 0 0x8000 0 0x8000))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i32x4 0xbf800000 0xbf800000 0xbf800000 0xbf800000))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i32x4 0x3f800000 0x3f800000 0x3f800000 0x3f800000))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i32x4 0x7f800001 0x7f800001 0x7f800001 0x7f800001))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i32x4 0xff800001 0xff800001 0xff800001 0xff800001))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i32x4 0x7fc00001 0x7fc00001 0x7fc00001 0x7fc00001))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 0xffffffff 0xfffffffe 0xfffffffd))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 2 4 6))
+                                   (v128.const i32x4 0 3 6 9))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                   (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                   (v128.const i32x4 02_469_135_780 02_469_135_780 02_469_135_780 02_469_135_780))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                                   (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                                   (v128.const i32x4 0x0_a2e0_2467 0x0_a2e0_2467 0x0_a2e0_2467 0x0_a2e0_2467))
+
+;; i32x4.sub
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -1 -1 -1 -1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483644 2147483644 2147483644 2147483644))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483645 2147483645 2147483645 2147483645))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483645 -2147483645 -2147483645 -2147483645))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x3fffffff 0x3fffffff 0x3fffffff 0x3fffffff)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -0x3fffffff -0x3fffffff -0x3fffffff -0x3fffffff)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000001 -0x40000001 -0x40000001 -0x40000001))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i8x16 0 0 0 0x80 0 0 0 0x80 0 0 0 0x80 0 0 0 0x80))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i16x8 0 0x8000 0 0x8000 0 0x8000 0 0x8000))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i32x4 0x02 0x02 0x02 0x02))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i32x4 0x40800000 0x40800000 0x40800000 0x40800000))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i32x4 0xc0800000 0xc0800000 0xc0800000 0xc0800000))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i32x4 0x80800001 0x80800001 0x80800001 0x80800001))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i32x4 0x00800001 0x00800001 0x00800001 0x00800001))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i32x4 0x80400001 0x80400001 0x80400001 0x80400001))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 0xffffffff 0xfffffffe 0xfffffffd))
+                                   (v128.const i32x4 0 0x02 0x04 0x06))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 2 4 6))
+                                   (v128.const i32x4 0 -1 -2 -3))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 03_214_567_890  03_214_567_890  03_214_567_890  03_214_567_890 )
+                                   (v128.const i32x4 01_234_567_890  01_234_567_890  01_234_567_890  01_234_567_890 ))
+                                   (v128.const i32x4 01_980_000_000 01_980_000_000 01_980_000_000 01_980_000_000))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                   (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                                   (v128.const i32x4 0x0_7e77_7777 0x0_7e77_7777 0x0_7e77_7777 0x0_7e77_7777))
+
+;; i32x4.mul
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -1 -1 -1 -1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483645 2147483645 2147483645 2147483645))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x3fffffff 0x3fffffff 0x3fffffff 0x3fffffff)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -0x3fffffff -0x3fffffff -0x3fffffff -0x3fffffff)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000001 -0x40000001 -0x40000001 -0x40000001))
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x10000000 0x10000000 0x10000000 0x10000000)
+                                   (v128.const i8x16 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i16x8 0 0x02 0 0x02 0 0x02 0 0x02))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i32x4 0x7f800000 0x7f800000 0x7f800000 0x7f800000))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i32x4 0xff800000 0xff800000 0xff800000 0xff800000))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i32x4 0x7fc00000 0x7fc00000 0x7fc00000 0x7fc00000))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 0xffffffff 0xfffffffe 0xfffffffd))
+                                   (v128.const i32x4 0 0xffffffff 0xfffffffc 0xfffffff7))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 2 4 6))
+                                   (v128.const i32x4 0 0x02 0x08 0x12))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                                   (v128.const i32x4 0_987_654_321 0_987_654_321 0_987_654_321 0_987_654_321))
+                                   (v128.const i32x4 04_227_814_277 04_227_814_277 04_227_814_277 04_227_814_277))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                                   (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                                   (v128.const i32x4 0x0_2a42_d208 0x0_2a42_d208 0x0_2a42_d208 0x0_2a42_d208))
+
+;; i32x4.neg
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+                                   (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -0x7fffffff -0x7fffffff -0x7fffffff -0x7fffffff))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i32x4 1 1 1 1))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.neg (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.add (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.sub (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.mul (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.neg-arg-empty (result v128)
+      (i32x4.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.add-1st-arg-empty (result v128)
+      (i32x4.add (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.add-arg-empty (result v128)
+      (i32x4.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.sub-1st-arg-empty (result v128)
+      (i32x4.sub (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.sub-arg-empty (result v128)
+      (i32x4.sub)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.mul-1st-arg-empty (result v128)
+      (i32x4.mul (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.mul-arg-empty (result v128)
+      (i32x4.mul)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (i32x4.add (i32x4.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-add") (param v128 v128 v128) (result v128)
+    (i32x4.mul (i32x4.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-sub") (param v128 v128 v128) (result v128)
+    (i32x4.mul (i32x4.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (i32x4.sub (i32x4.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (i32x4.add (i32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "mul-neg") (param v128 v128) (result v128)
+    (i32x4.mul (i32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (i32x4.sub (i32x4.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 2 4 6)
+                                 (v128.const i32x4 0 2 4 6))
+                                 (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "mul-add" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 2 2 2 2))
+                                 (v128.const i32x4 0 4 8 12))
+(assert_return (invoke "mul-sub" (v128.const i32x4 0 2 4 6)
+                                 (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 1 2 3))
+                                 (v128.const i32x4 0 1 4 9))
+(assert_return (invoke "sub-add" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 2 4 6)
+                                 (v128.const i32x4 0 2 4 6))
+                                 (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "add-neg" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 1 2 3))
+                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "mul-neg" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 2 2 2 2))
+                                 (v128.const i32x4 0 -2 -4 -6))
+(assert_return (invoke "sub-neg" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 1 2 3))
+                                 (v128.const i32x4 0 -2 -4 -6))
\ No newline at end of file
diff --git a/test/core/simd/simd_i32x4_arith2.wast b/test/core/simd/simd_i32x4_arith2.wast
new file mode 100644
index 000000000..63c3f4a42
--- /dev/null
+++ b/test/core/simd/simd_i32x4_arith2.wast
@@ -0,0 +1,494 @@
+;; Tests for i32x4 [min_s, min_u, max_s, max_u, abs] operations.
+
+(module
+  (func (export "i32x4.min_s") (param v128 v128) (result v128) (i32x4.min_s (local.get 0) (local.get 1)))
+  (func (export "i32x4.min_u") (param v128 v128) (result v128) (i32x4.min_u (local.get 0) (local.get 1)))
+  (func (export "i32x4.max_s") (param v128 v128) (result v128) (i32x4.max_s (local.get 0) (local.get 1)))
+  (func (export "i32x4.max_u") (param v128 v128) (result v128) (i32x4.max_u (local.get 0) (local.get 1)))
+  (func (export "i32x4.abs") (param v128) (result v128) (i32x4.abs (local.get 0)))
+  (func (export "i32x4.min_s_with_const_0") (result v128) (i32x4.min_s (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)))
+  (func (export "i32x4.min_s_with_const_1") (result v128) (i32x4.min_s (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0)))
+  (func (export "i32x4.min_u_with_const_2") (result v128) (i32x4.min_u (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)))
+  (func (export "i32x4.min_u_with_const_3") (result v128) (i32x4.min_u (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0)))
+  (func (export "i32x4.max_s_with_const_4") (result v128) (i32x4.max_s (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)))
+  (func (export "i32x4.max_s_with_const_5") (result v128) (i32x4.max_s (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0)))
+  (func (export "i32x4.max_u_with_const_6") (result v128) (i32x4.max_u (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)))
+  (func (export "i32x4.max_u_with_const_7") (result v128) (i32x4.max_u (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0)))
+  (func (export "i32x4.abs_with_const_8") (result v128) (i32x4.abs (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)))
+  (func (export "i32x4.min_s_with_const_9") (param v128) (result v128) (i32x4.min_s (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)))
+  (func (export "i32x4.min_s_with_const_10") (param v128) (result v128) (i32x4.min_s (local.get 0) (v128.const i32x4 0 1 2 3)))
+  (func (export "i32x4.min_u_with_const_11") (param v128) (result v128) (i32x4.min_u (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)))
+  (func (export "i32x4.min_u_with_const_12") (param v128) (result v128) (i32x4.min_u (local.get 0) (v128.const i32x4 0 1 2 3)))
+  (func (export "i32x4.max_s_with_const_13") (param v128) (result v128) (i32x4.max_s (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)))
+  (func (export "i32x4.max_s_with_const_14") (param v128) (result v128) (i32x4.max_s (local.get 0) (v128.const i32x4 0 1 2 3)))
+  (func (export "i32x4.max_u_with_const_15") (param v128) (result v128) (i32x4.max_u (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)))
+  (func (export "i32x4.max_u_with_const_16") (param v128) (result v128) (i32x4.max_u (local.get 0) (v128.const i32x4 0 1 2 3)))
+)
+
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0 0 0 0))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 -1 -1 -1 -1))
+                                     (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 -1 -1)
+                                     (v128.const i32x4 0 -1 0 -1))
+                                     (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 1 1 1 1)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 128 128 128 128))
+                                     (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 123 123 123 123)
+                                     (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i32x4 123 123 123 123))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0x80 0x80 0x80 0x80)
+                                     (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0 0 0 0))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 -1 -1 -1 -1))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 -1 -1)
+                                     (v128.const i32x4 0 -1 0 -1))
+                                     (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 1 1 1 1)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 128 128 128 128))
+                                     (v128.const i32x4 128 128 128 128))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 123 123 123 123)
+                                     (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i32x4 123 123 123 123))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0x80 0x80 0x80 0x80)
+                                     (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0 0 0 0))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 -1 -1 -1 -1))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 -1 -1)
+                                     (v128.const i32x4 0 -1 0 -1))
+                                     (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 1 1 1 1)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 128 128 128 128))
+                                     (v128.const i32x4 128 128 128 128))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 123 123 123 123)
+                                     (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i32x4 123 123 123 123))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0x80 0x80 0x80 0x80)
+                                     (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0 0 0 0))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 -1 -1 -1 -1))
+                                     (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 -1 -1)
+                                     (v128.const i32x4 0 -1 0 -1))
+                                     (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 1 1 1 1)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 128 128 128 128))
+                                     (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 123 123 123 123)
+                                     (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i32x4 123 123 123 123))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0x80 0x80 0x80 0x80)
+                                     (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i32x4 0x1 0x1 0x1 0x1))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+                                   (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000))
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+                                   (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -01_2_3 -01_2_3 -01_2_3 -01_2_3))
+                                   (v128.const i32x4 123 123 123 123))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 0x80 0x80 0x80 0x80))
+                                   (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0x80 -0x80 -0x80 -0x80))
+                                   (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                   (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0))
+                                   (v128.const i32x4 0x80 0x80 0x80 0x80))
+
+;; Const vs const
+(assert_return (invoke "i32x4.min_s_with_const_0") (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_s_with_const_1") (v128.const i32x4 0 1 1 0))
+(assert_return (invoke "i32x4.min_u_with_const_2") (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_u_with_const_3") (v128.const i32x4 0 1 1 0))
+(assert_return (invoke "i32x4.max_s_with_const_4") (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_s_with_const_5") (v128.const i32x4 3 2 2 3))
+(assert_return (invoke "i32x4.max_u_with_const_6") (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_u_with_const_7") (v128.const i32x4 3 2 2 3))
+(assert_return (invoke "i32x4.abs_with_const_8") (v128.const i32x4 2147483648 2147483647 1073741824 1))
+
+;; Param vs const
+(assert_return (invoke "i32x4.min_s_with_const_9" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                                  (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_s_with_const_10" (v128.const i32x4 3 2 1 0))
+                                                   (v128.const i32x4 0 1 1 0))
+(assert_return (invoke "i32x4.min_u_with_const_11" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                                   (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_u_with_const_12" (v128.const i32x4 3 2 1 0))
+                                                   (v128.const i32x4 0 1 1 0))
+(assert_return (invoke "i32x4.max_s_with_const_13" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                                   (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_s_with_const_14" (v128.const i32x4 3 2 1 0))
+                                                   (v128.const i32x4 3 2 2 3))
+(assert_return (invoke "i32x4.max_u_with_const_15" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                                   (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_u_with_const_16" (v128.const i32x4 3 2 1 0))
+                                                   (v128.const i32x4 3 2 2 3))
+
+;; Test different lanes go through different if-then clauses
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)
+                                     (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                     (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 1 2 128)
+                                     (v128.const i32x4 0 2 1 128))
+                                     (v128.const i32x4 0 1 1 128))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)
+                                     (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                     (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 1 2 128)
+                                     (v128.const i32x4 0 2 1 128))
+                                     (v128.const i32x4 0 1 1 128))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)
+                                     (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                     (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 1 2 128)
+                                     (v128.const i32x4 0 2 1 128))
+                                     (v128.const i32x4 0 2 2 128))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)
+                                     (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                     (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 1 2 128)
+                                     (v128.const i32x4 0 2 1 128))
+                                     (v128.const i32x4 0 2 2 128))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295))
+                                   (v128.const i32x4 2147483648 2147483647 1073741824 1))
+
+;; Test opposite signs of zero
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 -0 -0 +0 +0)
+                                     (v128.const i32x4 +0 0 -0 0))
+                                     (v128.const i32x4 -0 -0 +0 +0))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 -0 -0 -0 -0)
+                                     (v128.const i32x4 +0 +0 +0 +0))
+                                     (v128.const i32x4 -0 -0 -0 -0))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 -0 -0 +0 +0)
+                                     (v128.const i32x4 +0 0 -0 0))
+                                     (v128.const i32x4 -0 -0 +0 +0))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 -0 -0 -0 -0)
+                                     (v128.const i32x4 +0 +0 +0 +0))
+                                     (v128.const i32x4 -0 -0 -0 -0))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 -0 -0 +0 +0)
+                                     (v128.const i32x4 +0 0 -0 0))
+                                     (v128.const i32x4 -0 -0 +0 +0))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 -0 -0 -0 -0)
+                                     (v128.const i32x4 +0 +0 +0 +0))
+                                     (v128.const i32x4 -0 -0 -0 -0))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 -0 -0 +0 +0)
+                                     (v128.const i32x4 +0 0 -0 0))
+                                     (v128.const i32x4 -0 -0 +0 +0))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 -0 -0 -0 -0)
+                                     (v128.const i32x4 +0 +0 +0 +0))
+                                     (v128.const i32x4 -0 -0 -0 -0))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0 -0 +0 +0))
+                                   (v128.const i32x4 -0 -0 +0 +0))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 +0 0 -0 0))
+                                   (v128.const i32x4 +0 0 -0 0))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0 -0 -0 -0))
+                                   (v128.const i32x4 -0 -0 -0 -0))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 +0 +0 +0 +0))
+                                   (v128.const i32x4 +0 +0 +0 +0))
+
+;; Unknown operators
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.min_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.min_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.max_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.max_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.min_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.min_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.max_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.max_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.min_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.min_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.max_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.max_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+
+;; Type check
+(assert_invalid (module (func (result v128) (i32x4.min_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.min_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.max_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.max_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.abs (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.min_s-1st-arg-empty (result v128)
+      (i32x4.min_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.min_s-arg-empty (result v128)
+      (i32x4.min_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.min_u-1st-arg-empty (result v128)
+      (i32x4.min_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.min_u-arg-empty (result v128)
+      (i32x4.min_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.max_s-1st-arg-empty (result v128)
+      (i32x4.max_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.max_s-arg-empty (result v128)
+      (i32x4.max_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.max_u-1st-arg-empty (result v128)
+      (i32x4.max_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.max_u-arg-empty (result v128)
+      (i32x4.max_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.abs-arg-empty (result v128)
+      (i32x4.abs)
+    )
+  )
+  "type mismatch"
+)
+
+;; Combination
+(module
+  (func (export "i32x4.min_s-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_s-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_s-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_s-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_s-i32x4.abs") (param v128 v128) (result v128) (i32x4.min_s (i32x4.abs (local.get 0))(local.get 1)))
+  (func (export "i32x4.abs-i32x4.min_s") (param v128 v128) (result v128) (i32x4.abs (i32x4.min_s (local.get 0) (local.get 1))))
+  (func (export "i32x4.min_u-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_u-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_u-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_u-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_u-i32x4.abs") (param v128 v128) (result v128) (i32x4.min_u (i32x4.abs (local.get 0))(local.get 1)))
+  (func (export "i32x4.abs-i32x4.min_u") (param v128 v128) (result v128) (i32x4.abs (i32x4.min_u (local.get 0) (local.get 1))))
+  (func (export "i32x4.max_s-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_s-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_s-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_s-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_s-i32x4.abs") (param v128 v128) (result v128) (i32x4.max_s (i32x4.abs (local.get 0))(local.get 1)))
+  (func (export "i32x4.abs-i32x4.max_s") (param v128 v128) (result v128) (i32x4.abs (i32x4.max_s (local.get 0) (local.get 1))))
+  (func (export "i32x4.max_u-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_u-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_u-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_u-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_u-i32x4.abs") (param v128 v128) (result v128) (i32x4.max_u (i32x4.abs (local.get 0))(local.get 1)))
+  (func (export "i32x4.abs-i32x4.max_u") (param v128 v128) (result v128) (i32x4.abs (i32x4.max_u (local.get 0) (local.get 1))))
+  (func (export "i32x4.abs-i32x4.abs") (param v128) (result v128) (i32x4.abs (i32x4.abs (local.get 0))))
+)
+
+(assert_return (invoke "i32x4.min_s-i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_s-i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_s-i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_s-i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_s-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1)
+                                               (v128.const i32x4 0 0 0 0))
+                                               (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.abs-i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                               (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_u-i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_u-i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_u-i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_u-i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_u-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1)
+                                               (v128.const i32x4 0 0 0 0))
+                                               (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.abs-i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                               (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_s-i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_s-i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_s-i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_s-i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_s-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1)
+                                               (v128.const i32x4 0 0 0 0))
+                                               (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs-i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                               (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_u-i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_u-i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_u-i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_u-i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_u-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1)
+                                               (v128.const i32x4 0 0 0 0))
+                                               (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs-i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                               (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1))
+                                             (v128.const i32x4 1 1 1 1))
diff --git a/test/core/simd/simd_i32x4_cmp.wast b/test/core/simd/simd_i32x4_cmp.wast
new file mode 100644
index 000000000..fca45ab96
--- /dev/null
+++ b/test/core/simd/simd_i32x4_cmp.wast
@@ -0,0 +1,1920 @@
+
+;; Test all the i32x4 comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (i32x4.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (i32x4.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x v128) (param $y v128) (result v128) (i32x4.lt_s (local.get $x) (local.get $y)))
+  (func (export "lt_u") (param $x v128) (param $y v128) (result v128) (i32x4.lt_u (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x v128) (param $y v128) (result v128) (i32x4.le_s (local.get $x) (local.get $y)))
+  (func (export "le_u") (param $x v128) (param $y v128) (result v128) (i32x4.le_u (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x v128) (param $y v128) (result v128) (i32x4.gt_s (local.get $x) (local.get $y)))
+  (func (export "gt_u") (param $x v128) (param $y v128) (result v128) (i32x4.gt_u (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x v128) (param $y v128) (result v128) (i32x4.ge_s (local.get $x) (local.get $y)))
+  (func (export "ge_u") (param $x v128) (param $y v128) (result v128) (i32x4.ge_u (local.get $x) (local.get $y)))
+)
+
+
+;; eq
+
+;; i32x4.eq  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                            (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                            (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                            (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                            (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                            (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                            (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "eq" (v128.const i32x4 -1 -1 -1 -1)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 0 0)
+                            (v128.const i32x4 4294967295 4294967295 0 0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0 0 4294967295 4294967295)
+                            (v128.const i32x4 0 0 4294967295 4294967295))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                            (v128.const i32x4 2147483649 -1 0 -1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "eq" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "eq" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                            (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                            (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                            (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i32x4 2147483648 2147483647 0 -1)
+                            (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                            (v128.const i32x4 -1 0 0 0))
+
+;; i32x4.eq  (i32x4) (i8x16)
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 -8323200 0 1 4294967295)
+                            (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                            (v128.const i32x4 0 -1 0 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                            (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                            (v128.const i32x4 0 0 0 0))
+
+;; i32x4.eq  (i32x4) (i16x8)
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                            (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 0 1 65535)
+                            (v128.const i16x8 65535 65535 0 0 1 0 65535 65535))
+                            (v128.const i32x4 -1 -1 -1 0))
+(assert_return (invoke "eq" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                            (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                            (v128.const i32x4 123456789 123456789 123456789 123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                            (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; ne
+
+;; i32x4.ne  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                            (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                            (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                            (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                            (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                            (v128.const i32x4 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                            (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                            (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i32x4 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "ne" (v128.const i32x4 -1 -1 -1 -1)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 0 0)
+                            (v128.const i32x4 4294967295 4294967295 0 0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0 0 4294967295 4294967295)
+                            (v128.const i32x4 0 0 4294967295 4294967295))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                            (v128.const i32x4 2147483649 -1 0 -1))
+                            (v128.const i32x4 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "ne" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i32x4 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "ne" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                            (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                            (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                            (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 2147483648 2147483647 0 -1)
+                            (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                            (v128.const i32x4 0 -1 -1 -1))
+
+;; i32x4.ne  (i32x4) (i8x16)
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 -8323200 0 1 4294967295)
+                            (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                            (v128.const i32x4 -1 0 -1 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                            (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.ne  (i32x4) (i16x8)
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                            (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 -128 0 1 255)
+                            (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                            (v128.const i32x4 -1 0 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                            (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                            (v128.const i32x4 123456789 123456789 123456789 123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                            (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                            (v128.const i32x4 0 0 0 0))
+
+;; lt_s
+
+;; i32x4.lt_s  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_s" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_s" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 0 0 0 -1))
+
+;; i32x4.lt_s  (i32x4) (i8x16)
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 0 0 -1 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 0 0 0 0))
+
+;; i32x4.lt_s  (i32x4) (i16x8)
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                              (v128.const i32x4 -0x6f543210 -0x6f543210 -0x6f543210 -0x6f543210))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; lt_u
+
+;; i32x4.lt_u  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_u" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_u" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 0 -1 -1 0))
+
+;; i32x4.lt_u  (i32x4) (i8x16)
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 0 0 -1 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.lt_u  (i32x4) (i16x8)
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                              (v128.const i32x4 -0x6f543210 -0x6f543210 -0x6f543210 -0x6f543210))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; le_s
+
+;; i32x4.le_s  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_s" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_s" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "le_s" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 -1 0 0 -1))
+
+;; i32x4.le_s  (i32x4)(i8x16)
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 0 0 0 0))
+
+;; i32x4.le_s  (i32x4) (i16x8)
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                              (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; le_u
+
+;; i32x4.le_u  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_u" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_u" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "le_u" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "le_u" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "le_u" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 -1 -1 -1 0))
+
+;; i32x4.le_u  (i32x4) (i8x16)
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.le_u  (i32x4) (i16x8)
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                              (v128.const i32x4 0x90ABcdef 0x90ABcdef 0x90ABcdef 0x90ABcdef))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; gt_s
+
+;; i32x4.gt_s  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_s" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_s" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 -1 -1 -1 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 0 -1 -1 0))
+
+;; i32x4.gt_s  (i32x4) (i8x16)
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.gt_s  (i32x4) (i16x8)
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 65535 0 1 32768)
+                              (v128.const i16x8 65535 65535 0 0 1 1 32768 32768))
+                              (v128.const i32x4 -1 0 0 -1))
+(assert_return (invoke "gt_s" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                              (v128.const i32x4 -0x6f543211 -0x6f543211 -0x6f543211 -0x6f543211))
+                              (v128.const i32x4 0 0 0 0))
+
+;; gt_u
+
+;; i32x4.gt_u  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_u" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_u" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 0 0 0 -1))
+
+;; i32x4.gt_u  (i32x4) (i8x16)
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 0 0 0 0))
+
+;; i32x4.gt_u  (i32x4) (i16x8)
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                              (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                              (v128.const i32x4 0 0 0 0))
+
+;; ge_s
+
+;; i32x4.ge_s  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_s" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_s" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 -1 -1 -1 0))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 -1 -1 -1 0))
+
+;; i32x4.ge_s  (i32x4) (i8x16)
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 -1 -1 0 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.ge_s  (i32x4) (i16x8)
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 65535 0 1 32768)
+                              (v128.const i16x8 65535 65535 0 0 1 1 32768 32768))
+                              (v128.const i32x4 -1 -1 0 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                              (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; ge_u
+
+;; i32x4.ge_u  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_u" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_u" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 -1 0 0 -1))
+
+;; i32x4.ge_u  (i32x4) (i8x16)
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 -1 -1 0 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.ge_u  (i32x4) (i16x8)
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 65535 65535 0 0 1 1 32768 32768))
+                              (v128.const i32x4 0 -1 0 0))
+(assert_return (invoke "ge_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                              (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (i32x4.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.ge_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.gt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.le_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.lt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+
+
+;; combination
+
+(module (memory 1)
+  (func (export "eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "lt_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.lt_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "le_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.le_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "gt_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.gt_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ge_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.ge_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-eq")
+    (drop
+      (i32x4.eq
+        (i32x4.eq
+          (i32x4.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.eq
+          (i32x4.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ne")
+    (drop
+      (i32x4.ne
+        (i32x4.ne
+          (i32x4.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.ne
+          (i32x4.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-lt_s")
+    (drop
+      (i32x4.lt_s
+        (i32x4.lt_s
+          (i32x4.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.lt_s
+          (i32x4.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-le_u")
+    (drop
+      (i32x4.le_u
+        (i32x4.le_u
+          (i32x4.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.le_u
+          (i32x4.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-gt_u")
+    (drop
+      (i32x4.gt_u
+        (i32x4.gt_u
+          (i32x4.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.gt_u
+          (i32x4.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ge_s")
+    (drop
+      (i32x4.ge_s
+        (i32x4.ge_s
+          (i32x4.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.ge_s
+          (i32x4.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (i32x4.ge_u
+        (i32x4.eq
+          (i32x4.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.ne
+          (i32x4.gt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.lt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "eq-in-block"))
+(assert_return (invoke "ne-in-block"))
+(assert_return (invoke "lt_s-in-block"))
+(assert_return (invoke "le_u-in-block"))
+(assert_return (invoke "gt_u-in-block"))
+(assert_return (invoke "ge_s-in-block"))
+(assert_return (invoke "nested-eq"))
+(assert_return (invoke "nested-ne"))
+(assert_return (invoke "nested-lt_s"))
+(assert_return (invoke "nested-le_u"))
+(assert_return (invoke "nested-gt_u"))
+(assert_return (invoke "nested-ge_s"))
+(assert_return (invoke "as-param"))
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.eq-1st-arg-empty (result v128)
+      (i32x4.eq (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.eq-arg-empty (result v128)
+      (i32x4.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ne-1st-arg-empty (result v128)
+      (i32x4.ne (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ne-arg-empty (result v128)
+      (i32x4.ne)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.lt_s-1st-arg-empty (result v128)
+      (i32x4.lt_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.lt_s-arg-empty (result v128)
+      (i32x4.lt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.lt_u-1st-arg-empty (result v128)
+      (i32x4.lt_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.lt_u-arg-empty (result v128)
+      (i32x4.lt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.le_s-1st-arg-empty (result v128)
+      (i32x4.le_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.le_s-arg-empty (result v128)
+      (i32x4.le_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.le_u-1st-arg-empty (result v128)
+      (i32x4.le_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.le_u-arg-empty (result v128)
+      (i32x4.le_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.gt_s-1st-arg-empty (result v128)
+      (i32x4.gt_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.gt_s-arg-empty (result v128)
+      (i32x4.gt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.gt_u-1st-arg-empty (result v128)
+      (i32x4.gt_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.gt_u-arg-empty (result v128)
+      (i32x4.gt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ge_s-1st-arg-empty (result v128)
+      (i32x4.ge_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ge_s-arg-empty (result v128)
+      (i32x4.ge_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ge_u-1st-arg-empty (result v128)
+      (i32x4.ge_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ge_u-arg-empty (result v128)
+      (i32x4.ge_u)
+    )
+  )
+  "type mismatch"
+)
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.eq (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ne (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.lt_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.lt_u (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.le_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.le_u (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.gt_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.gt_u (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ge_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ge_u (local.get $x) (local.get $y)))") "unknown operator")
+
diff --git a/test/core/simd/simd_i32x4_dot_i16x8.wast b/test/core/simd/simd_i32x4_dot_i16x8.wast
new file mode 100644
index 000000000..b41de74d0
--- /dev/null
+++ b/test/core/simd/simd_i32x4_dot_i16x8.wast
@@ -0,0 +1,110 @@
+;; Tests for i32x4 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i32x4.dot_i16x8_s") (param v128 v128) (result v128) (i32x4.dot_i16x8_s (local.get 0) (local.get 1)))
+)
+
+
+;; i32x4.dot_i16x8_s
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                           (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                           (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                           (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                           (v128.const i32x4 536838144 536838144 536838144 536838144))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                           (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                           (v128.const i32x4 536870912 536870912 536870912 536870912))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                           (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                           (v128.const i32x4 536838144 536838144 536838144 536838144))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                           (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                           (v128.const i32x4 536870912 536870912 536870912 536870912))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                           (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                           (v128.const i32x4 536903680 536903680 536903680 536903680))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 65530 65530 65530 65530))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 65532 65532 65532 65532))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 -65536 -65536 -65536 -65536))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 65532 65532 65532 65532))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 65534 65534 65534 65534))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 65536 65536 65536 65536))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                           (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                           (v128.const i32x4 2147352578 2147352578 2147352578 2147352578))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                           (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                           (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                           (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                           (v128.const i32x4 2147418112 2147418112 2147418112 2147418112))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                           (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                           (v128.const i32x4 -65534 -65534 -65534 -65534))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                           (v128.const i32x4 65536 65536 65536 65536))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                           (v128.const i32x4 2 2 2 2))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.dot_i16x8_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.dot_i16x8_s-1st-arg-empty (result v128)
+      (i32x4.dot_i16x8_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.dot_i16x8_s-arg-empty (result v128)
+      (i32x4.dot_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast b/test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast
new file mode 100644
index 000000000..2d1682d40
--- /dev/null
+++ b/test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast
@@ -0,0 +1,68 @@
+;; Tests for i32x4 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i32x4.extadd_pairwise_i16x8_s") (param v128) (result v128) (i32x4.extadd_pairwise_i16x8_s (local.get 0)))
+  (func (export "i32x4.extadd_pairwise_i16x8_u") (param v128) (result v128) (i32x4.extadd_pairwise_i16x8_u (local.get 0)))
+)
+
+
+;; i32x4.extadd_pairwise_i16x8_s
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                       (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                       (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                       (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+                                                       (v128.const i32x4 65532 65532 65532 65532))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                       (v128.const i32x4 -65534 -65534 -65534 -65534))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                       (v128.const i32x4 -65536 -65536 -65536 -65536))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                       (v128.const i32x4 65534 65534 65534 65534))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                       (v128.const i32x4 -2 -2 -2 -2))
+
+;; i32x4.extadd_pairwise_i16x8_u
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                       (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                       (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                       (v128.const i32x4 131070 131070 131070 131070))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+                                                       (v128.const i32x4 65532 65532 65532 65532))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                       (v128.const i32x4 65538 65538 65538 65538))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                       (v128.const i32x4 65536 65536 65536 65536))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                       (v128.const i32x4 65534 65534 65534 65534))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                       (v128.const i32x4 131070 131070 131070 131070))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.extadd_pairwise_i16x8_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extadd_pairwise_i16x8_u (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.extadd_pairwise_i16x8_s-arg-empty (result v128)
+      (i32x4.extadd_pairwise_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extadd_pairwise_i16x8_u-arg-empty (result v128)
+      (i32x4.extadd_pairwise_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_i32x4_extmul_i16x8.wast b/test/core/simd/simd_i32x4_extmul_i16x8.wast
new file mode 100644
index 000000000..f04db6770
--- /dev/null
+++ b/test/core/simd/simd_i32x4_extmul_i16x8.wast
@@ -0,0 +1,404 @@
+;; Tests for i32x4 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i32x4.extmul_low_i16x8_s") (param v128 v128) (result v128) (i32x4.extmul_low_i16x8_s (local.get 0) (local.get 1)))
+  (func (export "i32x4.extmul_high_i16x8_s") (param v128 v128) (result v128) (i32x4.extmul_high_i16x8_s (local.get 0) (local.get 1)))
+  (func (export "i32x4.extmul_low_i16x8_u") (param v128 v128) (result v128) (i32x4.extmul_low_i16x8_u (local.get 0) (local.get 1)))
+  (func (export "i32x4.extmul_high_i16x8_u") (param v128 v128) (result v128) (i32x4.extmul_high_i16x8_u (local.get 0) (local.get 1)))
+)
+
+
+;; i32x4.extmul_low_i16x8_s
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                  (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                  (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 268451840 268451840 268451840 268451840))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 32765 32765 32765 32765))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                                  (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 1073676289 1073676289 1073676289 1073676289))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                  (v128.const i32x4 1073709056 1073709056 1073709056 1073709056))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                  (v128.const i32x4 1 1 1 1))
+
+;; i32x4.extmul_high_i16x8_s
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                   (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                   (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 268451840 268451840 268451840 268451840))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 32765 32765 32765 32765))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 1073676289 1073676289 1073676289 1073676289))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                   (v128.const i32x4 1073709056 1073709056 1073709056 1073709056))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                   (v128.const i32x4 1 1 1 1))
+
+;; i32x4.extmul_low_i16x8_u
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -131071 -131071 -131071 -131071))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                  (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                  (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 -1878999040 -1878999040 -1878999040 -1878999040))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 -1879048192 -1879048192 -1879048192 -1879048192))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 -1879097344 -1879097344 -1879097344 -1879097344))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 32765 32765 32765 32765))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -2147385346 -2147385346 -2147385346 -2147385346))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -2147450881 -2147450881 -2147450881 -2147450881))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 2147450880 2147450880 2147450880 2147450880))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                                  (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 1073676289 1073676289 1073676289 1073676289))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                  (v128.const i32x4 1073774592 1073774592 1073774592 1073774592))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -131071 -131071 -131071 -131071))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 2147385345 2147385345 2147385345 2147385345))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 2147450880 2147450880 2147450880 2147450880))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                  (v128.const i32x4 -131071 -131071 -131071 -131071))
+
+;; i32x4.extmul_high_i16x8_u
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -131071 -131071 -131071 -131071))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                   (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                   (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 -1878999040 -1878999040 -1878999040 -1878999040))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 -1879048192 -1879048192 -1879048192 -1879048192))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 -1879097344 -1879097344 -1879097344 -1879097344))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 32765 32765 32765 32765))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -2147385346 -2147385346 -2147385346 -2147385346))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -2147450881 -2147450881 -2147450881 -2147450881))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 2147450880 2147450880 2147450880 2147450880))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 1073676289 1073676289 1073676289 1073676289))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                   (v128.const i32x4 1073774592 1073774592 1073774592 1073774592))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -131071 -131071 -131071 -131071))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 2147385345 2147385345 2147385345 2147385345))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 2147450880 2147450880 2147450880 2147450880))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                   (v128.const i32x4 -131071 -131071 -131071 -131071))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.extmul_low_i16x8_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extmul_high_i16x8_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extmul_low_i16x8_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extmul_high_i16x8_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.extmul_low_i16x8_s-1st-arg-empty (result v128)
+      (i32x4.extmul_low_i16x8_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_low_i16x8_s-arg-empty (result v128)
+      (i32x4.extmul_low_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_high_i16x8_s-1st-arg-empty (result v128)
+      (i32x4.extmul_high_i16x8_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_high_i16x8_s-arg-empty (result v128)
+      (i32x4.extmul_high_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_low_i16x8_u-1st-arg-empty (result v128)
+      (i32x4.extmul_low_i16x8_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_low_i16x8_u-arg-empty (result v128)
+      (i32x4.extmul_low_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_high_i16x8_u-1st-arg-empty (result v128)
+      (i32x4.extmul_high_i16x8_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_high_i16x8_u-arg-empty (result v128)
+      (i32x4.extmul_high_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_i32x4_trunc_sat_f32x4.wast b/test/core/simd/simd_i32x4_trunc_sat_f32x4.wast
new file mode 100644
index 000000000..40af590f5
--- /dev/null
+++ b/test/core/simd/simd_i32x4_trunc_sat_f32x4.wast
@@ -0,0 +1,239 @@
+;; Tests for i32x4 trunc sat conversions from float.
+
+(module
+  (func (export "i32x4.trunc_sat_f32x4_s") (param v128) (result v128) (i32x4.trunc_sat_f32x4_s (local.get 0)))
+  (func (export "i32x4.trunc_sat_f32x4_u") (param v128) (result v128) (i32x4.trunc_sat_f32x4_u (local.get 0)))
+)
+
+
+;; i32x4.trunc_sat_f32x4_s
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0.0 0.0 0.0 0.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 1.5 1.5 1.5 1.5))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -1.5 -1.5 -1.5 -1.5))
+                                                 (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 1.9 1.9 1.9 1.9))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 2.0 2.0 2.0 2.0))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -1.9 -1.9 -1.9 -1.9))
+                                                 (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -2.0 -2.0 -2.0 -2.0))
+                                                 (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 2147483520.0 2147483520.0 2147483520.0 2147483520.0))
+                                                 (v128.const i32x4 2147483520 2147483520 2147483520 2147483520))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -2147483520.0 -2147483520.0 -2147483520.0 -2147483520.0))
+                                                 (v128.const i32x4 -2147483520 -2147483520 -2147483520 -2147483520))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 2147483648.0 2147483648.0 2147483648.0 2147483648.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -2147483648.0 -2147483648.0 -2147483648.0 -2147483648.0))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 4294967294.0 4294967294.0 4294967294.0 4294967294.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -4294967294.0 -4294967294.0 -4294967294.0 -4294967294.0))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 2147483647.0 2147483647.0 2147483647.0 2147483647.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -2147483647.0 -2147483647.0 -2147483647.0 -2147483647.0))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 4294967294.0 4294967294.0 4294967294.0 4294967294.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 4294967295.0 4294967295.0 4294967295.0 4294967295.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 4294967296.0 4294967296.0 4294967296.0 4294967296.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                                 (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.19999ap+0 0x1.19999ap+0 0x1.19999ap+0 0x1.19999ap+0))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.19999ap+0 -0x1.19999ap+0 -0x1.19999ap+0 -0x1.19999ap+0))
+                                                 (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                 (v128.const i32x4 6 6 6 6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                 (v128.const i32x4 -6 -6 -6 -6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.ccccccp-1 0x1.ccccccp-1 0x1.ccccccp-1 0x1.ccccccp-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.ccccccp-1 -0x1.ccccccp-1 -0x1.ccccccp-1 -0x1.ccccccp-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.fffffep-1 0x1.fffffep-1 0x1.fffffep-1 0x1.fffffep-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.fffffep-1 -0x1.fffffep-1 -0x1.fffffep-1 -0x1.fffffep-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                 (v128.const i32x4 6 6 6 6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                 (v128.const i32x4 -6 -6 -6 -6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 +inf +inf +inf +inf))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -inf -inf -inf -inf))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 +nan +nan +nan +nan))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -nan -nan -nan -nan))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 nan:0x444444 nan:0x444444 nan:0x444444 nan:0x444444))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -nan:0x444444 -nan:0x444444 -nan:0x444444 -nan:0x444444))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 42 42 42 42))
+                                                 (v128.const i32x4 42 42 42 42))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -42 -42 -42 -42))
+                                                 (v128.const i32x4 -42 -42 -42 -42))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0123456792.0 0123456792.0 0123456792.0 0123456792.0))
+                                                 (v128.const i32x4 123456792 123456792 123456792 123456792))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 01234567890.0 01234567890.0 01234567890.0 01234567890.0))
+                                                 (v128.const i32x4 1234567936 1234567936 1234567936 1234567936))
+
+;; i32x4.trunc_sat_f32x4_u
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0.0 0.0 0.0 0.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 1.5 1.5 1.5 1.5))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -1.5 -1.5 -1.5 -1.5))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 1.9 1.9 1.9 1.9))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 2.0 2.0 2.0 2.0))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -1.9 -1.9 -1.9 -1.9))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -2.0 -2.0 -2.0 -2.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 2147483520.0 2147483520.0 2147483520.0 2147483520.0))
+                                                 (v128.const i32x4 2147483520 2147483520 2147483520 2147483520))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -2147483520.0 -2147483520.0 -2147483520.0 -2147483520.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 2147483648.0 2147483648.0 2147483648.0 2147483648.0))
+                                                 (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -2147483648.0 -2147483648.0 -2147483648.0 -2147483648.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 4294967294.0 4294967294.0 4294967294.0 4294967294.0))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -4294967294.0 -4294967294.0 -4294967294.0 -4294967294.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 2147483647.0 2147483647.0 2147483647.0 2147483647.0))
+                                                 (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -2147483647.0 -2147483647.0 -2147483647.0 -2147483647.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 4294967294.0 4294967294.0 4294967294.0 4294967294.0))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 4294967295.0 4294967295.0 4294967295.0 4294967295.0))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 4294967296.0 4294967296.0 4294967296.0 4294967296.0))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.19999ap+0 0x1.19999ap+0 0x1.19999ap+0 0x1.19999ap+0))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.19999ap+0 -0x1.19999ap+0 -0x1.19999ap+0 -0x1.19999ap+0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                 (v128.const i32x4 6 6 6 6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.ccccccp-1 0x1.ccccccp-1 0x1.ccccccp-1 0x1.ccccccp-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.ccccccp-1 -0x1.ccccccp-1 -0x1.ccccccp-1 -0x1.ccccccp-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.fffffep-1 0x1.fffffep-1 0x1.fffffep-1 0x1.fffffep-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.fffffep-1 -0x1.fffffep-1 -0x1.fffffep-1 -0x1.fffffep-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                 (v128.const i32x4 6 6 6 6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 +inf +inf +inf +inf))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -inf -inf -inf -inf))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 +nan +nan +nan +nan))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -nan -nan -nan -nan))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 nan:0x444444 nan:0x444444 nan:0x444444 nan:0x444444))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -nan:0x444444 -nan:0x444444 -nan:0x444444 -nan:0x444444))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 42 42 42 42))
+                                                 (v128.const i32x4 42 42 42 42))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -42 -42 -42 -42))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0123456792.0 0123456792.0 0123456792.0 0123456792.0))
+                                                 (v128.const i32x4 123456792 123456792 123456792 123456792))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 01234567890.0 01234567890.0 01234567890.0 01234567890.0))
+                                                 (v128.const i32x4 1234567936 1234567936 1234567936 1234567936))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.trunc_sat_f32x4_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.trunc_sat_f32x4_u (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.trunc_sat_f32x4_s-arg-empty (result v128)
+      (i32x4.trunc_sat_f32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.trunc_sat_f32x4_u-arg-empty (result v128)
+      (i32x4.trunc_sat_f32x4_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_i32x4_trunc_sat_f64x2.wast b/test/core/simd/simd_i32x4_trunc_sat_f64x2.wast
new file mode 100644
index 000000000..9bf507d77
--- /dev/null
+++ b/test/core/simd/simd_i32x4_trunc_sat_f64x2.wast
@@ -0,0 +1,239 @@
+;; Tests for i32x4 trunc sat conversions from float.
+
+(module
+  (func (export "i32x4.trunc_sat_f64x2_s_zero") (param v128) (result v128) (i32x4.trunc_sat_f64x2_s_zero (local.get 0)))
+  (func (export "i32x4.trunc_sat_f64x2_u_zero") (param v128) (result v128) (i32x4.trunc_sat_f64x2_u_zero (local.get 0)))
+)
+
+
+;; i32x4.trunc_sat_f64x2_s_zero
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0.0 0.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0.0 -0.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 1.5 1.5))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -1.5 -1.5))
+                                                      (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 1.9 1.9))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 2.0 2.0))
+                                                      (v128.const i32x4 2 2 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -1.9 -1.9))
+                                                      (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -2.0 -2.0))
+                                                      (v128.const i32x4 -2 -2 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 2147483520.0 2147483520.0))
+                                                      (v128.const i32x4 2147483520 2147483520 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -2147483520.0 -2147483520.0))
+                                                      (v128.const i32x4 -2147483520 -2147483520 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 2147483648.0 2147483648.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -2147483648.0 -2147483648.0))
+                                                      (v128.const i32x4 -2147483648 -2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 4294967294.0 4294967294.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -4294967294.0 -4294967294.0))
+                                                      (v128.const i32x4 -2147483648 -2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 2147483647.0 2147483647.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -2147483647.0 -2147483647.0))
+                                                      (v128.const i32x4 -2147483647 -2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 4294967294.0 4294967294.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 4294967295.0 4294967295.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 4294967296.0 4294967296.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1p-149 0x1p-149))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1p-149 -0x1p-149))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1p-126 0x1p-126))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1p-126 -0x1p-126))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1p-1 0x1p-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1p+0 0x1p+0))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                                      (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.19999ap+0 0x1.19999ap+0))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.19999ap+0 -0x1.19999ap+0))
+                                                      (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                      (v128.const i32x4 6 6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                      (v128.const i32x4 -6 -6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                      (v128.const i32x4 -2147483648 -2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.ccccccp-1 0x1.ccccccp-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.ccccccp-1 -0x1.ccccccp-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.fffffep-1 0x1.fffffep-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.fffffep-1 -0x1.fffffep-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                      (v128.const i32x4 6 6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                      (v128.const i32x4 -6 -6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                      (v128.const i32x4 -2147483648 -2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 +inf +inf))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -inf -inf))
+                                                      (v128.const i32x4 -2147483648 -2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 +nan +nan))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -nan -nan))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 nan:0x444444 nan:0x444444))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -nan:0x444444 -nan:0x444444))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 42 42))
+                                                      (v128.const i32x4 42 42 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -42 -42))
+                                                      (v128.const i32x4 -42 -42 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0123456792.0 0123456792.0))
+                                                      (v128.const i32x4 123456792 123456792 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 01234567890.0 01234567890.0))
+                                                      (v128.const i32x4 1234567890 1234567890 0 0))
+
+;; i32x4.trunc_sat_f64x2_u_zero
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0.0 0.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0.0 -0.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 1.5 1.5))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -1.5 -1.5))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 1.9 1.9))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 2.0 2.0))
+                                                      (v128.const i32x4 2 2 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -1.9 -1.9))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -2.0 -2.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 2147483520.0 2147483520.0))
+                                                      (v128.const i32x4 2147483520 2147483520 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -2147483520.0 -2147483520.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 2147483648.0 2147483648.0))
+                                                      (v128.const i32x4 2147483648 2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -2147483648.0 -2147483648.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 4294967294.0 4294967294.0))
+                                                      (v128.const i32x4 4294967294 4294967294 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -4294967294.0 -4294967294.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 2147483647.0 2147483647.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -2147483647.0 -2147483647.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 4294967294.0 4294967294.0))
+                                                      (v128.const i32x4 4294967294 4294967294 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 4294967295.0 4294967295.0))
+                                                      (v128.const i32x4 4294967295 4294967295 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 4294967296.0 4294967296.0))
+                                                      (v128.const i32x4 4294967295 4294967295 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1p-149 0x1p-149))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1p-149 -0x1p-149))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1p-126 0x1p-126))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1p-126 -0x1p-126))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1p-1 0x1p-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1p+0 0x1p+0))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.19999ap+0 0x1.19999ap+0))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.19999ap+0 -0x1.19999ap+0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                      (v128.const i32x4 6 6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+                                                      (v128.const i32x4 4294967295 4294967295 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.ccccccp-1 0x1.ccccccp-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.ccccccp-1 -0x1.ccccccp-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.fffffep-1 0x1.fffffep-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.fffffep-1 -0x1.fffffep-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                      (v128.const i32x4 6 6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+                                                      (v128.const i32x4 4294967295 4294967295 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 +inf +inf))
+                                                      (v128.const i32x4 4294967295 4294967295 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -inf -inf))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 +nan +nan))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -nan -nan))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 nan:0x444444 nan:0x444444))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -nan:0x444444 -nan:0x444444))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 42 42))
+                                                      (v128.const i32x4 42 42 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -42 -42))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0123456792.0 0123456792.0))
+                                                      (v128.const i32x4 123456792 123456792 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 01234567890.0 01234567890.0))
+                                                      (v128.const i32x4 1234567890 1234567890 0 0))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.trunc_sat_f64x2_s_zero (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.trunc_sat_f64x2_u_zero (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.trunc_sat_f64x2_s_zero-arg-empty (result v128)
+      (i32x4.trunc_sat_f64x2_s_zero)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.trunc_sat_f64x2_u_zero-arg-empty (result v128)
+      (i32x4.trunc_sat_f64x2_u_zero)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_i64x2_arith.wast b/test/core/simd/simd_i64x2_arith.wast
new file mode 100644
index 000000000..00963a0d0
--- /dev/null
+++ b/test/core/simd/simd_i64x2_arith.wast
@@ -0,0 +1,652 @@
+;; Tests for i64x2 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i64x2.add") (param v128 v128) (result v128) (i64x2.add (local.get 0) (local.get 1)))
+  (func (export "i64x2.sub") (param v128 v128) (result v128) (i64x2.sub (local.get 0) (local.get 1)))
+  (func (export "i64x2.mul") (param v128 v128) (result v128) (i64x2.mul (local.get 0) (local.get 1)))
+  (func (export "i64x2.neg") (param v128) (result v128) (i64x2.neg (local.get 0)))
+)
+
+
+;; i64x2.add
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 2 2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -1 -1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 4611686018427387903 4611686018427387903)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 4611686018427387904 4611686018427387904)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -4611686018427387903 -4611686018427387903)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -4611686018427387904 -4611686018427387904)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -4611686018427387905 -4611686018427387905)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 9223372036854775805 9223372036854775805)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775806 9223372036854775806))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 9223372036854775806 9223372036854775806)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 9223372036854775808 9223372036854775808)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775806 -9223372036854775806)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775807 -9223372036854775807)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 9223372036854775807 9223372036854775807)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 9223372036854775806 9223372036854775806))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 18446744073709551615 18446744073709551615))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x3fffffffffffffff 0x3fffffffffffffff)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x4000000000000000 0x4000000000000000)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -0x3fffffffffffffff -0x3fffffffffffffff)
+                                   (v128.const i64x2 -0x40000000fffffff -0x40000000fffffff))
+                                   (v128.const i64x2 -4899916394847535102 -4899916394847535102))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000000 -0x400000000000000))
+                                   (v128.const i64x2 -4899916394579099648 -4899916394579099648))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000001 -0x400000000000001))
+                                   (v128.const i64x2 -4899916394579099649 -4899916394579099649))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x7ffffffffffffff 0x7ffffffffffffff))
+                                   (v128.const i64x2 -8646911284551352322 -8646911284551352322))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 -0x01 -0x01))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0x80 0 0 0 0 0 0 0 0x80))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i16x8 0 0 0 0x8000 0 0 0 0x8000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i32x4 0 0x80000000 0 0x80000000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 +0.0 +0.0))
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 -0.0 -0.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 1.0 1.0))
+                                   (v128.const i64x2 0xbff0000000000000 0xbff0000000000000))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 -1.0 -1.0))
+                                   (v128.const i64x2 0x3ff0000000000000 0x3ff0000000000000))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const f64x2 +inf +inf))
+                                   (v128.const i64x2 0x7ff0000000000001 0x7ff0000000000001))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const i64x2 0xfff0000000000001 0xfff0000000000001))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const i64x2 0x7ff8000000000001 0x7ff8000000000001))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 0xffffffffffffffff))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 2))
+                                   (v128.const i64x2 0 3))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)
+                                   (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789))
+                                   (v128.const i64x2 02_469_135_780_246_913_578 02_469_135_780_246_913_578))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef)
+                                   (v128.const i64x2 0x0_90AB_cdef_1234_5678 0x0_90AB_cdef_1234_5678))
+                                   (v128.const i64x2 0x0_a2e0_2467_a2e0_2467 0x0_a2e0_2467_a2e0_2467))
+
+;; i64x2.sub
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 2 2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -1 -1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 4611686018427387903 4611686018427387903)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 4611686018427387904 4611686018427387904)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -4611686018427387903 -4611686018427387903)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -4611686018427387904 -4611686018427387904)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -4611686018427387905 -4611686018427387905)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 9223372036854775805 9223372036854775805)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775804 9223372036854775804))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 9223372036854775806 9223372036854775806)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775805 9223372036854775805))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 9223372036854775808 9223372036854775808)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775806 -9223372036854775806)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775805 -9223372036854775805))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775807 -9223372036854775807)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775806 -9223372036854775806))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 9223372036854775807 9223372036854775807)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 18446744073709551615 18446744073709551615))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x3fffffffffffffff 0x3fffffffffffffff)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x4000000000000000 0x4000000000000000)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -0x3fffffffffffffff -0x3fffffffffffffff)
+                                   (v128.const i64x2 -0x40000000fffffff -0x40000000fffffff))
+                                   (v128.const i64x2 -4323455642007240704 -4323455642007240704))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000000 -0x400000000000000))
+                                   (v128.const i64x2 -4323455642275676160 -4323455642275676160))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000001 -0x400000000000001))
+                                   (v128.const i64x2 -4323455642275676159 -4323455642275676159))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x7ffffffffffffff 0x7ffffffffffffff))
+                                   (v128.const i64x2 8646911284551352320 8646911284551352320))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 9223372036854775806 9223372036854775806))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 -0x01 -0x01))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0x80 0 0 0 0 0 0 0 0x80))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i64x2 2 2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i16x8 0 0 0 0x8000 0 0 0 0x8000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i64x2 2 2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i32x4 0 0x80000000 0 0x80000000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i64x2 2 2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 +0.0 +0.0))
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 -0.0 -0.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 1.0 1.0))
+                                   (v128.const i64x2 0x4010000000000000 0x4010000000000000))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 -1.0 -1.0))
+                                   (v128.const i64x2 0xc010000000000000 0xc010000000000000))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 +inf +inf))
+                                   (v128.const i64x2 0x8010000000000001 0x8010000000000001))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const i64x2 0x0010000000000001 0x0010000000000001))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const i64x2 0x8008000000000001 0x8008000000000001))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 0xffffffffffffffff))
+                                   (v128.const i64x2 0 0x02))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 2))
+                                   (v128.const i64x2 0 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 03_214_567_890_123_456_789 03_214_567_890_123_456_789)
+                                   (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789))
+                                   (v128.const i64x2 01_980_000_000_000_000_000 01_980_000_000_000_000_000))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x0_90AB_cdef_8765_4321 0x0_90AB_cdef_8765_4321)
+                                   (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef))
+                                   (v128.const i64x2 0x0_7e77_7776_f6b9_7532 0x0_7e77_7776_f6b9_7532))
+
+;; i64x2.mul
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -1 -1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 4611686018427387903 4611686018427387903)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 4611686018427387904 4611686018427387904)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -4611686018427387903 -4611686018427387903)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -4611686018427387904 -4611686018427387904)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -4611686018427387905 -4611686018427387905)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 9223372036854775805 9223372036854775805)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775805 9223372036854775805))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 9223372036854775806 9223372036854775806)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775806 9223372036854775806))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 9223372036854775808 9223372036854775808)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775806 -9223372036854775806)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 9223372036854775806 9223372036854775806))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775807 -9223372036854775807)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 9223372036854775807 9223372036854775807)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 18446744073709551615 18446744073709551615))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x3fffffffffffffff 0x3fffffffffffffff)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x4000000000000000 0x4000000000000000)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -0x3fffffffffffffff -0x3fffffffffffffff)
+                                   (v128.const i64x2 -0x40000000fffffff -0x40000000fffffff))
+                                   (v128.const i64x2 -4899916394847535103 -4899916394847535103))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000000 -0x400000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000001 -0x400000000000001))
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x7ffffffffffffff 0x7ffffffffffffff))
+                                   (v128.const i64x2 8646911284551352321 8646911284551352321))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 -0x01 -0x01))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i8x16 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i16x8 0 0 0 0x02 0 0 0 0x02))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i32x4 0 0x02 0 0x02))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x80000000 0x80000000)
+                                   (v128.const f64x2 +0.0 +0.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x80000000 0x80000000)
+                                   (v128.const f64x2 -0.0 -0.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x80000000 0x80000000)
+                                   (v128.const f64x2 1.0 1.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x80000000 0x80000000)
+                                   (v128.const f64x2 -1.0 -1.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 +inf +inf))
+                                   (v128.const i64x2 0x7ff0000000000000 0x7ff0000000000000))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const i64x2 0xfff0000000000000 0xfff0000000000000))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const i64x2 0x7ff8000000000000 0x7ff8000000000000))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 0xffffffffffffffff))
+                                   (v128.const i64x2 0 0xffffffffffffffff))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 2))
+                                   (v128.const i64x2 0 0x02))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)
+                                   (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789))
+                                   (v128.const i64x2 09_710_478_858_155_731_897 09_710_478_858_155_731_897))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef)
+                                   (v128.const i64x2 0x0_90AB_cdef_8765_4321 0x0_90AB_cdef_8765_4321))
+                                   (v128.const i64x2 0x0_602f_05e9_e556_18cf 0x0_602f_05e9_e556_18cf))
+
+;; i64x2.neg
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 0 0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 9223372036854775806 9223372036854775806))
+                                   (v128.const i64x2 -9223372036854775806 -9223372036854775806))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 18446744073709551615 18446744073709551615))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -0x01 -0x01))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -0x8000000000000000 -0x8000000000000000))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -0x7fffffffffffffff -0x7fffffffffffffff))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff))
+                                   (v128.const i64x2 1 1))
+
+;; type check
+(assert_invalid (module (func (result v128) (i64x2.neg (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.add (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.sub (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.mul (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i64x2.neg-arg-empty (result v128)
+      (i64x2.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.add-1st-arg-empty (result v128)
+      (i64x2.add (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.add-arg-empty (result v128)
+      (i64x2.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.sub-1st-arg-empty (result v128)
+      (i64x2.sub (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.sub-arg-empty (result v128)
+      (i64x2.sub)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.mul-1st-arg-empty (result v128)
+      (i64x2.mul (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.mul-arg-empty (result v128)
+      (i64x2.mul)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (i64x2.add (i64x2.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-add") (param v128 v128 v128) (result v128)
+    (i64x2.mul (i64x2.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-sub") (param v128 v128 v128) (result v128)
+    (i64x2.mul (i64x2.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (i64x2.sub (i64x2.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (i64x2.add (i64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "mul-neg") (param v128 v128) (result v128)
+    (i64x2.mul (i64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (i64x2.sub (i64x2.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 2)
+                                 (v128.const i64x2 0 2))
+                                 (v128.const i64x2 0 1))
+(assert_return (invoke "mul-add" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 1)
+                                 (v128.const i64x2 2 2))
+                                 (v128.const i64x2 0 4))
+(assert_return (invoke "mul-sub" (v128.const i64x2 0 2)
+                                 (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 1))
+                                 (v128.const i64x2 0 1))
+(assert_return (invoke "sub-add" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 2)
+                                 (v128.const i64x2 0 2))
+                                 (v128.const i64x2 0 1))
+(assert_return (invoke "add-neg" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 1))
+                                 (v128.const i64x2 0 0))
+(assert_return (invoke "mul-neg" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 2 2))
+                                 (v128.const i64x2 0 -2))
+(assert_return (invoke "sub-neg" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 1))
+                                 (v128.const i64x2 0 -2))
\ No newline at end of file
diff --git a/test/core/simd/simd_i64x2_arith2.wast b/test/core/simd/simd_i64x2_arith2.wast
new file mode 100644
index 000000000..14398d8a4
--- /dev/null
+++ b/test/core/simd/simd_i64x2_arith2.wast
@@ -0,0 +1,78 @@
+;; Tests for i64x2 [abs] operations.
+
+(module
+  (func (export "i64x2.abs") (param v128) (result v128) (i64x2.abs (local.get 0)))
+  (func (export "i64x2.abs_with_const_0") (result v128) (i64x2.abs (v128.const i64x2 -9223372036854775808 9223372036854775807)))
+)
+
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 1 1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 18446744073709551615 18446744073709551615))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff))
+                                   (v128.const i64x2 0x1 0x1))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 9223372036854775808 9223372036854775808))
+                                   (v128.const i64x2 9223372036854775808 9223372036854775808))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 9223372036854775808 9223372036854775808))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0x8000000000000000 -0x8000000000000000))
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 01_2_3 01_2_3))
+                                   (v128.const i64x2 01_2_3 01_2_3))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -01_2_3 -01_2_3))
+                                   (v128.const i64x2 123 123))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 0x80 0x80))
+                                   (v128.const i64x2 0x80 0x80))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0x80 -0x80))
+                                   (v128.const i64x2 0x80 0x80))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 0x0_8_0 0x0_8_0))
+                                   (v128.const i64x2 0x0_8_0 0x0_8_0))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0x0_8_0 -0x0_8_0))
+                                   (v128.const i64x2 0x80 0x80))
+
+;; Const vs const
+(assert_return (invoke "i64x2.abs_with_const_0") (v128.const i64x2 9223372036854775808 9223372036854775807))
+
+;; Param vs const
+
+;; Test different lanes go through different if-then clauses
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -9223372036854775808 9223372036854775807))
+                                   (v128.const i64x2 9223372036854775808 9223372036854775807))
+
+;; Test opposite signs of zero
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0 -0))
+                                   (v128.const i64x2 -0 -0))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 +0 0))
+                                   (v128.const i64x2 +0 0))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0 -0))
+                                   (v128.const i64x2 -0 -0))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 +0 +0))
+                                   (v128.const i64x2 +0 +0))
+
+;; Unknown operators
+
+;; Type check
+(assert_invalid (module (func (result v128) (i64x2.abs (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i64x2.abs-arg-empty (result v128)
+      (i64x2.abs)
+    )
+  )
+  "type mismatch"
+)
+
+;; Combination
+(module
+  (func (export "i64x2.abs-i64x2.abs") (param v128) (result v128) (i64x2.abs (i64x2.abs (local.get 0))))
+)
+
+(assert_return (invoke "i64x2.abs-i64x2.abs" (v128.const i64x2 -1 -1))
+                                             (v128.const i64x2 1 1))
diff --git a/test/core/simd/simd_i64x2_cmp.wast b/test/core/simd/simd_i64x2_cmp.wast
new file mode 100644
index 000000000..50e58b64b
--- /dev/null
+++ b/test/core/simd/simd_i64x2_cmp.wast
@@ -0,0 +1,420 @@
+
+;; Test all the i64x2 comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (i64x2.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (i64x2.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x v128) (param $y v128) (result v128) (i64x2.lt_s (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x v128) (param $y v128) (result v128) (i64x2.le_s (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x v128) (param $y v128) (result v128) (i64x2.gt_s (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x v128) (param $y v128) (result v128) (i64x2.ge_s (local.get $x) (local.get $y)))
+)
+
+
+;; eq
+
+;; i64x2.eq  (i64x2) (i64x2)
+(assert_return (invoke "eq" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                            (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                            (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                            (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                            (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                            (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                            (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0x03020100 0x11100904)
+                            (v128.const i64x2 0x03020100 0x11100904))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                            (v128.const i64x2 0x0FFFFFFFFFFFFFFF 0x0FFFFFFFFFFFFFFF))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "eq" (v128.const i64x2 0x1 0x1)
+                            (v128.const i64x2 0x2 0x2))
+                            (v128.const i64x2 0 0))
+
+;; ne
+
+;; i64x2.ne  (i64x2) (i64x2)
+
+;; hex vs hex
+(assert_return (invoke "ne" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                            (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                            (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                            (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                            (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                            (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                            (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0x03020100 0x11100904)
+                            (v128.const i64x2 0x03020100 0x11100904))
+                            (v128.const i64x2 0 0))
+
+;; lt_s
+
+;; i64x2.lt_s  (i64x2) (i64x2)
+
+;; hex vs hex
+(assert_return (invoke "lt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                              (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                              (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                              (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B)
+                              (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B))
+                              (v128.const i64x2 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 9259542123273814144 9259542123273814144))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 -9187201950435737472 -9187201950435737472))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x8382818000FFFEFD 0x7F020100FFFEFD80)
+                              (v128.const i64x2 -8970465120996032771 9151878496576798080))
+                              (v128.const i64x2 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_s" (v128.const i64x2 -1 -1)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0 0)
+                              (v128.const i64x2 0 0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 18446744073709551615 0)
+                              (v128.const i64x2 18446744073709551615 0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0 18446744073709551615)
+                              (v128.const i64x2 0 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 -9223372036854775807 18446744073709551615)
+                              (v128.const i64x2 9223372036854775809 -1))
+                              (v128.const i64x2 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_s" (v128.const i64x2 0xc060000000000000 0xc05fc00000000000)
+                              (v128.const f64x2 -128.0 -127.0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x3ff0000000000000 0x405fc00000000000)
+                              (v128.const f64x2 1.0 127.0))
+                              (v128.const i64x2 0 0))
+
+;; le_s
+
+;; i64x2.le_s  (i64x2) (i64x2)
+
+;; hex vs hex
+(assert_return (invoke "le_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                              (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                              (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                              (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B)
+                              (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B))
+                              (v128.const i64x2 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 9259542123273814144 9259542123273814144))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 -9187201950435737472 -9187201950435737472))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x8382818000FFFEFD 0x7F020100FFFEFD80)
+                              (v128.const i64x2 -8970465120996032771 9151878496576798080))
+                              (v128.const i64x2 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_s" (v128.const i64x2 -1 -1)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0 0)
+                              (v128.const i64x2 0 -1))
+                              (v128.const i64x2 -1 0))
+(assert_return (invoke "le_s" (v128.const i64x2 0 0)
+                              (v128.const i64x2 0 0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 18446744073709551615 0)
+                              (v128.const i64x2 18446744073709551615 0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0 18446744073709551615)
+                              (v128.const i64x2 0 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 -9223372036854775807 18446744073709551615)
+                              (v128.const i64x2 9223372036854775809 -1))
+                              (v128.const i64x2 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_s" (v128.const i64x2 0xc060000000000000 0xc05fc00000000000)
+                              (v128.const f64x2 -128.0 -127.0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x3ff0000000000000 0x405fc00000000000)
+                              (v128.const f64x2 1.0 127.0))
+                              (v128.const i64x2 -1 -1))
+
+;; gt_s
+
+;; i64x2.gt_s  (i64x2) (i64x2)
+
+;; hex vs hex
+(assert_return (invoke "gt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                              (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                              (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                              (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B)
+                              (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B))
+                              (v128.const i64x2 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 9259542123273814144 9259542123273814144))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 -9187201950435737472 -9187201950435737472))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x8382818000FFFEFD 0x7F020100FFFEFD80)
+                              (v128.const i64x2 -8970465120996032771 9151878496576798080))
+                              (v128.const i64x2 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_s" (v128.const i64x2 -1 -1)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0 0)
+                              (v128.const i64x2 0 0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 18446744073709551615 0)
+                              (v128.const i64x2 18446744073709551615 0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0 18446744073709551615)
+                              (v128.const i64x2 0 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 -9223372036854775807 18446744073709551615)
+                              (v128.const i64x2 9223372036854775809 -1))
+                              (v128.const i64x2 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_s" (v128.const i64x2 0xc060000000000000 0xc05fc00000000000)
+                              (v128.const f64x2 -128.0 -127.0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x3ff0000000000000 0x405fc00000000000)
+                              (v128.const f64x2 1.0 127.0))
+                              (v128.const i64x2 0 0))
+
+;; ge_s
+
+;; i64x2.ge_s  (i64x2) (i64x2)
+
+;; hex vs hex
+(assert_return (invoke "ge_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                              (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                              (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                              (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B)
+                              (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B))
+                              (v128.const i64x2 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 9259542123273814144 9259542123273814144))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 -9187201950435737472 -9187201950435737472))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x8382818000FFFEFD 0x7F020100FFFEFD80)
+                              (v128.const i64x2 -8970465120996032771 9151878496576798080))
+                              (v128.const i64x2 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_s" (v128.const i64x2 -1 -1)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 -1 -1)
+                              (v128.const i64x2 0 -1))
+                              (v128.const i64x2 0 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0 0)
+                              (v128.const i64x2 0 0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 18446744073709551615 0)
+                              (v128.const i64x2 18446744073709551615 0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0 18446744073709551615)
+                              (v128.const i64x2 0 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 -9223372036854775807 18446744073709551615)
+                              (v128.const i64x2 9223372036854775809 -1))
+                              (v128.const i64x2 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_s" (v128.const i64x2 0xc060000000000000 0xc05fc00000000000)
+                              (v128.const f64x2 -128.0 -127.0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x3ff0000000000000 0x405fc00000000000)
+                              (v128.const f64x2 1.0 127.0))
+                              (v128.const i64x2 -1 -1))
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (i64x2.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i64x2.eq-1st-arg-empty (result v128)
+      (i64x2.eq (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.eq-arg-empty (result v128)
+      (i64x2.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.ne-1st-arg-empty (result v128)
+      (i64x2.ne (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.ne-arg-empty (result v128)
+      (i64x2.ne)
+    )
+  )
+  "type mismatch"
+)
\ No newline at end of file
diff --git a/test/core/simd/simd_i64x2_extmul_i32x4.wast b/test/core/simd/simd_i64x2_extmul_i32x4.wast
new file mode 100644
index 000000000..9259279c9
--- /dev/null
+++ b/test/core/simd/simd_i64x2_extmul_i32x4.wast
@@ -0,0 +1,404 @@
+;; Tests for i64x2 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i64x2.extmul_low_i32x4_s") (param v128 v128) (result v128) (i64x2.extmul_low_i32x4_s (local.get 0) (local.get 1)))
+  (func (export "i64x2.extmul_high_i32x4_s") (param v128 v128) (result v128) (i64x2.extmul_high_i32x4_s (local.get 0) (local.get 1)))
+  (func (export "i64x2.extmul_low_i32x4_u") (param v128 v128) (result v128) (i64x2.extmul_low_i32x4_u (local.get 0) (local.get 1)))
+  (func (export "i64x2.extmul_high_i32x4_u") (param v128 v128) (result v128) (i64x2.extmul_high_i32x4_u (local.get 0) (local.get 1)))
+)
+
+
+;; i64x2.extmul_low_i32x4_s
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -1 -1 -1 -1)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                  (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                  (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 1152921505680588800 1152921505680588800))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 2147483645 2147483645))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                                  (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 4611686014132420609 4611686014132420609))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                                  (v128.const i64x2 4611686016279904256 4611686016279904256))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 -2147483647 -2147483647))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                                  (v128.const i64x2 1 1))
+
+;; i64x2.extmul_high_i32x4_s
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -1 -1 -1 -1)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                   (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                   (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 1152921505680588800 1152921505680588800))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 2147483645 2147483645))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 4611686014132420609 4611686014132420609))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                                   (v128.const i64x2 4611686016279904256 4611686016279904256))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 -2147483647 -2147483647))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                                   (v128.const i64x2 1 1))
+
+;; i64x2.extmul_low_i32x4_u
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 -8589934591 -8589934591))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                  (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                  (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 -8070450529026703360 -8070450529026703360))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 -8070450532247928832 -8070450532247928832))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 -8070450535469154304 -8070450535469154304))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 2147483645 2147483645))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 -9223372030412324866 -9223372030412324866))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 -9223372034707292161 -9223372034707292161))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 9223372034707292160 9223372034707292160))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                                  (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 4611686014132420609 4611686014132420609))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                                  (v128.const i64x2 4611686020574871552 4611686020574871552))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 -8589934591 -8589934591))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 9223372030412324865 9223372030412324865))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 9223372034707292160 9223372034707292160))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                                  (v128.const i64x2 -8589934591 -8589934591))
+
+;; i64x2.extmul_high_i32x4_u
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 -8589934591 -8589934591))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                   (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                   (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 -8070450529026703360 -8070450529026703360))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 -8070450532247928832 -8070450532247928832))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 -8070450535469154304 -8070450535469154304))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 2147483645 2147483645))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 -9223372030412324866 -9223372030412324866))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 -9223372034707292161 -9223372034707292161))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 9223372034707292160 9223372034707292160))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 4611686014132420609 4611686014132420609))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                                   (v128.const i64x2 4611686020574871552 4611686020574871552))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 -8589934591 -8589934591))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 9223372030412324865 9223372030412324865))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 9223372034707292160 9223372034707292160))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                                   (v128.const i64x2 -8589934591 -8589934591))
+
+;; type check
+(assert_invalid (module (func (result v128) (i64x2.extmul_low_i32x4_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extmul_high_i32x4_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extmul_low_i32x4_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extmul_high_i32x4_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i64x2.extmul_low_i32x4_s-1st-arg-empty (result v128)
+      (i64x2.extmul_low_i32x4_s (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_low_i32x4_s-arg-empty (result v128)
+      (i64x2.extmul_low_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_high_i32x4_s-1st-arg-empty (result v128)
+      (i64x2.extmul_high_i32x4_s (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_high_i32x4_s-arg-empty (result v128)
+      (i64x2.extmul_high_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_low_i32x4_u-1st-arg-empty (result v128)
+      (i64x2.extmul_low_i32x4_u (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_low_i32x4_u-arg-empty (result v128)
+      (i64x2.extmul_low_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_high_i32x4_u-1st-arg-empty (result v128)
+      (i64x2.extmul_high_i32x4_u (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_high_i32x4_u-arg-empty (result v128)
+      (i64x2.extmul_high_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_i8x16_arith.wast b/test/core/simd/simd_i8x16_arith.wast
new file mode 100644
index 000000000..1e56b4c00
--- /dev/null
+++ b/test/core/simd/simd_i8x16_arith.wast
@@ -0,0 +1,426 @@
+;; Tests for i8x16 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i8x16.add") (param v128 v128) (result v128) (i8x16.add (local.get 0) (local.get 1)))
+  (func (export "i8x16.sub") (param v128 v128) (result v128) (i8x16.sub (local.get 0) (local.get 1)))
+  (func (export "i8x16.neg") (param v128) (result v128) (i8x16.neg (local.get 0)))
+)
+
+
+;; i8x16.add
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                   (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                   (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                   (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                   (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                   (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                   (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                   (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                   (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i8x16 0x80 0x80 0 0xbf 0x80 0x80 0 0xbf 0x80 0x80 0 0xbf 0x80 0x80 0 0xbf))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i8x16 0x80 0x80 0 0x3f 0x80 0x80 0 0x3f 0x80 0x80 0 0x3f 0x80 0x80 0 0x3f))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i8x16 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i8x16 0x01 0x01 0x81 0 0x01 0x01 0x81 0 0x01 0x01 0x81 0 0x01 0x01 0x81 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i8x16 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                   (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                   (v128.const i8x16 0 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45))
+
+;; i8x16.sub
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                   (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                   (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                   (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                   (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                   (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                   (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                   (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i8x16 0x80 0x80 0 0x41 0x80 0x80 0 0x41 0x80 0x80 0 0x41 0x80 0x80 0 0x41))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i8x16 0x80 0x80 0 0xc1 0x80 0x80 0 0xc1 0x80 0x80 0 0xc1 0x80 0x80 0 0xc1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i8x16 0x01 0x01 0x81 0x82 0x01 0x01 0x81 0x82 0x01 0x01 0x81 0x82 0x01 0x01 0x81 0x82))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i8x16 0x01 0x01 0x81 0x02 0x01 0x01 0x81 0x02 0x01 0x01 0x81 0x02 0x01 0x01 0x81 0x02))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i8x16 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                   (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                   (v128.const i8x16 0 0x02 0x04 0x06 0x08 0x0a 0x0c 0x0e 0x10 0x12 0x14 0x16 0x18 0x1a 0x1c 0x1e))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                   (v128.const i8x16 0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15))
+
+;; i8x16.neg
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+                                   (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+
+;; type check
+(assert_invalid (module (func (result v128) (i8x16.neg (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.add (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.sub (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.neg-arg-empty (result v128)
+      (i8x16.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.add-1st-arg-empty (result v128)
+      (i8x16.add (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.add-arg-empty (result v128)
+      (i8x16.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub-1st-arg-empty (result v128)
+      (i8x16.sub (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub-arg-empty (result v128)
+      (i8x16.sub)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (i8x16.add (i8x16.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (i8x16.sub (i8x16.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (i8x16.add (i8x16.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (i8x16.sub (i8x16.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                 (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30)
+                                 (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "sub-add" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                 (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30)
+                                 (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "add-neg" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+                                 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "sub-neg" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+                                 (v128.const i8x16 0 -2 -4 -6 -8 -10 -12 -14 -16 -18 -20 -22 -24 -26 -28 -30))
\ No newline at end of file
diff --git a/test/core/simd/simd_i8x16_arith2.wast b/test/core/simd/simd_i8x16_arith2.wast
new file mode 100644
index 000000000..991ec14bb
--- /dev/null
+++ b/test/core/simd/simd_i8x16_arith2.wast
@@ -0,0 +1,713 @@
+;; Tests for i8x16 [min_s, min_u, max_s, max_u, avgr_u, abs] operations.
+
+(module
+  (func (export "i8x16.min_s") (param v128 v128) (result v128) (i8x16.min_s (local.get 0) (local.get 1)))
+  (func (export "i8x16.min_u") (param v128 v128) (result v128) (i8x16.min_u (local.get 0) (local.get 1)))
+  (func (export "i8x16.max_s") (param v128 v128) (result v128) (i8x16.max_s (local.get 0) (local.get 1)))
+  (func (export "i8x16.max_u") (param v128 v128) (result v128) (i8x16.max_u (local.get 0) (local.get 1)))
+  (func (export "i8x16.avgr_u") (param v128 v128) (result v128) (i8x16.avgr_u (local.get 0) (local.get 1)))
+  (func (export "i8x16.abs") (param v128) (result v128) (i8x16.abs (local.get 0)))
+  (func (export "i8x16.popcnt") (param v128) (result v128) (i8x16.popcnt (local.get 0)))
+  (func (export "i8x16.min_s_with_const_0") (result v128) (i8x16.min_s (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)))
+  (func (export "i8x16.min_s_with_const_1") (result v128) (i8x16.min_s (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)))
+  (func (export "i8x16.min_u_with_const_2") (result v128) (i8x16.min_u (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)))
+  (func (export "i8x16.min_u_with_const_3") (result v128) (i8x16.min_u (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)))
+  (func (export "i8x16.max_s_with_const_4") (result v128) (i8x16.max_s (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)))
+  (func (export "i8x16.max_s_with_const_5") (result v128) (i8x16.max_s (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)))
+  (func (export "i8x16.max_u_with_const_6") (result v128) (i8x16.max_u (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)))
+  (func (export "i8x16.max_u_with_const_7") (result v128) (i8x16.max_u (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)))
+  (func (export "i8x16.avgr_u_with_const_8") (result v128) (i8x16.avgr_u (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)))
+  (func (export "i8x16.avgr_u_with_const_9") (result v128) (i8x16.avgr_u (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)))
+  (func (export "i8x16.abs_with_const_10") (result v128) (i8x16.abs (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.popcnt_with_const_11") (result v128) (i8x16.popcnt (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.min_s_with_const_12") (param v128) (result v128) (i8x16.min_s (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.min_s_with_const_13") (param v128) (result v128) (i8x16.min_s (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3)))
+  (func (export "i8x16.min_u_with_const_14") (param v128) (result v128) (i8x16.min_u (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.min_u_with_const_15") (param v128) (result v128) (i8x16.min_u (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3)))
+  (func (export "i8x16.max_s_with_const_16") (param v128) (result v128) (i8x16.max_s (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.max_s_with_const_17") (param v128) (result v128) (i8x16.max_s (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3)))
+  (func (export "i8x16.max_u_with_const_18") (param v128) (result v128) (i8x16.max_u (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.max_u_with_const_19") (param v128) (result v128) (i8x16.max_u (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3)))
+  (func (export "i8x16.avgr_u_with_const_20") (param v128) (result v128) (i8x16.avgr_u (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.avgr_u_with_const_21") (param v128) (result v128) (i8x16.avgr_u (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3)))
+)
+
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)
+                                     (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)
+                                     (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                     (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)
+                                     (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                     (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)
+                                     (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                      (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                      (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)
+                                      (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1))
+                                      (v128.const i8x16 0 0 0 0 128 128 128 128 128 128 128 128 255 255 255 255))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                      (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                      (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                      (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                      (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                      (v128.const i8x16 192 192 192 192 192 192 192 192 192 192 192 192 192 192 192 192))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                      (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                      (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                      (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                      (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)
+                                      (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                      (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                      (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                      (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                   (v128.const i8x16 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                   (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                   (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3))
+                                   (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                      (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                      (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                      (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                      (v128.const i8x16 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3))
+                                      (v128.const i8x16 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+
+;; Const vs const
+(assert_return (invoke "i8x16.min_s_with_const_0") (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_s_with_const_1") (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i8x16.min_u_with_const_2") (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_u_with_const_3") (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i8x16.max_s_with_const_4") (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_s_with_const_5") (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3))
+(assert_return (invoke "i8x16.max_u_with_const_6") (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_u_with_const_7") (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3))
+(assert_return (invoke "i8x16.avgr_u_with_const_8") (v128.const i8x16 192 192 192 192 96 96 96 96 96 96 96 96 192 192 192 192))
+(assert_return (invoke "i8x16.avgr_u_with_const_9") (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.abs_with_const_10") (v128.const i8x16 128 128 128 128 127 127 127 127 64 64 64 64 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt_with_const_11") (v128.const i8x16 1 1 1 1 7 7 7 7 1 1 1 1 8 8 8 8))
+
+;; Param vs const
+(assert_return (invoke "i8x16.min_s_with_const_12" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                                   (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_s_with_const_13" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i8x16.min_u_with_const_14" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                                   (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_u_with_const_15" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i8x16.max_s_with_const_16" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                                   (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_s_with_const_17" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))
+                                                   (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3))
+(assert_return (invoke "i8x16.max_u_with_const_18" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                                   (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_u_with_const_19" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))
+                                                   (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3))
+(assert_return (invoke "i8x16.avgr_u_with_const_20" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                                    (v128.const i8x16 192 192 192 192 96 96 96 96 96 96 96 96 192 192 192 192))
+(assert_return (invoke "i8x16.avgr_u_with_const_21" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))
+                                                    (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+
+;; Test different lanes go through different if-then clauses
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)
+                                     (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                     (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128)
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128))
+                                     (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 128 128 128 128))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)
+                                     (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                     (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128)
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128))
+                                     (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 128 128 128 128))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)
+                                     (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                     (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128)
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128))
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 2 2 2 2 128 128 128 128))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)
+                                     (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                     (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128)
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128))
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 2 2 2 2 128 128 128 128))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)
+                                      (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                      (v128.const i8x16 192 192 192 192 96 96 96 96 96 96 96 96 192 192 192 192))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128)
+                                      (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128))
+                                      (v128.const i8x16 0 0 0 0 2 2 2 2 2 2 2 2 128 128 128 128))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255))
+                                   (v128.const i8x16 128 128 128 128 127 127 127 127 64 64 64 64 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255))
+                                      (v128.const i8x16 1 1 1 1 7 7 7 7 1 1 1 1 8 8 8 8))
+
+;; Test opposite signs of zero
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)
+                                     (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)
+                                     (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)
+                                     (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)
+                                     (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)
+                                      (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)
+                                      (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                   (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                   (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+                                   (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                   (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; Unknown operators
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.avgr (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.avgr_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+
+;; Type check
+(assert_invalid (module (func (result v128) (i8x16.min_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.min_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.max_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.max_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.avgr_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.abs (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.popcnt (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.min_s-1st-arg-empty (result v128)
+      (i8x16.min_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.min_s-arg-empty (result v128)
+      (i8x16.min_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.min_u-1st-arg-empty (result v128)
+      (i8x16.min_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.min_u-arg-empty (result v128)
+      (i8x16.min_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.max_s-1st-arg-empty (result v128)
+      (i8x16.max_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.max_s-arg-empty (result v128)
+      (i8x16.max_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.max_u-1st-arg-empty (result v128)
+      (i8x16.max_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.max_u-arg-empty (result v128)
+      (i8x16.max_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.avgr_u-1st-arg-empty (result v128)
+      (i8x16.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.avgr_u-arg-empty (result v128)
+      (i8x16.avgr_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.abs-arg-empty (result v128)
+      (i8x16.abs)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.popcnt-arg-empty (result v128)
+      (i8x16.popcnt)
+    )
+  )
+  "type mismatch"
+)
+
+;; Combination
+(module
+  (func (export "i8x16.min_s-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_s-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_s-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_s-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_s-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_s-i8x16.abs") (param v128 v128) (result v128) (i8x16.min_s (i8x16.abs (local.get 0))(local.get 1)))
+  (func (export "i8x16.abs-i8x16.min_s") (param v128 v128) (result v128) (i8x16.abs (i8x16.min_s (local.get 0) (local.get 1))))
+  (func (export "i8x16.min_s-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.min_s (i8x16.popcnt (local.get 0))(local.get 1)))
+  (func (export "i8x16.popcnt-i8x16.min_s") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.min_s (local.get 0) (local.get 1))))
+  (func (export "i8x16.min_u-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_u-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_u-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_u-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_u-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_u-i8x16.abs") (param v128 v128) (result v128) (i8x16.min_u (i8x16.abs (local.get 0))(local.get 1)))
+  (func (export "i8x16.abs-i8x16.min_u") (param v128 v128) (result v128) (i8x16.abs (i8x16.min_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.min_u-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.min_u (i8x16.popcnt (local.get 0))(local.get 1)))
+  (func (export "i8x16.popcnt-i8x16.min_u") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.min_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.max_s-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_s-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_s-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_s-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_s-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_s-i8x16.abs") (param v128 v128) (result v128) (i8x16.max_s (i8x16.abs (local.get 0))(local.get 1)))
+  (func (export "i8x16.abs-i8x16.max_s") (param v128 v128) (result v128) (i8x16.abs (i8x16.max_s (local.get 0) (local.get 1))))
+  (func (export "i8x16.max_s-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.max_s (i8x16.popcnt (local.get 0))(local.get 1)))
+  (func (export "i8x16.popcnt-i8x16.max_s") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.max_s (local.get 0) (local.get 1))))
+  (func (export "i8x16.max_u-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_u-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_u-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_u-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_u-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_u-i8x16.abs") (param v128 v128) (result v128) (i8x16.max_u (i8x16.abs (local.get 0))(local.get 1)))
+  (func (export "i8x16.abs-i8x16.max_u") (param v128 v128) (result v128) (i8x16.abs (i8x16.max_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.max_u-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.max_u (i8x16.popcnt (local.get 0))(local.get 1)))
+  (func (export "i8x16.popcnt-i8x16.max_u") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.max_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.avgr_u-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.avgr_u-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.avgr_u-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.avgr_u-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.avgr_u-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.avgr_u-i8x16.abs") (param v128 v128) (result v128) (i8x16.avgr_u (i8x16.abs (local.get 0))(local.get 1)))
+  (func (export "i8x16.abs-i8x16.avgr_u") (param v128 v128) (result v128) (i8x16.abs (i8x16.avgr_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.avgr_u-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.avgr_u (i8x16.popcnt (local.get 0))(local.get 1)))
+  (func (export "i8x16.popcnt-i8x16.avgr_u") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.avgr_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.abs-i8x16.popcnt") (param v128) (result v128) (i8x16.abs (i8x16.popcnt (local.get 0))))
+  (func (export "i8x16.abs-i8x16.abs") (param v128) (result v128) (i8x16.abs (i8x16.abs (local.get 0))))
+  (func (export "i8x16.popcnt-i8x16.popcnt") (param v128) (result v128) (i8x16.popcnt (i8x16.popcnt (local.get 0))))
+  (func (export "i8x16.popcnt-i8x16.abs") (param v128) (result v128) (i8x16.popcnt (i8x16.abs (local.get 0))))
+)
+
+(assert_return (invoke "i8x16.min_s-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_s-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_s-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_s-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_s-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_s-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.abs-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                               (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_s-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.popcnt-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.min_u-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_u-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_u-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_u-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.abs-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                               (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.popcnt-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_s-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_s-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_s-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_s-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_s-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_s-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                               (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                               (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_s-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.popcnt-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_u-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_u-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_u-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_u-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_u-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_u-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                               (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                               (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.max_u-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.popcnt-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.avgr_u-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.avgr_u-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.avgr_u-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.avgr_u-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.avgr_u-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.avgr_u-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.avgr_u-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4))
+(assert_return (invoke "i8x16.popcnt-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.abs-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
diff --git a/test/core/simd/simd_i8x16_cmp.wast b/test/core/simd/simd_i8x16_cmp.wast
new file mode 100644
index 000000000..8683accea
--- /dev/null
+++ b/test/core/simd/simd_i8x16_cmp.wast
@@ -0,0 +1,1847 @@
+
+;; Test all the i8x16 comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (i8x16.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (i8x16.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x v128) (param $y v128) (result v128) (i8x16.lt_s (local.get $x) (local.get $y)))
+  (func (export "lt_u") (param $x v128) (param $y v128) (result v128) (i8x16.lt_u (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x v128) (param $y v128) (result v128) (i8x16.le_s (local.get $x) (local.get $y)))
+  (func (export "le_u") (param $x v128) (param $y v128) (result v128) (i8x16.le_u (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x v128) (param $y v128) (result v128) (i8x16.gt_s (local.get $x) (local.get $y)))
+  (func (export "gt_u") (param $x v128) (param $y v128) (result v128) (i8x16.gt_u (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x v128) (param $y v128) (result v128) (i8x16.ge_s (local.get $x) (local.get $y)))
+  (func (export "ge_u") (param $x v128) (param $y v128) (result v128) (i8x16.ge_u (local.get $x) (local.get $y)))
+)
+
+
+;; eq
+
+;; i8x16.eq  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                            (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                            (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                            (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                            (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                            (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "eq" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "eq" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                            (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                            (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                            (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                            (v128.const i8x16 0 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                            (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                            (v128.const i8x16 0 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 0))
+
+;; i8x16.eq  (i8x16) (i16x8)
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                            (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                            (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                            (v128.const i8x16 -1 0 -1 0 -1 -1 -1 -1 -1 0 -1 0 -1 0 -1 0))
+(assert_return (invoke "eq" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                            (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; i8x16.eq  (i8x16) (i32x4)
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                            (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                            (v128.const i32x4 -128 0 1 255))
+                            (v128.const i8x16 -1 0 0 0 -1 -1 -1 -1 -1 0 0 0 -1 0 0 0))
+(assert_return (invoke "eq" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                            (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; ne
+
+;; i8x16.ne  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                            (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                            (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                            (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                            (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                            (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "ne" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "ne" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                            (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                            (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                            (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 0 0 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                            (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 0 0 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.ne (i8x16) (i16x8)
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                            (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                            (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                            (v128.const i8x16 0 -1 0 -1 0 0 0 0 0 -1 0 -1 0 -1 0 -1))
+(assert_return (invoke "ne" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                            (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.ne  (i8x16) (i32x4)
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                            (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                            (v128.const i32x4 -128 0 1 255))
+                            (v128.const i8x16 0 -1 -1 -1 0 0 0 0 0 -1 -1 -1 0 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                            (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; lt_s
+
+;; i8x16.lt_s  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 0 -1 0 -1 0 0 0 -1 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 -1 -1 -1 0 0 0 0 0 -1 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 -1 -1 -1 0 0 0 0 0 -1 0 0 0))
+
+;; i8x16.lt_s  (i8x16) (i16x8)
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 0 -1 0 -1 0 0 0 0 0 0 0 0 0 -1 0 -1))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; i8x16.lt_s  (i8x16) (i32x4)
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 0 -1 -1 -1 0 0 0 0 0 0 0 0 0 -1 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; lt_u
+
+;; i8x16.lt_u  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 0 -1 0 -1 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 0 0 0 -1 -1 -1 -1 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 0 0 0 -1 -1 -1 -1 0 0 0))
+
+;; i8x16.lt_u  (i8x16) (i16x8)
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 0 -1 0 -1 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.lt_u  (i8x16) (i32x4)
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 0 -1 -1 -1 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; le_s
+
+;; i8x16.le_s  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 0 -1 0 -1 0 0 0 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 -1 -1 -1 -1 -1 0 0 0 -1 0 0 0))
+(assert_return (invoke "le_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 -1 -1 -1 -1 -1 0 0 0 -1 0 0 0))
+
+;; i8x16.le_s  (i8x16) (i16x8)
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 -1 0 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; i8x16.le_s  (i8x16) (i32x4)
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; le_u
+
+;; i8x16.le_u  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 0 -1 0 -1 0 0 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 0 -1 -1 -1 -1 -1 -1 0 0 0))
+(assert_return (invoke "le_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 0 -1 -1 -1 -1 -1 -1 0 0 0))
+
+;; i8x16.le_u  (i8x16) (i16x8)
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 -1 0 -1 0 -1 0))
+(assert_return (invoke "le_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.le_u  (i8x16) (i32x4)
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 -1 0 0 0))
+(assert_return (invoke "le_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; gt_s
+
+;; i8x16.gt_s  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 -1 0 -1 0 -1 -1 -1 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 0 0 0 0 0 -1 -1 -1 0 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 0 0 0 0 0 -1 -1 -1 0 -1 -1 -1))
+
+;; i8x16.gt_s  (i8x16) (i16x8)
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 -1 0 -1 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.gt_s  (i8x16) (i32x4)
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; gt_u
+
+;; i8x16.gt_u  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 -1 0 -1 0 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 -1 0 0 0 0 0 0 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 -1 0 0 0 0 0 0 -1 -1 -1))
+
+;; i8x16.gt_u  (i8x16) (i16x8)
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 -1 0 -1 0 -1 0 -1))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; i8x16.gt_u  (i8x16) (i32x4)
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 -1 -1 -1 0 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; ge_s
+
+;; i8x16.ge_s  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 -1 0 -1 0 -1 -1 -1 0 0 0))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 0 0 0 -1 -1 -1 -1 -1 0 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 0 0 0 -1 -1 -1 -1 -1 0 -1 -1 -1))
+
+;; i8x16.ge_s  (i8x16) (i16x8)
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 -1 0 -1 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 -1 0))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.ge_s  (i8x16) (i32x4)
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 -1 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; ge_u
+
+;; i8x16.ge_u  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 -1 0 -1 0 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 -1 -1 -1 0 0 0 0 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 -1 -1 -1 0 0 0 0 -1 -1 -1))
+
+;; i8x16.ge_u (i8x16) (i16x8)
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 -1 0 -1 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; i8x16.ge_u (i8x16) (i32x4)
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 -1 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (i8x16.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.ge_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.gt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.le_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.lt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+
+
+;; combination
+
+(module (memory 1)
+  (func (export "eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "lt_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.lt_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "le_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.le_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "gt_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.gt_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ge_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.ge_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-eq")
+    (drop
+      (i8x16.eq
+        (i8x16.eq
+          (i8x16.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.eq
+          (i8x16.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ne")
+    (drop
+      (i8x16.ne
+        (i8x16.ne
+          (i8x16.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.ne
+          (i8x16.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-lt_s")
+    (drop
+      (i8x16.lt_s
+        (i8x16.lt_s
+          (i8x16.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.lt_s
+          (i8x16.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-le_u")
+    (drop
+      (i8x16.le_u
+        (i8x16.le_u
+          (i8x16.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.le_u
+          (i8x16.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-gt_u")
+    (drop
+      (i8x16.gt_u
+        (i8x16.gt_u
+          (i8x16.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.gt_u
+          (i8x16.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ge_s")
+    (drop
+      (i8x16.ge_s
+        (i8x16.ge_s
+          (i8x16.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.ge_s
+          (i8x16.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (i8x16.ge_u
+        (i8x16.eq
+          (i8x16.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.ne
+          (i8x16.gt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.lt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "eq-in-block"))
+(assert_return (invoke "ne-in-block"))
+(assert_return (invoke "lt_s-in-block"))
+(assert_return (invoke "le_u-in-block"))
+(assert_return (invoke "gt_u-in-block"))
+(assert_return (invoke "ge_s-in-block"))
+(assert_return (invoke "nested-eq"))
+(assert_return (invoke "nested-ne"))
+(assert_return (invoke "nested-lt_s"))
+(assert_return (invoke "nested-le_u"))
+(assert_return (invoke "nested-gt_u"))
+(assert_return (invoke "nested-ge_s"))
+(assert_return (invoke "as-param"))
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.eq-1st-arg-empty (result v128)
+      (i8x16.eq (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.eq-arg-empty (result v128)
+      (i8x16.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ne-1st-arg-empty (result v128)
+      (i8x16.ne (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ne-arg-empty (result v128)
+      (i8x16.ne)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.lt_s-1st-arg-empty (result v128)
+      (i8x16.lt_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.lt_s-arg-empty (result v128)
+      (i8x16.lt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.lt_u-1st-arg-empty (result v128)
+      (i8x16.lt_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.lt_u-arg-empty (result v128)
+      (i8x16.lt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.le_s-1st-arg-empty (result v128)
+      (i8x16.le_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.le_s-arg-empty (result v128)
+      (i8x16.le_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.le_u-1st-arg-empty (result v128)
+      (i8x16.le_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.le_u-arg-empty (result v128)
+      (i8x16.le_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.gt_s-1st-arg-empty (result v128)
+      (i8x16.gt_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.gt_s-arg-empty (result v128)
+      (i8x16.gt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.gt_u-1st-arg-empty (result v128)
+      (i8x16.gt_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.gt_u-arg-empty (result v128)
+      (i8x16.gt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ge_s-1st-arg-empty (result v128)
+      (i8x16.ge_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ge_s-arg-empty (result v128)
+      (i8x16.ge_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ge_u-1st-arg-empty (result v128)
+      (i8x16.ge_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ge_u-arg-empty (result v128)
+      (i8x16.ge_u)
+    )
+  )
+  "type mismatch"
+)
\ No newline at end of file
diff --git a/test/core/simd/simd_i8x16_sat_arith.wast b/test/core/simd/simd_i8x16_sat_arith.wast
new file mode 100644
index 000000000..a799a8b73
--- /dev/null
+++ b/test/core/simd/simd_i8x16_sat_arith.wast
@@ -0,0 +1,718 @@
+;; Tests for i8x16 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i8x16.add_sat_s") (param v128 v128) (result v128) (i8x16.add_sat_s (local.get 0) (local.get 1)))
+  (func (export "i8x16.add_sat_u") (param v128 v128) (result v128) (i8x16.add_sat_u (local.get 0) (local.get 1)))
+  (func (export "i8x16.sub_sat_s") (param v128 v128) (result v128) (i8x16.sub_sat_s (local.get 0) (local.get 1)))
+  (func (export "i8x16.sub_sat_u") (param v128 v128) (result v128) (i8x16.sub_sat_u (local.get 0) (local.get 1)))
+)
+
+
+;; i8x16.add_sat_s
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i8x16 0x01 0x01 0x81 0x7f 0x01 0x01 0x81 0x7f 0x01 0x01 0x81 0x7f 0x01 0x01 0x81 0x7f))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i8x16 0x01 0x01 0x81 0 0x01 0x01 0x81 0 0x01 0x01 0x81 0 0x01 0x01 0x81 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i8x16 0x01 0x01 0xc1 0x7f 0x01 0x01 0xc1 0x7f 0x01 0x01 0xc1 0x7f 0x01 0x01 0xc1 0x7f))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i8x16 0x01 0x01 0xc1 0 0x01 0x01 0xc1 0 0x01 0x01 0xc1 0 0x01 0x01 0xc1 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                         (v128.const i8x16 0 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45))
+
+;; i8x16.add_sat_u
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 129 129 129 129 129 129 129 129 129 129 129 129 129 129 129 129))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                         (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i8x16 0x80 0x80 0x80 0xff 0x80 0x80 0x80 0xff 0x80 0x80 0x80 0xff 0x80 0x80 0x80 0xff))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i8x16 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i8x16 0x01 0x01 0x81 0xff 0x01 0x01 0x81 0xff 0x01 0x01 0x81 0xff 0x01 0x01 0x81 0xff))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i8x16 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i8x16 0x01 0x01 0xc1 0xff 0x01 0x01 0xc1 0xff 0x01 0x01 0xc1 0xff 0x01 0x01 0xc1 0xff))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                         (v128.const i8x16 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                         (v128.const i8x16 0 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45))
+
+;; i8x16.sub_sat_s
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i8x16 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i8x16 0x01 0x01 0x7f 0x82 0x01 0x01 0x7f 0x82 0x01 0x01 0x7f 0x82 0x01 0x01 0x7f 0x82))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i8x16 0x01 0x01 0x7f 0x02 0x01 0x01 0x7f 0x02 0x01 0x01 0x7f 0x02 0x01 0x01 0x7f 0x02))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i8x16 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i8x16 0x01 0x01 0x41 0x02 0x01 0x01 0x41 0x02 0x01 0x01 0x41 0x02 0x01 0x01 0x41 0x02))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                         (v128.const i8x16 0 0x02 0x04 0x06 0x08 0x0a 0x0c 0x0e 0x10 0x12 0x14 0x16 0x18 0x1a 0x1c 0x1e))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                         (v128.const i8x16 0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15))
+
+;; i8x16.sub_sat_u
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i8x16 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i8x16 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i8x16 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i8x16 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i8x16 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; Malformed cases: non-existent op names
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.add_sat (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.sub_sat (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.mul_sat (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.div_sat (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.add_sat_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.add_sat_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.sub_sat_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.sub_sat_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (f32x4.add_sat_s (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (f32x4.add_sat_u (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (f32x4.sub_sat_s (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (f32x4.sub_sat_u (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0)))")
+    "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (i8x16.add_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.add_sat_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.sub_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.sub_sat_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.add_sat_s-1st-arg-empty (result v128)
+      (i8x16.add_sat_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.add_sat_s-arg-empty (result v128)
+      (i8x16.add_sat_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.add_sat_u-1st-arg-empty (result v128)
+      (i8x16.add_sat_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.add_sat_u-arg-empty (result v128)
+      (i8x16.add_sat_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub_sat_s-1st-arg-empty (result v128)
+      (i8x16.sub_sat_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub_sat_s-arg-empty (result v128)
+      (i8x16.sub_sat_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub_sat_u-1st-arg-empty (result v128)
+      (i8x16.sub_sat_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub_sat_u-arg-empty (result v128)
+      (i8x16.sub_sat_u)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "sat-add_s-sub_s") (param v128 v128 v128) (result v128)
+    (i8x16.add_sat_s (i8x16.sub_sat_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_s-sub_u") (param v128 v128 v128) (result v128)
+    (i8x16.add_sat_s (i8x16.sub_sat_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_u-sub_s") (param v128 v128 v128) (result v128)
+    (i8x16.add_sat_u (i8x16.sub_sat_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_u-sub_u") (param v128 v128 v128) (result v128)
+    (i8x16.add_sat_u (i8x16.sub_sat_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_s-neg") (param v128 v128) (result v128)
+    (i8x16.add_sat_s (i8x16.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-add_u-neg") (param v128 v128) (result v128)
+    (i8x16.add_sat_u (i8x16.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-sub_s-neg") (param v128 v128) (result v128)
+    (i8x16.sub_sat_s (i8x16.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-sub_u-neg") (param v128 v128) (result v128)
+    (i8x16.sub_sat_u (i8x16.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "sat-add_s-sub_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "sat-add_s-sub_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "sat-add_u-sub_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254))
+(assert_return (invoke "sat-add_u-sub_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "sat-add_s-neg" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                       (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                       (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "sat-add_u-neg" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                       (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                       (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "sat-sub_s-neg" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                       (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                       (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "sat-sub_u-neg" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                       (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                       (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
\ No newline at end of file
diff --git a/test/core/simd/simd_int_to_int_extend.wast b/test/core/simd/simd_int_to_int_extend.wast
new file mode 100644
index 000000000..be8d554ca
--- /dev/null
+++ b/test/core/simd/simd_int_to_int_extend.wast
@@ -0,0 +1,599 @@
+;; Tests for int-to-int extension operations.
+
+(module
+  (func (export "i16x8.extend_high_i8x16_s") (param v128) (result v128) (i16x8.extend_high_i8x16_s (local.get 0)))
+  (func (export "i16x8.extend_high_i8x16_u") (param v128) (result v128) (i16x8.extend_high_i8x16_u (local.get 0)))
+  (func (export "i16x8.extend_low_i8x16_s") (param v128) (result v128) (i16x8.extend_low_i8x16_s (local.get 0)))
+  (func (export "i16x8.extend_low_i8x16_u") (param v128) (result v128) (i16x8.extend_low_i8x16_u (local.get 0)))
+  (func (export "i32x4.extend_high_i16x8_s") (param v128) (result v128) (i32x4.extend_high_i16x8_s (local.get 0)))
+  (func (export "i32x4.extend_high_i16x8_u") (param v128) (result v128) (i32x4.extend_high_i16x8_u (local.get 0)))
+  (func (export "i32x4.extend_low_i16x8_s") (param v128) (result v128) (i32x4.extend_low_i16x8_s (local.get 0)))
+  (func (export "i32x4.extend_low_i16x8_u") (param v128) (result v128) (i32x4.extend_low_i16x8_u (local.get 0)))
+  (func (export "i64x2.extend_high_i32x4_s") (param v128) (result v128) (i64x2.extend_high_i32x4_s (local.get 0)))
+  (func (export "i64x2.extend_high_i32x4_u") (param v128) (result v128) (i64x2.extend_high_i32x4_u (local.get 0)))
+  (func (export "i64x2.extend_low_i32x4_s") (param v128) (result v128) (i64x2.extend_low_i32x4_s (local.get 0)))
+  (func (export "i64x2.extend_low_i32x4_u") (param v128) (result v128) (i64x2.extend_low_i32x4_u (local.get 0)))
+)
+
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 126 126 126 126 126 126 126 126))
+                                                   (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                   (v128.const i16x8 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 126 126 126 126 126 126 126 126))
+                                                   (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                   (v128.const i16x8 129 129 129 129 129 129 129 129))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 126 126 126 126 126 126 126 126))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                  (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 126 126 126 126 126 126 126 126))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 129 129 129 129 129 129 129 129))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 0 0 0 0 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 1 1 1 1 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 1 1 1 1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32766 32766 32766 32766))
+                                                   (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32767 -32767 -32767 -32767))
+                                                   (v128.const i32x4 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 -32768 -32768 -32768 -32768))
+
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 0 0 0 0 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 1 1 1 1 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 1 1 1 1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32766 32766 32766 32766))
+                                                   (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 -1 -1 -1 -1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32767 -32767 -32767 -32767))
+                                                   (v128.const i32x4 32769 32769 32769 32769))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -1 -1 -1 -1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 0 0 0 0 1 1 1 1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 1 1 1 1 0 0 0 0))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 1 1 1 1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 1 1 1 1))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32767 32767 32767 32767))
+                                                  (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32766 32766 32766 32766))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 32767 32767 32767 32767))
+                                                  (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 32767 32767 32767 32767))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32767 -32767 -32767 -32767))
+                                                  (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 0 0 0 0 1 1 1 1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 1 1 1 1 0 0 0 0))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 1 1 1 1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 1 1 1 1))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32767 32767 32767 32767))
+                                                  (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32766 32766 32766 32766))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 32767 32767 32767 32767))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 32767 32767 32767 32767))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 32769 32769 32769 32769))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32767 -32767 -32767 -32767))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 0 0 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 0 0 -1 -1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 1 1 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -1 -1 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 1 1 -1 -1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -1 -1 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483646 2147483646 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483646 2147483646))
+                                                   (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 -2147483648 -2147483648))
+                                                   (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 -1 -1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -1 -1 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483647 -2147483647 -2147483648 -2147483648))
+                                                   (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483647 -2147483647))
+                                                   (v128.const i64x2 -2147483647 -2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -1 -1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -1 -1 -2147483648 -2147483648))
+                                                   (v128.const i64x2 -2147483648 -2147483648))
+
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 0 0 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 0 0 -1 -1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 1 1 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -1 -1 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 1 1 -1 -1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -1 -1 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483646 2147483646 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483646 2147483646))
+                                                   (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 -2147483648 -2147483648))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 -1 -1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -1 -1 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483647 -2147483647 -2147483648 -2147483648))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483647 -2147483647))
+                                                   (v128.const i64x2 2147483649 2147483649))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -1 -1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -1 -1 -2147483648 -2147483648))
+                                                   (v128.const i64x2 2147483648 2147483648))
+
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 0 0 1 1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 0 0 -1 -1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 1 1 0 0))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -1 -1 0 0))
+                                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 1 1 -1 -1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -1 -1 1 1))
+                                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483646 2147483646 2147483647 2147483647))
+                                                  (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483646 2147483646))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 -2147483648 -2147483648))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 2147483647 2147483647))
+                                                  (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 -1 -1))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -1 -1 2147483647 2147483647))
+                                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483647 -2147483647 -2147483648 -2147483648))
+                                                  (v128.const i64x2 -2147483647 -2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483647 -2147483647))
+                                                  (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -1 -1))
+                                                  (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -1 -1 -2147483648 -2147483648))
+                                                  (v128.const i64x2 -1 -1))
+
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 0 0 1 1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 0 0 -1 -1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 1 1 0 0))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -1 -1 0 0))
+                                                  (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 1 1 -1 -1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -1 -1 1 1))
+                                                  (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483646 2147483646 2147483647 2147483647))
+                                                  (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483646 2147483646))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 -2147483648 -2147483648))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 2147483647 2147483647))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 -1 -1))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -1 -1 2147483647 2147483647))
+                                                  (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483647 -2147483647 -2147483648 -2147483648))
+                                                  (v128.const i64x2 2147483649 2147483649))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483647 -2147483647))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -1 -1))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -1 -1 -2147483648 -2147483648))
+                                                  (v128.const i64x2 4294967295 4294967295))
+
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.extend_high_i8x16_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extend_high_i8x16_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extend_low_i8x16_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extend_low_i8x16_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extend_high_i16x8_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extend_high_i16x8_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extend_low_i16x8_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extend_low_i16x8_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extend_high_i32x4_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extend_high_i32x4_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extend_low_i32x4_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extend_low_i32x4_u (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.extend_high_i8x16_s-arg-empty (result v128)
+      (i16x8.extend_high_i8x16_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extend_high_i8x16_u-arg-empty (result v128)
+      (i16x8.extend_high_i8x16_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extend_low_i8x16_s-arg-empty (result v128)
+      (i16x8.extend_low_i8x16_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extend_low_i8x16_u-arg-empty (result v128)
+      (i16x8.extend_low_i8x16_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extend_high_i16x8_s-arg-empty (result v128)
+      (i32x4.extend_high_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extend_high_i16x8_u-arg-empty (result v128)
+      (i32x4.extend_high_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extend_low_i16x8_s-arg-empty (result v128)
+      (i32x4.extend_low_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extend_low_i16x8_u-arg-empty (result v128)
+      (i32x4.extend_low_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extend_high_i32x4_s-arg-empty (result v128)
+      (i64x2.extend_high_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extend_high_i32x4_u-arg-empty (result v128)
+      (i64x2.extend_high_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extend_low_i32x4_s-arg-empty (result v128)
+      (i64x2.extend_low_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extend_low_i32x4_u-arg-empty (result v128)
+      (i64x2.extend_low_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_lane.wast b/test/core/simd/simd_lane.wast
new file mode 100644
index 000000000..9d4b5fd72
--- /dev/null
+++ b/test/core/simd/simd_lane.wast
@@ -0,0 +1,1265 @@
+;; Tests for the extract_lane, replace_lane, swizzle and shuffle group instructions
+
+
+(module
+  (func (export "i8x16_extract_lane_s-first") (param v128) (result i32)
+    (i8x16.extract_lane_s 0 (local.get 0)))
+  (func (export "i8x16_extract_lane_s-last") (param v128) (result i32)
+    (i8x16.extract_lane_s 15 (local.get 0)))
+  (func (export "i8x16_extract_lane_u-first") (param v128) (result i32)
+    (i8x16.extract_lane_u 0 (local.get 0)))
+  (func (export "i8x16_extract_lane_u-last") (param v128) (result i32)
+    (i8x16.extract_lane_u 15 (local.get 0)))
+  (func (export "i16x8_extract_lane_s-first") (param v128) (result i32)
+    (i16x8.extract_lane_s 0 (local.get 0)))
+  (func (export "i16x8_extract_lane_s-last") (param v128) (result i32)
+    (i16x8.extract_lane_s 7 (local.get 0)))
+  (func (export "i16x8_extract_lane_u-first") (param v128) (result i32)
+    (i16x8.extract_lane_u 0 (local.get 0)))
+  (func (export "i16x8_extract_lane_u-last") (param v128) (result i32)
+    (i16x8.extract_lane_u 7 (local.get 0)))
+  (func (export "i32x4_extract_lane-first") (param v128) (result i32)
+    (i32x4.extract_lane 0 (local.get 0)))
+  (func (export "i32x4_extract_lane-last") (param v128) (result i32)
+    (i32x4.extract_lane 3 (local.get 0)))
+  (func (export "f32x4_extract_lane-first") (param v128) (result f32)
+    (f32x4.extract_lane 0 (local.get 0)))
+  (func (export "f32x4_extract_lane-last") (param v128) (result f32)
+    (f32x4.extract_lane 3 (local.get 0)))
+  (func (export "i8x16_replace_lane-first") (param v128 i32) (result v128)
+    (i8x16.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "i8x16_replace_lane-last") (param v128 i32) (result v128)
+    (i8x16.replace_lane 15 (local.get 0) (local.get 1)))
+  (func (export "i16x8_replace_lane-first") (param v128 i32) (result v128)
+    (i16x8.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "i16x8_replace_lane-last") (param v128 i32) (result v128)
+    (i16x8.replace_lane 7 (local.get 0) (local.get 1)))
+  (func (export "i32x4_replace_lane-first") (param v128 i32) (result v128)
+    (i32x4.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "i32x4_replace_lane-last") (param v128 i32) (result v128)
+    (i32x4.replace_lane 3 (local.get 0) (local.get 1)))
+  (func (export "f32x4_replace_lane-first") (param v128 f32) (result v128)
+    (f32x4.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "f32x4_replace_lane-last") (param v128 f32) (result v128)
+    (f32x4.replace_lane 3 (local.get 0) (local.get 1)))
+  (func (export "i64x2_extract_lane-first") (param v128) (result i64)
+    (i64x2.extract_lane 0 (local.get 0)))
+  (func (export "i64x2_extract_lane-last") (param v128) (result i64)
+    (i64x2.extract_lane 1 (local.get 0)))
+  (func (export "f64x2_extract_lane-first") (param v128) (result f64)
+    (f64x2.extract_lane 0 (local.get 0)))
+  (func (export "f64x2_extract_lane-last") (param v128) (result f64)
+    (f64x2.extract_lane 1 (local.get 0)))
+  (func (export "i64x2_replace_lane-first") (param v128 i64) (result v128)
+    (i64x2.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "i64x2_replace_lane-last") (param v128 i64) (result v128)
+    (i64x2.replace_lane 1 (local.get 0) (local.get 1)))
+  (func (export "f64x2_replace_lane-first") (param v128 f64) (result v128)
+    (f64x2.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "f64x2_replace_lane-last") (param v128 f64) (result v128)
+    (f64x2.replace_lane 1 (local.get 0) (local.get 1)))
+
+  ;; Swizzle and shuffle
+  (func (export "v8x16_swizzle") (param v128 v128) (result v128)
+    (i8x16.swizzle (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-1") (param v128 v128) (result v128)
+    (i8x16.shuffle  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-2") (param v128 v128) (result v128)
+    (i8x16.shuffle 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-3") (param v128 v128) (result v128)
+    (i8x16.shuffle 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-4") (param v128 v128) (result v128)
+    (i8x16.shuffle 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-5") (param v128 v128) (result v128)
+    (i8x16.shuffle  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-6") (param v128 v128) (result v128)
+    (i8x16.shuffle 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-7") (param v128 v128) (result v128)
+    (i8x16.shuffle  0  0  0  0  0  0  0  0 16 16 16 16 16 16 16 16 (local.get 0) (local.get 1)))
+)
+
+(assert_return (invoke "i8x16_extract_lane_s-first" (v128.const i8x16 127 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 127))
+(assert_return (invoke "i8x16_extract_lane_s-first" (v128.const i8x16 0x7f 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 127))
+(assert_return (invoke "i8x16_extract_lane_s-first" (v128.const i8x16 255 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const -1))
+(assert_return (invoke "i8x16_extract_lane_s-first" (v128.const i8x16 0xff 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const -1))
+(assert_return (invoke "i8x16_extract_lane_u-first" (v128.const i8x16 255 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 255))
+(assert_return (invoke "i8x16_extract_lane_u-first" (v128.const i8x16 0xff 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 255))
+(assert_return (invoke "i8x16_extract_lane_s-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -128)) (i32.const -128))
+(assert_return (invoke "i8x16_extract_lane_s-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0x80)) (i32.const -128))
+(assert_return (invoke "i8x16_extract_lane_u-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1)) (i32.const 255))
+(assert_return (invoke "i8x16_extract_lane_u-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0xff)) (i32.const 255))
+(assert_return (invoke "i8x16_extract_lane_u-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -128)) (i32.const 128))
+(assert_return (invoke "i8x16_extract_lane_u-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0x80)) (i32.const 128))
+
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 32767 0 0 0 0 0 0 0)) (i32.const 32767))
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 0x7fff 0 0 0 0 0 0 0)) (i32.const 32767))
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 65535 0 0 0 0 0 0 0)) (i32.const -1))
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 0xffff 0 0 0 0 0 0 0)) (i32.const -1))
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 012_345 0 0 0 0 0 0 0)) (i32.const 12345))
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 -0x0_1234 0 0 0 0 0 0 0)) (i32.const -0x1234))
+(assert_return (invoke "i16x8_extract_lane_u-first" (v128.const i16x8 65535 0 0 0 0 0 0 0)) (i32.const 65535))
+(assert_return (invoke "i16x8_extract_lane_u-first" (v128.const i16x8 0xffff 0 0 0 0 0 0 0)) (i32.const 65535))
+(assert_return (invoke "i16x8_extract_lane_u-first" (v128.const i16x8 012_345 0 0 0 0 0 0 0)) (i32.const 12345))
+(assert_return (invoke "i16x8_extract_lane_u-first" (v128.const i16x8 -0x0_1234 0 0 0 0 0 0 0)) (i32.const 60876))
+(assert_return (invoke "i16x8_extract_lane_s-last" (v128.const i16x8 0 0 0 0 0 0 0 -32768)) (i32.const -32768))
+(assert_return (invoke "i16x8_extract_lane_s-last" (v128.const i16x8 0 0 0 0 0 0 0 0x8000)) (i32.const -32768))
+(assert_return (invoke "i16x8_extract_lane_s-last" (v128.const i16x8 0 0 0 0 0 0 0 06_789)) (i32.const 6789))
+(assert_return (invoke "i16x8_extract_lane_s-last" (v128.const i16x8 0 0 0 0 0 0 0 -0x0_6789)) (i32.const -0x6789))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 -1)) (i32.const 65535))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 0xffff)) (i32.const 65535))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 -32768)) (i32.const 32768))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 0x8000)) (i32.const 32768))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 06_789)) (i32.const 6789))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 -0x0_6789)) (i32.const 39031))
+
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 2147483647 0 0 0)) (i32.const 2147483647))
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 0x7fffffff 0 0 0)) (i32.const 2147483647))
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 4294967295 0 0 0)) (i32.const -1))
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 0xffffffff 0 0 0)) (i32.const -1))
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 01_234_567_890 0 0 0)) (i32.const 1234567890))
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 -0x0_1234_5678 0 0 0)) (i32.const -0x12345678))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 -2147483648)) (i32.const -2147483648))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 0x80000000)) (i32.const -2147483648))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 -1)) (i32.const -1))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 0xffffffff)) (i32.const -1))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 0_987_654_321)) (i32.const 987654321))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 -0x0_1234_5678)) (i32.const -0x12345678))
+
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 9223372036854775807 0)) (i64.const 9223372036854775807))
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 0x7ffffffffffffffe 0)) (i64.const 0x7ffffffffffffffe))
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 18446744073709551615 0)) (i64.const -1))
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 0xffffffffffffffff 0)) (i64.const -1))
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 01_234_567_890_123_456_789 0)) (i64.const 1234567890123456789))
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 0x0_1234_5678_90AB_cdef 0)) (i64.const 0x1234567890abcdef))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 9223372036854775808)) (i64.const -9223372036854775808))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 0x8000000000000000)) (i64.const -0x8000000000000000))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 0x8000000000000000)) (i64.const 0x8000000000000000))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0x7f)) (i64.const 9223372036854775807))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0x8000)) (i64.const -9223372036854775808))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i32x4 0 0 0xffffffff 0x7fffffff)) (i64.const 9223372036854775807))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const f64x2 -inf +inf)) (i64.const 0x7ff0000000000000))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 01_234_567_890_123_456_789)) (i64.const 1234567890123456789))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 0x0_1234_5678_90AB_cdef)) (i64.const 0x1234567890abcdef))
+
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 -5.0 0.0 0.0 0.0)) (f32.const -5.0))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 1e38 0.0 0.0 0.0)) (f32.const 1e38))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 0x1.fffffep127 0.0 0.0 0.0)) (f32.const 0x1.fffffep127))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 0x1p127 0.0 0.0 0.0)) (f32.const 0x1p127))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 inf 0.0 0.0 0.0)) (f32.const inf))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 nan inf 0.0 0.0)) (f32.const nan))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 0123456789.0123456789e+019 0.0 0.0 0.0)) (f32.const 123456789.0123456789e+019))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0.0 0.0 0.0)) (f32.const 0x123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 -1e38)) (f32.const -1e38))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 -0x1.fffffep127)) (f32.const -0x1.fffffep127))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 -0x1p127)) (f32.const -0x1p127))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 -inf)) (f32.const -inf))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 -inf nan)) (f32.const nan))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 0123456789.)) (f32.const 123456789.0))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 0x0123456789ABCDEF.)) (f32.const 0x123456789ABCDEF.0p0))
+
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -1.5 0.0)) (f64.const -1.5))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 1.5 0.0)) (f64.const 1.5))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -1.7976931348623157e-308 0x0p+0)) (f64.const -1.7976931348623157e-308))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 1.7976931348623157e-308 0x0p-0)) (f64.const 1.7976931348623157e-308))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -0x1.fffffffffffffp-1023 0x0p+0)) (f64.const -0x1.fffffffffffffp-1023))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 0x1.fffffffffffffp-1023 0x0p-0)) (f64.const 0x1.fffffffffffffp-1023))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -inf 0.0)) (f64.const -inf))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 inf 0.0)) (f64.const inf))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -nan -0.0)) (f64.const -nan))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 nan 0.0)) (f64.const nan))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 0123456789.0123456789e+019 0.0)) (f64.const 123456789.0123456789e+019))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0.0)) (f64.const 0x123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 2.25)) (f64.const 2.25))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 -2.25)) (f64.const -2.25))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0x0p-0 -1.7976931348623157e+308)) (f64.const -1.7976931348623157e+308))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0x0p+0 1.7976931348623157e+308)) (f64.const 1.7976931348623157e+308))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0x0p-0 -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0x0p+0 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 -0.0 -inf)) (f64.const -inf))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 inf)) (f64.const inf))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 -0.0 -nan)) (f64.const -nan))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 nan)) (f64.const nan))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 0123456789.)) (f64.const 123456789.0))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 0x0123456789ABCDEFabcdef.)) (f64.const 0x123456789ABCDEFabcdef.0))
+
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (f64.const 0.0))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0x80)) (f64.const -0.0))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0x4000)) (f64.const 2.0))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0xc000)) (f64.const -2.0))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i32x4 0 0 0xffffffff 0x7fefffff)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i32x4 0 0 0 0x00100000)) (f64.const 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i32x4 0 0 0xffffffff 0x000fffff)) (f64.const 0x1.ffffffffffffep-1023))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i32x4 0 0 1 0)) (f64.const 0x0.0000000000002p-1023))
+
+(assert_return (invoke "i8x16_replace_lane-first" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 127)) (v128.const i8x16 127 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16_replace_lane-first" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 128)) (v128.const i8x16 -128 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16_replace_lane-first" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 255)) (v128.const i8x16 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16_replace_lane-first" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 256)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16_replace_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const -128)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -128))
+(assert_return (invoke "i8x16_replace_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const -129)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127))
+(assert_return (invoke "i8x16_replace_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 32767)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0xff))
+(assert_return (invoke "i8x16_replace_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const -32768)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 32767)) (v128.const i16x8 32767 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 32768)) (v128.const i16x8 -32768 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 65535)) (v128.const i16x8 -1 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 65536)) (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 012345)) (v128.const i16x8 012_345 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const -0x01234)) (v128.const i16x8 -0x0_1234 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const -32768)) (v128.const i16x8 0 0 0 0 0 0 0 -32768))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const -32769)) (v128.const i16x8 0 0 0 0 0 0 0 32767))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 0x7fffffff)) (v128.const i16x8 0 0 0 0 0 0 0 0xffff))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 0x80000000)) (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 054321)) (v128.const i16x8 0 0 0 0 0 0 0 054_321))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const -0x04321)) (v128.const i16x8 0 0 0 0 0 0 0 -0x0_4321))
+
+(assert_return (invoke "i32x4_replace_lane-first" (v128.const i32x4 0 0 0 0) (i32.const 2147483647)) (v128.const i32x4 2147483647 0 0 0))
+(assert_return (invoke "i32x4_replace_lane-first" (v128.const i32x4 0 0 0 0) (i32.const 4294967295)) (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "i32x4_replace_lane-first" (v128.const i32x4 0 0 0 0) (i32.const 01234567890)) (v128.const i32x4 01_234_567_890 0 0 0))
+(assert_return (invoke "i32x4_replace_lane-first" (v128.const i32x4 0 0 0 0) (i32.const -0x012345678)) (v128.const i32x4 -0x0_1234_5678 0 0 0))
+(assert_return (invoke "i32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (i32.const 2147483648)) (v128.const i32x4 0 0 0 2147483648))
+(assert_return (invoke "i32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (i32.const -2147483648)) (v128.const i32x4 0 0 0 -2147483648))
+(assert_return (invoke "i32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (i32.const 01234567890)) (v128.const i32x4 0 0 0 01_234_567_890))
+(assert_return (invoke "i32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (i32.const -0x012345678)) (v128.const i32x4 0 0 0 -0x0_1234_5678))
+
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 53.0)) (v128.const f32x4 53.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const i32x4 0 0 0 0 ) (f32.const 53.0)) (v128.const f32x4 53.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const nan)) (v128.const f32x4 nan 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const inf)) (v128.const f32x4 inf 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 nan 0.0 0.0 0.0) (f32.const 3.14)) (v128.const f32x4 3.14 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 inf 0.0 0.0 0.0) (f32.const 1e38)) (v128.const f32x4 1e38 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 inf 0.0 0.0 0.0) (f32.const 0x1.fffffep127)) (v128.const f32x4 0x1.fffffep127 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 inf 0.0 0.0 0.0) (f32.const 0x1p127)) (v128.const f32x4 0x1p127 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0123456789)) (v128.const f32x4 0123456789 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0123456789.)) (v128.const f32x4 0123456789. 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0x0123456789ABCDEF)) (v128.const f32x4 0x0123456789ABCDEF 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0x0123456789ABCDEF.)) (v128.const f32x4 0x0123456789ABCDEF. 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const -53.0)) (v128.const f32x4 0.0 0.0 0.0 -53.0))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (f32.const -53.0)) (v128.const f32x4 0.0 0.0 0.0 -53.0))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const nan)) (v128.const f32x4 0.0 0.0 0.0 nan))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const -inf)) (v128.const f32x4 0.0 0.0 0.0 -inf))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 nan) (f32.const 3.14)) (v128.const f32x4 0.0 0.0 0.0 3.14))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 -inf) (f32.const -1e38)) (v128.const f32x4 0.0 0.0 0.0 -1e38))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 -inf) (f32.const -0x1.fffffep127)) (v128.const f32x4 0.0 0.0 0.0 -0x1.fffffep127))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 -inf) (f32.const -0x1p127)) (v128.const f32x4 0.0 0.0 0.0 -0x1p127))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0123456789e019)) (v128.const f32x4 0.0 0.0 0.0 0123456789e019))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0123456789.e+019)) (v128.const f32x4 0.0 0.0 0.0 0123456789.e+019))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0x0123456789ABCDEFp019)) (v128.const f32x4 0.0 0.0 0.0 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0x0123456789ABCDEF.p-019)) (v128.const f32x4 0.0 0.0 0.0 0x0123456789ABCDEF.p-019))
+
+(assert_return (invoke "i64x2_replace_lane-first" (v128.const i64x2 0 0) (i64.const 9223372036854775807)) (v128.const i64x2 9223372036854775807 0))
+(assert_return (invoke "i64x2_replace_lane-first" (v128.const i64x2 0 0) (i64.const 18446744073709551615)) (v128.const i64x2 -1 0))
+(assert_return (invoke "i64x2_replace_lane-first" (v128.const i64x2 0 0) (i64.const 01234567890123456789)) (v128.const i64x2 01_234_567_890_123_456_789 0))
+(assert_return (invoke "i64x2_replace_lane-first" (v128.const i64x2 0 0) (i64.const 0x01234567890abcdef)) (v128.const i64x2 0x0_1234_5678_90AB_cdef 0))
+(assert_return (invoke "i64x2_replace_lane-last" (v128.const i64x2 0 0) (i64.const 9223372036854775808)) (v128.const i64x2 0 9223372036854775808))
+(assert_return (invoke "i64x2_replace_lane-last" (v128.const i64x2 0 0) (i64.const 9223372036854775808)) (v128.const i64x2 0 -9223372036854775808))
+(assert_return (invoke "i64x2_replace_lane-last" (v128.const i64x2 0 0) (i64.const 01234567890123456789)) (v128.const i64x2 0 01_234_567_890_123_456_789))
+(assert_return (invoke "i64x2_replace_lane-last" (v128.const i64x2 0 0) (i64.const 0x01234567890abcdef)) (v128.const i64x2 0 0x0_1234_5678_90AB_cdef))
+
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 1.0 1.0) (f64.const 0x0p+0)) (v128.const f64x2 0.0 1.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 -1.0 -1.0) (f64.const -0x0p-0)) (v128.const f64x2 -0.0 -1.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 1.25)) (v128.const f64x2 1.25 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const -1.25)) (v128.const f64x2 -1.25 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 -nan 0.0) (f64.const -1.7976931348623157e+308)) (v128.const f64x2 -1.7976931348623157e+308 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 nan 0.0) (f64.const 1.7976931348623157e+308)) (v128.const f64x2 1.7976931348623157e+308 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 -inf 0.0) (f64.const -0x1.fffffffffffffp-1023)) (v128.const f64x2 -0x1.fffffffffffffp-1023 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 inf 0.0) (f64.const 0x1.fffffffffffffp-1023)) (v128.const f64x2 0x1.fffffffffffffp-1023 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const -nan)) (v128.const f64x2 -nan 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const nan)) (v128.const f64x2 nan 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const -inf)) (v128.const f64x2 -inf 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const inf)) (v128.const f64x2 inf 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 0123456789)) (v128.const f64x2 0123456789 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 0123456789.)) (v128.const f64x2 0123456789. 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 0x0123456789ABCDEFabcdef)) (v128.const f64x2 0x0123456789ABCDEFabcdef 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 0x0123456789ABCDEFabcdef.)) (v128.const f64x2 0x0123456789ABCDEFabcdef. 0.0))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 2.0 2.0) (f64.const 0.0)) (v128.const f64x2 2.0 0.0))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 -2.0 -2.0) (f64.const -0.0)) (v128.const f64x2 -2.0 -0.0))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 2.25)) (v128.const f64x2 0.0 2.25))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const -2.25)) (v128.const f64x2 0.0 -2.25))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 -nan) (f64.const -1.7976931348623157e+308)) (v128.const f64x2 0.0 -1.7976931348623157e+308))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 nan) (f64.const 1.7976931348623157e+308)) (v128.const f64x2 0.0 1.7976931348623157e+308))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 -inf) (f64.const -0x1.fffffffffffffp-1023)) (v128.const f64x2 0.0 -0x1.fffffffffffffp-1023))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 inf) (f64.const 0x1.fffffffffffffp-1023)) (v128.const f64x2 0.0 0x1.fffffffffffffp-1023))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const -nan)) (v128.const f64x2 0.0 -nan))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const nan)) (v128.const f64x2 0.0 nan))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const -inf)) (v128.const f64x2 0.0 -inf))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const inf)) (v128.const f64x2 0.0 inf))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 0123456789e019)) (v128.const f64x2 0.0 0123456789e019))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 0123456789e+019)) (v128.const f64x2 0.0 0123456789e+019))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 0123456789.e019)) (v128.const f64x2 0.0 0123456789.e019))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 0123456789.e-019)) (v128.const f64x2 0.0 0123456789.e-019))
+
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+  (v128.const i8x16  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15))
+  (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16  -8  -7  -6  -5  -4  -3  -2 -1 16 17 18 19 20 21 22 23))
+  (v128.const i8x16   0   0   0   0   0   0   0  0  0  0  0  0  0  0  0  0))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115)
+  (v128.const i8x16  15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0))
+  (v128.const i8x16 115 114 113 112 111 110 109 108 107 106 105 104 103 102 101 100))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115)
+  (v128.const i8x16  -1   1  -2   2  -3   3  -4   4  -5   5  -6   6  -7   7  -8   8))
+  (v128.const i8x16   0 101   0 102   0 103   0 104   0 105   0 106   0 107   0 108))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115)
+  (v128.const i8x16   9  16  10  17  11  18  12  19  13  20  14  21  15  22  16  23))
+  (v128.const i8x16 109   0 110   0 111   0 112   0 113   0 114   0 115   0   0   0))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 0x64 0x65 0x66 0x67 0x68 0x69 0x6a 0x6b 0x6c 0x6d 0x6e 0x6f 0x70 0x71 0x72 0x73)
+  (v128.const i8x16    9   16   10   17  11    18   12   19  13    20   14   21   15   22   16   23))
+  (v128.const i8x16 0x6d    0 0x6e    0 0x6f    0 0x70    0 0x71    0 0x72    0 0x73    0    0    0))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i16x8 0x6465 0x6667 0x6869 0x6a6b 0x6c6d 0x6e6f 0x7071 0x7273)
+  (v128.const i8x16 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15))
+  (v128.const i16x8 0x6465 0x6667 0x6869 0x6a6b 0x6c6d 0x6e6f 0x7071 0x7273))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i32x4 0x64656667 0x68696a6b 0x6c6d6e6f 0x70717273)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0))
+  (v128.const i32x4 0x73727170 0x6f6e6d6c 0x6b6a6968 0x67666564))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const f32x4 nan -nan inf -inf)
+  (v128.const i8x16 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15))
+  (v128.const i32x4 0x7fc00000 0xffc00000 0x7f800000 0xff800000))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i32x4 0x67666564 0x6b6a6968 0x6f6e6d5c 0x73727170)
+  (v128.const f32x4 0.0 -0.0 inf -inf))
+  (v128.const i32x4 0x64646464 0x00646464 0x00006464 0x00006464))
+
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+  (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31))
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "v8x16_shuffle-2"
+  (v128.const i8x16   0   1   2   3   4   5   6  7  8  9 10 11 12 13 14 15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1))
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1))
+(assert_return (invoke "v8x16_shuffle-3"
+  (v128.const i8x16   0   1   2   3   4   5   6  7  8   9  10  11  12  13  14  15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8  -7  -6  -5  -4  -3  -2  -1))
+  (v128.const i8x16  -1  -2  -3  -4  -5  -6  -7 -8 -9 -10 -11 -12 -13 -14 -15 -16))
+(assert_return (invoke "v8x16_shuffle-4"
+  (v128.const i8x16   0   1   2   3   4   5   6  7  8  9 10 11 12 13 14 15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1))
+  (v128.const i8x16  15  14  13  12  11  10   9  8  7  6  5  4  3  2  1  0))
+(assert_return (invoke "v8x16_shuffle-5"
+  (v128.const i8x16   0   1   2   3   4   5   6  7  8  9 10 11 12 13 14 15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1))
+  (v128.const i8x16   0   0   0   0   0   0   0  0  0  0  0  0  0  0  0  0))
+(assert_return (invoke "v8x16_shuffle-6"
+  (v128.const i8x16   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10  -9  -8  -7  -6  -5  -4  -3  -2  -1))
+  (v128.const i8x16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16))
+(assert_return (invoke "v8x16_shuffle-7"
+  (v128.const i8x16   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10  -9  -8  -7  -6  -5  -4  -3  -2  -1))
+  (v128.const i8x16   0   0   0   0   0   0   0   0 -16 -16 -16 -16 -16 -16 -16 -16))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i8x16 0x64 0x65 0x66 0x67 0x68 0x69 0x6a 0x6b 0x6c 0x6d 0x6e 0x6f 0x70 0x71 0x72 0x73)
+  (v128.const i8x16 0xf0 0xf1 0xf2 0xf3 0xf4 0xf5 0xf6 0xf7 0xf8 0xf9 0xfa 0xfb 0xfc 0xfd 0xfe 0xff))
+  (v128.const i8x16 0x64 0x65 0x66 0x67 0x68 0x69 0x6a 0x6b 0x6c 0x6d 0x6e 0x6f 0x70 0x71 0x72 0x73))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0b0a 0x0d0c 0x0f0e)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10  -9  -8  -7  -6  -5  -4  -3  -2  -1))
+  (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0b0a 0x0d0c 0x0f0e))
+(assert_return (invoke "v8x16_shuffle-2"
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+  (v128.const i32x4 0xf3f2f1f0 0xf7f6f5f4 0xfbfaf9f8 0xfffefdfc))
+  (v128.const i32x4 0xf3f2f1f0 0xf7f6f5f4 0xfbfaf9f8 0xfffefdfc))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i32x4 0x10203 0x4050607 0x8090a0b 0xc0d0e0f)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+  (v128.const i32x4 0x10203 0x4050607 0x8090a0b 0xc0d0e0f))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const f32x4 1.0 nan inf -inf)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+  (v128.const i32x4 0x3f800000 0x7fc00000 0x7f800000 0xff800000))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i32x4 0x10203 0x4050607 0x8090a0b 0xc0d0e0f)
+  (v128.const f32x4 -0.0 nan inf -inf))
+  (v128.const i32x4 0x10203 0x4050607 0x8090a0b 0xc0d0e0f))
+
+;; More literals
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i32x4 1_234_567_890 0x1234_5678 01_234_567_890 0x0_1234_5678)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+  (v128.const i32x4 0x4996_02d2 0x1234_5678 0x4996_02d2 0x1234_5678))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i64x2 1_234_567_890_123_456_789_0 0x1234_5678_90AB_cdef)
+  (v128.const i64x2 01_234_567_890_123_456_789_0 0x0_1234_5678_90AB_cdef))
+  (v128.const i32x4 0xeb1f_0ad2 0xab54_a98c 0x90ab_cdef 0x1234_5678))
+
+;; Syntax errors for negative values
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_s  -1 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_u  -1 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_s  -1 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_u  -1 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane  -1 (v128.const i32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result f32) (f32x4.extract_lane  -1 (v128.const f32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i8x16.replace_lane  -1 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i16x8.replace_lane  -1 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i32x4.replace_lane  -1 (v128.const i32x4 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (f32x4.replace_lane  -1 (v128.const f32x4 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result i64) (i64x2.extract_lane  -1 (v128.const i64x2 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result f64) (f64x2.extract_lane  -1 (v128.const f64x2 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i64x2.replace_lane  -1 (v128.const i64x2 0 0) (i64.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (f64x2.replace_lane  -1 (v128.const f64x2 0 0) (f64.const 1)))") "unexpected token")
+
+;; Malformed lane index value
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_s 256 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_u 256 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_s 256 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_u 256 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane 256 (v128.const i32x4 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result f32) (f32x4.extract_lane 256 (v128.const f32x4 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (i8x16.replace_lane 256 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (i16x8.replace_lane 256 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (i32x4.replace_lane 256 (v128.const i32x4 0 0 0 0) (i32.const 1)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (f32x4.replace_lane 256 (v128.const f32x4 0 0 0 0) (i32.const 1)))") "malformed lane index")
+(assert_malformed (module quote "(func (result i64) (i64x2.extract_lane 256 (v128.const i64x2 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result f64) (f64x2.extract_lane 256 (v128.const f64x2 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (i64x2.replace_lane 256 (v128.const i64x2 0 0) (i64.const 1)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (f64x2.replace_lane 256 (v128.const f64x2 0 0) (f64.const 1)))") "malformed lane index")
+
+;; Invalid lane index value
+
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_s 16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_s 255 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_u 16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_u 255 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_s 8 (v128.const i16x8 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_s 255 (v128.const i16x8 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_u 8 (v128.const i16x8 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_u 255 (v128.const i16x8 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i32x4.extract_lane 4 (v128.const i32x4 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i32x4.extract_lane 255 (v128.const i32x4 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result f32) (f32x4.extract_lane 4 (v128.const f32x4 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result f32) (f32x4.extract_lane 255 (v128.const f32x4 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i8x16.replace_lane 16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i8x16.replace_lane 255 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i16x8.replace_lane 16 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i16x8.replace_lane 255 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 4 (v128.const i32x4 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 255 (v128.const i32x4 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 4 (v128.const f32x4 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 255 (v128.const f32x4 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result i64) (i64x2.extract_lane 2 (v128.const i64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i64) (i64x2.extract_lane 255 (v128.const i64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result f64) (f64x2.extract_lane 2 (v128.const f64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result f64) (f64x2.extract_lane 255 (v128.const f64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i64x2.replace_lane 2 (v128.const i64x2 0 0) (i64.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i64x2.replace_lane 255 (v128.const i64x2 0 0) (i64.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f64x2.replace_lane 2 (v128.const f64x2 0 0) (f64.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f64x2.replace_lane 255 (v128.const f64x2 0 0) (f64.const 1.0)))) "invalid lane index")
+
+;; Lane index is determined by the instruction's interpretation only.
+
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_s 8 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_u 8 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i32x4.extract_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (f32x4.extract_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i16x8.replace_lane 8 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result i64) (i64x2.extract_lane 2 (v128.const i64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result f64) (f64x2.extract_lane 2 (v128.const f64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i64x2.replace_lane 2 (v128.const i64x2 0 0) (i64.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f64x2.replace_lane 2 (v128.const f64x2 0 0) (f64.const 1.0)))) "invalid lane index")
+
+;; Invalid parameters: required v128 but pass other types
+
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_s 0 (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_u 0 (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_s 0 (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_u 0 (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32x4.extract_lane 0 (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32x4.extract_lane 0 (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.replace_lane 0 (i32.const 0) (i32.const 1)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.replace_lane 0 (i64.const 0) (i32.const 1)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 0 (i32.const 0) (i32.const 1)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 0 (f32.const 0.0) (i32.const 1)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64x2.extract_lane 0 (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64x2.extract_lane 0 (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 0 (i32.const 0) (i32.const 1)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 0 (f32.const 0.0) (i32.const 1)))) "type mismatch")
+
+;; Invalid types for the replaced value
+
+(assert_invalid (module (func (result v128) (i8x16.replace_lane 0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (f32.const 1.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.replace_lane 0 (v128.const i16x8 0 0 0 0 0 0 0 0) (f64.const 1.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 0 (v128.const i32x4 0 0 0 0) (f32.const 1.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 0 (v128.const f32x4 0 0 0 0) (i32.const 1)))) "type mismatch")
+
+(assert_invalid (module (func (result v128) (i64x2.replace_lane 0 (v128.const i64x2 0 0) (f64.const 1.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.replace_lane 0 (v128.const f64x2 0 0) (i64.const 1)))) "type mismatch")
+
+;; Invalid types for swizzle and shuffle values
+(assert_invalid (module (func (result v128)
+  (i8x16.swizzle (i32.const 1) (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)))) "type mismatch")
+(assert_invalid (module (func (result v128)
+  (i8x16.swizzle (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) (i32.const 2)))) "type mismatch")
+(assert_invalid (module (func (result v128)
+  (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (f32.const 3.0)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)))) "type mismatch")
+(assert_invalid (module (func (result v128)
+  (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) (f32.const 4.0)))) "type mismatch")
+
+;; i8x16.shuffle: the 1st argument must be 16-byte literals in 0..32
+(assert_malformed (module quote "(func (param v128) (result v128)"
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 (local.get 0) (local.get 0)))")
+  "invalid lane length")
+(assert_malformed (module quote "(func (param v128) (result v128)"
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 (local.get 0) (local.get 0)))")
+  "invalid lane length")
+(assert_malformed (module quote "(func (result v128)"
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 -1"
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)"
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128)"
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 256"
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)"
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_invalid (module (func (result v128)
+  (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 255
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))) "invalid lane index")
+
+;; Possible wrong instruction names that'd be used
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane 0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane 0 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane_s 0 (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane_u 0 (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(func (result i32) (i64x2.extract_lane_s 0 (v128.const i64x2 0 0)))") "unknown operator")
+(assert_malformed (module quote "(func (result i32) (i64x2.extract_lane_u 0 (v128.const i64x2 0 0)))") "unknown operator")
+
+
+;; Old shuffle instruction names will not work
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle1 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)))")
+  "unknown operator")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle2_imm  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)))")
+  "unknown operator")
+;; i8x16 not v8x16
+(assert_malformed (module quote "(func (result v128) "
+  "(v8x16.swizzle (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)))")
+  "unknown operator")
+(assert_malformed (module quote "(func (result v128) "
+  "(v8x16.shuffle  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)))")
+  "unknown operator")
+
+
+;; Malformed lane index
+
+;; Pass params as the lane index
+
+(assert_malformed (module quote "(func (param i32) (result i32) (i8x16.extract_lane_s (local.get 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result i32) (i8x16.extract_lane_u (local.get 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result i32) (i16x8.extract_lane_s (local.get 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result i32) (i16x8.extract_lane_u (local.get 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result i32) (i32x4.extract_lane (local.get 0) (v128.const i32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result f32) (f32x4.extract_lane (local.get 0) (v128.const f32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (i8x16.replace_lane (local.get 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (i16x8.replace_lane (local.get 0) (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (i32x4.replace_lane (local.get 0) (v128.const i32x4 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (f32x4.replace_lane (local.get 0) (v128.const f32x4 0 0 0 0) (f32.const 1.0)))") "unexpected token")
+
+(assert_malformed (module quote "(func (param i32) (result i64) (i64x2.extract_lane (local.get 0) (v128.const i64x2 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result f64) (f64x2.extract_lane (local.get 0) (v128.const f64x2 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (i64x2.replace_lane (local.get 0) (v128.const i64x2 0 0) (i64.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (f64x2.replace_lane (local.get 0) (v128.const f64x2 0 0) (f64.const 1.0)))") "unexpected token")
+
+;; Pass non-literal as the lane index
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_s 1.5 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_u nan (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_s inf (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_u -inf (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane nan (v128.const i32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result f32) (f32x4.extract_lane nan (v128.const f32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i8x16.replace_lane -2.5 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i16x8.replace_lane nan (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i32x4.replace_lane inf (v128.const i32x4 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (f32x4.replace_lane -inf (v128.const f32x4 0 0 0 0) (f32.const 1.1)))") "unexpected token")
+
+;; i8x16.shuffle expects a 16-byte literals as first argument
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "invalid lane length")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15.0) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle 0.5 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle -inf 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 inf) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle nan 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+
+
+;; Combination with each other
+
+(module
+  ;; as *.replace_lane's operand
+  (func (export "i8x16_extract_lane_s") (param v128 v128) (result v128)
+    (i8x16.replace_lane 0 (local.get 0) (i8x16.extract_lane_s 0 (local.get 1))))
+  (func (export "i8x16_extract_lane_u") (param v128 v128) (result v128)
+    (i8x16.replace_lane 0 (local.get 0) (i8x16.extract_lane_u 0 (local.get 1))))
+  (func (export "i16x8_extract_lane_s") (param v128 v128) (result v128)
+    (i16x8.replace_lane 0 (local.get 0) (i16x8.extract_lane_s 0 (local.get 1))))
+  (func (export "i16x8_extract_lane_u") (param v128 v128) (result v128)
+    (i16x8.replace_lane 0 (local.get 0) (i16x8.extract_lane_u 0 (local.get 1))))
+  (func (export "i32x4_extract_lane") (param v128 v128) (result v128)
+    (i32x4.replace_lane 0 (local.get 0) (i32x4.extract_lane 0 (local.get 1))))
+  (func (export "f32x4_extract_lane") (param v128 v128) (result v128)
+    (i32x4.replace_lane 0 (local.get 0) (i32x4.extract_lane 0 (local.get 1))))
+  (func (export "i64x2_extract_lane") (param v128 v128) (result v128)
+    (i64x2.replace_lane 0 (local.get 0) (i64x2.extract_lane 0 (local.get 1))))
+  (func (export "f64x2_extract_lane") (param v128 v128) (result v128)
+    (f64x2.replace_lane 0 (local.get 0) (f64x2.extract_lane 0 (local.get 1))))
+
+  ;; as *.extract_lane's operand
+  (func (export "i8x16_replace_lane-s") (param v128 i32) (result i32)
+    (i8x16.extract_lane_s 15 (i8x16.replace_lane 15 (local.get 0) (local.get 1))))
+  (func (export "i8x16_replace_lane-u") (param v128 i32) (result i32)
+    (i8x16.extract_lane_u 15 (i8x16.replace_lane 15 (local.get 0) (local.get 1))))
+  (func (export "i16x8_replace_lane-s") (param v128 i32) (result i32)
+    (i16x8.extract_lane_s 7 (i16x8.replace_lane 7 (local.get 0) (local.get 1))))
+  (func (export "i16x8_replace_lane-u") (param v128 i32) (result i32)
+    (i16x8.extract_lane_u 7 (i16x8.replace_lane 7 (local.get 0) (local.get 1))))
+  (func (export "i32x4_replace_lane") (param v128 i32) (result i32)
+    (i32x4.extract_lane 3 (i32x4.replace_lane 3 (local.get 0) (local.get 1))))
+  (func (export "f32x4_replace_lane") (param v128 f32) (result f32)
+    (f32x4.extract_lane 3 (f32x4.replace_lane 3 (local.get 0) (local.get 1))))
+  (func (export "i64x2_replace_lane") (param v128 i64) (result i64)
+    (i64x2.extract_lane 1 (i64x2.replace_lane 1 (local.get 0) (local.get 1))))
+  (func (export "f64x2_replace_lane") (param v128 f64) (result f64)
+    (f64x2.extract_lane 1 (f64x2.replace_lane 1 (local.get 0) (local.get 1))))
+
+  ;; i8x16.replace outputs as shuffle operand
+  (func (export "as-v8x16_swizzle-operand") (param v128 i32 v128) (result v128)
+    (i8x16.swizzle (i8x16.replace_lane 0 (local.get 0) (local.get 1)) (local.get 2)))
+  (func (export "as-v8x16_shuffle-operands") (param v128 i32 v128 i32) (result v128)
+    (i8x16.shuffle 16 1 18 3 20 5 22 7 24 9 26 11 28 13 30 15
+      (i8x16.replace_lane 0 (local.get 0) (local.get 1))
+      (i8x16.replace_lane 15 (local.get 2) (local.get 3))))
+)
+
+(assert_return (invoke "i8x16_extract_lane_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) (v128.const i8x16 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16_extract_lane_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) (v128.const i8x16 255 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_extract_lane_s" (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) (v128.const i16x8 -1 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_extract_lane_u" (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) (v128.const i16x8 65535 0 0 0 0 0 0 0))
+(assert_return (invoke "i32x4_extract_lane" (v128.const i32x4 0 0 0 0) (v128.const i32x4 0x10000 -1 -1 -1)) (v128.const i32x4 65536 0 0 0))
+(assert_return (invoke "f32x4_extract_lane" (v128.const f32x4 0 0 0 0) (v128.const f32x4 1e38 nan nan nan)) (v128.const f32x4 1e38 0 0 0))
+(assert_return (invoke "i8x16_replace_lane-s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 255)) (i32.const -1))
+(assert_return (invoke "i8x16_replace_lane-u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 255)) (i32.const 255))
+(assert_return (invoke "i16x8_replace_lane-s" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 65535)) (i32.const -1))
+(assert_return (invoke "i16x8_replace_lane-u" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 65535)) (i32.const 65535))
+(assert_return (invoke "i32x4_replace_lane" (v128.const i32x4 0 0 0 0) (i32.const -1)) (i32.const -1))
+(assert_return (invoke "f32x4_replace_lane" (v128.const f32x4 0 0 0 0) (f32.const 1.25)) (f32.const 1.25))
+
+(assert_return (invoke "i64x2_extract_lane" (v128.const i64x2 0 0) (v128.const i64x2 0xffffffffffffffff -1)) (v128.const i64x2 0xffffffffffffffff 0))
+(assert_return (invoke "f64x2_extract_lane" (v128.const f64x2 0 0) (v128.const f64x2 1e308 nan)) (v128.const f64x2 1e308 0))
+(assert_return (invoke "i64x2_replace_lane" (v128.const i64x2 0 0) (i64.const -1)) (i64.const -1))
+(assert_return (invoke "f64x2_replace_lane" (v128.const f64x2 0 0) (f64.const 2.5)) (f64.const 2.5))
+
+(assert_return (invoke "as-v8x16_swizzle-operand"
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) (i32.const 255)
+  (v128.const i8x16 -1 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1))
+  (v128.const i8x16 0 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1))
+(assert_return (invoke "as-v8x16_shuffle-operands"
+  (v128.const i8x16 0 255 0 255 15 255 0 255 255 255 0 255 127 255 0 255) (i32.const 1)
+  (v128.const i8x16 0x55 0 0x55 0 0x55 0 0x55 0 0x55 0 0x55 0 0x55 1 0x55 -1) (i32.const 0))
+  (v128.const i8x16 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff))
+
+;; Combination with other SIMD instructions
+
+(module
+  ;; Constructing SIMD values
+  (func (export "as-i8x16_splat-operand") (param v128) (result v128)
+    (i8x16.splat (i8x16.extract_lane_s 0 (local.get 0))))
+  (func (export "as-i16x8_splat-operand") (param v128) (result v128)
+    (i16x8.splat (i16x8.extract_lane_u 0 (local.get 0))))
+  (func (export "as-i32x4_splat-operand") (param v128) (result v128)
+    (i32x4.splat (i32x4.extract_lane 0 (local.get 0))))
+  (func (export "as-f32x4_splat-operand") (param v128) (result v128)
+    (f32x4.splat (f32x4.extract_lane 0 (local.get 0))))
+  (func (export "as-i64x2_splat-operand") (param v128) (result v128)
+    (i64x2.splat (i64x2.extract_lane 0 (local.get 0))))
+  (func (export "as-f64x2_splat-operand") (param v128) (result v128)
+    (f64x2.splat (f64x2.extract_lane 0 (local.get 0))))
+
+  ;; Integer arithmetic
+  (func (export "as-i8x16_add-operands") (param v128 i32 v128 i32) (result v128)
+    (i8x16.add (i8x16.replace_lane 0 (local.get 0) (local.get 1)) (i8x16.replace_lane 15 (local.get 2) (local.get 3))))
+  (func (export "as-i16x8_add-operands") (param v128 i32 v128 i32) (result v128)
+    (i16x8.add (i16x8.replace_lane 0 (local.get 0) (local.get 1)) (i16x8.replace_lane 7 (local.get 2) (local.get 3))))
+  (func (export "as-i32x4_add-operands") (param v128 i32 v128 i32) (result v128)
+    (i32x4.add (i32x4.replace_lane 0 (local.get 0) (local.get 1)) (i32x4.replace_lane 3 (local.get 2) (local.get 3))))
+  (func (export "as-i64x2_add-operands") (param v128 i64 v128 i64) (result v128)
+    (i64x2.add (i64x2.replace_lane 0 (local.get 0) (local.get 1)) (i64x2.replace_lane 1 (local.get 2) (local.get 3))))
+
+  (func (export "swizzle-as-i8x16_add-operands") (param v128 v128 v128 v128) (result v128)
+    (i8x16.add (i8x16.swizzle (local.get 0) (local.get 1)) (i8x16.swizzle (local.get 2) (local.get 3))))
+  (func (export "shuffle-as-i8x16_sub-operands") (param v128 v128 v128 v128) (result v128)
+    (i8x16.sub (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (local.get 0) (local.get 1))
+      (i8x16.shuffle 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 (local.get 2) (local.get 3))))
+
+  ;; Boolean horizontal reductions
+  (func (export "as-i8x16_any_true-operand") (param v128 i32) (result i32)
+    (v128.any_true (i8x16.replace_lane 0 (local.get 0) (local.get 1))))
+  (func (export "as-i16x8_any_true-operand") (param v128 i32) (result i32)
+    (v128.any_true (i16x8.replace_lane 0 (local.get 0) (local.get 1))))
+  (func (export "as-i32x4_any_true-operand1") (param v128 i32) (result i32)
+    (v128.any_true (i32x4.replace_lane 0 (local.get 0) (local.get 1))))
+  (func (export "as-i32x4_any_true-operand2") (param v128 i64) (result i32)
+    (v128.any_true (i64x2.replace_lane 0 (local.get 0) (local.get 1))))
+
+  (func (export "swizzle-as-i8x16_all_true-operands") (param v128 v128) (result i32)
+    (i8x16.all_true (i8x16.swizzle (local.get 0) (local.get 1))))
+  (func (export "shuffle-as-i8x16_any_true-operands") (param v128 v128) (result i32)
+    (v128.any_true (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (local.get 0) (local.get 1))))
+)
+
+(assert_return (invoke "as-i8x16_splat-operand" (v128.const i8x16 0xff 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "as-i16x8_splat-operand" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0)) (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "as-i32x4_splat-operand" (v128.const i32x4 0x10000 0 0 0)) (v128.const i32x4 65536 65536 65536 65536))
+(assert_return (invoke "as-f32x4_splat-operand" (v128.const f32x4 3.14 nan nan nan)) (v128.const f32x4 3.14 3.14 3.14 3.14))
+(assert_return (invoke "as-i64x2_splat-operand" (v128.const i64x2 -1 0)) (v128.const i64x2 -1 -1))
+(assert_return (invoke "as-f64x2_splat-operand" (v128.const f64x2 inf nan)) (v128.const f64x2 inf inf))
+(assert_return (invoke "as-i8x16_add-operands"
+  (v128.const i8x16 0xff 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16) (i32.const 1)
+  (v128.const i8x16 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 0xff) (i32.const 1))
+  (v128.const i8x16 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17))
+(assert_return (invoke "as-i16x8_add-operands"
+  (v128.const i16x8 -1 4 9 16 25 36 49 64) (i32.const 1)
+  (v128.const i16x8 64 49 36 25 16 9 4 -1) (i32.const 1))
+  (v128.const i16x8 65 53 45 41 41 45 53 65))
+(assert_return (invoke "as-i32x4_add-operands"
+  (v128.const i32x4 -1 8 27 64) (i32.const 1) (v128.const i32x4 64 27 8 -1) (i32.const 1)) (v128.const i32x4 65 35 35 65))
+(assert_return (invoke "as-i64x2_add-operands"
+  (v128.const i64x2 -1 8) (i64.const 1) (v128.const i64x2 64 27) (i64.const 1)) (v128.const i64x2 65 9))
+
+(assert_return (invoke "swizzle-as-i8x16_add-operands"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0))
+  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "shuffle-as-i8x16_sub-operands"
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0))
+  (v128.const i8x16 -15 -13 -11 -9 -7 -5 -3 -1 1 3 5 7 9 11 13 15))
+
+(assert_return (invoke "as-i8x16_any_true-operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-i16x8_any_true-operand" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-i32x4_any_true-operand1" (v128.const i32x4 1 0 0 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-i32x4_any_true-operand2" (v128.const i64x2 1 0) (i64.const 0)) (i32.const 0))
+
+(assert_return (invoke "swizzle-as-i8x16_all_true-operands"
+  (v128.const i8x16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) (i32.const 1))
+(assert_return (invoke "swizzle-as-i8x16_all_true-operands"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 16)) (i32.const 0))
+(assert_return (invoke "shuffle-as-i8x16_any_true-operands"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) (i32.const 1))
+
+;; Load and store
+
+(module
+  (memory 1)
+  (func (export "as-v128_store-operand-1") (param v128 i32) (result v128)
+    (v128.store (i32.const 0) (i8x16.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-2") (param v128 i32) (result v128)
+    (v128.store (i32.const 0) (i16x8.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-3") (param v128 i32) (result v128)
+    (v128.store (i32.const 0) (i32x4.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-4") (param v128 f32) (result v128)
+    (v128.store (i32.const 0) (f32x4.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-5") (param v128 i64) (result v128)
+    (v128.store (i32.const 0) (i64x2.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-6") (param v128 f64) (result v128)
+    (v128.store (i32.const 0) (f64x2.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+)
+
+(assert_return (invoke "as-v128_store-operand-1" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)) (v128.const i8x16 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "as-v128_store-operand-2" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 256)) (v128.const i16x8 0x100 0 0 0 0 0 0 0))
+(assert_return (invoke "as-v128_store-operand-3" (v128.const i32x4 0 0 0 0) (i32.const 0xffffffff)) (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "as-v128_store-operand-4" (v128.const f32x4 0 0 0 0) (f32.const 3.14)) (v128.const f32x4 3.14 0 0 0))
+(assert_return (invoke "as-v128_store-operand-5" (v128.const i64x2 0 0) (i64.const 0xffffffffffffffff)) (v128.const i64x2 -1 0))
+(assert_return (invoke "as-v128_store-operand-6" (v128.const f64x2 0 0) (f64.const 3.14)) (v128.const f64x2 3.14 0))
+
+;; As the argument of wasm core ops
+
+(module
+  (global $g (mut v128) (v128.const f32x4 0.0 0.0 0.0 0.0))
+  (global $h (mut v128) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+  (func (export "as-if-condition-value") (param v128) (result i32)
+    (if (result i32) (i8x16.extract_lane_s 0 (local.get 0)) (then (i32.const 0xff)) (else (i32.const 0))))
+  (func (export "as-return-value-1") (param v128 i32) (result v128)
+    (return (i16x8.replace_lane 0 (local.get 0) (local.get 1))))
+  (func (export "as-local_set-value") (param v128) (result i32) (local i32)
+    (local.set 1 (i32x4.extract_lane 0 (local.get 0)))
+    (return (local.get 1)))
+  (func (export "as-global_set-value-1") (param v128 f32) (result v128)
+    (global.set $g (f32x4.replace_lane 0 (local.get 0) (local.get 1)))
+    (return (global.get $g)))
+
+   (func (export "as-return-value-2") (param v128 v128) (result v128)
+    (return (i8x16.swizzle (local.get 0) (local.get 1))))
+  (func (export "as-global_set-value-2") (param v128 v128) (result v128)
+    (global.set $h (i8x16.shuffle 0 1 2 3 4 5 6 7 24 25 26 27 28 29 30 31 (local.get 0) (local.get 1)))
+    (return (global.get $h)))
+
+  (func (export "as-local_set-value-1") (param v128) (result i64) (local i64)
+    (local.set 1 (i64x2.extract_lane 0 (local.get 0)))
+    (return (local.get 1)))
+  (func (export "as-global_set-value-3") (param v128 f64) (result v128)
+    (global.set $g (f64x2.replace_lane 0 (local.get 0) (local.get 1)))
+    (return (global.get $g)))
+)
+
+(assert_return (invoke "as-if-condition-value" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 0))
+(assert_return (invoke "as-return-value-1" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)) (v128.const i16x8 1 0 0 0 0 0 0 0))
+(assert_return (invoke "as-local_set-value" (v128.const i32x4 -1 -1 -1 -1)) (i32.const -1))
+(assert_return (invoke "as-global_set-value-1" (v128.const f32x4 0 0 0 0)(f32.const 3.14)) (v128.const f32x4 3.14 0 0 0))
+
+(assert_return (invoke "as-return-value-2"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0))
+  (v128.const i8x16 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15 -16))
+(assert_return (invoke "as-global_set-value-2"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1))
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 8 7 6 5 4 3 2 1))
+
+(assert_return (invoke "as-local_set-value-1" (v128.const i64x2 -1 -1)) (i64.const -1))
+(assert_return (invoke "as-global_set-value-3" (v128.const f64x2 0 0)(f64.const 3.14)) (v128.const f64x2 3.14 0))
+
+;; Non-nat lane index
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_u +0x0f (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result f32) (f32x4.extract_lane +03 (v128.const f32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i64) (i64x2.extract_lane +1 (v128.const i64x2 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i8x16.replace_lane +015 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i16x8.replace_lane +0x7 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i32x4.replace_lane +3 (v128.const i32x4 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (f64x2.replace_lane +0x01 (v128.const f64x2 0 0) (f64.const 1.0)))") "unexpected token")
+
+;; Lane index literal
+
+(module (func (result i32) (i8x16.extract_lane_s 0x0f (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))))
+(module (func (result i32) (i16x8.extract_lane_s 0x07 (v128.const i16x8 0 0 0 0 0 0 0 0))))
+(module (func (result i32) (i16x8.extract_lane_u 0x0_7 (v128.const i16x8 0 0 0 0 0 0 0 0))))
+(module (func (result i32) (i32x4.extract_lane 03 (v128.const i32x4 0 0 0 0))))
+(module (func (result f64) (f64x2.extract_lane 0x1 (v128.const f64x2 0 0))))
+(module (func (result v128) (f32x4.replace_lane 0x3 (v128.const f32x4 0 0 0 0) (f32.const 1.0))))
+(module (func (result v128) (i64x2.replace_lane 01 (v128.const i64x2 0 0) (i64.const 1))))
+
+;; 1.0 is malformed lane index
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_s 1.0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+
+;; Test operation with empty argument
+
+(assert_malformed
+  (module quote
+    "(func $i8x16.extract_lane_s-1st-arg-empty (result i32)"
+    "  (i8x16.extract_lane_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i8x16.extract_lane_s-2nd-arg-empty (result i32)
+      (i8x16.extract_lane_s 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i8x16.extract_lane_s-arg-empty (result i32)"
+    "  (i8x16.extract_lane_s)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i16x8.extract_lane_u-1st-arg-empty (result i32)"
+    "  (i16x8.extract_lane_u (v128.const i16x8 0 0 0 0 0 0 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extract_lane_u-2nd-arg-empty (result i32)
+      (i16x8.extract_lane_u 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i16x8.extract_lane_u-arg-empty (result i32)"
+    "  (i16x8.extract_lane_u)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i32x4.extract_lane-1st-arg-empty (result i32)"
+    "  (i32x4.extract_lane (v128.const i32x4 0 0 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extract_lane-2nd-arg-empty (result i32)
+      (i32x4.extract_lane 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i32x4.extract_lane-arg-empty (result i32)"
+    "  (i32x4.extract_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i64x2.extract_lane-1st-arg-empty (result i64)"
+    "  (i64x2.extract_lane (v128.const i64x2 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extract_lane-2nd-arg-empty (result i64)
+      (i64x2.extract_lane 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i64x2.extract_lane-arg-empty (result i64)"
+    "  (i64x2.extract_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $f32x4.extract_lane-1st-arg-empty (result f32)"
+    "  (f32x4.extract_lane (v128.const f32x4 0 0 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $f32x4.extract_lane-2nd-arg-empty (result f32)
+      (f32x4.extract_lane 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $f32x4.extract_lane-arg-empty (result f32)"
+    "  (f32x4.extract_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $f64x2.extract_lane-1st-arg-empty (result f64)"
+    "  (f64x2.extract_lane (v128.const f64x2 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $f64x2.extract_lane-2nd-arg-empty (result f64)
+      (f64x2.extract_lane 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $f64x2.extract_lane-arg-empty (result f64)"
+    "  (f64x2.extract_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i8x16.replace_lane-1st-arg-empty (result v128)"
+    "  (i8x16.replace_lane (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i8x16.replace_lane-2nd-arg-empty (result v128)
+      (i8x16.replace_lane 0 (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.replace_lane-3rd-arg-empty (result v128)
+      (i8x16.replace_lane 0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i8x16.replace_lane-arg-empty (result v128)"
+    "  (i8x16.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i16x8.replace_lane-1st-arg-empty (result v128)"
+    "  (i16x8.replace_lane (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i16x8.replace_lane-2nd-arg-empty (result v128)
+      (i16x8.replace_lane 0 (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.replace_lane-3rd-arg-empty (result v128)
+      (i16x8.replace_lane 0 (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i16x8.replace_lane-arg-empty (result v128)"
+    "  (i16x8.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i32x4.replace_lane-1st-arg-empty (result v128)"
+    "  (i32x4.replace_lane (v128.const i32x4 0 0 0 0) (i32.const 1))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i32x4.replace_lane-2nd-arg-empty (result v128)
+      (i32x4.replace_lane 0 (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.replace_lane-3rd-arg-empty (result v128)
+      (i32x4.replace_lane 0 (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i32x4.replace_lane-arg-empty (result v128)"
+    "  (i32x4.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $f32x4.replace_lane-1st-arg-empty (result v128)"
+    "  (f32x4.replace_lane (v128.const f32x4 0 0 0 0) (f32.const 1.0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $f32x4.replace_lane-2nd-arg-empty (result v128)
+      (f32x4.replace_lane 0 (f32.const 1.0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.replace_lane-3rd-arg-empty (result v128)
+      (f32x4.replace_lane 0 (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $f32x4.replace_lane-arg-empty (result v128)"
+    "  (f32x4.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i64x2.replace_lane-1st-arg-empty (result v128)"
+    "  (i64x2.replace_lane (v128.const i64x2 0 0) (i64.const 1))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i64x2.replace_lane-2nd-arg-empty (result v128)
+      (i64x2.replace_lane 0 (i64.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.replace_lane-3rd-arg-empty (result v128)
+      (i64x2.replace_lane 0 (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i64x2.replace_lane-arg-empty (result v128)"
+    "  (i64x2.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $f64x2.replace_lane-1st-arg-empty (result v128)"
+    "  (f64x2.replace_lane (v128.const f64x2 0 0) (f64.const 1.0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $f64x2.replace_lane-2nd-arg-empty (result v128)
+      (f64x2.replace_lane 0 (f64.const 1.0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.replace_lane-3rd-arg-empty (result v128)
+      (f64x2.replace_lane 0 (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $f64x2.replace_lane-arg-empty (result v128)"
+    "  (f64x2.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i8x16.shuffle-1st-arg-empty (result v128)"
+    "  (i8x16.shuffle"
+    "    (v128.const i8x16 0 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15)"
+    "    (v128.const i8x16 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15 16)"
+    "  )"
+    ")"
+  )
+  "invalid lane length"
+)
+(assert_invalid
+  (module
+    (func $i8x16.shuffle-2nd-arg-empty (result v128)
+      (i8x16.shuffle 0 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15
+        (v128.const i8x16 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15 16)
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i8x16.shuffle-arg-empty (result v128)"
+    "  (i8x16.shuffle)"
+    ")"
+  )
+  "invalid lane length"
+)
diff --git a/test/core/simd/simd_load.wast b/test/core/simd/simd_load.wast
new file mode 100644
index 000000000..4b2edc160
--- /dev/null
+++ b/test/core/simd/simd_load.wast
@@ -0,0 +1,188 @@
+;; v128.load operater with normal argument (e.g. (i8x16, i16x8 i32x4))
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "v128.load") (result v128)
+    (v128.load (i32.const 0))
+  )
+)
+
+(assert_return (invoke "v128.load") (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f))
+(assert_return (invoke "v128.load") (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0b0a 0x0d0c 0x0f0e))
+(assert_return (invoke "v128.load") (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c))
+
+
+;; v128.load operater as the argument of other SIMD instructions
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "as-i8x16_extract_lane_s-value/0") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-i8x16_extract_lane_s-value/0") (i32.const 0x00))
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "as-i8x16.eq-operand") (result v128)
+    (i8x16.eq (v128.load offset=0 (i32.const 0)) (v128.load offset=16 (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-i8x16.eq-operand") (v128.const i32x4 0xffffffff 0x00000000 0x00000000 0x00000000))
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "as-v128.not-operand") (result v128)
+    (v128.not (v128.load (i32.const 0)))
+  )
+  (func (export "as-i8x16.all_true-operand") (result i32)
+    (i8x16.all_true (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-v128.not-operand") (v128.const i32x4 0xfcfdfeff 0xf8f9fafb 0xf4f5f6f7 0xf0f1f2f3))
+(assert_return (invoke "as-i8x16.all_true-operand") (i32.const 0))
+
+(module (memory 1)
+  (data (offset (i32.const 0))  "\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA")
+  (data (offset (i32.const 16)) "\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB")
+  (data (offset (i32.const 32)) "\F0\F0\F0\F0\FF\FF\FF\FF\00\00\00\00\FF\00\FF\00")
+  (func (export "as-v128.bitselect-operand") (result v128)
+    (v128.bitselect (v128.load (i32.const 0)) (v128.load (i32.const 16)) (v128.load (i32.const 32)))
+  )
+)
+(assert_return (invoke "as-v128.bitselect-operand") (v128.const i32x4 0xabababab 0xaaaaaaaa 0xbbbbbbbb 0xbbaabbaa))
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA")
+  (func (export "as-i8x16.shl-operand") (result v128)
+    (i8x16.shl (v128.load (i32.const 0)) (i32.const 1))
+  )
+)
+(assert_return (invoke "as-i8x16.shl-operand") (v128.const i32x4 0x54545454 0x54545454 0x54545454 0x54545454)) ;; 1010 1000 << 1010 1010
+
+(module (memory 1)
+  (data (offset (i32.const 0))  "\02\00\00\00\02\00\00\00\02\00\00\00\02\00\00\00")
+  (data (offset (i32.const 16)) "\03\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00")
+  (func (export "as-add/sub-operand") (result v128)
+    ;; 2 2 2 2 + 3 3 3 3 = 5 5 5 5
+    ;; 5 5 5 5 - 3 3 3 3 = 2 2 2 2
+    (i8x16.sub
+      (i8x16.add (v128.load (i32.const 0)) (v128.load (i32.const 16)))
+      (v128.load (i32.const 16))
+    )
+  )
+)
+(assert_return (invoke "as-add/sub-operand") (v128.const i32x4 2 2 2 2))
+
+(module (memory 1)
+  (data (offset (i32.const 0))  "\00\00\00\43\00\00\80\3f\66\66\e6\3f\00\00\80\bf")  ;; 128 1.0 1.8 -1
+  (data (offset (i32.const 16)) "\00\00\00\40\00\00\00\40\00\00\00\40\00\00\00\40")  ;; 2.0 2.0 2.0 2.0
+  (func (export "as-f32x4.mul-operand") (result v128)
+    (f32x4.mul (v128.load (i32.const 0)) (v128.load (i32.const 16)))
+  )
+)
+(assert_return (invoke "as-f32x4.mul-operand") (v128.const f32x4 256 2 3.6 -2))
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff")  ;; 1111 ...
+  (func (export "as-f32x4.abs-operand") (result v128)
+    (f32x4.abs (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-f32x4.abs-operand") (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)) ;; 1111 -> 0111
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA")
+  (data (offset (i32.const 16)) "\02\00\00\00\02\00\00\00\02\00\00\00\02\00\00\00")
+  (func (export "as-f32x4.min-operand") (result v128)
+    (f32x4.min (v128.load (i32.const 0)) (v128.load offset=16 (i32.const 1)))
+  )
+)
+(assert_return (invoke "as-f32x4.min-operand") (v128.const i32x4 0xaaaaaaaa 0xaaaaaaaa 0xaaaaaaaa 0xaaaaaaaa)) ;; signed 1010 < 0010
+
+(module (memory 1)
+  (data (offset (i32.const 0))  "\00\00\00\43\00\00\80\3f\66\66\e6\3f\00\00\80\bf")  ;; 128 1.0 1.8 -1
+  (func (export "as-i32x4.trunc_sat_f32x4_s-operand") (result v128)
+    (i32x4.trunc_sat_f32x4_s (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-i32x4.trunc_sat_f32x4_s-operand") (v128.const i32x4 128 1 1 -1)) ;; 128 1.0 1.8 -1 -> 128 1 1 -1
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\02\00\00\00\02\00\00\00\02\00\00\00\02\00\00\00")
+  (func (export "as-f32x4.convert_i32x4_u-operand") (result v128)
+    (f32x4.convert_i32x4_u (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-f32x4.convert_i32x4_u-operand") (v128.const f32x4 2 2 2 2))
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\64\65\66\67\68\69\6a\6b\6c\6d\6e\6f\70\71\72\73")  ;; 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
+  (data (offset (i32.const 16)) "\0f\0e\0d\0c\0b\0a\09\08\07\06\05\04\03\02\01\00")  ;;  15  14  13  12  11  10  09  08  07  06  05  04  03  02  01  00
+  (func (export "as-i8x16.swizzle-operand") (result v128)
+    (i8x16.swizzle (v128.load (i32.const 0)) (v128.load offset=15 (i32.const 1)))
+  )
+)
+(assert_return(invoke "as-i8x16.swizzle-operand") (v128.const i8x16 115 114 113 112 111 110 109 108 107 106 105 104 103 102 101 100))
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load (i32.const 0))))
+  )
+)
+(assert_return (invoke "as-br-value") (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c))
+
+
+;; Unknown operator(e.g. v128.load8, v128.load16, v128.load32)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (local v128) (drop (v128.load8 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (local v128) (drop (v128.load16 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (local v128) (drop (v128.load32 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+
+
+;; Type mismatched (e.g. v128.load(f32.const 0), type address empty)
+
+(assert_invalid
+  (module (memory 1) (func (local v128) (drop (v128.load (f32.const 0)))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (local v128) (block (br_if 0 (v128.load (i32.const 0))))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (local v128) (v128.load (i32.const 0))))
+  "type mismatch"
+)
+
+
+;; Type address empty
+
+(assert_invalid
+  (module (memory 1) (func (drop (v128.load (local.get 2)))))
+  "unknown local 2"
+)
+(assert_invalid
+  (module (memory 1) (func (drop (v128.load))))
+  "type mismatch"
+)
\ No newline at end of file
diff --git a/test/core/simd/simd_load16_lane.wast b/test/core/simd/simd_load16_lane.wast
new file mode 100644
index 000000000..8c72a5733
--- /dev/null
+++ b/test/core/simd/simd_load16_lane.wast
@@ -0,0 +1,211 @@
+;; Tests for load lane operations.
+
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F")
+  (func (export "v128.load16_lane_0")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_3")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 4 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_5")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 5 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_6")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 6 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_7")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 7 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_0_offset_0")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=0 0 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_1_offset_1")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=1 1 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_2_offset_2")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=2 2 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_3_offset_3")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=3 3 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_4_offset_4")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=4 4 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_5_offset_5")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=5 5 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_6_offset_6")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=6 6 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_7_offset_7")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=7 7 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_0_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_0_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_1_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_1_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_2_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_2_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_3_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_3_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_4_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 4 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_4_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 4 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_5_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 5 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_5_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 5 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_6_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 6 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_6_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 6 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_7_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 7 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_7_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 7 (local.get $address) (local.get $x)))
+)
+
+(assert_return (invoke "v128.load16_lane_0" (i32.const 0)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 256 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_1" (i32.const 1)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 513 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_2" (i32.const 2)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 770 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_3" (i32.const 3)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 0 1027 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_4" (i32.const 4)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 0 0 1284 0 0 0))
+(assert_return (invoke "v128.load16_lane_5" (i32.const 5)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 0 0 0 1541 0 0))
+(assert_return (invoke "v128.load16_lane_6" (i32.const 6)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 0 0 0 0 1798 0))
+(assert_return (invoke "v128.load16_lane_7" (i32.const 7)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 0 0 0 0 0 2055))
+(assert_return (invoke "v128.load16_lane_0_offset_0" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 256 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_1_offset_1" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 513 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_2_offset_2" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 770 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_3_offset_3" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 0 1027 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_4_offset_4" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 0 0 1284 0 0 0))
+(assert_return (invoke "v128.load16_lane_5_offset_5" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 0 0 0 1541 0 0))
+(assert_return (invoke "v128.load16_lane_6_offset_6" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 0 0 0 0 1798 0))
+(assert_return (invoke "v128.load16_lane_7_offset_7" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 0 0 0 0 0 2055))
+(assert_return (invoke "v128.load16_lane_0_align_1" (i32.const 0)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 256 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_0_align_2" (i32.const 0)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 256 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_1_align_1" (i32.const 1)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 513 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_1_align_2" (i32.const 1)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 513 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_2_align_1" (i32.const 2)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 770 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_2_align_2" (i32.const 2)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 770 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_3_align_1" (i32.const 3)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 1027 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_3_align_2" (i32.const 3)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 1027 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_4_align_1" (i32.const 4)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 1284 0 0 0))
+(assert_return (invoke "v128.load16_lane_4_align_2" (i32.const 4)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 1284 0 0 0))
+(assert_return (invoke "v128.load16_lane_5_align_1" (i32.const 5)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 1541 0 0))
+(assert_return (invoke "v128.load16_lane_5_align_2" (i32.const 5)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 1541 0 0))
+(assert_return (invoke "v128.load16_lane_6_align_1" (i32.const 6)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 0 1798 0))
+(assert_return (invoke "v128.load16_lane_6_align_2" (i32.const 6)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 0 1798 0))
+(assert_return (invoke "v128.load16_lane_7_align_1" (i32.const 7)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 2055))
+(assert_return (invoke "v128.load16_lane_7_align_2" (i32.const 7)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 2055))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load16_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load16_lane 8 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.load16_lane align=4 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/test/core/simd/simd_load32_lane.wast b/test/core/simd/simd_load32_lane.wast
new file mode 100644
index 000000000..e67690ff9
--- /dev/null
+++ b/test/core/simd/simd_load32_lane.wast
@@ -0,0 +1,143 @@
+;; Tests for load lane operations.
+
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F")
+  (func (export "v128.load32_lane_0")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_3")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_0_offset_0")
+    (param $x v128) (result v128)
+    (v128.load32_lane offset=0 0 (i32.const 0) (local.get $x)))
+  (func (export "v128.load32_lane_1_offset_1")
+    (param $x v128) (result v128)
+    (v128.load32_lane offset=1 1 (i32.const 0) (local.get $x)))
+  (func (export "v128.load32_lane_2_offset_2")
+    (param $x v128) (result v128)
+    (v128.load32_lane offset=2 2 (i32.const 0) (local.get $x)))
+  (func (export "v128.load32_lane_3_offset_3")
+    (param $x v128) (result v128)
+    (v128.load32_lane offset=3 3 (i32.const 0) (local.get $x)))
+  (func (export "v128.load32_lane_0_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=1 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_0_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=2 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_0_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=4 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_1_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=1 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_1_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=2 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_1_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=4 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_2_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=1 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_2_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=2 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_2_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=4 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_3_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=1 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_3_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=2 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_3_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=4 3 (local.get $address) (local.get $x)))
+)
+
+(assert_return (invoke "v128.load32_lane_0" (i32.const 0)
+                                            (v128.const i32x4 0 0 0 0))
+                                            (v128.const i32x4 50462976 0 0 0))
+(assert_return (invoke "v128.load32_lane_1" (i32.const 1)
+                                            (v128.const i32x4 0 0 0 0))
+                                            (v128.const i32x4 0 67305985 0 0))
+(assert_return (invoke "v128.load32_lane_2" (i32.const 2)
+                                            (v128.const i32x4 0 0 0 0))
+                                            (v128.const i32x4 0 0 84148994 0))
+(assert_return (invoke "v128.load32_lane_3" (i32.const 3)
+                                            (v128.const i32x4 0 0 0 0))
+                                            (v128.const i32x4 0 0 0 100992003))
+(assert_return (invoke "v128.load32_lane_0_offset_0" (v128.const i32x4 0 0 0 0))
+                                                     (v128.const i32x4 50462976 0 0 0))
+(assert_return (invoke "v128.load32_lane_1_offset_1" (v128.const i32x4 0 0 0 0))
+                                                     (v128.const i32x4 0 67305985 0 0))
+(assert_return (invoke "v128.load32_lane_2_offset_2" (v128.const i32x4 0 0 0 0))
+                                                     (v128.const i32x4 0 0 84148994 0))
+(assert_return (invoke "v128.load32_lane_3_offset_3" (v128.const i32x4 0 0 0 0))
+                                                     (v128.const i32x4 0 0 0 100992003))
+(assert_return (invoke "v128.load32_lane_0_align_1" (i32.const 0)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 50462976 0 0 0))
+(assert_return (invoke "v128.load32_lane_0_align_2" (i32.const 0)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 50462976 0 0 0))
+(assert_return (invoke "v128.load32_lane_0_align_4" (i32.const 0)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 50462976 0 0 0))
+(assert_return (invoke "v128.load32_lane_1_align_1" (i32.const 1)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 67305985 0 0))
+(assert_return (invoke "v128.load32_lane_1_align_2" (i32.const 1)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 67305985 0 0))
+(assert_return (invoke "v128.load32_lane_1_align_4" (i32.const 1)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 67305985 0 0))
+(assert_return (invoke "v128.load32_lane_2_align_1" (i32.const 2)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 84148994 0))
+(assert_return (invoke "v128.load32_lane_2_align_2" (i32.const 2)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 84148994 0))
+(assert_return (invoke "v128.load32_lane_2_align_4" (i32.const 2)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 84148994 0))
+(assert_return (invoke "v128.load32_lane_3_align_1" (i32.const 3)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 0 100992003))
+(assert_return (invoke "v128.load32_lane_3_align_2" (i32.const 3)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 0 100992003))
+(assert_return (invoke "v128.load32_lane_3_align_4" (i32.const 3)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 0 100992003))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load32_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load32_lane 4 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.load32_lane align=8 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/test/core/simd/simd_load64_lane.wast b/test/core/simd/simd_load64_lane.wast
new file mode 100644
index 000000000..5883a6eae
--- /dev/null
+++ b/test/core/simd/simd_load64_lane.wast
@@ -0,0 +1,97 @@
+;; Tests for load lane operations.
+
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F")
+  (func (export "v128.load64_lane_0")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_0_offset_0")
+    (param $x v128) (result v128)
+    (v128.load64_lane offset=0 0 (i32.const 0) (local.get $x)))
+  (func (export "v128.load64_lane_1_offset_1")
+    (param $x v128) (result v128)
+    (v128.load64_lane offset=1 1 (i32.const 0) (local.get $x)))
+  (func (export "v128.load64_lane_0_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=1 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_0_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=2 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_0_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=4 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_0_align_8")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=8 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_1_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=1 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_1_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=2 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_1_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=4 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_1_align_8")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=8 1 (local.get $address) (local.get $x)))
+)
+
+(assert_return (invoke "v128.load64_lane_0" (i32.const 0)
+                                            (v128.const i64x2 0 0))
+                                            (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_1" (i32.const 1)
+                                            (v128.const i64x2 0 0))
+                                            (v128.const i64x2 0 578437695752307201))
+(assert_return (invoke "v128.load64_lane_0_offset_0" (v128.const i64x2 0 0))
+                                                     (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_1_offset_1" (v128.const i64x2 0 0))
+                                                     (v128.const i64x2 0 578437695752307201))
+(assert_return (invoke "v128.load64_lane_0_align_1" (i32.const 0)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_0_align_2" (i32.const 0)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_0_align_4" (i32.const 0)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_0_align_8" (i32.const 0)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_1_align_1" (i32.const 1)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 0 578437695752307201))
+(assert_return (invoke "v128.load64_lane_1_align_2" (i32.const 1)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 0 578437695752307201))
+(assert_return (invoke "v128.load64_lane_1_align_4" (i32.const 1)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 0 578437695752307201))
+(assert_return (invoke "v128.load64_lane_1_align_8" (i32.const 1)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 0 578437695752307201))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load64_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load64_lane 2 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.load64_lane align=16 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/test/core/simd/simd_load8_lane.wast b/test/core/simd/simd_load8_lane.wast
new file mode 100644
index 000000000..d0706f535
--- /dev/null
+++ b/test/core/simd/simd_load8_lane.wast
@@ -0,0 +1,299 @@
+;; Tests for load lane operations.
+
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F")
+  (func (export "v128.load8_lane_0")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_3")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 4 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_5")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 5 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_6")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 6 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_7")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 7 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_8")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 8 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_9")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 9 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_10")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 10 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_11")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 11 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_12")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 12 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_13")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 13 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_14")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 14 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_15")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 15 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_0_offset_0")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=0 0 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_1_offset_1")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=1 1 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_2_offset_2")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=2 2 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_3_offset_3")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=3 3 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_4_offset_4")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=4 4 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_5_offset_5")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=5 5 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_6_offset_6")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=6 6 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_7_offset_7")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=7 7 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_8_offset_8")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=8 8 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_9_offset_9")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=9 9 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_10_offset_10")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=10 10 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_11_offset_11")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=11 11 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_12_offset_12")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=12 12 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_13_offset_13")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=13 13 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_14_offset_14")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=14 14 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_15_offset_15")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=15 15 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_0_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_1_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_2_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_3_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_4_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 4 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_5_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 5 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_6_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 6 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_7_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 7 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_8_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 8 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_9_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 9 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_10_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 10 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_11_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 11 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_12_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 12 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_13_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 13 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_14_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 14 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_15_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 15 (local.get $address) (local.get $x)))
+)
+
+(assert_return (invoke "v128.load8_lane_0" (i32.const 0)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_1" (i32.const 1)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_2" (i32.const 2)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_3" (i32.const 3)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_4" (i32.const 4)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_5" (i32.const 5)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_6" (i32.const 6)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_7" (i32.const 7)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_8" (i32.const 8)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_9" (i32.const 9)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_10" (i32.const 10)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_11" (i32.const 11)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_12" (i32.const 12)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+(assert_return (invoke "v128.load8_lane_13" (i32.const 13)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+(assert_return (invoke "v128.load8_lane_14" (i32.const 14)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+(assert_return (invoke "v128.load8_lane_15" (i32.const 15)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+(assert_return (invoke "v128.load8_lane_0_offset_0" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_1_offset_1" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_2_offset_2" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_3_offset_3" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_4_offset_4" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_5_offset_5" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_6_offset_6" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_7_offset_7" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_8_offset_8" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_9_offset_9" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_10_offset_10" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_11_offset_11" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_12_offset_12" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+(assert_return (invoke "v128.load8_lane_13_offset_13" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+(assert_return (invoke "v128.load8_lane_14_offset_14" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+(assert_return (invoke "v128.load8_lane_15_offset_15" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+(assert_return (invoke "v128.load8_lane_0_align_1" (i32.const 0)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_1_align_1" (i32.const 1)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_2_align_1" (i32.const 2)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_3_align_1" (i32.const 3)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_4_align_1" (i32.const 4)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_5_align_1" (i32.const 5)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_6_align_1" (i32.const 6)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_7_align_1" (i32.const 7)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_8_align_1" (i32.const 8)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_9_align_1" (i32.const 9)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_10_align_1" (i32.const 10)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_11_align_1" (i32.const 11)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_12_align_1" (i32.const 12)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+(assert_return (invoke "v128.load8_lane_13_align_1" (i32.const 13)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+(assert_return (invoke "v128.load8_lane_14_align_1" (i32.const 14)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+(assert_return (invoke "v128.load8_lane_15_align_1" (i32.const 15)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load8_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load8_lane 16 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.load8_lane align=2 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/test/core/simd/simd_load_extend.wast b/test/core/simd/simd_load_extend.wast
new file mode 100644
index 000000000..b9982bbfd
--- /dev/null
+++ b/test/core/simd/simd_load_extend.wast
@@ -0,0 +1,384 @@
+;; Load and Extend test cases
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+  (data (i32.const 65520) "\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+
+  (func (export "v128.load8x8_s") (param $0 i32) (result v128)
+    (v128.load8x8_s (local.get $0))
+  )
+  (func (export "v128.load8x8_u") (param $0 i32) (result v128)
+    (v128.load8x8_u (local.get $0))
+  )
+  (func (export "v128.load16x4_s") (param $0 i32) (result v128)
+    (v128.load16x4_s (local.get $0))
+  )
+  (func (export "v128.load16x4_u") (param $0 i32) (result v128)
+    (v128.load16x4_u (local.get $0))
+  )
+  (func (export "v128.load32x2_s") (param $0 i32) (result v128)
+    (v128.load32x2_s (local.get $0))
+  )
+  (func (export "v128.load32x2_u") (param $0 i32) (result v128)
+    (v128.load32x2_u (local.get $0))
+  )
+
+  ;; load by a constant amount
+  (func (export "v128.load8x8_s_const0") (result v128)
+    (v128.load8x8_s (i32.const 0))
+  )
+  (func (export "v128.load8x8_u_const8") (result v128)
+    (v128.load8x8_u (i32.const 8))
+  )
+  (func (export "v128.load16x4_s_const10") (result v128)
+    (v128.load16x4_s (i32.const 10))
+  )
+  (func (export "v128.load16x4_u_const20") (result v128)
+    (v128.load16x4_u (i32.const 20))
+  )
+  (func (export "v128.load32x2_s_const65520") (result v128)
+    (v128.load32x2_s (i32.const 65520))
+  )
+  (func (export "v128.load32x2_u_const65526") (result v128)
+    (v128.load32x2_u (i32.const 65526))
+  )
+
+  ;; load data with different offset/align arguments
+  ;; i16x8
+  (func (export "v128.load8x8_s_offset0") (param $0 i32) (result v128)
+    (v128.load8x8_s offset=0 (local.get $0))
+  )
+  (func (export "v128.load8x8_s_align1") (param $0 i32) (result v128)
+    (v128.load8x8_s align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_s_offset0_align1") (param $0 i32) (result v128)
+    (v128.load8x8_s offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_s_offset1_align1") (param $0 i32) (result v128)
+    (v128.load8x8_s offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_s_offset10_align4") (param $0 i32) (result v128)
+    (v128.load8x8_s offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load8x8_s_offset20_align8") (param $0 i32) (result v128)
+    (v128.load8x8_s offset=20 align=8 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_offset0") (param $0 i32) (result v128)
+    (v128.load8x8_u offset=0 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_align1") (param $0 i32) (result v128)
+    (v128.load8x8_u align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_offset0_align1") (param $0 i32) (result v128)
+    (v128.load8x8_u offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_offset1_align1") (param $0 i32) (result v128)
+    (v128.load8x8_u offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_offset10_align4") (param $0 i32) (result v128)
+    (v128.load8x8_u offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_offset20_align8") (param $0 i32) (result v128)
+    (v128.load8x8_u offset=20 align=8 (local.get $0))
+  )
+  ;; i32x4
+  (func (export "v128.load16x4_s_offset0") (param $0 i32) (result v128)
+    (v128.load16x4_s offset=0 (local.get $0))
+  )
+  (func (export "v128.load16x4_s_align1") (param $0 i32) (result v128)
+    (v128.load16x4_s align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_s_offset0_align1") (param $0 i32) (result v128)
+    (v128.load16x4_s offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_s_offset1_align1") (param $0 i32) (result v128)
+    (v128.load16x4_s offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_s_offset10_align4") (param $0 i32) (result v128)
+    (v128.load16x4_s offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load16x4_s_offset20_align8") (param $0 i32) (result v128)
+    (v128.load16x4_s offset=20 align=8 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_offset0") (param $0 i32) (result v128)
+    (v128.load16x4_u offset=0 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_align1") (param $0 i32) (result v128)
+    (v128.load16x4_u align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_offset0_align1") (param $0 i32) (result v128)
+    (v128.load16x4_u offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_offset1_align1") (param $0 i32) (result v128)
+    (v128.load16x4_u offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_offset10_align4") (param $0 i32) (result v128)
+    (v128.load16x4_u offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_offset20_align8") (param $0 i32) (result v128)
+    (v128.load16x4_u offset=20 align=8 (local.get $0))
+  )
+  ;; i64x2
+  (func (export "v128.load32x2_s_offset0") (param $0 i32) (result v128)
+    (v128.load32x2_s offset=0 (local.get $0))
+  )
+  (func (export "v128.load32x2_s_align1") (param $0 i32) (result v128)
+    (v128.load32x2_s align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_s_offset0_align1") (param $0 i32) (result v128)
+    (v128.load32x2_s offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_s_offset1_align1") (param $0 i32) (result v128)
+    (v128.load32x2_s offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_s_offset10_align4") (param $0 i32) (result v128)
+    (v128.load32x2_s offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load32x2_s_offset20_align8") (param $0 i32) (result v128)
+    (v128.load32x2_s offset=20 align=8 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_offset0") (param $0 i32) (result v128)
+    (v128.load32x2_u offset=0 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_align1") (param $0 i32) (result v128)
+    (v128.load32x2_u align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_offset0_align1") (param $0 i32) (result v128)
+    (v128.load32x2_u offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_offset1_align1") (param $0 i32) (result v128)
+    (v128.load32x2_u offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_offset10_align4") (param $0 i32) (result v128)
+    (v128.load32x2_u offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_offset20_align8") (param $0 i32) (result v128)
+    (v128.load32x2_u offset=20 align=8 (local.get $0))
+  )
+)
+
+
+;; normal
+(assert_return (invoke "v128.load8x8_s" (i32.const 0)) (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load8x8_u" (i32.const 0)) (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load16x4_s" (i32.const 0)) (v128.const i32x4 0x00000100 0x00000302 0x00000504 0x00000706))
+(assert_return (invoke "v128.load16x4_u" (i32.const 0)) (v128.const i32x4 0x00000100 0x00000302 0x00000504 0x00000706))
+(assert_return (invoke "v128.load32x2_s" (i32.const 0)) (v128.const i64x2 0x0000000003020100 0x0000000007060504))
+(assert_return (invoke "v128.load32x2_u" (i32.const 0)) (v128.const i64x2 0x0000000003020100 0x0000000007060504))
+(assert_return (invoke "v128.load8x8_s" (i32.const 10)) (v128.const i16x8 0x000A 0x000B 0x000C 0x000D 0x000E 0x000F 0xFF80 0xFF81))
+(assert_return (invoke "v128.load8x8_u" (i32.const 10)) (v128.const i16x8 0x000A 0x000B 0x000C 0x000D 0x000E 0x000F 0x0080 0x0081))
+(assert_return (invoke "v128.load16x4_s" (i32.const 10)) (v128.const i32x4 0x00000B0A 0x00000D0C 0x00000F0E 0xFFFF8180))
+(assert_return (invoke "v128.load16x4_u" (i32.const 10)) (v128.const i32x4 0x00000B0A 0x00000D0C 0x00000F0E 0x00008180))
+(assert_return (invoke "v128.load32x2_s" (i32.const 10)) (v128.const i64x2 0x000000000D0C0B0A 0xFFFFFFFF81800F0E))
+(assert_return (invoke "v128.load32x2_u" (i32.const 10)) (v128.const i64x2 0x000000000D0C0B0A 0x0000000081800F0E))
+(assert_return (invoke "v128.load8x8_s" (i32.const 20)) (v128.const i16x8 0xff84 0xff85 0xff86 0xff87 0xff88 0xff89 0x0000 0x0000))
+(assert_return (invoke "v128.load8x8_u" (i32.const 20)) (v128.const i16x8 0x0084 0x0085 0x0086 0x0087 0x0088 0x0089 0x0000 0x0000))
+(assert_return (invoke "v128.load16x4_s" (i32.const 20)) (v128.const i32x4 0xffff8584 0xffff8786 0xffff8988 0x00000000))
+(assert_return (invoke "v128.load16x4_u" (i32.const 20)) (v128.const i32x4 0x00008584 0x00008786 0x00008988 0x00000000))
+(assert_return (invoke "v128.load32x2_s" (i32.const 20)) (v128.const i64x2 0xFFFFFFFF87868584 0x0000000000008988))
+(assert_return (invoke "v128.load32x2_u" (i32.const 20)) (v128.const i64x2 0x0000000087868584 0x0000000000008988))
+
+;; load by a constant amount
+(assert_return (invoke "v128.load8x8_s_const0") (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load8x8_u_const8") (v128.const i16x8 0x0008 0x0009 0x000A 0x000B 0x000C 0x000D 0x000E 0x000F))
+(assert_return (invoke "v128.load16x4_s_const10") (v128.const i32x4 0x00000B0A 0x00000D0C 0x00000F0E 0xFFFF8180))
+(assert_return (invoke "v128.load16x4_u_const20") (v128.const i32x4 0x00008584 0x00008786 0x00008988 0x00000000))
+(assert_return (invoke "v128.load32x2_s_const65520") (v128.const i64x2 0x000000000D0C0B0A 0xFFFFFFFF81800F0E))
+(assert_return (invoke "v128.load32x2_u_const65526") (v128.const i64x2 0x0000000083828180 0x0000000087868584))
+
+;; load data with different offset/align arguments
+;; i16x8
+(assert_return (invoke "v128.load8x8_s_offset0" (i32.const 0)) (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load8x8_s_align1" (i32.const 1)) (v128.const i16x8 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008))
+(assert_return (invoke "v128.load8x8_s_offset0_align1" (i32.const 2)) (v128.const i16x8 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008 0x0009))
+(assert_return (invoke "v128.load8x8_s_offset10_align4" (i32.const 3)) (v128.const i16x8 0x000D 0x000E 0x000F 0xFF80 0xFF81 0xFF82 0xFF83 0xFF84))
+(assert_return (invoke "v128.load8x8_s_offset20_align8" (i32.const 4)) (v128.const i16x8 0xFF88 0xFF89 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+(assert_return (invoke "v128.load8x8_u_offset0" (i32.const 0)) (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load8x8_u_align1" (i32.const 1)) (v128.const i16x8 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008))
+(assert_return (invoke "v128.load8x8_u_offset0_align1" (i32.const 2)) (v128.const i16x8 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008 0x0009))
+(assert_return (invoke "v128.load8x8_u_offset10_align4" (i32.const 3)) (v128.const i16x8 0x000D 0x000E 0x000F 0x0080 0x0081 0x0082 0x0083 0x0084))
+(assert_return (invoke "v128.load8x8_u_offset20_align8" (i32.const 4)) (v128.const i16x8 0x0088 0x0089 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+;; i32x4
+(assert_return (invoke "v128.load16x4_s_offset0" (i32.const 0)) (v128.const i32x4 0x00000100 0x00000302 0x00000504 0x00000706))
+(assert_return (invoke "v128.load16x4_s_align1" (i32.const 1)) (v128.const i32x4 0x00000201 0x00000403 0x00000605 0x00000807))
+(assert_return (invoke "v128.load16x4_s_offset0_align1" (i32.const 2)) (v128.const i32x4 0x00000302 0x00000504 0x00000706 0x00000908))
+(assert_return (invoke "v128.load16x4_s_offset10_align4" (i32.const 3)) (v128.const i32x4 0x00000E0D 0xFFFF800F 0xFFFF8281 0xFFFF8483))
+(assert_return (invoke "v128.load16x4_s_offset20_align8" (i32.const 4)) (v128.const i32x4 0xFFFF8988 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load16x4_u_offset0" (i32.const 0)) (v128.const i32x4 0x00000100 0x00000302 0x00000504 0x00000706))
+(assert_return (invoke "v128.load16x4_u_align1" (i32.const 1)) (v128.const i32x4 0x00000201 0x00000403 0x00000605 0x00000807))
+(assert_return (invoke "v128.load16x4_u_offset0_align1" (i32.const 2)) (v128.const i32x4 0x00000302 0x00000504 0x00000706 0x00000908))
+(assert_return (invoke "v128.load16x4_u_offset10_align4" (i32.const 3)) (v128.const i32x4 0x00000E0D 0x0000800F 0x00008281 0x00008483))
+(assert_return (invoke "v128.load16x4_u_offset20_align8" (i32.const 4)) (v128.const i32x4 0x00008988 0x00000000 0x00000000 0x00000000))
+;; i64x2
+(assert_return (invoke "v128.load32x2_s_offset0" (i32.const 0)) (v128.const i64x2 0x0000000003020100 0x0000000007060504))
+(assert_return (invoke "v128.load32x2_s_align1" (i32.const 1)) (v128.const i64x2 0x0000000004030201 0x0000000008070605))
+(assert_return (invoke "v128.load32x2_s_offset0_align1" (i32.const 2)) (v128.const i64x2 0x0000000005040302 0x0000000009080706))
+(assert_return (invoke "v128.load32x2_s_offset10_align4" (i32.const 3)) (v128.const i64x2 0xFFFFFFFF800F0E0D 0xFFFFFFFF84838281))
+(assert_return (invoke "v128.load32x2_s_offset20_align8" (i32.const 4)) (v128.const i64x2 0x0000000000008988 0x0000000000000000))
+(assert_return (invoke "v128.load32x2_u_offset0" (i32.const 0)) (v128.const i64x2 0x0000000003020100 0x0000000007060504))
+(assert_return (invoke "v128.load32x2_u_align1" (i32.const 1)) (v128.const i64x2 0x0000000004030201 0x0000000008070605))
+(assert_return (invoke "v128.load32x2_u_offset0_align1" (i32.const 2)) (v128.const i64x2 0x0000000005040302 0x0000000009080706))
+(assert_return (invoke "v128.load32x2_u_offset10_align4" (i32.const 3)) (v128.const i64x2 0x00000000800F0E0D 0x0000000084838281))
+(assert_return (invoke "v128.load32x2_u_offset20_align8" (i32.const 4)) (v128.const i64x2 0x0000000000008988 0x0000000000000000))
+
+;; out of bounds memory access
+(assert_trap (invoke "v128.load8x8_s" (i32.const -1))  "out of bounds memory access")
+(assert_trap (invoke "v128.load8x8_u" (i32.const -1))  "out of bounds memory access")
+(assert_trap (invoke "v128.load16x4_s" (i32.const 65536))  "out of bounds memory access")
+(assert_trap (invoke "v128.load16x4_u" (i32.const 65536))  "out of bounds memory access")
+(assert_trap (invoke "v128.load32x2_s" (i32.const 65529))  "out of bounds memory access")
+(assert_trap (invoke "v128.load32x2_u" (i32.const 65529))  "out of bounds memory access")
+
+(assert_trap (invoke "v128.load8x8_s_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load8x8_u_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load16x4_s_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load16x4_u_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load32x2_s_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load32x2_u_offset1_align1" (i32.const -1)) "out of bounds memory access")
+
+;; type check
+(assert_invalid (module (memory 0) (func (result v128) (v128.load8x8_s (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load8x8_u (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load16x4_s (f64.const 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load16x4_u (f64.const 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load32x2_s (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load32x2_u (v128.const i32x4 0 0 0 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load8x8_s-arg-empty (result v128)
+      (v128.load8x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load8x8_u-arg-empty (result v128)
+      (v128.load8x8_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load16x4_s-arg-empty (result v128)
+      (v128.load16x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load16x4_u-arg-empty (result v128)
+      (v128.load16x4_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load32x2_s-arg-empty (result v128)
+      (v128.load32x2_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load32x2_u-arg-empty (result v128)
+      (v128.load32x2_u)
+    )
+  )
+  "type mismatch"
+)
+
+;; Unknown operator
+
+(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_u (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load32x2_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load32x2_u (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load64x1_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load64x1_u (i32.const 0))))") "unknown operator")
+
+;; combination
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+  (func (export "v128.load8x8_s-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load8x8_s (i32.const 0))))
+  )
+  (func (export "v128.load8x8_u-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load8x8_u (i32.const 1))))
+  )
+  (func (export "v128.load16x4_s-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load16x4_s (i32.const 2))))
+  )
+  (func (export "v128.load16x4_u-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load16x4_u (i32.const 3))))
+  )
+  (func (export "v128.load32x2_s-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load32x2_s (i32.const 4))))
+  )
+  (func (export "v128.load32x2_u-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load32x2_u (i32.const 5))))
+  )
+  (func (export "v128.load8x8_s-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load8x8_s (i32.const 6))))
+  )
+  (func (export "v128.load8x8_u-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load8x8_u (i32.const 7))))
+  )
+  (func (export "v128.load16x4_s-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load16x4_s (i32.const 8))))
+  )
+  (func (export "v128.load16x4_u-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load16x4_u (i32.const 9))))
+  )
+  (func (export "v128.load32x2_s-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load32x2_s (i32.const 10))))
+  )
+  (func (export "v128.load32x2_u-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load32x2_u (i32.const 11))))
+  )
+  (func (export "v128.load8x8_s-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load8x8_s (i32.const 12)))
+  )
+  (func (export "v128.load8x8_u-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load8x8_u (i32.const 13)))
+  )
+  (func (export "v128.load16x4_s-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load16x4_s (i32.const 14)))
+  )
+  (func (export "v128.load16x4_u-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load16x4_u (i32.const 15)))
+  )
+  (func (export "v128.load32x2_s-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load32x2_s (i32.const 16)))
+  )
+  (func (export "v128.load32x2_u-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load32x2_u (i32.const 17)))
+  )
+)
+(assert_return (invoke "v128.load8x8_s-in-block") (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load8x8_u-in-block") (v128.const i16x8 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008))
+(assert_return (invoke "v128.load16x4_s-in-block") (v128.const i32x4 0x00000302 0x00000504 0x00000706 0x00000908))
+(assert_return (invoke "v128.load16x4_u-in-block") (v128.const i32x4 0x00000403 0x00000605 0x00000807 0x00000A09))
+(assert_return (invoke "v128.load32x2_s-in-block") (v128.const i64x2 0x0000000007060504 0x000000000B0A0908))
+(assert_return (invoke "v128.load32x2_u-in-block") (v128.const i64x2 0x0000000008070605 0x000000000C0B0A09))
+(assert_return (invoke "v128.load8x8_s-as-br-value") (v128.const i16x8 0x0006 0x0007 0x0008 0x0009 0x000A 0x000B 0x000C 0x000D))
+(assert_return (invoke "v128.load8x8_u-as-br-value") (v128.const i16x8 0x0007 0x0008 0x0009 0x000A 0x000B 0x000C 0x000D 0x000E))
+(assert_return (invoke "v128.load16x4_s-as-br-value") (v128.const i32x4 0x00000908 0x00000B0A 0x00000D0C 0x00000F0E))
+(assert_return (invoke "v128.load16x4_u-as-br-value") (v128.const i32x4 0x00000A09 0x00000C0B 0x00000E0D 0x0000800F))
+(assert_return (invoke "v128.load32x2_s-as-br-value") (v128.const i64x2 0x000000000D0C0B0A 0xFFFFFFFF81800F0E))
+(assert_return (invoke "v128.load32x2_u-as-br-value") (v128.const i64x2 0x000000000E0D0C0B 0x000000008281800F))
+(assert_return (invoke "v128.load8x8_s-extract_lane_s-operand") (i32.const 12))
+(assert_return (invoke "v128.load8x8_u-extract_lane_s-operand") (i32.const 13))
+(assert_return (invoke "v128.load16x4_s-extract_lane_s-operand") (i32.const 14))
+(assert_return (invoke "v128.load16x4_u-extract_lane_s-operand") (i32.const 15))
+(assert_return (invoke "v128.load32x2_s-extract_lane_s-operand") (i32.const -128))
+(assert_return (invoke "v128.load32x2_u-extract_lane_s-operand") (i32.const -127))
diff --git a/test/core/simd/simd_load_splat.wast b/test/core/simd/simd_load_splat.wast
new file mode 100644
index 000000000..d9642f8bd
--- /dev/null
+++ b/test/core/simd/simd_load_splat.wast
@@ -0,0 +1,261 @@
+;; Tests for the load_splat instructions
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F")
+  (data (i32.const 65520) "\10\11\12\13\14\15\16\17\18\19\1A\1B\1C\1D\1E\1F")
+
+  (func (export "v128.load8_splat") (param $address i32) (result v128) (v128.load8_splat (local.get $address)))
+  (func (export "v128.load16_splat") (param $address i32) (result v128) (v128.load16_splat (local.get $address)))
+  (func (export "v128.load32_splat") (param $address i32) (result v128) (v128.load32_splat (local.get $address)))
+  (func (export "v128.load64_splat") (param $address i32) (result v128) (v128.load64_splat (local.get $address)))
+
+  ;; Load data with different offset/align arguments
+  (func (export "v8x16.offset0") (param $address i32) (result v128) (v128.load8_splat offset=0 (local.get $address)))
+  (func (export "v8x16.align1") (param $address i32) (result v128) (v128.load8_splat align=1 (local.get $address)))
+  (func (export "v8x16.offset1_align1") (param $address i32) (result v128) (v128.load8_splat offset=1 align=1 (local.get $address)))
+  (func (export "v8x16.offset2_align1") (param $address i32) (result v128) (v128.load8_splat offset=2 align=1 (local.get $address)))
+  (func (export "v8x16.offset15_align1") (param $address i32) (result v128) (v128.load8_splat offset=15 align=1 (local.get $address)))
+
+  (func (export "v16x8.offset0") (param $address i32) (result v128) (v128.load16_splat offset=0 (local.get $address)))
+  (func (export "v16x8.align1") (param $address i32) (result v128) (v128.load16_splat align=1 (local.get $address)))
+  (func (export "v16x8.offset1_align1") (param $address i32) (result v128) (v128.load16_splat offset=1 align=1 (local.get $address)))
+  (func (export "v16x8.offset2_align1") (param $address i32) (result v128) (v128.load16_splat offset=2 align=1 (local.get $address)))
+  (func (export "v16x8.offset15_align2") (param $address i32) (result v128) (v128.load16_splat offset=15 align=2 (local.get $address)))
+
+  (func (export "v32x4.offset0") (param $address i32) (result v128) (v128.load32_splat offset=0 (local.get $address)))
+  (func (export "v32x4.align1") (param $address i32) (result v128) (v128.load32_splat align=1 (local.get $address)))
+  (func (export "v32x4.offset1_align1") (param $address i32) (result v128) (v128.load32_splat offset=1 align=1 (local.get $address)))
+  (func (export "v32x4.offset2_align2") (param $address i32) (result v128) (v128.load32_splat offset=2 align=2 (local.get $address)))
+  (func (export "v32x4.offset15_align4") (param $address i32) (result v128) (v128.load32_splat offset=15 align=4 (local.get $address)))
+
+  (func (export "v64x2.offset0") (param $address i32) (result v128) (v128.load64_splat offset=0 (local.get $address)))
+  (func (export "v64x2.align1") (param $address i32) (result v128) (v128.load64_splat align=1 (local.get $address)))
+  (func (export "v64x2.offset1_align2") (param $address i32) (result v128) (v128.load64_splat offset=1 align=2 (local.get $address)))
+  (func (export "v64x2.offset2_align4") (param $address i32) (result v128) (v128.load64_splat offset=2 align=4 (local.get $address)))
+  (func (export "v64x2.offset15_align8") (param $address i32) (result v128) (v128.load64_splat offset=15 align=8 (local.get $address)))
+
+  (func (export "v8x16.offset65536") (param $address i32) (result v128) (v128.load8_splat offset=65536 (local.get $address)))
+  (func (export "v16x8.offset65535") (param $address i32) (result v128) (v128.load16_splat offset=65535 (local.get $address)))
+  (func (export "v32x4.offset65533") (param $address i32) (result v128) (v128.load32_splat offset=65533 (local.get $address)))
+  (func (export "v64x2.offset65529") (param $address i32) (result v128) (v128.load64_splat offset=65529 (local.get $address)))
+)
+(assert_return (invoke "v128.load8_splat" (i32.const 0)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_splat" (i32.const 1)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "v128.load8_splat" (i32.const 2)) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "v128.load8_splat" (i32.const 3)) (v128.const i8x16 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3))
+(assert_return (invoke "v128.load8_splat" (i32.const 65535)) (v128.const i8x16 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31))
+(assert_return (invoke "v128.load16_splat" (i32.const 4)) (v128.const i16x8 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504))
+(assert_return (invoke "v128.load16_splat" (i32.const 5)) (v128.const i16x8 0x0605 0x0605 0x0605 0x0605 0x0605 0x0605 0x0605 0x0605))
+(assert_return (invoke "v128.load16_splat" (i32.const 6)) (v128.const i16x8 0x0706 0x0706 0x0706 0x0706 0x0706 0x0706 0x0706 0x0706))
+(assert_return (invoke "v128.load16_splat" (i32.const 7)) (v128.const i16x8 0x0807 0x0807 0x0807 0x0807 0x0807 0x0807 0x0807 0x0807))
+(assert_return (invoke "v128.load16_splat" (i32.const 65534)) (v128.const i16x8 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E))
+(assert_return (invoke "v128.load32_splat" (i32.const 8)) (v128.const i32x4 0x0B0A0908 0x0B0A0908 0x0B0A0908 0x0B0A0908))
+(assert_return (invoke "v128.load32_splat" (i32.const 9)) (v128.const i32x4 0x0C0B0A09 0x0C0B0A09 0x0C0B0A09 0x0C0B0A09))
+(assert_return (invoke "v128.load32_splat" (i32.const 10)) (v128.const i32x4 0x0D0C0B0A 0x0D0C0B0A 0x0D0C0B0A 0x0D0C0B0A))
+(assert_return (invoke "v128.load32_splat" (i32.const 11)) (v128.const i32x4 0x0E0D0C0B 0x0E0D0C0B 0x0E0D0C0B 0x0E0D0C0B))
+(assert_return (invoke "v128.load32_splat" (i32.const 65532)) (v128.const i32x4 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C))
+(assert_return (invoke "v128.load64_splat" (i32.const 12)) (v128.const i64x2 0x000000000F0E0D0C 0x000000000F0E0D0C))
+(assert_return (invoke "v128.load64_splat" (i32.const 13)) (v128.const i64x2 0x00000000000F0E0D 0x00000000000F0E0D))
+(assert_return (invoke "v128.load64_splat" (i32.const 14)) (v128.const i64x2 0x0000000000000F0E 0x0000000000000F0E))
+(assert_return (invoke "v128.load64_splat" (i32.const 15)) (v128.const i64x2 0x000000000000000F 0x000000000000000F))
+(assert_return (invoke "v128.load64_splat" (i32.const 65528)) (v128.const i64x2 0x1F1E1D1C1B1A1918 0x1F1E1D1C1B1A1918))
+
+;; v8x16
+(assert_return (invoke "v8x16.offset0" (i32.const 0)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v8x16.align1" (i32.const 0)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v8x16.offset1_align1" (i32.const 0)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "v8x16.offset2_align1" (i32.const 0)) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "v8x16.offset15_align1" (i32.const 0)) (v128.const i8x16 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15))
+(assert_return (invoke "v8x16.offset0" (i32.const 1)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "v8x16.align1" (i32.const 1)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "v8x16.offset1_align1" (i32.const 1)) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "v8x16.offset2_align1" (i32.const 1)) (v128.const i8x16 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3))
+(assert_return (invoke "v8x16.offset15_align1" (i32.const 1)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v8x16.offset0" (i32.const 65535)) (v128.const i8x16 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31))
+(assert_return (invoke "v8x16.align1" (i32.const 65535)) (v128.const i8x16 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31))
+;; v16x8
+(assert_return (invoke "v16x8.offset0" (i32.const 0)) (v128.const i16x8 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100))
+(assert_return (invoke "v16x8.align1" (i32.const 0)) (v128.const i16x8 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100))
+(assert_return (invoke "v16x8.offset1_align1" (i32.const 0)) (v128.const i16x8 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201))
+(assert_return (invoke "v16x8.offset2_align1" (i32.const 0)) (v128.const i16x8 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302))
+(assert_return (invoke "v16x8.offset15_align2" (i32.const 0)) (v128.const i16x8 0x000F 0x000F 0x000F 0x000F 0x000F 0x000F 0x000F 0x000F))
+(assert_return (invoke "v16x8.offset0" (i32.const 1)) (v128.const i16x8 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201))
+(assert_return (invoke "v16x8.align1" (i32.const 1)) (v128.const i16x8 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201))
+(assert_return (invoke "v16x8.offset1_align1" (i32.const 1)) (v128.const i16x8 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302))
+(assert_return (invoke "v16x8.offset2_align1" (i32.const 1)) (v128.const i16x8 0x0403 0x0403 0x0403 0x0403 0x0403 0x0403 0x0403 0x0403))
+(assert_return (invoke "v16x8.offset15_align2" (i32.const 1)) (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+(assert_return (invoke "v16x8.offset0" (i32.const 65534)) (v128.const i16x8 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E))
+(assert_return (invoke "v16x8.align1" (i32.const 65534)) (v128.const i16x8 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E))
+;; v32x4
+(assert_return (invoke "v32x4.offset0" (i32.const 0)) (v128.const i32x4 0x03020100 0x03020100 0x03020100 0x03020100))
+(assert_return (invoke "v32x4.align1" (i32.const 0)) (v128.const i32x4 0x03020100 0x03020100 0x03020100 0x03020100))
+(assert_return (invoke "v32x4.offset1_align1" (i32.const 0)) (v128.const i32x4 0x04030201 0x04030201 0x04030201 0x04030201))
+(assert_return (invoke "v32x4.offset2_align2" (i32.const 0)) (v128.const i32x4 0x05040302 0x05040302 0x05040302 0x05040302))
+(assert_return (invoke "v32x4.offset15_align4" (i32.const 0)) (v128.const i32x4 0x0000000F 0x0000000F 0x0000000F 0x0000000F))
+(assert_return (invoke "v32x4.offset0" (i32.const 1)) (v128.const i32x4 0x04030201 0x04030201 0x04030201 0x04030201))
+(assert_return (invoke "v32x4.align1" (i32.const 1)) (v128.const i32x4 0x04030201 0x04030201 0x04030201 0x04030201))
+(assert_return (invoke "v32x4.offset1_align1" (i32.const 1)) (v128.const i32x4 0x05040302 0x05040302 0x05040302 0x05040302))
+(assert_return (invoke "v32x4.offset2_align2" (i32.const 1)) (v128.const i32x4 0x06050403 0x06050403 0x06050403 0x06050403))
+(assert_return (invoke "v32x4.offset15_align4" (i32.const 1)) (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v32x4.offset0" (i32.const 65532)) (v128.const i32x4 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C))
+(assert_return (invoke "v32x4.align1" (i32.const 65532)) (v128.const i32x4 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C))
+;; v64x2
+(assert_return (invoke "v64x2.offset0" (i32.const 0)) (v128.const i64x2 0x0706050403020100 0x0706050403020100))
+(assert_return (invoke "v64x2.align1" (i32.const 0)) (v128.const i64x2 0x0706050403020100 0x0706050403020100))
+(assert_return (invoke "v64x2.offset1_align2" (i32.const 0)) (v128.const i64x2 0x0807060504030201 0x0807060504030201))
+(assert_return (invoke "v64x2.offset2_align4" (i32.const 0)) (v128.const i64x2 0x0908070605040302 0x0908070605040302))
+(assert_return (invoke "v64x2.offset15_align8" (i32.const 0)) (v128.const i64x2 0x000000000000000F 0x000000000000000F))
+(assert_return (invoke "v64x2.offset0" (i32.const 1)) (v128.const i64x2 0x0807060504030201 0x0807060504030201))
+(assert_return (invoke "v64x2.align1" (i32.const 1)) (v128.const i64x2 0x0807060504030201 0x0807060504030201))
+(assert_return (invoke "v64x2.offset1_align2" (i32.const 1)) (v128.const i64x2 0x0908070605040302 0x0908070605040302))
+(assert_return (invoke "v64x2.offset2_align4" (i32.const 1)) (v128.const i64x2 0x0A09080706050403 0x0A09080706050403))
+(assert_return (invoke "v64x2.offset15_align8" (i32.const 1)) (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+(assert_return (invoke "v64x2.offset0" (i32.const 65528)) (v128.const i64x2 0x1F1E1D1C1B1A1918 0x1F1E1D1C1B1A1918))
+(assert_return (invoke "v64x2.align1" (i32.const 65528)) (v128.const i64x2 0x1F1E1D1C1B1A1918 0x1F1E1D1C1B1A1918))
+
+
+;; Out of bounds memory access
+(assert_trap (invoke "v128.load8_splat" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load16_splat" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load32_splat" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load64_splat" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load8_splat" (i32.const 65536)) "out of bounds memory access")
+(assert_trap (invoke "v128.load16_splat" (i32.const 65535)) "out of bounds memory access")
+(assert_trap (invoke "v128.load32_splat" (i32.const 65533)) "out of bounds memory access")
+(assert_trap (invoke "v128.load64_splat" (i32.const 65529)) "out of bounds memory access")
+
+(assert_trap (invoke "v8x16.offset1_align1" (i32.const 65535)) "out of bounds memory access")
+(assert_trap (invoke "v8x16.offset2_align1" (i32.const 65535)) "out of bounds memory access")
+(assert_trap (invoke "v8x16.offset15_align1" (i32.const 65535)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset1_align1" (i32.const 65534)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset2_align1" (i32.const 65534)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset15_align2" (i32.const 65534)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset1_align1" (i32.const 65532)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset2_align2" (i32.const 65532)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset15_align4" (i32.const 65532)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset1_align2" (i32.const 65528)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset2_align4" (i32.const 65528)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset15_align8" (i32.const 65528)) "out of bounds memory access")
+
+(assert_trap (invoke "v8x16.offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset1_align2" (i32.const -1)) "out of bounds memory access")
+
+(assert_trap (invoke "v8x16.offset65536" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset65535" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset65533" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset65529" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "v8x16.offset65536" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset65535" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset65533" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset65529" (i32.const 1)) "out of bounds memory access")
+
+
+;; Combination
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A")
+
+  (func (export "v128.load8_splat-in-block") (result v128)
+      (block (result v128) (block (result v128) (v128.load8_splat (i32.const 0))))
+  )
+  (func (export "v128.load16_splat-in-block") (result v128)
+      (block (result v128) (block (result v128) (v128.load16_splat (i32.const 1))))
+  )
+  (func (export "v128.load32_splat-in-block") (result v128)
+      (block (result v128) (block (result v128) (v128.load32_splat (i32.const 2))))
+  )
+  (func (export "v128.load64_splat-in-block") (result v128)
+      (block (result v128) (block (result v128) (v128.load64_splat (i32.const 9))))
+  )
+  (func (export "v128.load8_splat-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load8_splat (i32.const 3))))
+  )
+  (func (export "v128.load16_splat-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load16_splat (i32.const 4))))
+  )
+  (func (export "v128.load32_splat-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load32_splat (i32.const 5))))
+  )
+  (func (export "v128.load64_splat-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load64_splat (i32.const 10))))
+  )
+  (func (export "v128.load8_splat-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load8_splat (i32.const 6)))
+  )
+  (func (export "v128.load16_splat-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load16_splat (i32.const 7)))
+  )
+  (func (export "v128.load32_splat-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load32_splat (i32.const 8)))
+  )
+  (func (export "v128.load64_splat-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load64_splat (i32.const 11)))
+  )
+)
+(assert_return (invoke "v128.load8_splat-in-block") (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_splat-in-block") (v128.const i16x8 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201))
+(assert_return (invoke "v128.load32_splat-in-block") (v128.const i32x4 0x05040302 0x05040302 0x05040302 0x05040302))
+(assert_return (invoke "v128.load64_splat-in-block") (v128.const i64x2 0x0000000000000A09 0x0000000000000A09))
+(assert_return (invoke "v128.load8_splat-as-br-value") (v128.const i8x16 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3))
+(assert_return (invoke "v128.load16_splat-as-br-value") (v128.const i16x8 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504))
+(assert_return (invoke "v128.load32_splat-as-br-value") (v128.const i32x4 0x08070605 0x08070605 0x08070605 0x08070605))
+(assert_return (invoke "v128.load64_splat-as-br-value") (v128.const i64x2 0x000000000000000A 0x000000000000000A))
+(assert_return (invoke "v128.load8_splat-extract_lane_s-operand") (i32.const 6))
+(assert_return (invoke "v128.load16_splat-extract_lane_s-operand") (i32.const 7))
+(assert_return (invoke "v128.load32_splat-extract_lane_s-operand") (i32.const 8))
+(assert_return (invoke "v128.load64_splat-extract_lane_s-operand") (i32.const 0))
+
+
+;; Type check
+
+(assert_invalid (module (memory 0) (func (result v128) (v128.load8_splat (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load16_splat (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load32_splat (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load64_splat (v128.const i32x4 0 0 0 0)))) "type mismatch")
+
+
+;; Unknown operator
+
+(assert_malformed (module quote "(memory 1) (func (drop (i8x16.load_splat (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load_splat (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load_splat (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load_splat (i32.const 0))))") "unknown operator")
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load8_splat-arg-empty (result v128)
+      (v128.load8_splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load16_splat-arg-empty (result v128)
+      (v128.load16_splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load32_splat-arg-empty (result v128)
+      (v128.load32_splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load64_splat-arg-empty (result v128)
+      (v128.load64_splat)
+    )
+  )
+  "type mismatch"
+)
diff --git a/test/core/simd/simd_load_zero.wast b/test/core/simd/simd_load_zero.wast
new file mode 100644
index 000000000..6276a6863
--- /dev/null
+++ b/test/core/simd/simd_load_zero.wast
@@ -0,0 +1,154 @@
+;; Load and Zero extend test cases
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+  (data (i32.const 65520) "\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+
+  (func (export "v128.load32_zero") (param $0 i32) (result v128)
+    (v128.load32_zero (local.get $0))
+  )
+  (func (export "v128.load64_zero") (param $0 i32) (result v128)
+    (v128.load64_zero (local.get $0))
+  )
+
+  ;; load by a constant amount
+  (func (export "v128.load32_zero_const0") (result v128)
+    (v128.load32_zero (i32.const 0))
+  )
+  (func (export "v128.load64_zero_const8") (result v128)
+    (v128.load64_zero (i32.const 8))
+  )
+
+  ;; load data with different offset/align arguments
+  ;; i16x8
+  (func (export "v128.load32_zero_offset0") (param $0 i32) (result v128)
+    (v128.load32_zero offset=0 (local.get $0))
+  )
+  (func (export "v128.load32_zero_align1") (param $0 i32) (result v128)
+    (v128.load32_zero align=1 (local.get $0))
+  )
+  (func (export "v128.load32_zero_offset0_align1") (param $0 i32) (result v128)
+    (v128.load32_zero offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load32_zero_offset1_align1") (param $0 i32) (result v128)
+    (v128.load32_zero offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load32_zero_offset10_align4") (param $0 i32) (result v128)
+    (v128.load32_zero offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load64_zero_offset0") (param $0 i32) (result v128)
+    (v128.load64_zero offset=0 (local.get $0))
+  )
+  (func (export "v128.load64_zero_align1") (param $0 i32) (result v128)
+    (v128.load64_zero align=1 (local.get $0))
+  )
+  (func (export "v128.load64_zero_offset0_align1") (param $0 i32) (result v128)
+    (v128.load64_zero offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load64_zero_offset1_align1") (param $0 i32) (result v128)
+    (v128.load64_zero offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load64_zero_offset10_align4") (param $0 i32) (result v128)
+    (v128.load64_zero offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load64_zero_offset20_align8") (param $0 i32) (result v128)
+    (v128.load64_zero offset=20 align=8 (local.get $0))
+  )
+)
+
+
+;; normal
+(assert_return (invoke "v128.load32_zero" (i32.const 0)) (v128.const i32x4 0x03020100 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero" (i32.const 0)) (v128.const i64x2 0x0706050403020100 0x0000000000000000))
+(assert_return (invoke "v128.load32_zero" (i32.const 10)) (v128.const i32x4 0x0D0C0B0A 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero" (i32.const 10)) (v128.const i64x2 0x81800F0E0D0C0B0A 0x0000000000000000))
+(assert_return (invoke "v128.load32_zero" (i32.const 20)) (v128.const i32x4 0x87868584 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero" (i32.const 20)) (v128.const i64x2 0x0000898887868584 0x0000000000000000))
+
+;; load by a constant amount
+(assert_return (invoke "v128.load32_zero_const0") (v128.const i32x4 0x03020100 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero_const8") (v128.const i64x2 0x0F0E0D0C0B0A0908 0x0000000000000000))
+
+;; load data with different offset/align arguments
+;; load32_zero
+(assert_return (invoke "v128.load32_zero_offset0" (i32.const 0)) (v128.const i32x4 0x03020100 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load32_zero_align1" (i32.const 1)) (v128.const i32x4 0x04030201 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load32_zero_offset0_align1" (i32.const 2)) (v128.const i32x4 0x05040302 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load32_zero_offset10_align4" (i32.const 3)) (v128.const i32x4 0x800F0E0D 0x00000000 0x00000000 0x00000000))
+
+;; load64_zero
+(assert_return (invoke "v128.load64_zero_offset0" (i32.const 0)) (v128.const i64x2 0x0706050403020100 0x0000000000000000))
+(assert_return (invoke "v128.load64_zero_align1" (i32.const 1)) (v128.const i64x2 0x0807060504030201 0x0000000000000000))
+(assert_return (invoke "v128.load64_zero_offset0_align1" (i32.const 2)) (v128.const i64x2 0x0908070605040302 0x0000000000000000))
+(assert_return (invoke "v128.load64_zero_offset10_align4" (i32.const 3)) (v128.const i64x2 0x84838281800F0E0D 0x0000000000000000))
+(assert_return (invoke "v128.load64_zero_offset20_align8" (i32.const 4)) (v128.const i64x2 0x0000000000008988 0x0000000000000000))
+
+;; out of bounds memory access
+(assert_trap (invoke "v128.load32_zero" (i32.const -1))  "out of bounds memory access")
+(assert_trap (invoke "v128.load64_zero" (i32.const -1))  "out of bounds memory access")
+
+(assert_trap (invoke "v128.load32_zero_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load64_zero_offset1_align1" (i32.const -1)) "out of bounds memory access")
+
+;; type check
+(assert_invalid (module (memory 0) (func (result v128) (v128.load32_zero (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load64_zero (f32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load32_zero-arg-empty (result v128)
+      (v128.load32_zero)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load64_zero-arg-empty (result v128)
+      (v128.load64_zero)
+    )
+  )
+  "type mismatch"
+)
+
+;; Unknown operator
+
+(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_u (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load32x2_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load32x2_u (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load64x1_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load64x1_u (i32.const 0))))") "unknown operator")
+
+;; combination
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+  (func (export "v128.load32_zero-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load32_zero (i32.const 0))))
+  )
+  (func (export "v128.load64_zero-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load64_zero (i32.const 1))))
+  )
+  (func (export "v128.load32_zero-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load32_zero (i32.const 6))))
+  )
+  (func (export "v128.load64_zero-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load64_zero (i32.const 7))))
+  )
+  (func (export "v128.load32_zero-extract_lane_s-operand") (result i32)
+    (i32x4.extract_lane 0 (v128.load32_zero (i32.const 12)))
+  )
+  (func (export "v128.load64_zero-extract_lane_s-operand") (result i64)
+    (i64x2.extract_lane 0 (v128.load64_zero (i32.const 13)))
+  )
+)
+(assert_return (invoke "v128.load32_zero-in-block") (v128.const i32x4 0x03020100 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero-in-block") (v128.const i64x2 0x0807060504030201 0x0000000000000000))
+(assert_return (invoke "v128.load32_zero-as-br-value") (v128.const i32x4 0x09080706 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero-as-br-value") (v128.const i64x2 0x0E0D0C0B0A090807 0x0000000000000000))
+(assert_return (invoke "v128.load32_zero-extract_lane_s-operand") (i32.const 0x0F0E0D0C))
+(assert_return (invoke "v128.load64_zero-extract_lane_s-operand") (i64.const 0x84838281800F0E0D))
diff --git a/test/core/simd/simd_splat.wast b/test/core/simd/simd_splat.wast
new file mode 100644
index 000000000..4be04ef17
--- /dev/null
+++ b/test/core/simd/simd_splat.wast
@@ -0,0 +1,430 @@
+;; Tests for the *_splat instructions
+
+(module
+  (func (export "i8x16.splat") (param i32) (result v128) (i8x16.splat (local.get 0)))
+  (func (export "i16x8.splat") (param i32) (result v128) (i16x8.splat (local.get 0)))
+  (func (export "i32x4.splat") (param i32) (result v128) (i32x4.splat (local.get 0)))
+  (func (export "f32x4.splat") (param f32) (result v128) (f32x4.splat (local.get 0)))
+  (func (export "i64x2.splat") (param i64) (result v128) (i64x2.splat (local.get 0)))
+  (func (export "f64x2.splat") (param f64) (result v128) (f64x2.splat (local.get 0)))
+)
+
+(assert_return (invoke "i8x16.splat" (i32.const 0)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.splat" (i32.const 5)) (v128.const i8x16 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5))
+(assert_return (invoke "i8x16.splat" (i32.const -5)) (v128.const i8x16 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5))
+(assert_return (invoke "i8x16.splat" (i32.const 257)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.splat" (i32.const 0xff)) (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.splat" (i32.const -128)) (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.splat" (i32.const 127)) (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.splat" (i32.const -129)) (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.splat" (i32.const 128)) (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.splat" (i32.const 0xff7f)) (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.splat" (i32.const 0x80)) (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.splat" (i32.const 0xAB)) (v128.const i32x4 0xABABABAB 0xABABABAB 0xABABABAB 0xABABABAB))
+
+(assert_return (invoke "i16x8.splat" (i32.const 0)) (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.splat" (i32.const 5)) (v128.const i16x8 5 5 5 5 5 5 5 5))
+(assert_return (invoke "i16x8.splat" (i32.const -5)) (v128.const i16x8 -5 -5 -5 -5 -5 -5 -5 -5))
+(assert_return (invoke "i16x8.splat" (i32.const 65537)) (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.splat" (i32.const 0xffff)) (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.splat" (i32.const -32768)) (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.splat" (i32.const 32767)) (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.splat" (i32.const -32769)) (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.splat" (i32.const 32768)) (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.splat" (i32.const 0xffff7fff)) (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.splat" (i32.const 0x8000)) (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.splat" (i32.const 0xABCD)) (v128.const i32x4 0xABCDABCD 0xABCDABCD 0xABCDABCD 0xABCDABCD))
+(assert_return (invoke "i16x8.splat" (i32.const 012345)) (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+(assert_return (invoke "i16x8.splat" (i32.const 0x01234)) (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+
+(assert_return (invoke "i32x4.splat" (i32.const 0)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.splat" (i32.const 5)) (v128.const i32x4 5 5 5 5))
+(assert_return (invoke "i32x4.splat" (i32.const -5)) (v128.const i32x4 -5 -5 -5 -5))
+(assert_return (invoke "i32x4.splat" (i32.const 0xffffffff)) (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.splat" (i32.const 4294967295)) (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.splat" (i32.const -2147483648)) (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.splat" (i32.const 2147483647)) (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff))
+(assert_return (invoke "i32x4.splat" (i32.const 2147483648)) (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.splat" (i32.const 01234567890)) (v128.const i32x4 012_3456_7890 012_3456_7890 012_3456_7890 012_3456_7890))
+(assert_return (invoke "i32x4.splat" (i32.const 0x012345678)) (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+
+(assert_return (invoke "f32x4.splat" (f32.const 0.0)) (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.splat" (f32.const 1.1)) (v128.const f32x4 1.1 1.1 1.1 1.1))
+(assert_return (invoke "f32x4.splat" (f32.const -1.1)) (v128.const f32x4 -1.1 -1.1 -1.1 -1.1))
+(assert_return (invoke "f32x4.splat" (f32.const 1e38)) (v128.const f32x4 1e38 1e38 1e38 1e38))
+(assert_return (invoke "f32x4.splat" (f32.const -1e38)) (v128.const f32x4 -1e38 -1e38 -1e38 -1e38))
+(assert_return (invoke "f32x4.splat" (f32.const 0x1.fffffep127)) (v128.const f32x4 0x1.fffffep127 0x1.fffffep127 0x1.fffffep127 0x1.fffffep127))
+(assert_return (invoke "f32x4.splat" (f32.const -0x1.fffffep127)) (v128.const f32x4 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127))
+(assert_return (invoke "f32x4.splat" (f32.const 0x1p127)) (v128.const f32x4 0x1p127 0x1p127 0x1p127 0x1p127))
+(assert_return (invoke "f32x4.splat" (f32.const -0x1p127)) (v128.const f32x4 -0x1p127 -0x1p127 -0x1p127 -0x1p127))
+(assert_return (invoke "f32x4.splat" (f32.const inf)) (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.splat" (f32.const -inf)) (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.splat" (f32.const nan)) (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.splat" (f32.const nan:0x1)) (v128.const f32x4 nan:0x1 nan:0x1 nan:0x1 nan:0x1))
+(assert_return (invoke "f32x4.splat" (f32.const nan:0x7f_ffff)) (v128.const f32x4 nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff))
+(assert_return (invoke "f32x4.splat" (f32.const 0123456789)) (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.splat" (f32.const 0123456789.)) (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.splat" (f32.const 0x0123456789ABCDEF)) (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.splat" (f32.const 0x0123456789ABCDEF.)) (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.splat" (f32.const 0123456789e019)) (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.splat" (f32.const 0123456789.e+019)) (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.splat" (f32.const 0x0123456789ABCDEFp019)) (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.splat" (f32.const 0x0123456789ABCDEF.p-019)) (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+
+(assert_return (invoke "i64x2.splat" (i64.const 0)) (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.splat" (i64.const -0)) (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.splat" (i64.const 1)) (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.splat" (i64.const -1)) (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.splat" (i64.const -9223372036854775808)) (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.splat" (i64.const -9223372036854775808)) (v128.const i64x2 9223372036854775808 9223372036854775808))
+(assert_return (invoke "i64x2.splat" (i64.const 9223372036854775807)) (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.splat" (i64.const 18446744073709551615)) (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.splat" (i64.const 0x7fffffffffffffff)) (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff))
+(assert_return (invoke "i64x2.splat" (i64.const 0xffffffffffffffff)) (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.splat" (i64.const -0x8000000000000000)) (v128.const i64x2 -0x8000000000000000 -0x8000000000000000))
+(assert_return (invoke "i64x2.splat" (i64.const -0x8000000000000000)) (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+(assert_return (invoke "i64x2.splat" (i64.const 01234567890123456789)) (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789))
+(assert_return (invoke "i64x2.splat" (i64.const 0x01234567890ABcdef)) (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef))
+
+(assert_return (invoke "f64x2.splat" (f64.const 0.0)) (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.splat" (f64.const -0.0)) (v128.const f64x2 -0.0 -0.0))
+(assert_return (invoke "f64x2.splat" (f64.const 1.1)) (v128.const f64x2 1.1 1.1))
+(assert_return (invoke "f64x2.splat" (f64.const -1.1)) (v128.const f64x2 -1.1 -1.1))
+(assert_return (invoke "f64x2.splat" (f64.const 0x0.0000000000001p-1022)) (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.splat" (f64.const -0x0.0000000000001p-1022)) (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.splat" (f64.const 0x1p-1022)) (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.splat" (f64.const -0x1p-1022)) (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.splat" (f64.const 0x1p-1)) (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.splat" (f64.const -0x1p-1)) (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.splat" (f64.const 0x1p+0)) (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.splat" (f64.const -0x1p+0)) (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.splat" (f64.const 0x1.921fb54442d18p+2)) (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.splat" (f64.const -0x1.921fb54442d18p+2)) (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.splat" (f64.const 0x1.fffffffffffffp+1023)) (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.splat" (f64.const -0x1.fffffffffffffp+1023)) (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.splat" (f64.const inf)) (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.splat" (f64.const -inf)) (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.splat" (f64.const nan)) (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.splat" (f64.const -nan)) (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.splat" (f64.const nan:0x4000000000000)) (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.splat" (f64.const -nan:0x4000000000000)) (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.splat" (f64.const 0123456789)) (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.splat" (f64.const 0123456789.)) (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.splat" (f64.const 0x0123456789ABCDEFabcdef)) (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.splat" (f64.const 0x0123456789ABCDEFabcdef.)) (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.splat" (f64.const 0123456789e019)) (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.splat" (f64.const 0123456789e+019)) (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.splat" (f64.const 0x0123456789ABCDEFabcdef.p019)) (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.splat" (f64.const 0x0123456789ABCDEFabcdef.p-019)) (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+
+;; Unknown operator
+
+(assert_malformed (module quote "(func (result v128) (v128.splat (i32.const 0)))") "unknown operator")
+
+
+;; Type mismatched
+
+(assert_invalid (module (func (result v128) i8x16.splat (i64.const 0))) "type mismatch")
+(assert_invalid (module (func (result v128) i8x16.splat (f32.const 0.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i8x16.splat (f64.const 0.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i16x8.splat (i64.const 1))) "type mismatch")
+(assert_invalid (module (func (result v128) i16x8.splat (f32.const 1.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i16x8.splat (f64.const 1.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i32x4.splat (i64.const 2))) "type mismatch")
+(assert_invalid (module (func (result v128) i32x4.splat (f32.const 2.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i32x4.splat (f64.const 2.0))) "type mismatch")
+(assert_invalid (module (func (result v128) f32x4.splat (i32.const 4))) "type mismatch")
+(assert_invalid (module (func (result v128) f32x4.splat (i64.const 4))) "type mismatch")
+(assert_invalid (module (func (result v128) f32x4.splat (f64.const 4.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i64x2.splat (i32.const 0))) "type mismatch")
+(assert_invalid (module (func (result v128) i64x2.splat (f64.const 0.0))) "type mismatch")
+(assert_invalid (module (func (result v128) f64x2.splat (i32.const 0))) "type mismatch")
+(assert_invalid (module (func (result v128) f64x2.splat (f32.const 0.0))) "type mismatch")
+
+
+;; V128 splat operators as the argument of other SIMD instructions
+
+;; v128.store and v128.load
+(module (memory 1)
+  (func (export "as-v128_store-operand-1") (param i32) (result v128)
+    (v128.store (i32.const 0) (i8x16.splat (local.get 0)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-2") (param i32) (result v128)
+    (v128.store (i32.const 0) (i16x8.splat (local.get 0)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-3") (param i32) (result v128)
+    (v128.store (i32.const 0) (i32x4.splat (local.get 0)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-4") (param i64) (result v128)
+    (v128.store (i32.const 0) (i64x2.splat (local.get 0)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-5") (param f64) (result v128)
+    (v128.store (i32.const 0) (f64x2.splat (local.get 0)))
+    (v128.load (i32.const 0)))
+)
+
+(assert_return (invoke "as-v128_store-operand-1" (i32.const 1)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "as-v128_store-operand-2" (i32.const 256)) (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+(assert_return (invoke "as-v128_store-operand-3" (i32.const 0xffffffff)) (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "as-v128_store-operand-4" (i64.const 1)) (v128.const i64x2 1 1))
+(assert_return (invoke "as-v128_store-operand-5" (f64.const -0x1p+0)) (v128.const f64x2 -0x1p+0 -0x1p+0))
+
+(module
+  ;; Accessing lane
+  (func (export "as-i8x16_extract_lane_s-operand-first") (param i32) (result i32)
+    (i8x16.extract_lane_s 0 (i8x16.splat (local.get 0))))
+  (func (export "as-i8x16_extract_lane_s-operand-last") (param i32) (result i32)
+    (i8x16.extract_lane_s 15 (i8x16.splat (local.get 0))))
+  (func (export "as-i16x8_extract_lane_s-operand-first") (param i32) (result i32)
+    (i16x8.extract_lane_s 0 (i16x8.splat (local.get 0))))
+  (func (export "as-i16x8_extract_lane_s-operand-last") (param i32) (result i32)
+    (i16x8.extract_lane_s 7 (i16x8.splat (local.get 0))))
+  (func (export "as-i32x4_extract_lane_s-operand-first") (param i32) (result i32)
+    (i32x4.extract_lane 0 (i32x4.splat (local.get 0))))
+  (func (export "as-i32x4_extract_lane_s-operand-last") (param i32) (result i32)
+    (i32x4.extract_lane 3 (i32x4.splat (local.get 0))))
+  (func (export "as-f32x4_extract_lane_s-operand-first") (param f32) (result f32)
+    (f32x4.extract_lane 0 (f32x4.splat (local.get 0))))
+  (func (export "as-f32x4_extract_lane_s-operand-last") (param f32) (result f32)
+    (f32x4.extract_lane 3 (f32x4.splat (local.get 0))))
+  (func (export "as-v8x16_swizzle-operands") (param i32) (param i32) (result v128)
+    (i8x16.swizzle (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1))))
+  (func (export "as-i64x2_extract_lane-operand-first") (param i64) (result i64)
+    (i64x2.extract_lane 0 (i64x2.splat (local.get 0))))
+  (func (export "as-i64x2_extract_lane-operand-last") (param i64) (result i64)
+    (i64x2.extract_lane 1 (i64x2.splat (local.get 0))))
+  (func (export "as-f64x2_extract_lane-operand-first") (param f64) (result f64)
+    (f64x2.extract_lane 0 (f64x2.splat (local.get 0))))
+  (func (export "as-f64x2_extract_lane-operand-last") (param f64) (result f64)
+    (f64x2.extract_lane 1 (f64x2.splat (local.get 0))))
+
+  ;; Integer arithmetic
+  (func (export "as-i8x16_add_sub-operands") (param i32 i32 i32) (result v128)
+    (i8x16.add (i8x16.splat (local.get 0))
+      (i8x16.sub (i8x16.splat (local.get 1)) (i8x16.splat (local.get 2)))))
+  (func (export "as-i16x8_add_sub_mul-operands") (param i32 i32 i32 i32) (result v128)
+    (i16x8.add (i16x8.splat (local.get 0))
+      (i16x8.sub (i16x8.splat (local.get 1))
+        (i16x8.mul (i16x8.splat (local.get 2)) (i16x8.splat (local.get 3))))))
+  (func (export "as-i32x4_add_sub_mul-operands") (param i32 i32 i32 i32) (result v128)
+    (i32x4.add (i32x4.splat (local.get 0))
+      (i32x4.sub (i32x4.splat (local.get 1))
+        (i32x4.mul (i32x4.splat (local.get 2)) (i32x4.splat (local.get 3))))))
+
+  (func (export "as-i64x2_add_sub_mul-operands") (param i64 i64 i64 i64) (result v128)
+    (i64x2.add (i64x2.splat (local.get 0))
+      (i64x2.sub (i64x2.splat (local.get 1))
+        (i64x2.mul (i64x2.splat (local.get 2)) (i64x2.splat (local.get 3))))))
+  (func (export "as-f64x2_add_sub_mul-operands") (param f64 f64 f64 f64) (result v128)
+    (f64x2.add (f64x2.splat (local.get 0))
+      (f64x2.sub (f64x2.splat (local.get 1))
+        (f64x2.mul (f64x2.splat (local.get 2)) (f64x2.splat (local.get 3))))))
+
+  ;; Saturating integer arithmetic
+  (func (export "as-i8x16_add_sat_s-operands") (param i32 i32) (result v128)
+    (i8x16.add_sat_s (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1))))
+  (func (export "as-i16x8_add_sat_s-operands") (param i32 i32) (result v128)
+    (i16x8.add_sat_s (i16x8.splat (local.get 0)) (i16x8.splat (local.get 1))))
+  (func (export "as-i8x16_sub_sat_u-operands") (param i32 i32) (result v128)
+    (i8x16.sub_sat_u (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1))))
+  (func (export "as-i16x8_sub_sat_u-operands") (param i32 i32) (result v128)
+    (i16x8.sub_sat_u (i16x8.splat (local.get 0)) (i16x8.splat (local.get 1))))
+
+  ;; Bit shifts
+  (func (export "as-i8x16_shr_s-operand") (param i32 i32) (result v128)
+    (i8x16.shr_s (i8x16.splat (local.get 0)) (local.get 1)))
+  (func (export "as-i16x8_shr_s-operand") (param i32 i32) (result v128)
+    (i16x8.shr_s (i16x8.splat (local.get 0)) (local.get 1)))
+  (func (export "as-i32x4_shr_s-operand") (param i32 i32) (result v128)
+    (i32x4.shr_s (i32x4.splat (local.get 0)) (local.get 1)))
+
+  ;; Bitwise operantions
+  (func (export "as-v128_and-operands") (param i32 i32) (result v128)
+    (v128.and (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1))))
+  (func (export "as-v128_or-operands") (param i32 i32) (result v128)
+    (v128.or (i16x8.splat (local.get 0)) (i16x8.splat (local.get 1))))
+  (func (export "as-v128_xor-operands") (param i32 i32) (result v128)
+    (v128.xor (i32x4.splat (local.get 0)) (i32x4.splat (local.get 1))))
+
+  ;; Boolean horizontal reductions
+  (func (export "as-i8x16_all_true-operand") (param i32) (result i32)
+    (i8x16.all_true (i8x16.splat (local.get 0))))
+  (func (export "as-i16x8_all_true-operand") (param i32) (result i32)
+    (i16x8.all_true (i16x8.splat (local.get 0))))
+  (func (export "as-i32x4_all_true-operand1") (param i32) (result i32)
+    (i32x4.all_true (i32x4.splat (local.get 0))))
+  (func (export "as-i32x4_all_true-operand2") (param i64) (result i32)
+    (i32x4.all_true (i64x2.splat (local.get 0))))
+
+  ;; Comparisons
+  (func (export "as-i8x16_eq-operands") (param i32 i32) (result v128)
+    (i8x16.eq (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1))))
+  (func (export "as-i16x8_eq-operands") (param i32 i32) (result v128)
+    (i16x8.eq (i16x8.splat (local.get 0)) (i16x8.splat (local.get 1))))
+  (func (export "as-i32x4_eq-operands1") (param i32 i32) (result v128)
+    (i32x4.eq (i32x4.splat (local.get 0)) (i32x4.splat (local.get 1))))
+  (func (export "as-i32x4_eq-operands2") (param i64 i64) (result v128)
+    (i32x4.eq (i64x2.splat (local.get 0)) (i64x2.splat (local.get 1))))
+  (func (export "as-f32x4_eq-operands") (param f32 f32) (result v128)
+    (f32x4.eq (f32x4.splat (local.get 0)) (f32x4.splat (local.get 1))))
+  (func (export "as-f64x2_eq-operands") (param f64 f64) (result v128)
+    (f64x2.eq (f64x2.splat (local.get 0)) (f64x2.splat (local.get 1))))
+
+  ;; Floating-point sign bit operations
+  (func (export "as-f32x4_abs-operand") (param f32) (result v128)
+    (f32x4.abs (f32x4.splat (local.get 0))))
+
+  ;; Floating-point min
+  (func (export "as-f32x4_min-operands") (param f32 f32) (result v128)
+    (f32x4.min (f32x4.splat (local.get 0)) (f32x4.splat (local.get 1))))
+
+  ;; Floating-point arithmetic
+  (func (export "as-f32x4_div-operands") (param f32 f32) (result v128)
+    (f32x4.div (f32x4.splat (local.get 0)) (f32x4.splat (local.get 1))))
+
+  ;; Conversions
+  (func (export "as-f32x4_convert_s_i32x4-operand") (param i32) (result v128)
+    (f32x4.convert_i32x4_s (i32x4.splat (local.get 0))))
+  (func (export "as-i32x4_trunc_s_f32x4_sat-operand") (param f32) (result v128)
+    (i32x4.trunc_sat_f32x4_s (f32x4.splat (local.get 0))))
+)
+
+(assert_return (invoke "as-i8x16_extract_lane_s-operand-first" (i32.const 42)) (i32.const 42))
+(assert_return (invoke "as-i8x16_extract_lane_s-operand-last" (i32.const -42)) (i32.const -42))
+(assert_return (invoke "as-i16x8_extract_lane_s-operand-first" (i32.const 0xffff7fff)) (i32.const 32767))
+(assert_return (invoke "as-i16x8_extract_lane_s-operand-last" (i32.const 0x8000)) (i32.const -32768))
+(assert_return (invoke "as-i32x4_extract_lane_s-operand-first" (i32.const 0x7fffffff)) (i32.const 2147483647))
+(assert_return (invoke "as-i32x4_extract_lane_s-operand-last" (i32.const 0x80000000)) (i32.const -2147483648))
+(assert_return (invoke "as-f32x4_extract_lane_s-operand-first" (f32.const 1.5)) (f32.const 1.5))
+(assert_return (invoke "as-f32x4_extract_lane_s-operand-last" (f32.const -0.25)) (f32.const -0.25))
+(assert_return (invoke "as-v8x16_swizzle-operands" (i32.const 1) (i32.const -1)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "as-i64x2_extract_lane-operand-last" (i64.const -42)) (i64.const -42))
+(assert_return (invoke "as-i64x2_extract_lane-operand-first" (i64.const 42)) (i64.const 42))
+(assert_return (invoke "as-f64x2_extract_lane-operand-first" (f64.const 1.5)) (f64.const 1.5))
+(assert_return (invoke "as-f64x2_extract_lane-operand-last" (f64.const -0x1p+0)) (f64.const -0x1p+0))
+
+(assert_return (invoke "as-i8x16_add_sub-operands" (i32.const 3) (i32.const 2) (i32.const 1)) (v128.const i8x16 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4))
+(assert_return (invoke "as-i16x8_add_sub_mul-operands" (i32.const 257) (i32.const 128) (i32.const 16) (i32.const 16)) (v128.const i16x8 129 129 129 129 129 129 129 129))
+(assert_return (invoke "as-i32x4_add_sub_mul-operands" (i32.const 65535) (i32.const 65537) (i32.const 256) (i32.const 256)) (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+(assert_return (invoke "as-i64x2_add_sub_mul-operands" (i64.const 0x7fffffff) (i64.const 0x1_0000_0001) (i64.const 65536) (i64.const 65536)) (v128.const i64x2 0x8000_0000 0x8000_0000))
+(assert_return (invoke "as-f64x2_add_sub_mul-operands" (f64.const 0x1p-1) (f64.const 0.75) (f64.const 0x1p-1) (f64.const 0.5)) (v128.const f64x2 0x1p+0 0x1p+0))
+
+(assert_return (invoke "as-i8x16_add_sat_s-operands" (i32.const 0x7f) (i32.const 1)) (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "as-i16x8_add_sat_s-operands" (i32.const 0x7fff) (i32.const 1)) (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "as-i8x16_sub_sat_u-operands" (i32.const 0x7f) (i32.const 0xff)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "as-i16x8_sub_sat_u-operands" (i32.const 0x7fff) (i32.const 0xffff)) (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+(assert_return (invoke "as-i8x16_shr_s-operand" (i32.const 0xf0) (i32.const 3)) (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "as-i16x8_shr_s-operand" (i32.const 0x100) (i32.const 4)) (v128.const i16x8 16 16 16 16 16 16 16 16))
+(assert_return (invoke "as-i32x4_shr_s-operand" (i32.const -1) (i32.const 16)) (v128.const i32x4 -1 -1 -1 -1))
+
+(assert_return (invoke "as-v128_and-operands" (i32.const 0x11) (i32.const 0xff)) (v128.const i8x16 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17))
+(assert_return (invoke "as-v128_or-operands" (i32.const 0) (i32.const 0xffff)) (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "as-v128_xor-operands" (i32.const 0xf0f0f0f0) (i32.const 0xffffffff)) (v128.const i32x4 0xf0f0f0f 0xf0f0f0f 0xf0f0f0f 0xf0f0f0f))
+
+(assert_return (invoke "as-i8x16_all_true-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-i16x8_all_true-operand" (i32.const 0xffff)) (i32.const 1))
+(assert_return (invoke "as-i32x4_all_true-operand1" (i32.const 0xf0f0f0f0)) (i32.const 1))
+(assert_return (invoke "as-i32x4_all_true-operand2" (i64.const -1)) (i32.const 1))
+
+(assert_return (invoke "as-i8x16_eq-operands" (i32.const 1) (i32.const 2)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "as-i16x8_eq-operands" (i32.const -1) (i32.const 65535)) (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "as-i32x4_eq-operands1" (i32.const -1) (i32.const 0xffffffff)) (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+(assert_return (invoke "as-f32x4_eq-operands" (f32.const +0.0) (f32.const -0.0)) (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+(assert_return (invoke "as-i32x4_eq-operands2" (i64.const 1) (i64.const 2)) (v128.const i64x2 0xffffffff00000000 0xffffffff00000000))
+(assert_return (invoke "as-f64x2_eq-operands" (f64.const +0.0) (f64.const -0.0)) (v128.const i64x2 -1 -1))
+
+(assert_return (invoke "as-f32x4_abs-operand" (f32.const -1.125)) (v128.const f32x4 1.125 1.125 1.125 1.125))
+(assert_return (invoke "as-f32x4_min-operands" (f32.const 0.25) (f32.const 1e-38)) (v128.const f32x4 1e-38 1e-38 1e-38 1e-38))
+(assert_return (invoke "as-f32x4_div-operands" (f32.const 1.0) (f32.const 8.0)) (v128.const f32x4 0.125 0.125 0.125 0.125))
+
+(assert_return (invoke "as-f32x4_convert_s_i32x4-operand" (i32.const 12345)) (v128.const f32x4 12345.0 12345.0 12345.0 12345.0))
+(assert_return (invoke "as-i32x4_trunc_s_f32x4_sat-operand" (f32.const 1.1)) (v128.const i32x4 1 1 1 1))
+
+
+;; As the argument of control constructs and WASM instructions
+
+(module
+  (global $g (mut v128) (v128.const f32x4 0.0 0.0 0.0 0.0))
+  (func (export "as-br-value1") (param i32) (result v128)
+    (block (result v128) (br 0 (i8x16.splat (local.get 0)))))
+  (func (export "as-return-value1") (param i32) (result v128)
+    (return (i16x8.splat (local.get 0))))
+  (func (export "as-local_set-value1") (param i32) (result v128) (local v128)
+    (local.set 1 (i32x4.splat (local.get 0)))
+    (return (local.get 1)))
+  (func (export "as-global_set-value1") (param f32) (result v128)
+    (global.set $g (f32x4.splat (local.get 0)))
+    (return (global.get $g)))
+  (func (export "as-br-value2") (param i64) (result v128)
+    (block (result v128) (br 0 (i64x2.splat (local.get 0)))))
+  (func (export "as-return-value2") (param i64) (result v128)
+    (return (i64x2.splat (local.get 0))))
+  (func (export "as-local_set-value2") (param i64) (result v128) (local v128)
+    (local.set 1 (i64x2.splat (local.get 0)))
+    (return (local.get 1)))
+  (func (export "as-global_set-value2") (param f64) (result v128)
+    (global.set $g (f64x2.splat (local.get 0)))
+    (return (global.get $g)))
+)
+
+(assert_return (invoke "as-br-value1" (i32.const 0xAB)) (v128.const i8x16 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB))
+(assert_return (invoke "as-return-value1" (i32.const 0xABCD)) (v128.const i16x8 0xABCD 0xABCD 0xABCD 0xABCD 0xABCD 0xABCD 0xABCD 0xABCD))
+(assert_return (invoke "as-local_set-value1" (i32.const 0x10000)) (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+(assert_return (invoke "as-global_set-value1" (f32.const 1.0)) (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "as-br-value2" (i64.const 0xABCD)) (v128.const i64x2 0xABCD 0xABCD))
+(assert_return (invoke "as-return-value2" (i64.const 0xABCD)) (v128.const i64x2 0xABCD 0xABCD))
+(assert_return (invoke "as-local_set-value2" (i64.const 0x10000)) (v128.const i64x2 0x10000 0x10000))
+(assert_return (invoke "as-global_set-value2" (f64.const 1.0)) (v128.const f64x2 1.0 1.0))
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.splat-arg-empty (result v128)
+      (i8x16.splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.splat-arg-empty (result v128)
+      (i16x8.splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.splat-arg-empty (result v128)
+      (i32x4.splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.splat-arg-empty (result v128)
+      (f32x4.splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.splat-arg-empty (result v128)
+      (i64x2.splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.splat-arg-empty (result v128)
+      (f64x2.splat)
+    )
+  )
+  "type mismatch"
+)
diff --git a/test/core/simd/simd_store.wast b/test/core/simd/simd_store.wast
new file mode 100644
index 000000000..50349c41b
--- /dev/null
+++ b/test/core/simd/simd_store.wast
@@ -0,0 +1,166 @@
+;; v128.store operater with normal argument (e.g. (i8x16, i16x8, i32x4, f32x4))
+
+(module
+  (memory 1)
+  (func (export "v128.store_i8x16") (result v128)
+    (v128.store (i32.const 0) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i16x8") (result v128)
+    (v128.store (i32.const 0) (v128.const i16x8 0 1 2 3 4 5 6 7))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i16x8_2") (result v128)
+    (v128.store (i32.const 0) (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i16x8_3") (result v128)
+    (v128.store (i32.const 0) (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i32x4") (result v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i32x4_2") (result v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i32x4_3") (result v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+    (v128.load (i32.const 0))
+  )
+
+  (func (export "v128.store_f32x4") (result v128)
+    (v128.store (i32.const 0) (v128.const f32x4 0 1 2 3))
+    (v128.load (i32.const 0))
+  )
+)
+
+(assert_return (invoke "v128.store_i8x16") (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "v128.store_i16x8") (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "v128.store_i16x8_2") (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+(assert_return (invoke "v128.store_i16x8_3") (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+(assert_return (invoke "v128.store_i32x4") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "v128.store_i32x4_2") (v128.const i32x4 123456789 123456789 123456789 123456789))
+(assert_return (invoke "v128.store_i32x4_3") (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+(assert_return (invoke "v128.store_f32x4") (v128.const f32x4 0 1 2 3))
+
+
+;; v128.store operator as the argument of control constructs and instructions
+
+(module
+  (memory 1)
+  (func (export "as-block-value")
+    (block (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+  )
+  (func (export "as-loop-value")
+    (loop (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+  )
+  (func (export "as-br-value")
+    (block (br 0 (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  )
+  (func (export "as-br_if-value")
+    (block
+      (br_if 0 (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)) (i32.const 1))
+    )
+  )
+  (func (export "as-br_if-value-cond")
+    (block
+      (br_if 0 (i32.const 6) (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+    )
+  )
+  (func (export "as-br_table-value")
+    (block
+      (br_table 0 (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)) (i32.const 1))
+    )
+  )
+  (func (export "as-return-value")
+    (return (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+  )
+  (func (export "as-if-then")
+    (if (i32.const 1) (then (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  )
+  (func (export "as-if-else")
+    (if (i32.const 0) (then) (else (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  )
+)
+
+(assert_return (invoke "as-block-value"))
+(assert_return (invoke "as-loop-value"))
+(assert_return (invoke "as-br-value"))
+(assert_return (invoke "as-br_if-value"))
+(assert_return (invoke "as-br_if-value-cond"))
+(assert_return (invoke "as-br_table-value"))
+(assert_return (invoke "as-return-value"))
+(assert_return (invoke "as-if-then"))
+(assert_return (invoke "as-if-else"))
+
+
+;; Unknown operator(e.g. v128.store8, v128.store16, v128.store32)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store8 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store16 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store32 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+
+
+;; Type mismatched (e.g. v128.load(f32.const 0), type address empty)
+
+(assert_invalid
+  (module (memory 1) (func (v128.store (f32.const 0) (v128.const i32x4 0 0 0 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (local v128) (block (br_if 0 (v128.store)))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  "type mismatch"
+)
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module (memory 0)
+    (func $v128.store-1st-arg-empty
+      (v128.store (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.store-2nd-arg-empty
+      (v128.store (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.store-arg-empty
+      (v128.store)
+    )
+  )
+  "type mismatch"
+)
diff --git a/test/core/simd/simd_store16_lane.wast b/test/core/simd/simd_store16_lane.wast
new file mode 100644
index 000000000..d8ea35c3f
--- /dev/null
+++ b/test/core/simd/simd_store16_lane.wast
@@ -0,0 +1,299 @@
+;; Tests for store lane operations.
+
+
+(module
+  (memory 1)
+  (global $zero (mut v128) (v128.const i32x4 0 0 0 0))
+  (func (export "v128.store16_lane_0")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_3")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 4 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_5")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 5 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_6")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 6 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_7")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 7 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_0_offset_0")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=0 0 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=0 (i32.const 0)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_1_offset_1")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=1 1 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=1 (i32.const 0)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_2_offset_2")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=2 2 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=2 (i32.const 0)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_3_offset_3")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=3 3 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=3 (i32.const 0)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_4_offset_4")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=4 4 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=4 (i32.const 0)))
+    (v128.store offset=4 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_5_offset_5")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=5 5 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=5 (i32.const 0)))
+    (v128.store offset=5 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_6_offset_6")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=6 6 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=6 (i32.const 0)))
+    (v128.store offset=6 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_7_offset_7")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=7 7 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=7 (i32.const 0)))
+    (v128.store offset=7 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_0_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_0_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_1_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_1_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_2_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_2_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_3_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_3_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_4_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 4 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=4 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_4_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 4 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=4 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_5_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 5 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=5 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_5_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 5 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=5 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_6_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 6 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=6 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_6_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 6 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=6 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_7_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 7 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=7 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_7_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 7 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=7 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+)
+
+(assert_return (invoke "v128.store16_lane_0" (i32.const 0)
+                                             (v128.const i16x8 256 0 0 0 0 0 0 0))
+                                             (i64.const 256))
+(assert_return (invoke "v128.store16_lane_1" (i32.const 1)
+                                             (v128.const i16x8 0 513 0 0 0 0 0 0))
+                                             (i64.const 513))
+(assert_return (invoke "v128.store16_lane_2" (i32.const 2)
+                                             (v128.const i16x8 0 0 770 0 0 0 0 0))
+                                             (i64.const 770))
+(assert_return (invoke "v128.store16_lane_3" (i32.const 3)
+                                             (v128.const i16x8 0 0 0 1027 0 0 0 0))
+                                             (i64.const 1027))
+(assert_return (invoke "v128.store16_lane_4" (i32.const 4)
+                                             (v128.const i16x8 0 0 0 0 1284 0 0 0))
+                                             (i64.const 1284))
+(assert_return (invoke "v128.store16_lane_5" (i32.const 5)
+                                             (v128.const i16x8 0 0 0 0 0 1541 0 0))
+                                             (i64.const 1541))
+(assert_return (invoke "v128.store16_lane_6" (i32.const 6)
+                                             (v128.const i16x8 0 0 0 0 0 0 1798 0))
+                                             (i64.const 1798))
+(assert_return (invoke "v128.store16_lane_7" (i32.const 7)
+                                             (v128.const i16x8 0 0 0 0 0 0 0 2055))
+                                             (i64.const 2055))
+(assert_return (invoke "v128.store16_lane_0_offset_0" (v128.const i16x8 256 0 0 0 0 0 0 0))
+                                                      (i64.const 256))
+(assert_return (invoke "v128.store16_lane_1_offset_1" (v128.const i16x8 0 513 0 0 0 0 0 0))
+                                                      (i64.const 513))
+(assert_return (invoke "v128.store16_lane_2_offset_2" (v128.const i16x8 0 0 770 0 0 0 0 0))
+                                                      (i64.const 770))
+(assert_return (invoke "v128.store16_lane_3_offset_3" (v128.const i16x8 0 0 0 1027 0 0 0 0))
+                                                      (i64.const 1027))
+(assert_return (invoke "v128.store16_lane_4_offset_4" (v128.const i16x8 0 0 0 0 1284 0 0 0))
+                                                      (i64.const 1284))
+(assert_return (invoke "v128.store16_lane_5_offset_5" (v128.const i16x8 0 0 0 0 0 1541 0 0))
+                                                      (i64.const 1541))
+(assert_return (invoke "v128.store16_lane_6_offset_6" (v128.const i16x8 0 0 0 0 0 0 1798 0))
+                                                      (i64.const 1798))
+(assert_return (invoke "v128.store16_lane_7_offset_7" (v128.const i16x8 0 0 0 0 0 0 0 2055))
+                                                      (i64.const 2055))
+(assert_return (invoke "v128.store16_lane_0_align_1" (i32.const 0)
+                                                     (v128.const i16x8 256 0 0 0 0 0 0 0))
+                                                     (i64.const 256))
+(assert_return (invoke "v128.store16_lane_0_align_2" (i32.const 0)
+                                                     (v128.const i16x8 256 0 0 0 0 0 0 0))
+                                                     (i64.const 256))
+(assert_return (invoke "v128.store16_lane_1_align_1" (i32.const 1)
+                                                     (v128.const i16x8 0 513 0 0 0 0 0 0))
+                                                     (i64.const 513))
+(assert_return (invoke "v128.store16_lane_1_align_2" (i32.const 1)
+                                                     (v128.const i16x8 0 513 0 0 0 0 0 0))
+                                                     (i64.const 513))
+(assert_return (invoke "v128.store16_lane_2_align_1" (i32.const 2)
+                                                     (v128.const i16x8 0 0 770 0 0 0 0 0))
+                                                     (i64.const 770))
+(assert_return (invoke "v128.store16_lane_2_align_2" (i32.const 2)
+                                                     (v128.const i16x8 0 0 770 0 0 0 0 0))
+                                                     (i64.const 770))
+(assert_return (invoke "v128.store16_lane_3_align_1" (i32.const 3)
+                                                     (v128.const i16x8 0 0 0 1027 0 0 0 0))
+                                                     (i64.const 1027))
+(assert_return (invoke "v128.store16_lane_3_align_2" (i32.const 3)
+                                                     (v128.const i16x8 0 0 0 1027 0 0 0 0))
+                                                     (i64.const 1027))
+(assert_return (invoke "v128.store16_lane_4_align_1" (i32.const 4)
+                                                     (v128.const i16x8 0 0 0 0 1284 0 0 0))
+                                                     (i64.const 1284))
+(assert_return (invoke "v128.store16_lane_4_align_2" (i32.const 4)
+                                                     (v128.const i16x8 0 0 0 0 1284 0 0 0))
+                                                     (i64.const 1284))
+(assert_return (invoke "v128.store16_lane_5_align_1" (i32.const 5)
+                                                     (v128.const i16x8 0 0 0 0 0 1541 0 0))
+                                                     (i64.const 1541))
+(assert_return (invoke "v128.store16_lane_5_align_2" (i32.const 5)
+                                                     (v128.const i16x8 0 0 0 0 0 1541 0 0))
+                                                     (i64.const 1541))
+(assert_return (invoke "v128.store16_lane_6_align_1" (i32.const 6)
+                                                     (v128.const i16x8 0 0 0 0 0 0 1798 0))
+                                                     (i64.const 1798))
+(assert_return (invoke "v128.store16_lane_6_align_2" (i32.const 6)
+                                                     (v128.const i16x8 0 0 0 0 0 0 1798 0))
+                                                     (i64.const 1798))
+(assert_return (invoke "v128.store16_lane_7_align_1" (i32.const 7)
+                                                     (v128.const i16x8 0 0 0 0 0 0 0 2055))
+                                                     (i64.const 2055))
+(assert_return (invoke "v128.store16_lane_7_align_2" (i32.const 7)
+                                                     (v128.const i16x8 0 0 0 0 0 0 0 2055))
+                                                     (i64.const 2055))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store16_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store16_lane 8 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.store16_lane align=4 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/test/core/simd/simd_store32_lane.wast b/test/core/simd/simd_store32_lane.wast
new file mode 100644
index 000000000..847bab9e6
--- /dev/null
+++ b/test/core/simd/simd_store32_lane.wast
@@ -0,0 +1,199 @@
+;; Tests for store lane operations.
+
+
+(module
+  (memory 1)
+  (global $zero (mut v128) (v128.const i32x4 0 0 0 0))
+  (func (export "v128.store32_lane_0")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store32_lane_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store32_lane_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store32_lane_3")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store32_lane_0_offset_0")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane offset=0 0 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=0 (i32.const 0)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_1_offset_1")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane offset=1 1 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=1 (i32.const 0)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_2_offset_2")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane offset=2 2 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=2 (i32.const 0)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_3_offset_3")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane offset=3 3 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=3 (i32.const 0)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_0_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=1 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_0_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=2 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_0_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=4 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_1_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=1 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_1_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=2 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_1_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=4 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_2_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=1 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_2_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=2 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_2_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=4 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_3_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=1 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_3_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=2 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_3_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=4 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+)
+
+(assert_return (invoke "v128.store32_lane_0" (i32.const 0)
+                                             (v128.const i32x4 50462976 0 0 0))
+                                             (i64.const 50462976))
+(assert_return (invoke "v128.store32_lane_1" (i32.const 1)
+                                             (v128.const i32x4 0 67305985 0 0))
+                                             (i64.const 67305985))
+(assert_return (invoke "v128.store32_lane_2" (i32.const 2)
+                                             (v128.const i32x4 0 0 84148994 0))
+                                             (i64.const 84148994))
+(assert_return (invoke "v128.store32_lane_3" (i32.const 3)
+                                             (v128.const i32x4 0 0 0 100992003))
+                                             (i64.const 100992003))
+(assert_return (invoke "v128.store32_lane_0_offset_0" (v128.const i32x4 50462976 0 0 0))
+                                                      (i64.const 50462976))
+(assert_return (invoke "v128.store32_lane_1_offset_1" (v128.const i32x4 0 67305985 0 0))
+                                                      (i64.const 67305985))
+(assert_return (invoke "v128.store32_lane_2_offset_2" (v128.const i32x4 0 0 84148994 0))
+                                                      (i64.const 84148994))
+(assert_return (invoke "v128.store32_lane_3_offset_3" (v128.const i32x4 0 0 0 100992003))
+                                                      (i64.const 100992003))
+(assert_return (invoke "v128.store32_lane_0_align_1" (i32.const 0)
+                                                     (v128.const i32x4 50462976 0 0 0))
+                                                     (i64.const 50462976))
+(assert_return (invoke "v128.store32_lane_0_align_2" (i32.const 0)
+                                                     (v128.const i32x4 50462976 0 0 0))
+                                                     (i64.const 50462976))
+(assert_return (invoke "v128.store32_lane_0_align_4" (i32.const 0)
+                                                     (v128.const i32x4 50462976 0 0 0))
+                                                     (i64.const 50462976))
+(assert_return (invoke "v128.store32_lane_1_align_1" (i32.const 1)
+                                                     (v128.const i32x4 0 67305985 0 0))
+                                                     (i64.const 67305985))
+(assert_return (invoke "v128.store32_lane_1_align_2" (i32.const 1)
+                                                     (v128.const i32x4 0 67305985 0 0))
+                                                     (i64.const 67305985))
+(assert_return (invoke "v128.store32_lane_1_align_4" (i32.const 1)
+                                                     (v128.const i32x4 0 67305985 0 0))
+                                                     (i64.const 67305985))
+(assert_return (invoke "v128.store32_lane_2_align_1" (i32.const 2)
+                                                     (v128.const i32x4 0 0 84148994 0))
+                                                     (i64.const 84148994))
+(assert_return (invoke "v128.store32_lane_2_align_2" (i32.const 2)
+                                                     (v128.const i32x4 0 0 84148994 0))
+                                                     (i64.const 84148994))
+(assert_return (invoke "v128.store32_lane_2_align_4" (i32.const 2)
+                                                     (v128.const i32x4 0 0 84148994 0))
+                                                     (i64.const 84148994))
+(assert_return (invoke "v128.store32_lane_3_align_1" (i32.const 3)
+                                                     (v128.const i32x4 0 0 0 100992003))
+                                                     (i64.const 100992003))
+(assert_return (invoke "v128.store32_lane_3_align_2" (i32.const 3)
+                                                     (v128.const i32x4 0 0 0 100992003))
+                                                     (i64.const 100992003))
+(assert_return (invoke "v128.store32_lane_3_align_4" (i32.const 3)
+                                                     (v128.const i32x4 0 0 0 100992003))
+                                                     (i64.const 100992003))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store32_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store32_lane 4 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.store32_lane align=8 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/test/core/simd/simd_store64_lane.wast b/test/core/simd/simd_store64_lane.wast
new file mode 100644
index 000000000..2ed1dcd68
--- /dev/null
+++ b/test/core/simd/simd_store64_lane.wast
@@ -0,0 +1,131 @@
+;; Tests for store lane operations.
+
+
+(module
+  (memory 1)
+  (global $zero (mut v128) (v128.const i32x4 0 0 0 0))
+  (func (export "v128.store64_lane_0")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store64_lane_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store64_lane_0_offset_0")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane offset=0 0 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=0 (i32.const 0)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_1_offset_1")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane offset=1 1 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=1 (i32.const 0)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_0_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=1 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_0_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=2 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_0_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=4 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_0_align_8")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=8 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_1_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=1 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_1_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=2 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_1_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=4 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_1_align_8")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=8 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+)
+
+(assert_return (invoke "v128.store64_lane_0" (i32.const 0)
+                                             (v128.const i64x2 506097522914230528 0))
+                                             (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_1" (i32.const 1)
+                                             (v128.const i64x2 0 578437695752307201))
+                                             (i64.const 578437695752307201))
+(assert_return (invoke "v128.store64_lane_0_offset_0" (v128.const i64x2 506097522914230528 0))
+                                                      (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_1_offset_1" (v128.const i64x2 0 578437695752307201))
+                                                      (i64.const 578437695752307201))
+(assert_return (invoke "v128.store64_lane_0_align_1" (i32.const 0)
+                                                     (v128.const i64x2 506097522914230528 0))
+                                                     (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_0_align_2" (i32.const 0)
+                                                     (v128.const i64x2 506097522914230528 0))
+                                                     (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_0_align_4" (i32.const 0)
+                                                     (v128.const i64x2 506097522914230528 0))
+                                                     (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_0_align_8" (i32.const 0)
+                                                     (v128.const i64x2 506097522914230528 0))
+                                                     (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_1_align_1" (i32.const 1)
+                                                     (v128.const i64x2 0 578437695752307201))
+                                                     (i64.const 578437695752307201))
+(assert_return (invoke "v128.store64_lane_1_align_2" (i32.const 1)
+                                                     (v128.const i64x2 0 578437695752307201))
+                                                     (i64.const 578437695752307201))
+(assert_return (invoke "v128.store64_lane_1_align_4" (i32.const 1)
+                                                     (v128.const i64x2 0 578437695752307201))
+                                                     (i64.const 578437695752307201))
+(assert_return (invoke "v128.store64_lane_1_align_8" (i32.const 1)
+                                                     (v128.const i64x2 0 578437695752307201))
+                                                     (i64.const 578437695752307201))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store64_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store64_lane 2 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.store64_lane align=16 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/test/core/simd/simd_store8_lane.wast b/test/core/simd/simd_store8_lane.wast
new file mode 100644
index 000000000..b4e4a583f
--- /dev/null
+++ b/test/core/simd/simd_store8_lane.wast
@@ -0,0 +1,427 @@
+;; Tests for store lane operations.
+
+
+(module
+  (memory 1)
+  (global $zero (mut v128) (v128.const i32x4 0 0 0 0))
+  (func (export "v128.store8_lane_0")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_3")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 4 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_5")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 5 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_6")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 6 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_7")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 7 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_8")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 8 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_9")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 9 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_10")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 10 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_11")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 11 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_12")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 12 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_13")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 13 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_14")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 14 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_15")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 15 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_0_offset_0")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=0 0 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=0 (i32.const 0)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_1_offset_1")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=1 1 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=1 (i32.const 0)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_2_offset_2")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=2 2 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=2 (i32.const 0)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_3_offset_3")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=3 3 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=3 (i32.const 0)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_4_offset_4")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=4 4 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=4 (i32.const 0)))
+    (v128.store offset=4 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_5_offset_5")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=5 5 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=5 (i32.const 0)))
+    (v128.store offset=5 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_6_offset_6")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=6 6 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=6 (i32.const 0)))
+    (v128.store offset=6 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_7_offset_7")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=7 7 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=7 (i32.const 0)))
+    (v128.store offset=7 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_8_offset_8")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=8 8 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=8 (i32.const 0)))
+    (v128.store offset=8 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_9_offset_9")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=9 9 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=9 (i32.const 0)))
+    (v128.store offset=9 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_10_offset_10")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=10 10 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=10 (i32.const 0)))
+    (v128.store offset=10 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_11_offset_11")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=11 11 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=11 (i32.const 0)))
+    (v128.store offset=11 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_12_offset_12")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=12 12 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=12 (i32.const 0)))
+    (v128.store offset=12 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_13_offset_13")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=13 13 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=13 (i32.const 0)))
+    (v128.store offset=13 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_14_offset_14")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=14 14 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=14 (i32.const 0)))
+    (v128.store offset=14 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_15_offset_15")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=15 15 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=15 (i32.const 0)))
+    (v128.store offset=15 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_0_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_1_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_2_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_3_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_4_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 4 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=4 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_5_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 5 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=5 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_6_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 6 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=6 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_7_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 7 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=7 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_8_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 8 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=8 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_9_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 9 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=9 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_10_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 10 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=10 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_11_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 11 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=11 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_12_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 12 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=12 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_13_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 13 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=13 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_14_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 14 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=14 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_15_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 15 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=15 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+)
+
+(assert_return (invoke "v128.store8_lane_0" (i32.const 0)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 0))
+(assert_return (invoke "v128.store8_lane_1" (i32.const 1)
+                                            (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 1))
+(assert_return (invoke "v128.store8_lane_2" (i32.const 2)
+                                            (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 2))
+(assert_return (invoke "v128.store8_lane_3" (i32.const 3)
+                                            (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 3))
+(assert_return (invoke "v128.store8_lane_4" (i32.const 4)
+                                            (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 4))
+(assert_return (invoke "v128.store8_lane_5" (i32.const 5)
+                                            (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 5))
+(assert_return (invoke "v128.store8_lane_6" (i32.const 6)
+                                            (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 6))
+(assert_return (invoke "v128.store8_lane_7" (i32.const 7)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+                                            (i64.const 7))
+(assert_return (invoke "v128.store8_lane_8" (i32.const 8)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+                                            (i64.const 8))
+(assert_return (invoke "v128.store8_lane_9" (i32.const 9)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+                                            (i64.const 9))
+(assert_return (invoke "v128.store8_lane_10" (i32.const 10)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+                                             (i64.const 10))
+(assert_return (invoke "v128.store8_lane_11" (i32.const 11)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+                                             (i64.const 11))
+(assert_return (invoke "v128.store8_lane_12" (i32.const 12)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+                                             (i64.const 12))
+(assert_return (invoke "v128.store8_lane_13" (i32.const 13)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+                                             (i64.const 13))
+(assert_return (invoke "v128.store8_lane_14" (i32.const 14)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+                                             (i64.const 14))
+(assert_return (invoke "v128.store8_lane_15" (i32.const 15)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+                                             (i64.const 15))
+(assert_return (invoke "v128.store8_lane_0_offset_0" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 0))
+(assert_return (invoke "v128.store8_lane_1_offset_1" (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 1))
+(assert_return (invoke "v128.store8_lane_2_offset_2" (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 2))
+(assert_return (invoke "v128.store8_lane_3_offset_3" (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 3))
+(assert_return (invoke "v128.store8_lane_4_offset_4" (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 4))
+(assert_return (invoke "v128.store8_lane_5_offset_5" (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 5))
+(assert_return (invoke "v128.store8_lane_6_offset_6" (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 6))
+(assert_return (invoke "v128.store8_lane_7_offset_7" (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+                                                     (i64.const 7))
+(assert_return (invoke "v128.store8_lane_8_offset_8" (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+                                                     (i64.const 8))
+(assert_return (invoke "v128.store8_lane_9_offset_9" (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+                                                     (i64.const 9))
+(assert_return (invoke "v128.store8_lane_10_offset_10" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+                                                       (i64.const 10))
+(assert_return (invoke "v128.store8_lane_11_offset_11" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+                                                       (i64.const 11))
+(assert_return (invoke "v128.store8_lane_12_offset_12" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+                                                       (i64.const 12))
+(assert_return (invoke "v128.store8_lane_13_offset_13" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+                                                       (i64.const 13))
+(assert_return (invoke "v128.store8_lane_14_offset_14" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+                                                       (i64.const 14))
+(assert_return (invoke "v128.store8_lane_15_offset_15" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+                                                       (i64.const 15))
+(assert_return (invoke "v128.store8_lane_0_align_1" (i32.const 0)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 0))
+(assert_return (invoke "v128.store8_lane_1_align_1" (i32.const 1)
+                                                    (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 1))
+(assert_return (invoke "v128.store8_lane_2_align_1" (i32.const 2)
+                                                    (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 2))
+(assert_return (invoke "v128.store8_lane_3_align_1" (i32.const 3)
+                                                    (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 3))
+(assert_return (invoke "v128.store8_lane_4_align_1" (i32.const 4)
+                                                    (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 4))
+(assert_return (invoke "v128.store8_lane_5_align_1" (i32.const 5)
+                                                    (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 5))
+(assert_return (invoke "v128.store8_lane_6_align_1" (i32.const 6)
+                                                    (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 6))
+(assert_return (invoke "v128.store8_lane_7_align_1" (i32.const 7)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+                                                    (i64.const 7))
+(assert_return (invoke "v128.store8_lane_8_align_1" (i32.const 8)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+                                                    (i64.const 8))
+(assert_return (invoke "v128.store8_lane_9_align_1" (i32.const 9)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+                                                    (i64.const 9))
+(assert_return (invoke "v128.store8_lane_10_align_1" (i32.const 10)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+                                                     (i64.const 10))
+(assert_return (invoke "v128.store8_lane_11_align_1" (i32.const 11)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+                                                     (i64.const 11))
+(assert_return (invoke "v128.store8_lane_12_align_1" (i32.const 12)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+                                                     (i64.const 12))
+(assert_return (invoke "v128.store8_lane_13_align_1" (i32.const 13)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+                                                     (i64.const 13))
+(assert_return (invoke "v128.store8_lane_14_align_1" (i32.const 14)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+                                                     (i64.const 14))
+(assert_return (invoke "v128.store8_lane_15_align_1" (i32.const 15)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+                                                     (i64.const 15))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store8_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store8_lane 16 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.store8_lane align=2 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
diff --git a/test/js-api/global/constructor.any.js b/test/js-api/global/constructor.any.js
index f536f5d7b..7c2c02c79 100644
--- a/test/js-api/global/constructor.any.js
+++ b/test/js-api/global/constructor.any.js
@@ -164,3 +164,8 @@ test(() => {
   const global = new WebAssembly.Global(argument, 0, {});
   assert_Global(global, 0);
 }, "Stray argument");
+
+test(() => {
+  const argument = { "value": "v128" };
+  assert_throws_js(TypeError, () =>new WebAssembly.Global(argument));
+}, "Construct v128 global");

From 57e2b6e973cb893354f6ce2865fad291105b3a96 Mon Sep 17 00:00:00 2001
From: Ng Zhi An <zhin@google.com>
Date: Mon, 22 Nov 2021 08:43:24 -0800
Subject: [PATCH 074/285] Remove merge conflict marker

---
 document/js-api/index.bs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 6e3f888ca..1c6e2ce90 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -898,7 +898,6 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. If |s| equals "anyfunc", return [=funcref=].
     1. If |s| equals "externref", return [=externref=].
     1. Assert: This step is not reached.
->>>>>>> upstream/master
 </div>
 
 <div algorithm>

From 98493151c578434e82558001677d4fc947ba1129 Mon Sep 17 00:00:00 2001
From: Ng Zhi An <zhin@chromium.org>
Date: Mon, 22 Nov 2021 23:49:26 -0800
Subject: [PATCH 075/285] [spec] Handle v128 in validation algorithm (#1399)

---
 document/core/appendix/algorithm.rst | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/document/core/appendix/algorithm.rst b/document/core/appendix/algorithm.rst
index fa6fa1110..72c83ea56 100644
--- a/document/core/appendix/algorithm.rst
+++ b/document/core/appendix/algorithm.rst
@@ -28,7 +28,10 @@ Types are representable as an enumeration.
    type val_type = I32 | I64 | F32 | F64 | V128 | Funcref | Externref
 
    func is_num(t : val_type | Unknown) : bool =
-     return t = I32 || t = I64 || t = F32 || t = F64 || t = V128 || t = Unknown
+     return t = I32 || t = I64 || t = F32 || t = F64 || t = Unknown
+
+   func is_vec(t : val_type | Unknown) : bool =
+     return t = V128 || t = Unknown
 
    func is_ref(t : val_type | Unknown) : bool =
      return t = Funcref || t = Externref || t = Unknown
@@ -172,7 +175,7 @@ Other instructions are checked in a similar manner.
          pop_val(I32)
          let t1 = pop_val()
          let t2 = pop_val()
-         error_if(not (is_num(t1) && is_num(t2)))
+         error_if(not ((is_num(t1) && is_num(t2)) || (is_vec(t1) && is_vec(t2))))
          error_if(t1 =/= t2 && t1 =/= Unknown && t2 =/= Unknown)
          push_val(if (t1 = Unknown) t2 else t1)
 

From 2460ad02b51fb5ed5824f44de287a8638b19a5f8 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@dfinity.org>
Date: Thu, 2 Dec 2021 17:21:54 +0100
Subject: [PATCH 076/285] [spec] Fix instruction table (#1402)

---
 .../core/appendix/gen-index-instructions.py   | 28 +++++++------------
 document/core/appendix/index-instructions.rst | 28 +++++++------------
 2 files changed, 20 insertions(+), 36 deletions(-)

diff --git a/document/core/appendix/gen-index-instructions.py b/document/core/appendix/gen-index-instructions.py
index 9e8dbb8c3..477c7cf43 100755
--- a/document/core/appendix/gen-index-instructions.py
+++ b/document/core/appendix/gen-index-instructions.py
@@ -331,25 +331,17 @@ def Instruction(name, opcode, type=None, validation=None, execution=None, operat
     Instruction(r'\TABLEGROW~x', r'\hex{FC}~\hex{0F}', r'[t~\I32] \to [\I32]', r'valid-table.grow', r'exec-table.grow'),
     Instruction(r'\TABLESIZE~x', r'\hex{FC}~\hex{10}', r'[] \to [\I32]', r'valid-table.size', r'exec-table.size'),
     Instruction(r'\TABLEFILL~x', r'\hex{FC}~\hex{11}', r'[\I32~t~\I32] \to []', r'valid-table.fill', r'exec-table.fill'),
-    Instruction(r'\I32.\TRUNC\K{\_sat\_}\F32\K{\_s}', r'\hex{FC}~~0', r'[\F32] \to [\I32]', r'valid-cvtop', r'exec-cvtop', r'op-trunc_sat_s'),
-    Instruction(r'\I32.\TRUNC\K{\_sat\_}\F32\K{\_u}', r'\hex{FC}~~1', r'[\F32] \to [\I32]', r'valid-cvtop', r'exec-cvtop', r'op-trunc_sat_u'),
-    Instruction(r'\I32.\TRUNC\K{\_sat\_}\F64\K{\_s}', r'\hex{FC}~~2', r'[\F64] \to [\I32]', r'valid-cvtop', r'exec-cvtop', r'op-trunc_sat_s'),
-    Instruction(r'\I32.\TRUNC\K{\_sat\_}\F64\K{\_u}', r'\hex{FC}~~3', r'[\F64] \to [\I32]', r'valid-cvtop', r'exec-cvtop', r'op-trunc_sat_u'),
-    Instruction(r'\I64.\TRUNC\K{\_sat\_}\F32\K{\_s}', r'\hex{FC}~~4', r'[\F32] \to [\I64]', r'valid-cvtop', r'exec-cvtop', r'op-trunc_sat_s'),
-    Instruction(r'\I64.\TRUNC\K{\_sat\_}\F32\K{\_u}', r'\hex{FC}~~5', r'[\F32] \to [\I64]', r'valid-cvtop', r'exec-cvtop', r'op-trunc_sat_u'),
-    Instruction(r'\I64.\TRUNC\K{\_sat}\_\F64\K{\_s}', r'\hex{FC}~~6', r'[\F64] \to [\I64]', r'valid-cvtop', r'exec-cvtop', r'op-trunc_sat_s'),
-    Instruction(r'\I64.\TRUNC\K{\_sat\_}\F64\K{\_u}', r'\hex{FC}~~7', r'[\F64] \to [\I64]', r'valid-cvtop', r'exec-cvtop', r'op-trunc_sat_u'),
     Instruction(r'\V128.\LOAD~\memarg', r'\hex{FD}~~\hex{00}', r'[\I32] \to [\V128]', r'valid-load', r'exec-load'),
-    Instruction(r'\I16X8.\LOAD\K{8x8\_s}~\memarg', r'\hex{FD}~~\hex{01}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
-    Instruction(r'\I16X8.\LOAD\K{8x8\_u}~\memarg', r'\hex{FD}~~\hex{02}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
-    Instruction(r'\I32X4.\LOAD\K{16x4\_s}~\memarg', r'\hex{FD}~~\hex{03}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
-    Instruction(r'\I32X4.\LOAD\K{16x4\_u}~\memarg', r'\hex{FD}~~\hex{04}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
-    Instruction(r'\I64X2.\LOAD\K{32x2\_s}~\memarg', r'\hex{FD}~~\hex{05}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
-    Instruction(r'\I64X2.\LOAD\K{32x2\_u}~\memarg', r'\hex{FD}~~\hex{06}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
-    Instruction(r'\I8X16.\LOAD\K{\_splat}~\memarg', r'\hex{FD}~~\hex{07}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
-    Instruction(r'\I16X8.\LOAD\K{\_splat}~\memarg', r'\hex{FD}~~\hex{08}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
-    Instruction(r'\I32X4.\LOAD\K{\_splat}~\memarg', r'\hex{FD}~~\hex{09}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
-    Instruction(r'\I64X2.\LOAD\K{\_splat}~\memarg', r'\hex{FD}~~\hex{0A}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
+    Instruction(r'\V128.\LOAD\K{8x8\_s}~\memarg', r'\hex{FD}~~\hex{01}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
+    Instruction(r'\V128.\LOAD\K{8x8\_u}~\memarg', r'\hex{FD}~~\hex{02}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
+    Instruction(r'\V128.\LOAD\K{16x4\_s}~\memarg', r'\hex{FD}~~\hex{03}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
+    Instruction(r'\V128.\LOAD\K{16x4\_u}~\memarg', r'\hex{FD}~~\hex{04}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
+    Instruction(r'\V128.\LOAD\K{32x2\_s}~\memarg', r'\hex{FD}~~\hex{05}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
+    Instruction(r'\V128.\LOAD\K{32x2\_u}~\memarg', r'\hex{FD}~~\hex{06}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
+    Instruction(r'\V128.\LOAD\K{\_splat}~\memarg', r'\hex{FD}~~\hex{07}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
+    Instruction(r'\V128.\LOAD\K{\_splat}~\memarg', r'\hex{FD}~~\hex{08}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
+    Instruction(r'\V128.\LOAD\K{\_splat}~\memarg', r'\hex{FD}~~\hex{09}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
+    Instruction(r'\V128.\LOAD\K{\_splat}~\memarg', r'\hex{FD}~~\hex{0A}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
     Instruction(r'\V128.\STORE~\memarg', r'\hex{FD}~~\hex{0B}', r'[\I32~\V128] \to []', r'valid-store', r'exec-store'),
     Instruction(r'\V128.\VCONST~\i128', r'\hex{FD}~~\hex{0C}', r'[] \to [\V128]', r'valid-vconst', r'exec-vconst'),
     Instruction(r'\I8X16.\SHUFFLE~\laneidx^{16}', r'\hex{FD}~~\hex{0D}', r'[\V128~\V128] \to [\V128]', r'valid-vec-shuffle', r'exec-vec-shuffle'),
diff --git a/document/core/appendix/index-instructions.rst b/document/core/appendix/index-instructions.rst
index 0c43fe0f1..2a6e6f397 100644
--- a/document/core/appendix/index-instructions.rst
+++ b/document/core/appendix/index-instructions.rst
@@ -279,25 +279,17 @@ Instruction                                        Binary Opcode               T
 :math:`\TABLEGROW~x`                               :math:`\hex{FC}~\hex{0F}`   :math:`[t~\I32] \to [\I32]`                    :ref:`validation <valid-table.grow>`           :ref:`execution <exec-table.grow>`                                
 :math:`\TABLESIZE~x`                               :math:`\hex{FC}~\hex{10}`   :math:`[] \to [\I32]`                          :ref:`validation <valid-table.size>`           :ref:`execution <exec-table.size>`                                
 :math:`\TABLEFILL~x`                               :math:`\hex{FC}~\hex{11}`   :math:`[\I32~t~\I32] \to []`                   :ref:`validation <valid-table.fill>`           :ref:`execution <exec-table.fill>`                                
-:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_s}`          :math:`\hex{FC}~~0`         :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
-:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_u}`          :math:`\hex{FC}~~1`         :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
-:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_s}`          :math:`\hex{FC}~~2`         :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
-:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_u}`          :math:`\hex{FC}~~3`         :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
-:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_s}`          :math:`\hex{FC}~~4`         :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
-:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_u}`          :math:`\hex{FC}~~5`         :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
-:math:`\I64.\TRUNC\K{\_sat}\_\F64\K{\_s}`          :math:`\hex{FC}~~6`         :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
-:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_u}`          :math:`\hex{FC}~~7`         :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
 :math:`\V128.\LOAD~\memarg`                        :math:`\hex{FD}~~\hex{00}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
-:math:`\I16X8.\LOAD\K{8x8\_s}~\memarg`             :math:`\hex{FD}~~\hex{01}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
-:math:`\I16X8.\LOAD\K{8x8\_u}~\memarg`             :math:`\hex{FD}~~\hex{02}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
-:math:`\I32X4.\LOAD\K{16x4\_s}~\memarg`            :math:`\hex{FD}~~\hex{03}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
-:math:`\I32X4.\LOAD\K{16x4\_u}~\memarg`            :math:`\hex{FD}~~\hex{04}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
-:math:`\I64X2.\LOAD\K{32x2\_s}~\memarg`            :math:`\hex{FD}~~\hex{05}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
-:math:`\I64X2.\LOAD\K{32x2\_u}~\memarg`            :math:`\hex{FD}~~\hex{06}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
-:math:`\I8X16.\LOAD\K{\_splat}~\memarg`            :math:`\hex{FD}~~\hex{07}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
-:math:`\I16X8.\LOAD\K{\_splat}~\memarg`            :math:`\hex{FD}~~\hex{08}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
-:math:`\I32X4.\LOAD\K{\_splat}~\memarg`            :math:`\hex{FD}~~\hex{09}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
-:math:`\I64X2.\LOAD\K{\_splat}~\memarg`            :math:`\hex{FD}~~\hex{0A}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
+:math:`\V128.\LOAD\K{8x8\_s}~\memarg`              :math:`\hex{FD}~~\hex{01}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\V128.\LOAD\K{8x8\_u}~\memarg`              :math:`\hex{FD}~~\hex{02}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\V128.\LOAD\K{16x4\_s}~\memarg`             :math:`\hex{FD}~~\hex{03}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\V128.\LOAD\K{16x4\_u}~\memarg`             :math:`\hex{FD}~~\hex{04}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\V128.\LOAD\K{32x2\_s}~\memarg`             :math:`\hex{FD}~~\hex{05}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\V128.\LOAD\K{32x2\_u}~\memarg`             :math:`\hex{FD}~~\hex{06}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\V128.\LOAD\K{\_splat}~\memarg`             :math:`\hex{FD}~~\hex{07}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
+:math:`\V128.\LOAD\K{\_splat}~\memarg`             :math:`\hex{FD}~~\hex{08}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
+:math:`\V128.\LOAD\K{\_splat}~\memarg`             :math:`\hex{FD}~~\hex{09}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
+:math:`\V128.\LOAD\K{\_splat}~\memarg`             :math:`\hex{FD}~~\hex{0A}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
 :math:`\V128.\STORE~\memarg`                       :math:`\hex{FD}~~\hex{0B}`  :math:`[\I32~\V128] \to []`                    :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
 :math:`\V128.\VCONST~\i128`                        :math:`\hex{FD}~~\hex{0C}`  :math:`[] \to [\V128]`                         :ref:`validation <valid-vconst>`               :ref:`execution <exec-vconst>`                                    
 :math:`\I8X16.\SHUFFLE~\laneidx^{16}`              :math:`\hex{FD}~~\hex{0D}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-shuffle>`          :ref:`execution <exec-vec-shuffle>`                               

From db2602122f23d829c5c09c59b73a172312f8e4c1 Mon Sep 17 00:00:00 2001
From: Sam Clegg <sbc@chromium.org>
Date: Mon, 13 Dec 2021 10:00:15 -0800
Subject: [PATCH 077/285] Add tests for functions without end marker. NFC
 (#1405)

Inspired by this downstream test in wabt:
https://github.com/WebAssembly/wabt/pull/1775

Fixes: #1404
---
 test/core/binary.wast | 56 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

diff --git a/test/core/binary.wast b/test/core/binary.wast
index ebebd2ead..e80d3e20b 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -368,6 +368,62 @@
   "integer too large"
 )
 
+;; Function with missing end marker (between two functions)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section: 1 type
+    "\03\03\02\00\00"          ;; Function section: 2 functions
+    "\0a\0c\02"                ;; Code section: 2 functions
+    ;; function 0
+    "\04\00"                   ;; Function size and local type count
+    "\41\01"                   ;; i32.const 1
+    "\1a"                      ;; drop
+    ;; Missing end marker here
+    ;; function 1
+    "\05\00"                   ;; Function size and local type count
+    "\41\01"                   ;; i32.const 1
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "END opcode expected"
+)
+
+;; Function with missing end marker (at EOF)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section: 1 type
+    "\03\02\01\00"             ;; Function section: 1 function
+    "\0a\06\01"                ;; Code section: 1 function
+    ;; function 0
+    "\04\00"                   ;; Function size and local type count
+    "\41\01"                   ;; i32.const 1
+    "\1a"                      ;; drop
+    ;; Missing end marker here
+  )
+  "unexpected end of section or function"
+)
+
+;; Function with missing end marker (at end of code sections)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section: 1 type
+    "\03\02\01\00"             ;; Function section: 1 function
+    "\0a\06\01"                ;; Code section: 1 function
+    ;; function 0
+    "\04\00"                   ;; Function size and local type count
+    "\41\01"                   ;; i32.const 1
+    "\1a"                      ;; drop
+    ;; Missing end marker here
+    "\0b\03\01\01\00"          ;; Data section
+  )
+  ;; The spec interpreter consumes the `\0b` (data section start) as an
+  ;; END instruction (also happens to be `\0b`) and reports the code section as
+  ;; being larger than declared.
+  "section size mismatch"
+)
 
 ;; Unsigned LEB128 must not be overlong
 (assert_malformed

From 9c0d7457c88d960975aa0d3a16dfee597659293a Mon Sep 17 00:00:00 2001
From: Thomas Lively <7121787+tlively@users.noreply.github.com>
Date: Wed, 15 Dec 2021 07:44:45 -0800
Subject: [PATCH 078/285] Describe correct tail call behavior across modules

Whether tail calls across module boundaries would guarantee tail call behavior was previously an open question, but @thibaudmichaud confirmed that they would guarantee tail call behavior in V8 in https://github.com/WebAssembly/tail-call/issues/15#issuecomment-994821853.
---
 proposals/tail-call/Overview.md | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/proposals/tail-call/Overview.md b/proposals/tail-call/Overview.md
index 81753693c..ce08d1abc 100644
--- a/proposals/tail-call/Overview.md
+++ b/proposals/tail-call/Overview.md
@@ -46,6 +46,8 @@ This can be applied to any form of call, that is:
 
 * Tail calls to host functions cannot guarantee tail behaviour (outside the scope of the spec)
 
+* Tail calls across WebAssembly module boundaries *do* guarantee tail behavior
+
 
 ### Typing
 
@@ -141,8 +143,3 @@ Use the reserved opcodes after existing call instructions, i.e.:
 ### Text Format
 
 The text format is extended with two new instructions in the obvious manner.
-
-
-## Open Questions
-
-* Can tail calls across module boundaries guarantee tail behaviour?

From ffb5e3b40db7a45237d4e2fc972c1552ac4abef5 Mon Sep 17 00:00:00 2001
From: Gabor Greif <ggreif@gmail.com>
Date: Sat, 18 Dec 2021 09:00:25 +0100
Subject: [PATCH 079/285] [interpreter] Fix a typo in README (#1406)

---
 interpreter/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interpreter/README.md b/interpreter/README.md
index 63900136b..6f55c1f3f 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -449,7 +449,7 @@ When running scripts, the interpreter predefines a simple host module named `"sp
   (func (export "print_f64_f64") (param f64 f64))
 )
 ```
-The `print` functions are assumes to print their respective argument values to stdout (followed by a newline) and can be used to produce observable output.
+The `print` functions are assumed to print their respective argument values to stdout (followed by a newline) and can be used to produce observable output.
 
 Note: This module predates the `register` command and should no longer be needed for new tests.
 We might remove it in the future, so consider it deprecated.

From 63881c277f3f057ac427f44277cae481f0e4f182 Mon Sep 17 00:00:00 2001
From: Thomas Lively <7121787+tlively@users.noreply.github.com>
Date: Mon, 17 Jan 2022 21:06:53 -0800
Subject: [PATCH 080/285] Add a link to the proposals repo (#1409)

Fixes #1407.
---
 proposals/README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/proposals/README.md b/proposals/README.md
index 364b7ab4d..170c15123 100644
--- a/proposals/README.md
+++ b/proposals/README.md
@@ -1,3 +1,4 @@
 # Proposals
 
-This directory contains overviews for post-MVP proposals that are included in this repository.
+This directory contains overviews for post-MVP proposals that have been finished and merged into the spec.
+Proposals that are not yet finished can be found at https://github.com/WebAssembly/proposals.

From f2086a49a9a6f5738294df8bed074c3e8772c7b7 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@dfinity.org>
Date: Fri, 28 Jan 2022 08:35:45 +0100
Subject: [PATCH 081/285] [spec] Add note regarding parameter names (#1412)

---
 document/core/text/types.rst | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/document/core/text/types.rst b/document/core/text/types.rst
index 5e63b7c9c..7705cc575 100644
--- a/document/core/text/types.rst
+++ b/document/core/text/types.rst
@@ -93,6 +93,10 @@ Function Types
        &\Rightarrow& t \\
    \end{array}
 
+.. note::
+   The optional identifier names for parameters in a function type only have documentation purpose.
+   They cannot be referenced from anywhere.
+
 
 Abbreviations
 .............

From 76a7090bde6b6419e649c31b8996eed96bb66676 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Fri, 4 Feb 2022 08:02:46 +0100
Subject: [PATCH 082/285] Comments WIP

---
 document/core/appendix/properties.rst | 13 +++++++++----
 document/core/exec/modules.rst        |  8 ++++----
 2 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index 80ca1d341..a38d2e4b4 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -56,11 +56,11 @@ Results
 :ref:`Results <syntax-result>` :math:`\TRAP`
 ............................................
 
-* The result is valid with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`, for any sequence :math:`t^\ast` of :ref:`valid <valid-valtype>` :ref:`semantic <syntax-typeid>` :ref:`value types <syntax-valtype>`.
+* The result is valid with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`, for any :ref:`valid <valid-resulttype>` :ref:`semantic <syntax-typeid>` :ref:`result types <syntax-resulttype>`.
 
 .. math::
    \frac{
-     (S \vdashvaltype t \ok)^\ast
+     S \vdashresulttype [t^\ast] \ok
    }{
      S \vdashresult \TRAP : [t^\ast]
    }
@@ -538,10 +538,13 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
 :math:`\TRAP`
 .............
 
-* The instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
+* The instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`, for any sequences of :ref:`valid <valid-valtype>` :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
 .. math::
    \frac{
+     (S \vdashvaltype t_1 \ok)^\ast
+     \qquad
+     (S \vdashvaltype t_2 \ok)^\ast
    }{
      S; C \vdashadmininstr \TRAP : [t_1^\ast] \to [t_2^\ast]
    }
@@ -624,13 +627,15 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
 :math:`\FRAME_n\{F\}~\instr^\ast~\END`
 ...........................................
 
-* Under the return type :math:`[t^n]`,
+* Under the :ref:`valid <valid-resulttype>` return type :math:`[t^n]`,
   the :ref:`thread <syntax-frame>` :math:`F; \instr^\ast` must be :ref:`valid <valid-frame>` with :ref:`result type <syntax-resulttype>` :math:`[t^n]`.
 
 * Then the compound instruction is valid with type :math:`[] \to [t^n]`.
 
 .. math::
    \frac{
+     S \vdashresulttype [t^n] \ok
+     \qquad
      S; [t^n] \vdashinstrseq F; \instr^\ast : [t^n]
    }{
      S; C \vdashadmininstr \FRAME_n\{F\}~\instr^\ast~\END : [] \to [t^n]
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index 0892a0348..b7fdc2805 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -168,9 +168,9 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 
 2. Let :math:`a` be the first free :ref:`type address <syntax-typeaddr>` in :math:`S`.
 
-3. Assert: due to :ref:`validation <valid-module>`, any :ref:`type index <syntax-typeidx>` occurring in :math:`\functype` is smaller than the length of :math:`\moduleinst.MITYPES`.
+3. Assert: due to :ref:`validation <valid-module>`, any :ref:`type index <syntax-typeidx>` occurring in :math:`\functype` is smaller than the length of :math:`\moduleinst.\MITYPES`.
 
-4. Let :math:`\typeinst` be the :ref:`type instance <syntax-typeinst>` obtained from :math:`\functype` by substituting each :ref:`type index <syntax-typeidx>` :math:`x` occurring in it with the :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.MITYPES[x]`.
+4. Let :math:`\typeinst` be the :ref:`type instance <syntax-typeinst>` obtained from :math:`\functype` by substituting each :ref:`type index <syntax-typeidx>` :math:`x` occurring in it with the :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.\MITYPES[x]`.
 
 5. Append :math:`\typeinst` to the |STYPES| of :math:`S`.
 
@@ -201,7 +201,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 
 4. Let :math:`\functype` be the :ref:`function type <syntax-functype>` :math:`S.\STYPES[\typeaddr]`.
 
-5. Let :math:`\functype'` be the :ref:`function type <syntax-functype>` obtained from :math:`\functype` by substituting each :ref:`type index <syntax-typeidx>` :math:`x` occurring in it with the :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.MITYPES[x]`.
+5. Let :math:`\functype'` be the :ref:`function type <syntax-functype>` obtained from :math:`\functype` by substituting each :ref:`type index <syntax-typeidx>` :math:`x` occurring in it with the :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.\MITYPES[x]`.
 
 6. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`\{ \FITYPE~\functype', \FIMODULE~\moduleinst, \FICODE~\func \}`.
 
@@ -262,7 +262,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 
 2. Let :math:`(\{\LMIN~n, \LMAX~m^?\}~\reftype)` be the structure of :ref:`table type <syntax-tabletype>` :math:`\tabletype`.
 
-3. Let :math:`\tabletype'` be the :ref:`table type <syntax-tabletype>` obtained from :math:`\tabletype` by substituting each :ref:`type index <syntax-typeidx>` :math:`x` occurring in it with the :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.MITYPES[x]`.
+3. Let :math:`\tabletype'` be the :ref:`table type <syntax-tabletype>` obtained from :math:`\tabletype` by substituting each :ref:`type index <syntax-typeidx>` :math:`x` occurring in it with the :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.\MITYPES[x]`.
 
 4. Let :math:`a` be the first free :ref:`table address <syntax-tableaddr>` in :math:`S`.
 

From e75f3b2df98e11a42b7117385206258a06871a9d Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@dfinity.org>
Date: Fri, 4 Feb 2022 12:33:17 +0100
Subject: [PATCH 083/285] Merge upstream (#55)

---
 .github/workflows/main.yml                    |    26 +-
 .github/workflows/mirror.yml                  |    17 +
 Contributing.md                               |     2 +-
 document/README.md                            |     2 +-
 document/core/appendix/algorithm.rst          |    83 +-
 document/core/appendix/changes.rst            |    47 +-
 .../core/appendix/gen-index-instructions.py   |   240 +-
 document/core/appendix/index-instructions.rst |   784 +-
 document/core/appendix/index-types.rst        |     3 +-
 document/core/binary/conventions.rst          |     6 +-
 document/core/binary/instructions.rst         |   377 +
 document/core/binary/types.rst                |    16 +
 document/core/conf.py                         |    18 +-
 document/core/exec/instructions.rst           |   997 +-
 document/core/exec/modules.rst                |    16 +-
 document/core/exec/numerics.rst               |   379 +-
 document/core/exec/runtime.rst                |     9 +-
 document/core/index.rst                       |     6 +-
 document/core/intro/overview.rst              |    16 +-
 document/core/syntax/instructions.rst         |   256 +-
 document/core/syntax/types.rst                |    38 +-
 document/core/syntax/values.rst               |    13 +-
 document/core/text/conventions.rst            |     6 +-
 document/core/text/instructions.rst           |   357 +
 document/core/text/types.rst                  |    21 +-
 document/core/util/bikeshed/conf.py           |   475 +-
 document/core/util/katex                      |     2 +-
 document/core/util/macros.def                 |   125 +
 document/core/util/mathjax2katex.py           |    15 +-
 document/core/valid/instructions.rst          |   459 +-
 document/core/valid/types.rst                 |    17 +
 document/deploy.sh                            |     2 +-
 document/js-api/index.bs                      |    24 +-
 interpreter/Makefile                          |    32 +-
 interpreter/README.md                         |    67 +-
 interpreter/binary/decode.ml                  |   288 +-
 interpreter/binary/encode.ml                  |   360 +-
 interpreter/exec/eval.ml                      |   160 +-
 .../exec/{eval_numeric.ml => eval_num.ml}     |    42 +-
 .../exec/{eval_numeric.mli => eval_num.mli}   |     2 -
 interpreter/exec/eval_vec.ml                  |   314 +
 interpreter/exec/eval_vec.mli                 |    16 +
 interpreter/exec/i16.ml                       |    12 +
 interpreter/exec/i32.ml                       |     3 +
 interpreter/exec/i32_convert.ml               |    16 +-
 interpreter/exec/i64.ml                       |     3 +
 interpreter/exec/i64_convert.ml               |    16 +-
 interpreter/exec/i8.ml                        |    12 +
 interpreter/exec/ixx.ml                       |   158 +-
 interpreter/exec/numeric_error.ml             |     3 -
 interpreter/exec/v128.ml                      |   506 +
 interpreter/exec/v128.mli                     |   211 +
 interpreter/host/spectest.ml                  |     1 +
 interpreter/runtime/instance.ml               |     7 +
 interpreter/runtime/memory.ml                 |    56 +-
 interpreter/runtime/memory.mli                |    13 +-
 interpreter/runtime/value.ml                  |   111 +-
 interpreter/script/js.ml                      |   155 +-
 interpreter/script/run.ml                     |   120 +-
 interpreter/script/script.ml                  |    28 +-
 interpreter/syntax/ast.ml                     |    96 +-
 interpreter/syntax/free.ml                    |    13 +-
 interpreter/syntax/operators.ml               |   315 +-
 interpreter/syntax/types.ml                   |    40 +-
 interpreter/tests/smallint.ml                 |   108 +
 interpreter/text/arrange.ml                   |   327 +-
 interpreter/text/lexer.mll                    |   297 +-
 interpreter/text/parser.mly                   |   139 +-
 interpreter/util/lib.ml                       |     7 +-
 interpreter/util/lib.mli                      |     3 +-
 interpreter/valid/match.ml                    |     8 +
 interpreter/valid/valid.ml                    |   171 +-
 proposals/README.md                           |     3 +-
 proposals/multi-value/Overview.md             |     2 +-
 .../Overview.md                               |     4 +-
 proposals/reference-types/Overview.md         |     4 +-
 proposals/sign-extension-ops/Overview.md      |     2 +-
 proposals/simd/BinarySIMD.md                  |   270 +
 proposals/simd/ImplementationStatus.md        |   248 +
 proposals/simd/NewOpcodes.md                  |   157 +
 proposals/simd/SIMD.md                        |  1178 ++
 proposals/simd/TextSIMD.md                    |    27 +
 proposals/simd/W3CTAG-SIMDExplainer.md        |    72 +
 proposals/simd/WebAssembly-SIMD-May-2017.pdf  |   Bin 0 -> 128301 bytes
 test/Todo.md                                  |     2 +-
 test/core/README.md                           |     4 +-
 test/core/binary.wast                         |    66 +-
 test/core/comments.wast                       |   Bin 701 -> 772 bytes
 test/core/f32.wast                            |    10 +
 test/core/f64.wast                            |    10 +
 test/core/i32.wast                            |     9 +
 test/core/i64.wast                            |     9 +
 test/core/memory_trap.wast                    |    14 +-
 test/core/run.py                              |     7 +-
 test/core/select.wast                         |     3 +
 test/core/simd/meta/README.md                 |    55 +
 test/core/simd/meta/gen_tests.py              |    77 +
 test/core/simd/meta/simd.py                   |    84 +
 test/core/simd/meta/simd_arithmetic.py        |   328 +
 test/core/simd/meta/simd_bitwise.py           |   502 +
 test/core/simd/meta/simd_compare.py           |   412 +
 test/core/simd/meta/simd_ext_mul.py           |    75 +
 test/core/simd/meta/simd_extadd_pairwise.py   |    62 +
 test/core/simd/meta/simd_f32x4.py             |   376 +
 test/core/simd/meta/simd_f32x4_arith.py       |   229 +
 test/core/simd/meta/simd_f32x4_cmp.py         |   507 +
 test/core/simd/meta/simd_f32x4_pmin_pmax.py   |    83 +
 test/core/simd/meta/simd_f32x4_rounding.py    |    85 +
 test/core/simd/meta/simd_f64x2.py             |   395 +
 test/core/simd/meta/simd_f64x2_arith.py       |   165 +
 test/core/simd/meta/simd_f64x2_cmp.py         |   220 +
 test/core/simd/meta/simd_f64x2_pmin_pmax.py   |    27 +
 test/core/simd/meta/simd_f64x2_rounding.py    |    29 +
 test/core/simd/meta/simd_float_op.py          |   303 +
 test/core/simd/meta/simd_i16x8_arith.py       |   176 +
 test/core/simd/meta/simd_i16x8_cmp.py         |   825 ++
 .../simd/meta/simd_i16x8_q15mulr_sat_s.py     |    36 +
 test/core/simd/meta/simd_i32x4_arith.py       |   176 +
 test/core/simd/meta/simd_i32x4_cmp.py         |   837 ++
 test/core/simd/meta/simd_i32x4_dot_i16x8.py   |    56 +
 test/core/simd/meta/simd_i64x2_arith.py       |   201 +
 test/core/simd/meta/simd_i64x2_cmp.py         |   252 +
 test/core/simd/meta/simd_i8x16_arith.py       |   148 +
 test/core/simd/meta/simd_i8x16_cmp.py         |   825 ++
 test/core/simd/meta/simd_int_arith2.py        |   575 +
 test/core/simd/meta/simd_int_to_int_extend.py |   113 +
 .../simd/meta/simd_int_trunc_sat_float.py     |   178 +
 test/core/simd/meta/simd_integer_op.py        |   209 +
 test/core/simd/meta/simd_lane_value.py        |    38 +
 test/core/simd/meta/simd_load_lane.py         |   227 +
 test/core/simd/meta/simd_sat_arith.py         |   456 +
 test/core/simd/meta/simd_store_lane.py        |   237 +
 test/core/simd/meta/test_assert.py            |    91 +
 test/core/simd/simd_address.wast              |   157 +
 test/core/simd/simd_align.wast                |   355 +
 test/core/simd/simd_bit_shift.wast            |  1104 ++
 test/core/simd/simd_bitwise.wast              |   812 ++
 test/core/simd/simd_boolean.wast              |  1058 ++
 test/core/simd/simd_const.wast                |  1664 +++
 test/core/simd/simd_conversions.wast          |   899 ++
 test/core/simd/simd_f32x4.wast                |  2407 ++++
 test/core/simd/simd_f32x4_arith.wast          |  5476 ++++++++
 test/core/simd/simd_f32x4_cmp.wast            |  8167 +++++++++++
 test/core/simd/simd_f32x4_pmin_pmax.wast      | 11676 ++++++++++++++++
 test/core/simd/simd_f32x4_rounding.wast       |   424 +
 test/core/simd/simd_f64x2.wast                |  2459 ++++
 test/core/simd/simd_f64x2_arith.wast          |  5483 ++++++++
 test/core/simd/simd_f64x2_cmp.wast            |  8337 +++++++++++
 test/core/simd/simd_f64x2_pmin_pmax.wast      | 11676 ++++++++++++++++
 test/core/simd/simd_f64x2_rounding.wast       |   424 +
 test/core/simd/simd_i16x8_arith.wast          |   634 +
 test/core/simd/simd_i16x8_arith2.wast         |   610 +
 test/core/simd/simd_i16x8_cmp.wast            |  1901 +++
 .../simd_i16x8_extadd_pairwise_i8x16.wast     |    68 +
 test/core/simd/simd_i16x8_extmul_i8x16.wast   |   404 +
 test/core/simd/simd_i16x8_q15mulr_sat_s.wast  |   110 +
 test/core/simd/simd_i16x8_sat_arith.wast      |   742 +
 test/core/simd/simd_i32x4_arith.wast          |   634 +
 test/core/simd/simd_i32x4_arith2.wast         |   494 +
 test/core/simd/simd_i32x4_cmp.wast            |  1920 +++
 test/core/simd/simd_i32x4_dot_i16x8.wast      |   110 +
 .../simd_i32x4_extadd_pairwise_i16x8.wast     |    68 +
 test/core/simd/simd_i32x4_extmul_i16x8.wast   |   404 +
 .../core/simd/simd_i32x4_trunc_sat_f32x4.wast |   239 +
 .../core/simd/simd_i32x4_trunc_sat_f64x2.wast |   239 +
 test/core/simd/simd_i64x2_arith.wast          |   652 +
 test/core/simd/simd_i64x2_arith2.wast         |    78 +
 test/core/simd/simd_i64x2_cmp.wast            |   420 +
 test/core/simd/simd_i64x2_extmul_i32x4.wast   |   404 +
 test/core/simd/simd_i8x16_arith.wast          |   426 +
 test/core/simd/simd_i8x16_arith2.wast         |   713 +
 test/core/simd/simd_i8x16_cmp.wast            |  1847 +++
 test/core/simd/simd_i8x16_sat_arith.wast      |   718 +
 test/core/simd/simd_int_to_int_extend.wast    |   599 +
 test/core/simd/simd_lane.wast                 |  1265 ++
 test/core/simd/simd_load.wast                 |   188 +
 test/core/simd/simd_load16_lane.wast          |   211 +
 test/core/simd/simd_load32_lane.wast          |   143 +
 test/core/simd/simd_load64_lane.wast          |    97 +
 test/core/simd/simd_load8_lane.wast           |   299 +
 test/core/simd/simd_load_extend.wast          |   384 +
 test/core/simd/simd_load_splat.wast           |   261 +
 test/core/simd/simd_load_zero.wast            |   154 +
 test/core/simd/simd_splat.wast                |   430 +
 test/core/simd/simd_store.wast                |   166 +
 test/core/simd/simd_store16_lane.wast         |   299 +
 test/core/simd/simd_store32_lane.wast         |   199 +
 test/core/simd/simd_store64_lane.wast         |   131 +
 test/core/simd/simd_store8_lane.wast          |   427 +
 test/core/type.wast                           |     2 +-
 test/js-api/assertions.js                     |     9 +-
 test/js-api/constructor/toStringTag.any.js    |    42 +
 test/js-api/functions/helper.js               |    12 +
 test/js-api/global/constructor.any.js         |     5 +
 test/js-api/instanceTestFactory.js            |   128 +
 test/js-api/memory/constructor.any.js         |    11 +-
 test/js-api/module/exports.any.js             |    54 +
 test/js-api/module/imports.any.js             |    60 +
 test/js-api/table/assertions.js               |    11 +
 test/js-api/table/constructor.any.js          |    51 +-
 test/js-api/table/get-set.any.js              |    40 +-
 test/js-api/table/grow.any.js                 |    30 +
 test/js-api/wasm-module-builder.js            |    16 +-
 203 files changed, 101671 insertions(+), 1327 deletions(-)
 create mode 100644 .github/workflows/mirror.yml
 rename interpreter/exec/{eval_numeric.ml => eval_num.ml} (88%)
 rename interpreter/exec/{eval_numeric.mli => eval_num.mli} (82%)
 create mode 100644 interpreter/exec/eval_vec.ml
 create mode 100644 interpreter/exec/eval_vec.mli
 create mode 100644 interpreter/exec/i16.ml
 create mode 100644 interpreter/exec/i8.ml
 delete mode 100644 interpreter/exec/numeric_error.ml
 create mode 100644 interpreter/exec/v128.ml
 create mode 100644 interpreter/exec/v128.mli
 create mode 100644 interpreter/tests/smallint.ml
 create mode 100644 proposals/simd/BinarySIMD.md
 create mode 100644 proposals/simd/ImplementationStatus.md
 create mode 100644 proposals/simd/NewOpcodes.md
 create mode 100644 proposals/simd/SIMD.md
 create mode 100644 proposals/simd/TextSIMD.md
 create mode 100644 proposals/simd/W3CTAG-SIMDExplainer.md
 create mode 100644 proposals/simd/WebAssembly-SIMD-May-2017.pdf
 create mode 100644 test/core/simd/meta/README.md
 create mode 100644 test/core/simd/meta/gen_tests.py
 create mode 100644 test/core/simd/meta/simd.py
 create mode 100644 test/core/simd/meta/simd_arithmetic.py
 create mode 100644 test/core/simd/meta/simd_bitwise.py
 create mode 100644 test/core/simd/meta/simd_compare.py
 create mode 100644 test/core/simd/meta/simd_ext_mul.py
 create mode 100644 test/core/simd/meta/simd_extadd_pairwise.py
 create mode 100644 test/core/simd/meta/simd_f32x4.py
 create mode 100644 test/core/simd/meta/simd_f32x4_arith.py
 create mode 100644 test/core/simd/meta/simd_f32x4_cmp.py
 create mode 100644 test/core/simd/meta/simd_f32x4_pmin_pmax.py
 create mode 100644 test/core/simd/meta/simd_f32x4_rounding.py
 create mode 100644 test/core/simd/meta/simd_f64x2.py
 create mode 100644 test/core/simd/meta/simd_f64x2_arith.py
 create mode 100644 test/core/simd/meta/simd_f64x2_cmp.py
 create mode 100644 test/core/simd/meta/simd_f64x2_pmin_pmax.py
 create mode 100644 test/core/simd/meta/simd_f64x2_rounding.py
 create mode 100644 test/core/simd/meta/simd_float_op.py
 create mode 100644 test/core/simd/meta/simd_i16x8_arith.py
 create mode 100644 test/core/simd/meta/simd_i16x8_cmp.py
 create mode 100644 test/core/simd/meta/simd_i16x8_q15mulr_sat_s.py
 create mode 100644 test/core/simd/meta/simd_i32x4_arith.py
 create mode 100644 test/core/simd/meta/simd_i32x4_cmp.py
 create mode 100644 test/core/simd/meta/simd_i32x4_dot_i16x8.py
 create mode 100644 test/core/simd/meta/simd_i64x2_arith.py
 create mode 100644 test/core/simd/meta/simd_i64x2_cmp.py
 create mode 100644 test/core/simd/meta/simd_i8x16_arith.py
 create mode 100644 test/core/simd/meta/simd_i8x16_cmp.py
 create mode 100644 test/core/simd/meta/simd_int_arith2.py
 create mode 100644 test/core/simd/meta/simd_int_to_int_extend.py
 create mode 100644 test/core/simd/meta/simd_int_trunc_sat_float.py
 create mode 100644 test/core/simd/meta/simd_integer_op.py
 create mode 100644 test/core/simd/meta/simd_lane_value.py
 create mode 100644 test/core/simd/meta/simd_load_lane.py
 create mode 100644 test/core/simd/meta/simd_sat_arith.py
 create mode 100644 test/core/simd/meta/simd_store_lane.py
 create mode 100644 test/core/simd/meta/test_assert.py
 create mode 100644 test/core/simd/simd_address.wast
 create mode 100644 test/core/simd/simd_align.wast
 create mode 100644 test/core/simd/simd_bit_shift.wast
 create mode 100644 test/core/simd/simd_bitwise.wast
 create mode 100644 test/core/simd/simd_boolean.wast
 create mode 100644 test/core/simd/simd_const.wast
 create mode 100644 test/core/simd/simd_conversions.wast
 create mode 100644 test/core/simd/simd_f32x4.wast
 create mode 100644 test/core/simd/simd_f32x4_arith.wast
 create mode 100644 test/core/simd/simd_f32x4_cmp.wast
 create mode 100644 test/core/simd/simd_f32x4_pmin_pmax.wast
 create mode 100644 test/core/simd/simd_f32x4_rounding.wast
 create mode 100644 test/core/simd/simd_f64x2.wast
 create mode 100644 test/core/simd/simd_f64x2_arith.wast
 create mode 100644 test/core/simd/simd_f64x2_cmp.wast
 create mode 100644 test/core/simd/simd_f64x2_pmin_pmax.wast
 create mode 100644 test/core/simd/simd_f64x2_rounding.wast
 create mode 100644 test/core/simd/simd_i16x8_arith.wast
 create mode 100644 test/core/simd/simd_i16x8_arith2.wast
 create mode 100644 test/core/simd/simd_i16x8_cmp.wast
 create mode 100644 test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast
 create mode 100644 test/core/simd/simd_i16x8_extmul_i8x16.wast
 create mode 100644 test/core/simd/simd_i16x8_q15mulr_sat_s.wast
 create mode 100644 test/core/simd/simd_i16x8_sat_arith.wast
 create mode 100644 test/core/simd/simd_i32x4_arith.wast
 create mode 100644 test/core/simd/simd_i32x4_arith2.wast
 create mode 100644 test/core/simd/simd_i32x4_cmp.wast
 create mode 100644 test/core/simd/simd_i32x4_dot_i16x8.wast
 create mode 100644 test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast
 create mode 100644 test/core/simd/simd_i32x4_extmul_i16x8.wast
 create mode 100644 test/core/simd/simd_i32x4_trunc_sat_f32x4.wast
 create mode 100644 test/core/simd/simd_i32x4_trunc_sat_f64x2.wast
 create mode 100644 test/core/simd/simd_i64x2_arith.wast
 create mode 100644 test/core/simd/simd_i64x2_arith2.wast
 create mode 100644 test/core/simd/simd_i64x2_cmp.wast
 create mode 100644 test/core/simd/simd_i64x2_extmul_i32x4.wast
 create mode 100644 test/core/simd/simd_i8x16_arith.wast
 create mode 100644 test/core/simd/simd_i8x16_arith2.wast
 create mode 100644 test/core/simd/simd_i8x16_cmp.wast
 create mode 100644 test/core/simd/simd_i8x16_sat_arith.wast
 create mode 100644 test/core/simd/simd_int_to_int_extend.wast
 create mode 100644 test/core/simd/simd_lane.wast
 create mode 100644 test/core/simd/simd_load.wast
 create mode 100644 test/core/simd/simd_load16_lane.wast
 create mode 100644 test/core/simd/simd_load32_lane.wast
 create mode 100644 test/core/simd/simd_load64_lane.wast
 create mode 100644 test/core/simd/simd_load8_lane.wast
 create mode 100644 test/core/simd/simd_load_extend.wast
 create mode 100644 test/core/simd/simd_load_splat.wast
 create mode 100644 test/core/simd/simd_load_zero.wast
 create mode 100644 test/core/simd/simd_splat.wast
 create mode 100644 test/core/simd/simd_store.wast
 create mode 100644 test/core/simd/simd_store16_lane.wast
 create mode 100644 test/core/simd/simd_store32_lane.wast
 create mode 100644 test/core/simd/simd_store64_lane.wast
 create mode 100644 test/core/simd/simd_store8_lane.wast
 create mode 100644 test/js-api/constructor/toStringTag.any.js
 create mode 100644 test/js-api/functions/helper.js

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 1386b4c67..4a5527ca2 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -2,9 +2,9 @@ name: CI
 
 on:
   push:
-    branches: [ master ]
+    branches: [ main ]
   pull_request:
-    branches: [ master ]
+    branches: [ main ]
 
   # Allows you to run this workflow manually from the Actions tab
   workflow_dispatch:
@@ -25,29 +25,23 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - name: Build JS API bikeshed
-        uses: netwerk-digitaal-erfgoed/bikeshed-action@v1
-        with:
-          source: "document/js-api/index.bs"
-          destination: "document/js-api/index.html"
+      - run: pip install bikeshed && bikeshed update
+      - run: bikeshed spec "document/js-api/index.bs" "document/js-api/index.html"
       - uses: actions/upload-artifact@v2
         with:
           name: js-api-rendered
-          path: document/js-api
+          path: document/js-api/index.html
 
   build-web-api-spec:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - name: Build JS API bikeshed
-        uses: netwerk-digitaal-erfgoed/bikeshed-action@v1
-        with:
-          source: "document/web-api/index.bs"
-          destination: "document/web-api/index.html"
+      - run: pip install bikeshed && bikeshed update
+      - run: bikeshed spec "document/web-api/index.bs" "document/web-api/index.html"
       - uses: actions/upload-artifact@v2
         with:
           name: web-api-rendered
-          path: document/web-api
+          path: document/web-api/index.html
 
   build-core-spec:
     runs-on: ubuntu-latest
@@ -58,7 +52,7 @@ jobs:
       - run: pip install bikeshed && bikeshed update
       - run: pip install six
       - run: sudo apt-get update -y && sudo apt-get install -y latexmk texlive-latex-recommended texlive-latex-extra texlive-fonts-recommended
-      - run: pip install sphinx==3.5.2
+      - run: pip install sphinx==4.0.0
       - run: cd document/core && make all
       - uses: actions/upload-artifact@v2
         with:
@@ -84,7 +78,7 @@ jobs:
           name: core-api-rendered
           path: _output/core
       - name: Publish HTML to GitHub Pages
-        if: github.ref == 'refs/heads/master'
+        if: github.ref == 'refs/heads/main'
         uses: peaceiris/actions-gh-pages@v3
         with:
           publish_dir: ./_output
diff --git a/.github/workflows/mirror.yml b/.github/workflows/mirror.yml
new file mode 100644
index 000000000..5c4707573
--- /dev/null
+++ b/.github/workflows/mirror.yml
@@ -0,0 +1,17 @@
+on:
+  push:
+    branches:
+      - 'main'
+
+jobs:
+  mirror_job:
+    runs-on: ubuntu-latest
+    name: Mirror main branch to master branch
+    steps:
+    - name: Mirror action step
+      id: mirror
+      uses: google/mirror-branch-action@v1.0
+      with:
+        github-token: ${{ secrets.GITHUB_TOKEN }}
+        source: 'main'
+        dest: 'master'
diff --git a/Contributing.md b/Contributing.md
index 1cc607fa4..2c299890b 100644
--- a/Contributing.md
+++ b/Contributing.md
@@ -3,6 +3,6 @@
 Interested in participating? Please follow
 [the same contributing guidelines as the design repository][].
 
-  [the same contributing guidelines as the design repository]: https://github.com/WebAssembly/design/blob/master/Contributing.md
+  [the same contributing guidelines as the design repository]: https://github.com/WebAssembly/design/blob/main/Contributing.md
 
 Also, please be sure to read [the README.md](README.md) for this repository.
diff --git a/document/README.md b/document/README.md
index a11196f66..caf75430d 100644
--- a/document/README.md
+++ b/document/README.md
@@ -42,7 +42,7 @@ pipenv shell
 Install Python dependencies:
 
 ```
-pipenv install Sphinx==3.5.2
+pipenv install Sphinx==4.0.0
 ```
 
 ### Checking out the repository
diff --git a/document/core/appendix/algorithm.rst b/document/core/appendix/algorithm.rst
index 8bcf42039..fddc20e42 100644
--- a/document/core/appendix/algorithm.rst
+++ b/document/core/appendix/algorithm.rst
@@ -26,15 +26,19 @@ Types are representable as a set of enumerations.
 .. code-block:: pseudo
 
    type num_type = I32 | I64 | F32 | F64
+   type vec_type = V128
    type heap_type = Def(idx : nat) | Func | Extern | Bot
    type ref_type = Ref(heap : heap_type, null : bool)
-   type val_type = num_type | ref_type | Bot
+   type val_type = num_type | vec_type | ref_type | Bot
 
    func is_num(t : val_type) : bool =
      return t = I32 || t = I64 || t = F32 || t = F64 || t = Bot
 
-   func is_ref(t : val_type) : bool =
-     return t = not (is_num t) || t = Bot
+   func is_vec(t : val_type | Unknown) : bool =
+     return t = V128 || t = Unknown
+
+   func is_ref(t : val_type | Unknown) : bool =
+     return t = not (is_num t || is_vec t) || t = Bot
 
 Equivalence and subtyping checks can be defined on these types.
 
@@ -105,6 +109,11 @@ However, these variables are not manipulated directly by the main checking funct
      error_if(vals.size() = ctrls[0].height)
      return vals.pop()
 
+   func pop_val(expect : val_type) : val_type =
+     let actual = pop_val()
+     error_if(not matches(actual, expect))
+     return actual
+
    func pop_num() : num_type | Bot =
      let actual = pop_val()
      error_if(not is_num(actual))
@@ -116,15 +125,10 @@ However, these variables are not manipulated directly by the main checking funct
      if actual = Bot then return Ref(Bot, false)
      return actual
 
-   func pop_val(expect : val_type) : val_type =
-     let actual = pop_val()
-     error_if(not matches(actual, expect))
-     return actual
-
    func push_vals(types : list(val_type)) = foreach (t in types) push_val(t)
    func pop_vals(types : list(val_type)) : list(val_type) =
      var popped := []
-     foreach (t in reverse(types)) popped.append(pop_val(t))
+     foreach (t in reverse(types)) popped.prepend(pop_val(t))
      return popped
 
 Pushing an operand value simply pushes the respective type to the value stack.
@@ -150,24 +154,24 @@ The control stack is likewise manipulated through auxiliary functions:
 .. code-block:: pseudo
 
    func push_ctrl(opcode : opcode, in : list(val_type), out : list(val_type)) =
-     let frame = ctrl_frame(opcode, in, out, vals.size(), false)
-     ctrls.push(frame)
+     let frame = ctrl_frame(opcode, in, out, vals.size(), false)
+     ctrls.push(frame)
      push_vals(in)
 
    func pop_ctrl() : ctrl_frame =
-     error_if(ctrls.is_empty())
-     let frame = ctrls[0]
-     pop_vals(frame.end_types)
-     error_if(vals.size() =/= frame.height)
+     error_if(ctrls.is_empty())
+     let frame = ctrls[0]
+     pop_vals(frame.end_types)
+     error_if(vals.size() =/= frame.height)
      ctrls.pop()
-     return frame
+     return frame
 
    func label_types(frame : ctrl_frame) : list(val_types) =
      return (if frame.opcode == loop then frame.start_types else frame.end_types)
 
    func unreachable() =
-     vals.resize(ctrls[0].height)
-     ctrls[0].unreachable := true
+     vals.resize(ctrls[0].height)
+     ctrls[0].unreachable := true
 
 Pushing a control frame takes the types of the label and result values.
 It allocates a new frame record recording them along with the current height of the operand stack and marks the block as reachable.
@@ -213,10 +217,11 @@ Other instructions are checked in a similar manner.
 
        case (select)
          pop_val(I32)
-         let t1 = pop_num()
-         let t2 = pop_num()
+         let t1 = pop_val()
+         let t2 = pop_val()
+         error_if(not (is_num(t1) && is_num(t2) || is_vec(t1) && is_vec(t2)))
          error_if(t1 =/= t2 && t1 =/= Bot && t2 =/= Bot)
-         push_val(if (t1 = Bot) t2 else t1)
+         push_val(if (t1 == Bot) t2 else t1)
 
        case (select t)
          pop_val(I32)
@@ -232,8 +237,8 @@ Other instructions are checked in a similar manner.
          let rt = pop_ref()
          push_val(Ref(rt.heap, false))
 
-       case (unreachable)
-         unreachable()
+       case (unreachable)
+         unreachable()
 
        case (block t1*->t2*)
          pop_vals([t1*])
@@ -258,32 +263,32 @@ Other instructions are checked in a similar manner.
          push_ctrl(else, frame.start_types, frame.end_types)
 
        case (br n)
-         error_if(ctrls.size() < n)
-         pop_vals(label_types(ctrls[n]))
-         unreachable()
+         error_if(ctrls.size() < n)
+         pop_vals(label_types(ctrls[n]))
+         unreachable()
 
        case (br_if n)
-         error_if(ctrls.size() < n)
+         error_if(ctrls.size() < n)
          pop_val(I32)
-         pop_vals(label_types(ctrls[n]))
-         push_vals(label_types(ctrls[n]))
+         pop_vals(label_types(ctrls[n]))
+         push_vals(label_types(ctrls[n]))
 
-       case (br_table n* m)
+       case (br_table n* m)
          pop_val(I32)
-         error_if(ctrls.size() < m)
+         error_if(ctrls.size() < m)
          let arity = label_types(ctrls[m]).size()
-         foreach (n in n*)
-           error_if(ctrls.size() < n)
-           error_if(label_types(ctrls[n]).size() =/= arity)
+         foreach (n in n*)
+           error_if(ctrls.size() < n)
+           error_if(label_types(ctrls[n]).size() =/= arity)
            push_vals(pop_vals(label_types(ctrls[n])))
-         pop_vals(label_types(ctrls[m]))
-         unreachable()
+         pop_vals(label_types(ctrls[m]))
+         unreachable()
 
        case (br_on_null n)
-         error_if(ctrls.size() < n)
+         error_if(ctrls.size() < n)
          let rt = pop_ref()
-         pop_vals(label_types(ctrls[n]))
-         push_vals(label_types(ctrls[n]))
+         pop_vals(label_types(ctrls[n]))
+         push_vals(label_types(ctrls[n]))
          push_val(Ref(rt.heap, false))
 
        case (call_ref)
diff --git a/document/core/appendix/changes.rst b/document/core/appendix/changes.rst
index 9488c1882..66303ba21 100644
--- a/document/core/appendix/changes.rst
+++ b/document/core/appendix/changes.rst
@@ -104,17 +104,54 @@ Added instructions that modify ranges of memory or table entries [#proposal-reft
 * Active data and element segments boundaries are no longer checked at compile time but may trap instead
 
 
+.. index:: instructions, SIMD, value type, vector type
+
+Vector instructions
+...................
+
+Added vector type and instructions that manipulate multiple numeric values in parallel (also known as *SIMD*, single instruction multiple data) [#proposal-vectype]_
+
+* New :ref:`value type <syntax-valtype>`: |V128|
+
+* New :ref:`memory instructions <syntax-instr-memory>`: :math:`\K{v128.}\LOAD`, :math:`\K{v128.}\LOAD{}\!N\!\K{x}\!M\!\K{\_}\sx`, :math:`\K{v128.}\LOAD{}N\K{\_zero}`, :math:`\K{v128.}\LOAD{}N\K{\_splat}`, :math:`\K{v128.}\LOAD{}N\K{\_lane}`, :math:`\K{v128.}\STORE`, :math:`\K{v128.}\STORE{}N\K{\_lane}`
+
+* New constant :ref:`vector instruction <syntax-instr-vec>`: :math:`\K{v128.}\VCONST`
+
+* New unary :ref:`vector instructions <syntax-instr-vec>`: :math:`\K{v128.not}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.abs}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.neg}`, :math:`\K{i8x16.popcnt}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.abs}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.neg}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.sqrt}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.ceil}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.floor}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.trunc}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.nearest}`
+
+* New binary :ref:`vector instructions <syntax-instr-vec>`: :math:`\K{v128.and}`, :math:`\K{v128.andnot}`, :math:`\K{v128.or}`, :math:`\K{v128.xor}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.add}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.sub}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.mul}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.add\_sat\_}\sx`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.sub\_sat\_}\sx`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.min\_}\sx`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.max\_}\sx`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.shl}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.shr\_}\sx`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.add}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.extmul\_}\half\K{\_i}\!N'\!\K{x}\!M'\!\K{\_}\sx`, :math:`\K{i16x8.q15mulr\_sat\_s}`, :math:`\K{i32x4.dot\_i16x8\_s}`, :math:`\K{i16x8.extadd\_pairwise\_i8x16\_}\sx`, :math:`\K{i32x4.extadd\_pairwise\_i16x8\_}\sx`, :math:`\K{i8x16.avgr\_u}`, :math:`\K{i16x8.avgr\_u}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.sub}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.mul}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.div}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.min}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.max}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.pmin}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.pmax}`
+
+* New ternary :ref:`vector instruction <syntax-instr-vec>`: :math:`\K{v128.bitselect}`
+
+* New test :ref:`vector instructions <syntax-instr-vec>`: :math:`\K{v128.any\_true}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.all\_true}`
+
+* New relational :ref:`vector instructions <syntax-instr-vec>`: :math:`\K{i}\!N\!\K{x}\!M\!\K{.eq}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.ne}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.lt\_}\sx`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.gt\_}\sx`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.le\_}\sx`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.ge\_}\sx`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.eq}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.ne}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.lt}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.gt}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.le}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.ge}`
+
+* New conversion :ref:`vector instructions <syntax-instr-vec>`::math:`\K{i32x4.trunc\_sat\_f32x4\_}\sx`, :math:`\K{i32x4.trunc\_sat\_f64x2\_}\sx\K{\_zero}`, :math:`\K{f32x4.convert\_i32x4\_}\sx`, :math:`\K{f32x4.demote\_f64x2\_zero}`, :math:`\K{f64x2.convert\_low\_i32x4\_}\sx`, :math:`\K{f64x2.promote\_low\_f32x4}`
+
+* New lane access :ref:`vector instructions <syntax-instr-vec>`: :math:`\K{i}\!N\!\K{x}\!M\!\K{.extract\_lane\_}\sx^?`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.replace\_lane}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.extract\_lane}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.replace\_lane}`
+
+* New lane splitting/combining :ref:`vector instructions <syntax-instr-vec>`: :math:`\K{i}\!N\!\K{x}\!M\!\K{.extend\_}\half\K{\_i}\!N'\!\K{x}\!M'\!\K{\_}\sx`, :math:`\K{i8x16.narrow\_i16x8\_}\sx`, :math:`\K{i16x8.narrow\_i32x4\_}\sx`
+
+* New byte reordering :ref:`vector instructions <syntax-instr-vec>`: :math:`\K{i8x16.shuffle}`, :math:`\K{i8x16.swizzle}`
+
+* New injection/projection :ref:`vector instructions <syntax-instr-vec>`: :math:`\K{i}\!N\!\K{x}\!M\!\K{.splat}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.splat}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.bitmask}`
+
+
 .. [#proposal-signext]
-   https://github.com/WebAssembly/spec/tree/master/proposals/sign-extension-ops/
+   https://github.com/WebAssembly/spec/tree/main/proposals/sign-extension-ops/
 
 .. [#proposal-cvtsat]
-   https://github.com/WebAssembly/spec/tree/master/proposals/nontrapping-float-to-int-conversion/
+   https://github.com/WebAssembly/spec/tree/main/proposals/nontrapping-float-to-int-conversion/
 
 .. [#proposal-multivalue]
-   https://github.com/WebAssembly/spec/tree/master/proposals/multi-value/
+   https://github.com/WebAssembly/spec/tree/main/proposals/multi-value/
 
 .. [#proposal-reftype]
-   https://github.com/WebAssembly/spec/tree/master/proposals/reference-types/
+   https://github.com/WebAssembly/spec/tree/main/proposals/reference-types/
 
 .. [#proposal-bulk]
-   https://github.com/WebAssembly/spec/tree/master/proposals/bulk-memory-operations/
+   https://github.com/WebAssembly/spec/tree/main/proposals/bulk-memory-operations/
+
+.. [#proposal-vectype]
+   https://github.com/WebAssembly/spec/tree/main/proposals/simd/
diff --git a/document/core/appendix/gen-index-instructions.py b/document/core/appendix/gen-index-instructions.py
index f366ae480..bd02a4196 100755
--- a/document/core/appendix/gen-index-instructions.py
+++ b/document/core/appendix/gen-index-instructions.py
@@ -65,7 +65,7 @@ def Instruction(name, opcode, type=None, validation=None, execution=None, operat
     Instruction(r'\NOP', r'\hex{01}', r'[] \to []', r'valid-nop', r'exec-nop'),
     Instruction(r'\BLOCK~\X{bt}', r'\hex{02}', r'[t_1^\ast] \to [t_2^\ast]', r'valid-block', r'exec-block'),
     Instruction(r'\LOOP~\X{bt}', r'\hex{03}', r'[t_1^\ast] \to [t_2^\ast]', r'valid-loop', r'exec-loop'),
-    Instruction(r'\IF~\X{bt}', r'\hex{04}', r'[t_1^\ast] \to [t_2^\ast]', r'valid-if', r'exec-if'),
+    Instruction(r'\IF~\X{bt}', r'\hex{04}', r'[t_1^\ast~\I32] \to [t_2^\ast]', r'valid-if', r'exec-if'),
     Instruction(r'\ELSE', r'\hex{05}'),
     Instruction(None, r'\hex{06}'),
     Instruction(None, r'\hex{07}'),
@@ -328,9 +328,245 @@ def Instruction(name, opcode, type=None, validation=None, execution=None, operat
     Instruction(r'\TABLEINIT~x~y', r'\hex{FC}~\hex{0C}', r'[\I32~\I32~\I32] \to []', r'valid-table.init', r'exec-table.init'),
     Instruction(r'\ELEMDROP~x', r'\hex{FC}~\hex{0D}', r'[] \to []', r'valid-elem.drop', r'exec-elem.drop'),
     Instruction(r'\TABLECOPY~x~y', r'\hex{FC}~\hex{0E}', r'[\I32~\I32~\I32] \to []', r'valid-table.copy', r'exec-table.copy'),
-    Instruction(r'\TABLEGROW~x', r'\hex{FC}~\hex{0F}', r'[t~\I32] \to []', r'valid-table.grow', r'exec-table.grow'),
+    Instruction(r'\TABLEGROW~x', r'\hex{FC}~\hex{0F}', r'[t~\I32] \to [\I32]', r'valid-table.grow', r'exec-table.grow'),
     Instruction(r'\TABLESIZE~x', r'\hex{FC}~\hex{10}', r'[] \to [\I32]', r'valid-table.size', r'exec-table.size'),
     Instruction(r'\TABLEFILL~x', r'\hex{FC}~\hex{11}', r'[\I32~t~\I32] \to []', r'valid-table.fill', r'exec-table.fill'),
+    Instruction(r'\V128.\LOAD~\memarg', r'\hex{FD}~~\hex{00}', r'[\I32] \to [\V128]', r'valid-load', r'exec-load'),
+    Instruction(r'\V128.\LOAD\K{8x8\_s}~\memarg', r'\hex{FD}~~\hex{01}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
+    Instruction(r'\V128.\LOAD\K{8x8\_u}~\memarg', r'\hex{FD}~~\hex{02}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
+    Instruction(r'\V128.\LOAD\K{16x4\_s}~\memarg', r'\hex{FD}~~\hex{03}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
+    Instruction(r'\V128.\LOAD\K{16x4\_u}~\memarg', r'\hex{FD}~~\hex{04}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
+    Instruction(r'\V128.\LOAD\K{32x2\_s}~\memarg', r'\hex{FD}~~\hex{05}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
+    Instruction(r'\V128.\LOAD\K{32x2\_u}~\memarg', r'\hex{FD}~~\hex{06}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
+    Instruction(r'\V128.\LOAD\K{\_splat}~\memarg', r'\hex{FD}~~\hex{07}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
+    Instruction(r'\V128.\LOAD\K{\_splat}~\memarg', r'\hex{FD}~~\hex{08}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
+    Instruction(r'\V128.\LOAD\K{\_splat}~\memarg', r'\hex{FD}~~\hex{09}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
+    Instruction(r'\V128.\LOAD\K{\_splat}~\memarg', r'\hex{FD}~~\hex{0A}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
+    Instruction(r'\V128.\STORE~\memarg', r'\hex{FD}~~\hex{0B}', r'[\I32~\V128] \to []', r'valid-store', r'exec-store'),
+    Instruction(r'\V128.\VCONST~\i128', r'\hex{FD}~~\hex{0C}', r'[] \to [\V128]', r'valid-vconst', r'exec-vconst'),
+    Instruction(r'\I8X16.\SHUFFLE~\laneidx^{16}', r'\hex{FD}~~\hex{0D}', r'[\V128~\V128] \to [\V128]', r'valid-vec-shuffle', r'exec-vec-shuffle'),
+    Instruction(r'\I8X16.\SWIZZLE', r'\hex{FD}~~\hex{0E}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vec-swizzle'),
+    Instruction(r'\I8X16.\SPLAT', r'\hex{FD}~~\hex{0F}', r'[\I32] \to [\V128]', r'valid-vec-splat', r'exec-vec-splat'),
+    Instruction(r'\I16X8.\SPLAT', r'\hex{FD}~~\hex{10}', r'[\I32] \to [\V128]', r'valid-vec-splat', r'exec-vec-splat'),
+    Instruction(r'\I32X4.\SPLAT', r'\hex{FD}~~\hex{11}', r'[\I32] \to [\V128]', r'valid-vec-splat', r'exec-vec-splat'),
+    Instruction(r'\I64X2.\SPLAT', r'\hex{FD}~~\hex{12}', r'[\I64] \to [\V128]', r'valid-vec-splat', r'exec-vec-splat'),
+    Instruction(r'\F32X4.\SPLAT', r'\hex{FD}~~\hex{13}', r'[\F32] \to [\V128]', r'valid-vec-splat', r'exec-vec-splat'),
+    Instruction(r'\F64X2.\SPLAT', r'\hex{FD}~~\hex{14}', r'[\F64] \to [\V128]', r'valid-vec-splat', r'exec-vec-splat'),
+    Instruction(r'\I8X16.\EXTRACTLANE\K{\_s}~\laneidx', r'\hex{FD}~~\hex{15}', r'[\V128] \to [\I32]', r'valid-vec-extract_lane', r'exec-vec-extract_lane'),
+    Instruction(r'\I8X16.\EXTRACTLANE\K{\_u}~\laneidx', r'\hex{FD}~~\hex{16}', r'[\V128] \to [\I32]', r'valid-vec-extract_lane', r'exec-vec-extract_lane'),
+    Instruction(r'\I8X16.\REPLACELANE~\laneidx', r'\hex{FD}~~\hex{17}', r'[\V128~\I32] \to [\V128]', r'valid-vec-replace_lane', r'exec-vec-replace_lane'),
+    Instruction(r'\I16X8.\EXTRACTLANE\K{\_s}~\laneidx', r'\hex{FD}~~\hex{18}', r'[\V128] \to [\I32]', r'valid-vec-extract_lane', r'exec-vec-extract_lane'),
+    Instruction(r'\I16X8.\EXTRACTLANE\K{\_u}~\laneidx', r'\hex{FD}~~\hex{19}', r'[\V128] \to [\I32]', r'valid-vec-extract_lane', r'exec-vec-extract_lane'),
+    Instruction(r'\I16X8.\REPLACELANE~\laneidx', r'\hex{FD}~~\hex{1A}', r'[\V128~\I32] \to [\V128]', r'valid-vec-replace_lane', r'exec-vec-replace_lane'),
+    Instruction(r'\I32X4.\EXTRACTLANE~\laneidx', r'\hex{FD}~~\hex{1B}', r'[\V128] \to [\I32]', r'valid-vec-extract_lane', r'exec-vec-extract_lane'),
+    Instruction(r'\I32X4.\REPLACELANE~\laneidx', r'\hex{FD}~~\hex{1C}', r'[\V128~\I32] \to [\V128]', r'valid-vec-replace_lane', r'exec-vec-replace_lane'),
+    Instruction(r'\I64X2.\EXTRACTLANE~\laneidx', r'\hex{FD}~~\hex{1D}', r'[\V128] \to [\I64]', r'valid-vec-extract_lane', r'exec-vec-extract_lane'),
+    Instruction(r'\I64X2.\REPLACELANE~\laneidx', r'\hex{FD}~~\hex{1E}', r'[\V128~\I64] \to [\V128]', r'valid-vec-replace_lane', r'exec-vec-replace_lane'),
+    Instruction(r'\F32X4.\EXTRACTLANE~\laneidx', r'\hex{FD}~~\hex{1F}', r'[\V128] \to [\F32]', r'valid-vec-extract_lane', r'exec-vec-extract_lane'),
+    Instruction(r'\F32X4.\REPLACELANE~\laneidx', r'\hex{FD}~~\hex{20}', r'[\V128~\F32] \to [\V128]', r'valid-vec-replace_lane', r'exec-vec-replace_lane'),
+    Instruction(r'\F64X2.\EXTRACTLANE~\laneidx', r'\hex{FD}~~\hex{21}', r'[\V128] \to [\F64]', r'valid-vec-extract_lane', r'exec-vec-extract_lane'),
+    Instruction(r'\F64X2.\REPLACELANE~\laneidx', r'\hex{FD}~~\hex{22}', r'[\V128~\F64] \to [\V128]', r'valid-vec-replace_lane', r'exec-vec-replace_lane'),
+    Instruction(r'\I8X16.\VEQ', r'\hex{FD}~~\hex{23}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ieq'),
+    Instruction(r'\I8X16.\VNE', r'\hex{FD}~~\hex{24}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ine'),
+    Instruction(r'\I8X16.\VLT\K{\_s}', r'\hex{FD}~~\hex{25}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ilt_s'),
+    Instruction(r'\I8X16.\VLT\K{\_u}', r'\hex{FD}~~\hex{26}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ilt_u'),
+    Instruction(r'\I8X16.\VGT\K{\_s}', r'\hex{FD}~~\hex{27}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-igt_s'),
+    Instruction(r'\I8X16.\VGT\K{\_u}', r'\hex{FD}~~\hex{28}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-igt_u'),
+    Instruction(r'\I8X16.\VLE\K{\_s}', r'\hex{FD}~~\hex{29}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ile_s'),
+    Instruction(r'\I8X16.\VLE\K{\_u}', r'\hex{FD}~~\hex{2A}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ile_u'),
+    Instruction(r'\I8X16.\VGE\K{\_s}', r'\hex{FD}~~\hex{2B}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ige_s'),
+    Instruction(r'\I8X16.\VGE\K{\_u}', r'\hex{FD}~~\hex{2C}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ige_u'),
+    Instruction(r'\I16X8.\VEQ', r'\hex{FD}~~\hex{2D}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ieq'),
+    Instruction(r'\I16X8.\VNE', r'\hex{FD}~~\hex{2E}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ine'),
+    Instruction(r'\I16X8.\VLT\K{\_s}', r'\hex{FD}~~\hex{2F}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ilt_s'),
+    Instruction(r'\I16X8.\VLT\K{\_u}', r'\hex{FD}~~\hex{30}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ilt_u'),
+    Instruction(r'\I16X8.\VGT\K{\_s}', r'\hex{FD}~~\hex{31}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-igt_s'),
+    Instruction(r'\I16X8.\VGT\K{\_u}', r'\hex{FD}~~\hex{32}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-igt_u'),
+    Instruction(r'\I16X8.\VLE\K{\_s}', r'\hex{FD}~~\hex{33}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ile_s'),
+    Instruction(r'\I16X8.\VLE\K{\_u}', r'\hex{FD}~~\hex{34}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ile_u'),
+    Instruction(r'\I16X8.\VGE\K{\_s}', r'\hex{FD}~~\hex{35}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ige_s'),
+    Instruction(r'\I16X8.\VGE\K{\_u}', r'\hex{FD}~~\hex{36}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ige_u'),
+    Instruction(r'\I32X4.\VEQ', r'\hex{FD}~~\hex{37}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ieq'),
+    Instruction(r'\I32X4.\VNE', r'\hex{FD}~~\hex{38}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ine'),
+    Instruction(r'\I32X4.\VLT\K{\_s}', r'\hex{FD}~~\hex{39}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ilt_s'),
+    Instruction(r'\I32X4.\VLT\K{\_u}', r'\hex{FD}~~\hex{3A}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ilt_u'),
+    Instruction(r'\I32X4.\VGT\K{\_s}', r'\hex{FD}~~\hex{3B}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-igt_s'),
+    Instruction(r'\I32X4.\VGT\K{\_u}', r'\hex{FD}~~\hex{3C}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-igt_u'),
+    Instruction(r'\I32X4.\VLE\K{\_s}', r'\hex{FD}~~\hex{3D}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ile_s'),
+    Instruction(r'\I32X4.\VLE\K{\_u}', r'\hex{FD}~~\hex{3E}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ile_u'),
+    Instruction(r'\I32X4.\VGE\K{\_s}', r'\hex{FD}~~\hex{3F}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ige_s'),
+    Instruction(r'\I32X4.\VGE\K{\_u}', r'\hex{FD}~~\hex{40}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ige_u'),
+    Instruction(r'\F32X4.\VEQ', r'\hex{FD}~~\hex{41}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-feq'),
+    Instruction(r'\F32X4.\VNE', r'\hex{FD}~~\hex{42}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fne'),
+    Instruction(r'\F32X4.\VLT', r'\hex{FD}~~\hex{43}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-flt'),
+    Instruction(r'\F32X4.\VGT', r'\hex{FD}~~\hex{44}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fgt'),
+    Instruction(r'\F32X4.\VLE', r'\hex{FD}~~\hex{45}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fle'),
+    Instruction(r'\F32X4.\VGE', r'\hex{FD}~~\hex{46}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fge'),
+    Instruction(r'\F64X2.\VEQ', r'\hex{FD}~~\hex{47}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-feq'),
+    Instruction(r'\F64X2.\VNE', r'\hex{FD}~~\hex{48}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fne'),
+    Instruction(r'\F64X2.\VLT', r'\hex{FD}~~\hex{49}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-flt'),
+    Instruction(r'\F64X2.\VGT', r'\hex{FD}~~\hex{4A}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fgt'),
+    Instruction(r'\F64X2.\VLE', r'\hex{FD}~~\hex{4B}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fle'),
+    Instruction(r'\F64X2.\VGE', r'\hex{FD}~~\hex{4C}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fge'),
+    Instruction(r'\V128.\VNOT', r'\hex{FD}~~\hex{4D}', r'[\V128] \to [\V128]', r'valid-vvunop', r'exec-vvunop', r'op-inot'),
+    Instruction(r'\V128.\VAND', r'\hex{FD}~~\hex{4E}', r'[\V128~\V128] \to [\V128]', r'valid-vvbinop', r'exec-vvbinop', r'op-iand'),
+    Instruction(r'\V128.\VANDNOT', r'\hex{FD}~~\hex{4F}', r'[\V128~\V128] \to [\V128]', r'valid-vvbinop', r'exec-vvbinop', r'op-iandnot'),
+    Instruction(r'\V128.\VOR', r'\hex{FD}~~\hex{50}', r'[\V128~\V128] \to [\V128]', r'valid-vvbinop', r'exec-vvbinop', r'op-ior'),
+    Instruction(r'\V128.\VXOR', r'\hex{FD}~~\hex{51}', r'[\V128~\V128] \to [\V128]', r'valid-vvbinop', r'exec-vvbinop', r'op-ixor'),
+    Instruction(r'\V128.\BITSELECT', r'\hex{FD}~~\hex{52}', r'[\V128~\V128~\V128] \to [\V128]', r'valid-vvternop', r'exec-vvternop', r'op-ibitselect'),
+    Instruction(r'\V128.\ANYTRUE', r'\hex{FD}~~\hex{53}', r'[\V128] \to [\I32]', r'valid-vvtestop', r'exec-vvtestop'),
+    Instruction(r'\V128.\LOAD\K{8\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{54}', r'[\I32~\V128] \to [\V128]', r'valid-load-lane', r'exec-load-lane'),
+    Instruction(r'\V128.\LOAD\K{16\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{55}', r'[\I32~\V128] \to [\V128]', r'valid-load-lane', r'exec-load-lane'),
+    Instruction(r'\V128.\LOAD\K{32\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{56}', r'[\I32~\V128] \to [\V128]', r'valid-load-lane', r'exec-load-lane'),
+    Instruction(r'\V128.\LOAD\K{64\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{57}', r'[\I32~\V128] \to [\V128]', r'valid-load-lane', r'exec-load-lane'),
+    Instruction(r'\V128.\STORE\K{8\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{58}', r'[\I32~\V128] \to [\V128]', r'valid-store-lane', r'exec-store-lane'),
+    Instruction(r'\V128.\STORE\K{16\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{59}', r'[\I32~\V128] \to [\V128]', r'valid-store-lane', r'exec-store-lane'),
+    Instruction(r'\V128.\STORE\K{32\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{5A}', r'[\I32~\V128] \to [\V128]', r'valid-store-lane', r'exec-store-lane'),
+    Instruction(r'\V128.\STORE\K{64\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{5B}', r'[\I32~\V128] \to [\V128]', r'valid-store-lane', r'exec-store-lane'),
+    Instruction(r'\V128.\LOAD\K{32\_zero}~\memarg~\laneidx', r'\hex{FD}~~\hex{5C}', r'[\I32] \to [\V128]', r'valid-load-zero', r'exec-load-zero'),
+    Instruction(r'\V128.\LOAD\K{64\_zero}~\memarg~\laneidx', r'\hex{FD}~~\hex{5D}', r'[\I32] \to [\V128]', r'valid-load-zero', r'exec-load-zero'),
+    Instruction(r'\F32X4.\VDEMOTE\K{\_f64x2\_zero}', r'\hex{FD}~~\hex{5E}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-demote'),
+    Instruction(r'\F64X2.\VPROMOTE\K{\_low\_f32x4}', r'\hex{FD}~~\hex{5F}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-promote'),
+    Instruction(r'\I8X16.\VABS', r'\hex{FD}~~\hex{60}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-iabs'),
+    Instruction(r'\I8X16.\VNEG', r'\hex{FD}~~\hex{61}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ineg'),
+    Instruction(r'\I8X16.\VPOPCNT', r'\hex{FD}~~\hex{62}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ipopcnt'),
+    Instruction(r'\I8X16.\ALLTRUE', r'\hex{FD}~~\hex{63}', r'[\V128] \to [\I32]', r'valid-vtestop', r'exec-vtestop'),
+    Instruction(r'\I8X16.\BITMASK', r'\hex{FD}~~\hex{64}', r'[\V128] \to [\I32]', r'valid-vec-bitmask', r'exec-vec-bitmask'),
+    Instruction(r'\I8X16.\NARROW\K{\_i16x8\_s}', r'\hex{FD}~~\hex{65}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vec-narrow'),
+    Instruction(r'\I8X16.\NARROW\K{\_i16x8\_u}', r'\hex{FD}~~\hex{66}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vec-narrow'),
+    Instruction(r'\F32X4.\VCEIL', r'\hex{FD}~~\hex{67}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fceil'),
+    Instruction(r'\F32X4.\VFLOOR', r'\hex{FD}~~\hex{68}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ffloor'),
+    Instruction(r'\F32X4.\VTRUNC', r'\hex{FD}~~\hex{69}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ftrunc'),
+    Instruction(r'\F32X4.\VNEAREST', r'\hex{FD}~~\hex{6A}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fnearest'),
+    Instruction(r'\I8X16.\VSHL', r'\hex{FD}~~\hex{6B}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishl'),
+    Instruction(r'\I8X16.\VSHR\K{\_s}', r'\hex{FD}~~\hex{6C}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_s'),
+    Instruction(r'\I8X16.\VSHR\K{\_u}', r'\hex{FD}~~\hex{6D}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_u'),
+    Instruction(r'\I8X16.\VADD', r'\hex{FD}~~\hex{6E}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd'),
+    Instruction(r'\I8X16.\VADD\K{\_sat\_s}', r'\hex{FD}~~\hex{6F}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd_sat_s'),
+    Instruction(r'\I8X16.\VADD\K{\_sat\_u}', r'\hex{FD}~~\hex{70}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd_sat_u'),
+    Instruction(r'\I8X16.\VSUB', r'\hex{FD}~~\hex{71}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub'),
+    Instruction(r'\I8X16.\VSUB\K{\_sat\_s}', r'\hex{FD}~~\hex{72}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub_sat_s'),
+    Instruction(r'\I8X16.\VSUB\K{\_sat\_u}', r'\hex{FD}~~\hex{73}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub_sat_u'),
+    Instruction(r'\F64X2.\VCEIL', r'\hex{FD}~~\hex{74}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fceil'),
+    Instruction(r'\F64X2.\VFLOOR', r'\hex{FD}~~\hex{75}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ffloor'),
+    Instruction(r'\I8X16.\VMIN\K{\_s}', r'\hex{FD}~~\hex{76}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imin_s'),
+    Instruction(r'\I8X16.\VMIN\K{\_u}', r'\hex{FD}~~\hex{77}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imin_u'),
+    Instruction(r'\I8X16.\VMAX\K{\_s}', r'\hex{FD}~~\hex{78}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imax_s'),
+    Instruction(r'\I8X16.\VMAX\K{\_u}', r'\hex{FD}~~\hex{79}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imax_u'),
+    Instruction(r'\F64X2.\VTRUNC', r'\hex{FD}~~\hex{7A}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ftrunc'),
+    Instruction(r'\I8X16.\AVGR\K{\_u}', r'\hex{FD}~~\hex{7B}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iavgr_u'),
+    Instruction(r'\I16X8.\EXTADDPAIRWISE\K{\_i8x16\_s}', r'\hex{FD}~~\hex{7C}', r'[\V128] \to [\V128]', r'valid-vec-extadd_pairwise', r'exec-vec-extadd_pairwise'),
+    Instruction(r'\I16X8.\EXTADDPAIRWISE\K{\_i8x16\_u}', r'\hex{FD}~~\hex{7D}', r'[\V128] \to [\V128]', r'valid-vec-extadd_pairwise', r'exec-vec-extadd_pairwise'),
+    Instruction(r'\I32X4.\EXTADDPAIRWISE\K{\_i16x8\_s}', r'\hex{FD}~~\hex{7E}', r'[\V128] \to [\V128]', r'valid-vec-extadd_pairwise', r'exec-vec-extadd_pairwise'),
+    Instruction(r'\I32X4.\EXTADDPAIRWISE\K{\_i16x8\_u}', r'\hex{FD}~~\hex{7F}', r'[\V128] \to [\V128]', r'valid-vec-extadd_pairwise', r'exec-vec-extadd_pairwise'),
+    Instruction(r'\I16X8.\VABS', r'\hex{FD}~~\hex{80}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-iabs'),
+    Instruction(r'\I16X8.\VNEG', r'\hex{FD}~~\hex{81}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ineg'),
+    Instruction(r'\I16X8.\Q15MULRSAT\K{\_s}', r'\hex{FD}~~\hex{82}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iq15mulrsat_s'),
+    Instruction(r'\I16X8.\ALLTRUE', r'\hex{FD}~~\hex{83}', r'[\V128] \to [\I32]', r'valid-vtestop', r'exec-vtestop'),
+    Instruction(r'\I16X8.\BITMASK', r'\hex{FD}~~\hex{84}', r'[\V128] \to [\I32]', r'valid-vec-bitmask', r'exec-vec-bitmask'),
+    Instruction(r'\I16X8.\NARROW\K{\_i32x4\_s}', r'\hex{FD}~~\hex{85}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vec-narrow'),
+    Instruction(r'\I16X8.\NARROW\K{\_i32x4\_u}', r'\hex{FD}~~\hex{86}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vec-narrow'),
+    Instruction(r'\I16X8.\VEXTEND\K{\_low\_i8x16\_s}', r'\hex{FD}~~\hex{87}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I16X8.\VEXTEND\K{\_high\_i8x16\_s}', r'\hex{FD}~~\hex{88}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I16X8.\VEXTEND\K{\_low\_i8x16\_u}', r'\hex{FD}~~\hex{89}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I16X8.\VEXTEND\K{\_high\_i8x16\_u}', r'\hex{FD}~~\hex{8A}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I16X8.\VSHL', r'\hex{FD}~~\hex{8B}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishl'),
+    Instruction(r'\I16X8.\VSHR\K{\_s}', r'\hex{FD}~~\hex{8C}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_s'),
+    Instruction(r'\I16X8.\VSHR\K{\_u}', r'\hex{FD}~~\hex{8D}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_u'),
+    Instruction(r'\I16X8.\VADD', r'\hex{FD}~~\hex{8E}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd'),
+    Instruction(r'\I16X8.\VADD\K{\_sat\_s}', r'\hex{FD}~~\hex{8F}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd_sat_s'),
+    Instruction(r'\I16X8.\VADD\K{\_sat\_u}', r'\hex{FD}~~\hex{90}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd_sat_u'),
+    Instruction(r'\I16X8.\VSUB', r'\hex{FD}~~\hex{91}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub'),
+    Instruction(r'\I16X8.\VSUB\K{\_sat\_s}', r'\hex{FD}~~\hex{92}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub_sat_s'),
+    Instruction(r'\I16X8.\VSUB\K{\_sat\_u}', r'\hex{FD}~~\hex{93}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub_sat_u'),
+    Instruction(r'\F64X2.\VNEAREST', r'\hex{FD}~~\hex{94}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fnearest'),
+    Instruction(r'\I16X8.\VMUL', r'\hex{FD}~~\hex{95}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imul'),
+    Instruction(r'\I16X8.\VMIN\K{\_s}', r'\hex{FD}~~\hex{96}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imin_s'),
+    Instruction(r'\I16X8.\VMIN\K{\_u}', r'\hex{FD}~~\hex{97}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imin_u'),
+    Instruction(r'\I16X8.\VMAX\K{\_s}', r'\hex{FD}~~\hex{98}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imax_s'),
+    Instruction(r'\I16X8.\VMAX\K{\_u}', r'\hex{FD}~~\hex{99}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imax_u'),
+    Instruction(r'\I16X8.\AVGR\K{\_u}', r'\hex{FD}~~\hex{9B}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iavgr_u'),
+    Instruction(r'\I16X8.\EXTMUL\K{\_low\_i8x16\_s}', r'\hex{FD}~~\hex{9C}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I16X8.\EXTMUL\K{\_high\_i8x16\_s}', r'\hex{FD}~~\hex{9D}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I16X8.\EXTMUL\K{\_low\_i8x16\_u}', r'\hex{FD}~~\hex{9E}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I16X8.\EXTMUL\K{\_high\_i8x16\_u}', r'\hex{FD}~~\hex{9F}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I32X4.\VABS', r'\hex{FD}~~\hex{A0}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-iabs'),
+    Instruction(r'\I32X4.\VNEG', r'\hex{FD}~~\hex{A1}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ineg'),
+    Instruction(r'\I32X4.\ALLTRUE', r'\hex{FD}~~\hex{A3}', r'[\V128] \to [\I32]', r'valid-vtestop', r'exec-vtestop'),
+    Instruction(r'\I32X4.\BITMASK', r'\hex{FD}~~\hex{A4}', r'[\V128] \to [\I32]', r'valid-vec-bitmask', r'exec-vec-bitmask'),
+    Instruction(r'\I32X4.\VEXTEND\K{\_low\_i16x8\_s}', r'\hex{FD}~~\hex{A7}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I32X4.\VEXTEND\K{\_high\_i16x8\_s}', r'\hex{FD}~~\hex{A8}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I32X4.\VEXTEND\K{\_low\_i16x8\_u}', r'\hex{FD}~~\hex{A9}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I32X4.\VEXTEND\K{\_high\_i16x8\_u}', r'\hex{FD}~~\hex{AA}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I32X4.\VSHL', r'\hex{FD}~~\hex{AB}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishl'),
+    Instruction(r'\I32X4.\VSHR\K{\_s}', r'\hex{FD}~~\hex{AC}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_s'),
+    Instruction(r'\I32X4.\VSHR\K{\_u}', r'\hex{FD}~~\hex{AD}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_u'),
+    Instruction(r'\I32X4.\VADD', r'\hex{FD}~~\hex{AE}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd'),
+    Instruction(r'\I32X4.\VSUB', r'\hex{FD}~~\hex{B1}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub'),
+    Instruction(r'\I32X4.\VMUL', r'\hex{FD}~~\hex{B5}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imul'),
+    Instruction(r'\I32X4.\VMIN\K{\_s}', r'\hex{FD}~~\hex{B6}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imin_s'),
+    Instruction(r'\I32X4.\VMIN\K{\_u}', r'\hex{FD}~~\hex{B7}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imin_u'),
+    Instruction(r'\I32X4.\VMAX\K{\_s}', r'\hex{FD}~~\hex{B8}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imax_s'),
+    Instruction(r'\I32X4.\VMAX\K{\_u}', r'\hex{FD}~~\hex{B9}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imax_u'),
+    Instruction(r'\I32X4.\DOT\K{\_i16x8\_s}', r'\hex{FD}~~\hex{BA}', r'[\V128~\V128] \to [\V128]', r'valid-vec-dot', r'exec-vec-dot'),
+    Instruction(r'\I32X4.\EXTMUL\K{\_low\_i16x8\_s}', r'\hex{FD}~~\hex{BC}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I32X4.\EXTMUL\K{\_high\_i16x8\_s}', r'\hex{FD}~~\hex{BD}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I32X4.\EXTMUL\K{\_low\_i16x8\_u}', r'\hex{FD}~~\hex{BE}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I32X4.\EXTMUL\K{\_high\_i16x8\_u}', r'\hex{FD}~~\hex{BF}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I64X2.\VABS', r'\hex{FD}~~\hex{C0}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-iabs'),
+    Instruction(r'\I64X2.\VNEG', r'\hex{FD}~~\hex{C1}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ineg'),
+    Instruction(r'\I64X2.\ALLTRUE', r'\hex{FD}~~\hex{C3}', r'[\V128] \to [\I32]', r'valid-vtestop', r'exec-vtestop'),
+    Instruction(r'\I64X2.\BITMASK', r'\hex{FD}~~\hex{C4}', r'[\V128] \to [\I32]', r'valid-vec-bitmask', r'exec-vec-bitmask'),
+    Instruction(r'\I64X2.\VEXTEND\K{\_low\_i32x4\_s}', r'\hex{FD}~~\hex{C7}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I64X2.\VEXTEND\K{\_high\_i32x4\_s}', r'\hex{FD}~~\hex{C8}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I64X2.\VEXTEND\K{\_low\_i32x4\_u}', r'\hex{FD}~~\hex{C9}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I64X2.\VEXTEND\K{\_high\_i32x4\_u}', r'\hex{FD}~~\hex{CA}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I64X2.\VSHL', r'\hex{FD}~~\hex{CB}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishl'),
+    Instruction(r'\I64X2.\VSHR\K{\_s}', r'\hex{FD}~~\hex{CC}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_s'),
+    Instruction(r'\I64X2.\VSHR\K{\_u}', r'\hex{FD}~~\hex{CD}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_u'),
+    Instruction(r'\I64X2.\VADD', r'\hex{FD}~~\hex{CE}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd'),
+    Instruction(r'\I64X2.\VSUB', r'\hex{FD}~~\hex{D1}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub'),
+    Instruction(r'\I64X2.\VMUL', r'\hex{FD}~~\hex{D5}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imul'),
+    Instruction(r'\I64X2.\VEQ', r'\hex{FD}~~\hex{D6}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ieq'),
+    Instruction(r'\I64X2.\VNE', r'\hex{FD}~~\hex{D7}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ine'),
+    Instruction(r'\I64X2.\VLT\K{\_s}', r'\hex{FD}~~\hex{D8}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ilt_s'),
+    Instruction(r'\I64X2.\VGT\K{\_s}', r'\hex{FD}~~\hex{D9}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-igt_s'),
+    Instruction(r'\I64X2.\VLE\K{\_s}', r'\hex{FD}~~\hex{DA}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ile_s'),
+    Instruction(r'\I64X2.\VGE\K{\_s}', r'\hex{FD}~~\hex{DB}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ige_s'),
+    Instruction(r'\I64X2.\EXTMUL\K{\_low\_i32x4\_s}', r'\hex{FD}~~\hex{DC}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I64X2.\EXTMUL\K{\_high\_i32x4\_s}', r'\hex{FD}~~\hex{DD}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I64X2.\EXTMUL\K{\_low\_i32x4\_u}', r'\hex{FD}~~\hex{DE}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I64X2.\EXTMUL\K{\_high\_i32x4\_u}', r'\hex{FD}~~\hex{DF}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\F32X4.\VABS', r'\hex{FD}~~\hex{E0}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fabs'),
+    Instruction(r'\F32X4.\VNEG', r'\hex{FD}~~\hex{E1}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fneg'),
+    Instruction(r'\F32X4.\VSQRT', r'\hex{FD}~~\hex{E3}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fsqrt'),
+    Instruction(r'\F32X4.\VADD', r'\hex{FD}~~\hex{E4}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fadd'),
+    Instruction(r'\F32X4.\VSUB', r'\hex{FD}~~\hex{E5}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fsub'),
+    Instruction(r'\F32X4.\VMUL', r'\hex{FD}~~\hex{E6}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmul'),
+    Instruction(r'\F32X4.\VDIV', r'\hex{FD}~~\hex{E7}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fdiv'),
+    Instruction(r'\F32X4.\VMIN', r'\hex{FD}~~\hex{E8}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmin'),
+    Instruction(r'\F32X4.\VMAX', r'\hex{FD}~~\hex{E9}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmax'),
+    Instruction(r'\F32X4.\VPMIN', r'\hex{FD}~~\hex{EA}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fpmin'),
+    Instruction(r'\F32X4.\VPMAX', r'\hex{FD}~~\hex{EB}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fpmax'),
+    Instruction(r'\F64X2.\VABS', r'\hex{FD}~~\hex{EC}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fabs'),
+    Instruction(r'\F64X2.\VNEG', r'\hex{FD}~~\hex{ED}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fneg'),
+    Instruction(r'\F64X2.\VSQRT', r'\hex{FD}~~\hex{EF}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fsqrt'),
+    Instruction(r'\F64X2.\VADD', r'\hex{FD}~~\hex{F0}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fadd'),
+    Instruction(r'\F64X2.\VSUB', r'\hex{FD}~~\hex{F1}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fsub'),
+    Instruction(r'\F64X2.\VMUL', r'\hex{FD}~~\hex{F2}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmul'),
+    Instruction(r'\F64X2.\VDIV', r'\hex{FD}~~\hex{F3}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fdiv'),
+    Instruction(r'\F64X2.\VMIN', r'\hex{FD}~~\hex{F4}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmin'),
+    Instruction(r'\F64X2.\VMAX', r'\hex{FD}~~\hex{F5}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmax'),
+    Instruction(r'\F64X2.\VPMIN', r'\hex{FD}~~\hex{F6}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fpmin'),
+    Instruction(r'\F64X2.\VPMAX', r'\hex{FD}~~\hex{F7}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fpmax'),
+    Instruction(r'\I32X4.\TRUNC\K{\_sat\_f32x4\_s}', r'\hex{FD}~~\hex{F8}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-trunc_sat_s'),
+    Instruction(r'\I32X4.\TRUNC\K{\_sat\_f32x4\_u}', r'\hex{FD}~~\hex{F9}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-trunc_sat_u'),
+    Instruction(r'\F32X4.\VCONVERT\K{\_i32x4\_s}', r'\hex{FD}~~\hex{FA}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-convert_s'),
+    Instruction(r'\F32X4.\VCONVERT\K{\_i32x4\_u}', r'\hex{FD}~~\hex{FB}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-convert_u'),
+    Instruction(r'\I32X4.\VTRUNC\K{\_sat\_f64x2\_s\_zero}', r'\hex{FD}~~\hex{FC}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-trunc_sat_s'),
+    Instruction(r'\I32X4.\VTRUNC\K{\_sat\_f64x2\_u\_zero}', r'\hex{FD}~~\hex{FD}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-trunc_sat_u'),
+    Instruction(r'\F64X2.\VCONVERT\K{\_low\_i32x4\_s}', r'\hex{FD}~~\hex{FE}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-convert_s'),
+    Instruction(r'\F64X2.\VCONVERT\K{\_low\_i32x4\_u}', r'\hex{FD}~~\hex{FF}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-convert_u'),
 ]
 
 
diff --git a/document/core/appendix/index-instructions.rst b/document/core/appendix/index-instructions.rst
index 545638b6b..bba37458a 100644
--- a/document/core/appendix/index-instructions.rst
+++ b/document/core/appendix/index-instructions.rst
@@ -6,277 +6,513 @@
 Index of Instructions
 ---------------------
 
-=========================================  =========================  ===============================================================  =========================================  ===============================================================
-Instruction                                Binary Opcode              Type                                                             Validation                                 Execution                                                      
-=========================================  =========================  ===============================================================  =========================================  ===============================================================
-:math:`\UNREACHABLE`                       :math:`\hex{00}`           :math:`[t_1^\ast] \to [t_2^\ast]`                                :ref:`validation <valid-unreachable>`      :ref:`execution <exec-unreachable>`                            
-:math:`\NOP`                               :math:`\hex{01}`           :math:`[] \to []`                                                :ref:`validation <valid-nop>`              :ref:`execution <exec-nop>`                                    
-:math:`\BLOCK~\X{bt}`                      :math:`\hex{02}`           :math:`[t_1^\ast] \to [t_2^\ast]`                                :ref:`validation <valid-block>`            :ref:`execution <exec-block>`                                  
-:math:`\LOOP~\X{bt}`                       :math:`\hex{03}`           :math:`[t_1^\ast] \to [t_2^\ast]`                                :ref:`validation <valid-loop>`             :ref:`execution <exec-loop>`                                   
-:math:`\IF~\X{bt}`                         :math:`\hex{04}`           :math:`[t_1^\ast] \to [t_2^\ast]`                                :ref:`validation <valid-if>`               :ref:`execution <exec-if>`                                     
-:math:`\ELSE`                              :math:`\hex{05}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{06}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{07}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{08}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{09}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{0A}`                                                                                                                                                                                      
-:math:`\END`                               :math:`\hex{0B}`                                                                                                                                                                                      
-:math:`\BR~l`                              :math:`\hex{0C}`           :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`                         :ref:`validation <valid-br>`               :ref:`execution <exec-br>`                                     
-:math:`\BRIF~l`                            :math:`\hex{0D}`           :math:`[t^\ast~\I32] \to [t^\ast]`                               :ref:`validation <valid-br_if>`            :ref:`execution <exec-br_if>`                                  
-:math:`\BRTABLE~l^\ast~l`                  :math:`\hex{0E}`           :math:`[t_1^\ast~t^\ast~\I32] \to [t_2^\ast]`                    :ref:`validation <valid-br_table>`         :ref:`execution <exec-br_table>`                               
-:math:`\RETURN`                            :math:`\hex{0F}`           :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`                         :ref:`validation <valid-return>`           :ref:`execution <exec-return>`                                 
-:math:`\CALL~x`                            :math:`\hex{10}`           :math:`[t_1^\ast] \to [t_2^\ast]`                                :ref:`validation <valid-call>`             :ref:`execution <exec-call>`                                   
-:math:`\CALLINDIRECT~x~y`                  :math:`\hex{11}`           :math:`[t_1^\ast~\I32] \to [t_2^\ast]`                           :ref:`validation <valid-call_indirect>`    :ref:`execution <exec-call_indirect>`                          
-(reserved)                                 :math:`\hex{12}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{13}`                                                                                                                                                                                      
-:math:`\CALLREF`                           :math:`\hex{14}`           :math:`[t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]`                 :ref:`validation <valid-call_ref>`         :ref:`execution <exec-call_ref>`                               
-(reserved)                                 :math:`\hex{15}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{16}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{17}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{18}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{19}`                                                                                                                                                                                      
-:math:`\DROP`                              :math:`\hex{1A}`           :math:`[t] \to []`                                               :ref:`validation <valid-drop>`             :ref:`execution <exec-drop>`                                   
-:math:`\SELECT`                            :math:`\hex{1B}`           :math:`[t~t~\I32] \to [t]`                                       :ref:`validation <valid-select>`           :ref:`execution <exec-select>`                                 
-:math:`\SELECT~t`                          :math:`\hex{1C}`           :math:`[t~t~\I32] \to [t]`                                       :ref:`validation <valid-select>`           :ref:`execution <exec-select>`                                 
-(reserved)                                 :math:`\hex{1D}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{1E}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{1F}`                                                                                                                                                                                      
-:math:`\LOCALGET~x`                        :math:`\hex{20}`           :math:`[] \to [t]`                                               :ref:`validation <valid-local.get>`        :ref:`execution <exec-local.get>`                              
-:math:`\LOCALSET~x`                        :math:`\hex{21}`           :math:`[t] \to []`                                               :ref:`validation <valid-local.set>`        :ref:`execution <exec-local.set>`                              
-:math:`\LOCALTEE~x`                        :math:`\hex{22}`           :math:`[t] \to [t]`                                              :ref:`validation <valid-local.tee>`        :ref:`execution <exec-local.tee>`                              
-:math:`\GLOBALGET~x`                       :math:`\hex{23}`           :math:`[] \to [t]`                                               :ref:`validation <valid-global.get>`       :ref:`execution <exec-global.get>`                             
-:math:`\GLOBALSET~x`                       :math:`\hex{24}`           :math:`[t] \to []`                                               :ref:`validation <valid-global.set>`       :ref:`execution <exec-global.set>`                             
-:math:`\TABLEGET~x`                        :math:`\hex{25}`           :math:`[\I32] \to [t]`                                           :ref:`validation <valid-table.get>`        :ref:`execution <exec-table.get>`                              
-:math:`\TABLESET~x`                        :math:`\hex{26}`           :math:`[\I32~t] \to []`                                          :ref:`validation <valid-table.set>`        :ref:`execution <exec-table.set>`                              
-(reserved)                                 :math:`\hex{27}`                                                                                                                                                                                      
-:math:`\I32.\LOAD~\memarg`                 :math:`\hex{28}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-load>`             :ref:`execution <exec-load>`                                   
-:math:`\I64.\LOAD~\memarg`                 :math:`\hex{29}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-load>`             :ref:`execution <exec-load>`                                   
-:math:`\F32.\LOAD~\memarg`                 :math:`\hex{2A}`           :math:`[\I32] \to [\F32]`                                        :ref:`validation <valid-load>`             :ref:`execution <exec-load>`                                   
-:math:`\F64.\LOAD~\memarg`                 :math:`\hex{2B}`           :math:`[\I32] \to [\F64]`                                        :ref:`validation <valid-load>`             :ref:`execution <exec-load>`                                   
-:math:`\I32.\LOAD\K{8\_s}~\memarg`         :math:`\hex{2C}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
-:math:`\I32.\LOAD\K{8\_u}~\memarg`         :math:`\hex{2D}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
-:math:`\I32.\LOAD\K{16\_s}~\memarg`        :math:`\hex{2E}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
-:math:`\I32.\LOAD\K{16\_u}~\memarg`        :math:`\hex{2F}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{8\_s}~\memarg`         :math:`\hex{30}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{8\_u}~\memarg`         :math:`\hex{31}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{16\_s}~\memarg`        :math:`\hex{32}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{16\_u}~\memarg`        :math:`\hex{33}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{32\_s}~\memarg`        :math:`\hex{34}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
-:math:`\I64.\LOAD\K{32\_u}~\memarg`        :math:`\hex{35}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`            :ref:`execution <exec-loadn>`                                  
-:math:`\I32.\STORE~\memarg`                :math:`\hex{36}`           :math:`[\I32~\I32] \to []`                                       :ref:`validation <valid-store>`            :ref:`execution <exec-store>`                                  
-:math:`\I64.\STORE~\memarg`                :math:`\hex{37}`           :math:`[\I32~\I64] \to []`                                       :ref:`validation <valid-store>`            :ref:`execution <exec-store>`                                  
-:math:`\F32.\STORE~\memarg`                :math:`\hex{38}`           :math:`[\I32~\F32] \to []`                                       :ref:`validation <valid-store>`            :ref:`execution <exec-store>`                                  
-:math:`\F64.\STORE~\memarg`                :math:`\hex{39}`           :math:`[\I32~\F64] \to []`                                       :ref:`validation <valid-store>`            :ref:`execution <exec-store>`                                  
-:math:`\I32.\STORE\K{8}~\memarg`           :math:`\hex{3A}`           :math:`[\I32~\I32] \to []`                                       :ref:`validation <valid-storen>`           :ref:`execution <exec-storen>`                                 
-:math:`\I32.\STORE\K{16}~\memarg`          :math:`\hex{3B}`           :math:`[\I32~\I32] \to []`                                       :ref:`validation <valid-storen>`           :ref:`execution <exec-storen>`                                 
-:math:`\I64.\STORE\K{8}~\memarg`           :math:`\hex{3C}`           :math:`[\I32~\I64] \to []`                                       :ref:`validation <valid-storen>`           :ref:`execution <exec-storen>`                                 
-:math:`\I64.\STORE\K{16}~\memarg`          :math:`\hex{3D}`           :math:`[\I32~\I64] \to []`                                       :ref:`validation <valid-storen>`           :ref:`execution <exec-storen>`                                 
-:math:`\I64.\STORE\K{32}~\memarg`          :math:`\hex{3E}`           :math:`[\I32~\I64] \to []`                                       :ref:`validation <valid-storen>`           :ref:`execution <exec-storen>`                                 
-:math:`\MEMORYSIZE`                        :math:`\hex{3F}`           :math:`[] \to [\I32]`                                            :ref:`validation <valid-memory.size>`      :ref:`execution <exec-memory.size>`                            
-:math:`\MEMORYGROW`                        :math:`\hex{40}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-memory.grow>`      :ref:`execution <exec-memory.grow>`                            
-:math:`\I32.\CONST~\i32`                   :math:`\hex{41}`           :math:`[] \to [\I32]`                                            :ref:`validation <valid-const>`            :ref:`execution <exec-const>`                                  
-:math:`\I64.\CONST~\i64`                   :math:`\hex{42}`           :math:`[] \to [\I64]`                                            :ref:`validation <valid-const>`            :ref:`execution <exec-const>`                                  
-:math:`\F32.\CONST~\f32`                   :math:`\hex{43}`           :math:`[] \to [\F32]`                                            :ref:`validation <valid-const>`            :ref:`execution <exec-const>`                                  
-:math:`\F64.\CONST~\f64`                   :math:`\hex{44}`           :math:`[] \to [\F64]`                                            :ref:`validation <valid-const>`            :ref:`execution <exec-const>`                                  
-:math:`\I32.\EQZ`                          :math:`\hex{45}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-testop>`           :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`      
-:math:`\I32.\EQ`                           :math:`\hex{46}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`        
-:math:`\I32.\NE`                           :math:`\hex{47}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`        
-:math:`\I32.\LT\K{\_s}`                    :math:`\hex{48}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`      
-:math:`\I32.\LT\K{\_u}`                    :math:`\hex{49}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`      
-:math:`\I32.\GT\K{\_s}`                    :math:`\hex{4A}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`      
-:math:`\I32.\GT\K{\_u}`                    :math:`\hex{4B}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`      
-:math:`\I32.\LE\K{\_s}`                    :math:`\hex{4C}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`      
-:math:`\I32.\LE\K{\_u}`                    :math:`\hex{4D}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`      
-:math:`\I32.\GE\K{\_s}`                    :math:`\hex{4E}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`      
-:math:`\I32.\GE\K{\_u}`                    :math:`\hex{4F}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`      
-:math:`\I64.\EQZ`                          :math:`\hex{50}`           :math:`[\I64] \to [\I32]`                                        :ref:`validation <valid-testop>`           :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`      
-:math:`\I64.\EQ`                           :math:`\hex{51}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`        
-:math:`\I64.\NE`                           :math:`\hex{52}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`        
-:math:`\I64.\LT\K{\_s}`                    :math:`\hex{53}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`      
-:math:`\I64.\LT\K{\_u}`                    :math:`\hex{54}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`      
-:math:`\I64.\GT\K{\_s}`                    :math:`\hex{55}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`      
-:math:`\I64.\GT\K{\_u}`                    :math:`\hex{56}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`      
-:math:`\I64.\LE\K{\_s}`                    :math:`\hex{57}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`      
-:math:`\I64.\LE\K{\_u}`                    :math:`\hex{58}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`      
-:math:`\I64.\GE\K{\_s}`                    :math:`\hex{59}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`      
-:math:`\I64.\GE\K{\_u}`                    :math:`\hex{5A}`           :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`      
-:math:`\F32.\EQ`                           :math:`\hex{5B}`           :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`        
-:math:`\F32.\NE`                           :math:`\hex{5C}`           :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`        
-:math:`\F32.\LT`                           :math:`\hex{5D}`           :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`        
-:math:`\F32.\GT`                           :math:`\hex{5E}`           :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`        
-:math:`\F32.\LE`                           :math:`\hex{5F}`           :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`        
-:math:`\F32.\GE`                           :math:`\hex{60}`           :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`        
-:math:`\F64.\EQ`                           :math:`\hex{61}`           :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`        
-:math:`\F64.\NE`                           :math:`\hex{62}`           :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`        
-:math:`\F64.\LT`                           :math:`\hex{63}`           :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`        
-:math:`\F64.\GT`                           :math:`\hex{64}`           :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`        
-:math:`\F64.\LE`                           :math:`\hex{65}`           :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`        
-:math:`\F64.\GE`                           :math:`\hex{66}`           :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`            :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`        
-:math:`\I32.\CLZ`                          :math:`\hex{67}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`        
-:math:`\I32.\CTZ`                          :math:`\hex{68}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`        
-:math:`\I32.\POPCNT`                       :math:`\hex{69}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`     
-:math:`\I32.\ADD`                          :math:`\hex{6A}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`       
-:math:`\I32.\SUB`                          :math:`\hex{6B}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`       
-:math:`\I32.\MUL`                          :math:`\hex{6C}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`       
-:math:`\I32.\DIV\K{\_s}`                   :math:`\hex{6D}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`     
-:math:`\I32.\DIV\K{\_u}`                   :math:`\hex{6E}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`     
-:math:`\I32.\REM\K{\_s}`                   :math:`\hex{6F}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`     
-:math:`\I32.\REM\K{\_u}`                   :math:`\hex{70}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`     
-:math:`\I32.\AND`                          :math:`\hex{71}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`       
-:math:`\I32.\OR`                           :math:`\hex{72}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`        
-:math:`\I32.\XOR`                          :math:`\hex{73}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`       
-:math:`\I32.\SHL`                          :math:`\hex{74}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`       
-:math:`\I32.\SHR\K{\_s}`                   :math:`\hex{75}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`     
-:math:`\I32.\SHR\K{\_u}`                   :math:`\hex{76}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`     
-:math:`\I32.\ROTL`                         :math:`\hex{77}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`      
-:math:`\I32.\ROTR`                         :math:`\hex{78}`           :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`      
-:math:`\I64.\CLZ`                          :math:`\hex{79}`           :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`        
-:math:`\I64.\CTZ`                          :math:`\hex{7A}`           :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`        
-:math:`\I64.\POPCNT`                       :math:`\hex{7B}`           :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`     
-:math:`\I64.\ADD`                          :math:`\hex{7C}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`       
-:math:`\I64.\SUB`                          :math:`\hex{7D}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`       
-:math:`\I64.\MUL`                          :math:`\hex{7E}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`       
-:math:`\I64.\DIV\K{\_s}`                   :math:`\hex{7F}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`     
-:math:`\I64.\DIV\K{\_u}`                   :math:`\hex{80}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`     
-:math:`\I64.\REM\K{\_s}`                   :math:`\hex{81}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`     
-:math:`\I64.\REM\K{\_u}`                   :math:`\hex{82}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`     
-:math:`\I64.\AND`                          :math:`\hex{83}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`       
-:math:`\I64.\OR`                           :math:`\hex{84}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`        
-:math:`\I64.\XOR`                          :math:`\hex{85}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`       
-:math:`\I64.\SHL`                          :math:`\hex{86}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`       
-:math:`\I64.\SHR\K{\_s}`                   :math:`\hex{87}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`     
-:math:`\I64.\SHR\K{\_u}`                   :math:`\hex{88}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`     
-:math:`\I64.\ROTL`                         :math:`\hex{89}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`      
-:math:`\I64.\ROTR`                         :math:`\hex{8A}`           :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`      
-:math:`\F32.\ABS`                          :math:`\hex{8B}`           :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`        
-:math:`\F32.\NEG`                          :math:`\hex{8C}`           :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`        
-:math:`\F32.\CEIL`                         :math:`\hex{8D}`           :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`       
-:math:`\F32.\FLOOR`                        :math:`\hex{8E}`           :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`      
-:math:`\F32.\TRUNC`                        :math:`\hex{8F}`           :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`      
-:math:`\F32.\NEAREST`                      :math:`\hex{90}`           :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`    
-:math:`\F32.\SQRT`                         :math:`\hex{91}`           :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`       
-:math:`\F32.\ADD`                          :math:`\hex{92}`           :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`       
-:math:`\F32.\SUB`                          :math:`\hex{93}`           :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`       
-:math:`\F32.\MUL`                          :math:`\hex{94}`           :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`       
-:math:`\F32.\DIV`                          :math:`\hex{95}`           :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`       
-:math:`\F32.\FMIN`                         :math:`\hex{96}`           :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`       
-:math:`\F32.\FMAX`                         :math:`\hex{97}`           :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`       
-:math:`\F32.\COPYSIGN`                     :math:`\hex{98}`           :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`  
-:math:`\F64.\ABS`                          :math:`\hex{99}`           :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`        
-:math:`\F64.\NEG`                          :math:`\hex{9A}`           :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`        
-:math:`\F64.\CEIL`                         :math:`\hex{9B}`           :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`       
-:math:`\F64.\FLOOR`                        :math:`\hex{9C}`           :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`      
-:math:`\F64.\TRUNC`                        :math:`\hex{9D}`           :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`      
-:math:`\F64.\NEAREST`                      :math:`\hex{9E}`           :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`    
-:math:`\F64.\SQRT`                         :math:`\hex{9F}`           :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`       
-:math:`\F64.\ADD`                          :math:`\hex{A0}`           :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`       
-:math:`\F64.\SUB`                          :math:`\hex{A1}`           :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`       
-:math:`\F64.\MUL`                          :math:`\hex{A2}`           :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`       
-:math:`\F64.\DIV`                          :math:`\hex{A3}`           :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`       
-:math:`\F64.\FMIN`                         :math:`\hex{A4}`           :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`       
-:math:`\F64.\FMAX`                         :math:`\hex{A5}`           :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`       
-:math:`\F64.\COPYSIGN`                     :math:`\hex{A6}`           :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`            :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`  
-:math:`\I32.\WRAP\K{\_}\I64`               :math:`\hex{A7}`           :math:`[\I64] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-wrap>`       
-:math:`\I32.\TRUNC\K{\_}\F32\K{\_s}`       :math:`\hex{A8}`           :math:`[\F32] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
-:math:`\I32.\TRUNC\K{\_}\F32\K{\_u}`       :math:`\hex{A9}`           :math:`[\F32] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
-:math:`\I32.\TRUNC\K{\_}\F64\K{\_s}`       :math:`\hex{AA}`           :math:`[\F64] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
-:math:`\I32.\TRUNC\K{\_}\F64\K{\_u}`       :math:`\hex{AB}`           :math:`[\F64] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
-:math:`\I64.\EXTEND\K{\_}\I32\K{\_s}`      :math:`\hex{AC}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_s>`   
-:math:`\I64.\EXTEND\K{\_}\I32\K{\_u}`      :math:`\hex{AD}`           :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_u>`   
-:math:`\I64.\TRUNC\K{\_}\F32\K{\_s}`       :math:`\hex{AE}`           :math:`[\F32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
-:math:`\I64.\TRUNC\K{\_}\F32\K{\_u}`       :math:`\hex{AF}`           :math:`[\F32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
-:math:`\I64.\TRUNC\K{\_}\F64\K{\_s}`       :math:`\hex{B0}`           :math:`[\F64] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`    
-:math:`\I64.\TRUNC\K{\_}\F64\K{\_u}`       :math:`\hex{B1}`           :math:`[\F64] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`    
-:math:`\F32.\CONVERT\K{\_}\I32\K{\_s}`     :math:`\hex{B2}`           :math:`[\I32] \to [\F32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
-:math:`\F32.\CONVERT\K{\_}\I32\K{\_u}`     :math:`\hex{B3}`           :math:`[\I32] \to [\F32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
-:math:`\F32.\CONVERT\K{\_}\I64\K{\_s}`     :math:`\hex{B4}`           :math:`[\I64] \to [\F32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
-:math:`\F32.\CONVERT\K{\_}\I64\K{\_u}`     :math:`\hex{B5}`           :math:`[\I64] \to [\F32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
-:math:`\F32.\DEMOTE\K{\_}\F64`             :math:`\hex{B6}`           :math:`[\F64] \to [\F32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-demote>`     
-:math:`\F64.\CONVERT\K{\_}\I32\K{\_s}`     :math:`\hex{B7}`           :math:`[\I32] \to [\F64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
-:math:`\F64.\CONVERT\K{\_}\I32\K{\_u}`     :math:`\hex{B8}`           :math:`[\I32] \to [\F64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
-:math:`\F64.\CONVERT\K{\_}\I64\K{\_s}`     :math:`\hex{B9}`           :math:`[\I64] \to [\F64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`  
-:math:`\F64.\CONVERT\K{\_}\I64\K{\_u}`     :math:`\hex{BA}`           :math:`[\I64] \to [\F64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`  
-:math:`\F64.\PROMOTE\K{\_}\F32`            :math:`\hex{BB}`           :math:`[\F32] \to [\F64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-promote>`    
-:math:`\I32.\REINTERPRET\K{\_}\F32`        :math:`\hex{BC}`           :math:`[\F32] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
-:math:`\I64.\REINTERPRET\K{\_}\F64`        :math:`\hex{BD}`           :math:`[\F64] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
-:math:`\F32.\REINTERPRET\K{\_}\I32`        :math:`\hex{BE}`           :math:`[\I32] \to [\F32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
-:math:`\F64.\REINTERPRET\K{\_}\I64`        :math:`\hex{BF}`           :math:`[\I64] \to [\F64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
-:math:`\I32.\EXTEND\K{8\_s}`               :math:`\hex{C0}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
-:math:`\I32.\EXTEND\K{16\_s}`              :math:`\hex{C1}`           :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
-:math:`\I64.\EXTEND\K{8\_s}`               :math:`\hex{C2}`           :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
-:math:`\I64.\EXTEND\K{16\_s}`              :math:`\hex{C3}`           :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
-:math:`\I64.\EXTEND\K{32\_s}`              :math:`\hex{C4}`           :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`             :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`  
-(reserved)                                 :math:`\hex{C5}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{C6}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{C7}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{C8}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{C9}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{CA}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{CB}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{CC}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{CD}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{CE}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{CF}`                                                                                                                                                                                      
-:math:`\REFNULL~\X{ht}`                    :math:`\hex{D0}`           :math:`[] \to [(\REF~\NULL~\X{ht})]`                             :ref:`validation <valid-ref.null>`         :ref:`execution <exec-ref.null>`                               
-:math:`\REFISNULL`                         :math:`\hex{D1}`           :math:`[(\REF~\NULL~\X{ht})] \to [\I32]`                         :ref:`validation <valid-ref.is_null>`      :ref:`execution <exec-ref.is_null>`                            
-:math:`\REFFUNC~x`                         :math:`\hex{D2}`           :math:`[] \to [\FUNCREF]`                                        :ref:`validation <valid-ref.func>`         :ref:`execution <exec-ref.func>`                               
-:math:`\REFASNONNULL`                      :math:`\hex{D3}`           :math:`[(\REF~\NULL~\X{ht})] \to [(\REF~\X{ht})]`                :ref:`validation <valid-ref.as_non_null>`  :ref:`execution <exec-ref.as_non_null>`                        
-:math:`\BRONNULL~l`                        :math:`\hex{D4}`           :math:`[t^\ast~(\REF~\NULL~\X{ht})] \to [t^\ast~(\REF~\X{ht})]`  :ref:`validation <valid-br_on_null>`       :ref:`execution <exec-br_on_null>`                             
-(reserved)                                 :math:`\hex{D5}`                                                                                                                                                                                      
-:math:`\BRONNONNULL~l`                     :math:`\hex{D6}`           :math:`[t^\ast~(\REF~\NULL~\X{ht})] \to [t^\ast]`                :ref:`validation <valid-br_on_non_null>`   :ref:`execution <exec-br_on_non_null>`                         
-(reserved)                                 :math:`\hex{D7}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{D8}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{D9}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{DA}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{DB}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{DC}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{DD}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{DE}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{DF}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{E0}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{E1}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{E2}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{E3}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{E4}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{E5}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{E6}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{E7}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{E8}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{E9}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{EA}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{EB}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{EC}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{ED}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{EE}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{EF}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{F0}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{F1}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{F2}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{F3}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{F4}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{F5}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{F6}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{F7}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{F8}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{F9}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{FA}`                                                                                                                                                                                      
-(reserved)                                 :math:`\hex{FB}`                                                                                                                                                                                      
-:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_s}`  :math:`\hex{FC}~\hex{00}`  :math:`[\F32] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
-:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_u}`  :math:`\hex{FC}~\hex{01}`  :math:`[\F32] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
-:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_s}`  :math:`\hex{FC}~\hex{02}`  :math:`[\F64] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
-:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_u}`  :math:`\hex{FC}~\hex{03}`  :math:`[\F64] \to [\I32]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
-:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_s}`  :math:`\hex{FC}~\hex{04}`  :math:`[\F32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
-:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_u}`  :math:`\hex{FC}~\hex{05}`  :math:`[\F32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
-:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_s}`  :math:`\hex{FC}~\hex{06}`  :math:`[\F64] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`
-:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_u}`  :math:`\hex{FC}~\hex{07}`  :math:`[\F64] \to [\I64]`                                        :ref:`validation <valid-cvtop>`            :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`
-:math:`\MEMORYINIT~x`                      :math:`\hex{FC}~\hex{08}`  :math:`[\I32~\I32~\I32] \to []`                                  :ref:`validation <valid-memory.init>`      :ref:`execution <exec-memory.init>`                            
-:math:`\DATADROP~x`                        :math:`\hex{FC}~\hex{09}`  :math:`[] \to []`                                                :ref:`validation <valid-data.drop>`        :ref:`execution <exec-data.drop>`                              
-:math:`\MEMORYCOPY`                        :math:`\hex{FC}~\hex{0A}`  :math:`[\I32~\I32~\I32] \to []`                                  :ref:`validation <valid-memory.copy>`      :ref:`execution <exec-memory.copy>`                            
-:math:`\MEMORYFILL`                        :math:`\hex{FC}~\hex{0B}`  :math:`[\I32~\I32~\I32] \to []`                                  :ref:`validation <valid-memory.fill>`      :ref:`execution <exec-memory.fill>`                            
-:math:`\TABLEINIT~x~y`                     :math:`\hex{FC}~\hex{0C}`  :math:`[\I32~\I32~\I32] \to []`                                  :ref:`validation <valid-table.init>`       :ref:`execution <exec-table.init>`                             
-:math:`\ELEMDROP~x`                        :math:`\hex{FC}~\hex{0D}`  :math:`[] \to []`                                                :ref:`validation <valid-elem.drop>`        :ref:`execution <exec-elem.drop>`                              
-:math:`\TABLECOPY~x~y`                     :math:`\hex{FC}~\hex{0E}`  :math:`[\I32~\I32~\I32] \to []`                                  :ref:`validation <valid-table.copy>`       :ref:`execution <exec-table.copy>`                             
-:math:`\TABLEGROW~x`                       :math:`\hex{FC}~\hex{0F}`  :math:`[t~\I32] \to []`                                          :ref:`validation <valid-table.grow>`       :ref:`execution <exec-table.grow>`                             
-:math:`\TABLESIZE~x`                       :math:`\hex{FC}~\hex{10}`  :math:`[] \to [\I32]`                                            :ref:`validation <valid-table.size>`       :ref:`execution <exec-table.size>`                             
-:math:`\TABLEFILL~x`                       :math:`\hex{FC}~\hex{11}`  :math:`[\I32~t~\I32] \to []`                                     :ref:`validation <valid-table.fill>`       :ref:`execution <exec-table.fill>`                             
-=========================================  =========================  ===============================================================  =========================================  ===============================================================
+=================================================  ==========================  ===============================================================  =============================================  ==================================================================
+Instruction                                        Binary Opcode               Type                                                             Validation                                     Execution                                                         
+=================================================  ==========================  ===============================================================  =============================================  ==================================================================
+:math:`\UNREACHABLE`                               :math:`\hex{00}`            :math:`[t_1^\ast] \to [t_2^\ast]`                                :ref:`validation <valid-unreachable>`          :ref:`execution <exec-unreachable>`                               
+:math:`\NOP`                                       :math:`\hex{01}`            :math:`[] \to []`                                                :ref:`validation <valid-nop>`                  :ref:`execution <exec-nop>`                                       
+:math:`\BLOCK~\X{bt}`                              :math:`\hex{02}`            :math:`[t_1^\ast] \to [t_2^\ast]`                                :ref:`validation <valid-block>`                :ref:`execution <exec-block>`                                     
+:math:`\LOOP~\X{bt}`                               :math:`\hex{03}`            :math:`[t_1^\ast] \to [t_2^\ast]`                                :ref:`validation <valid-loop>`                 :ref:`execution <exec-loop>`                                      
+:math:`\IF~\X{bt}`                                 :math:`\hex{04}`            :math:`[t_1^\ast~\I32] \to [t_2^\ast]`                           :ref:`validation <valid-if>`                   :ref:`execution <exec-if>`                                        
+:math:`\ELSE`                                      :math:`\hex{05}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{06}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{07}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{08}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{09}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{0A}`                                                                                                                                                                                              
+:math:`\END`                                       :math:`\hex{0B}`                                                                                                                                                                                              
+:math:`\BR~l`                                      :math:`\hex{0C}`            :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`                         :ref:`validation <valid-br>`                   :ref:`execution <exec-br>`                                        
+:math:`\BRIF~l`                                    :math:`\hex{0D}`            :math:`[t^\ast~\I32] \to [t^\ast]`                               :ref:`validation <valid-br_if>`                :ref:`execution <exec-br_if>`                                     
+:math:`\BRTABLE~l^\ast~l`                          :math:`\hex{0E}`            :math:`[t_1^\ast~t^\ast~\I32] \to [t_2^\ast]`                    :ref:`validation <valid-br_table>`             :ref:`execution <exec-br_table>`                                  
+:math:`\RETURN`                                    :math:`\hex{0F}`            :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`                         :ref:`validation <valid-return>`               :ref:`execution <exec-return>`                                    
+:math:`\CALL~x`                                    :math:`\hex{10}`            :math:`[t_1^\ast] \to [t_2^\ast]`                                :ref:`validation <valid-call>`                 :ref:`execution <exec-call>`                                      
+:math:`\CALLINDIRECT~x~y`                          :math:`\hex{11}`            :math:`[t_1^\ast~\I32] \to [t_2^\ast]`                           :ref:`validation <valid-call_indirect>`        :ref:`execution <exec-call_indirect>`                             
+(reserved)                                         :math:`\hex{12}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{13}`                                                                                                                                                                                              
+:math:`\CALLREF`                                   :math:`\hex{14}`            :math:`[t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]`                 :ref:`validation <valid-call_ref>`             :ref:`execution <exec-call_ref>`                                  
+(reserved)                                         :math:`\hex{15}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{16}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{17}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{18}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{19}`                                                                                                                                                                                              
+:math:`\DROP`                                      :math:`\hex{1A}`            :math:`[t] \to []`                                               :ref:`validation <valid-drop>`                 :ref:`execution <exec-drop>`                                      
+:math:`\SELECT`                                    :math:`\hex{1B}`            :math:`[t~t~\I32] \to [t]`                                       :ref:`validation <valid-select>`               :ref:`execution <exec-select>`                                    
+:math:`\SELECT~t`                                  :math:`\hex{1C}`            :math:`[t~t~\I32] \to [t]`                                       :ref:`validation <valid-select>`               :ref:`execution <exec-select>`                                    
+(reserved)                                         :math:`\hex{1D}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{1E}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{1F}`                                                                                                                                                                                              
+:math:`\LOCALGET~x`                                :math:`\hex{20}`            :math:`[] \to [t]`                                               :ref:`validation <valid-local.get>`            :ref:`execution <exec-local.get>`                                 
+:math:`\LOCALSET~x`                                :math:`\hex{21}`            :math:`[t] \to []`                                               :ref:`validation <valid-local.set>`            :ref:`execution <exec-local.set>`                                 
+:math:`\LOCALTEE~x`                                :math:`\hex{22}`            :math:`[t] \to [t]`                                              :ref:`validation <valid-local.tee>`            :ref:`execution <exec-local.tee>`                                 
+:math:`\GLOBALGET~x`                               :math:`\hex{23}`            :math:`[] \to [t]`                                               :ref:`validation <valid-global.get>`           :ref:`execution <exec-global.get>`                                
+:math:`\GLOBALSET~x`                               :math:`\hex{24}`            :math:`[t] \to []`                                               :ref:`validation <valid-global.set>`           :ref:`execution <exec-global.set>`                                
+:math:`\TABLEGET~x`                                :math:`\hex{25}`            :math:`[\I32] \to [t]`                                           :ref:`validation <valid-table.get>`            :ref:`execution <exec-table.get>`                                 
+:math:`\TABLESET~x`                                :math:`\hex{26}`            :math:`[\I32~t] \to []`                                          :ref:`validation <valid-table.set>`            :ref:`execution <exec-table.set>`                                 
+(reserved)                                         :math:`\hex{27}`                                                                                                                                                                                              
+:math:`\I32.\LOAD~\memarg`                         :math:`\hex{28}`            :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
+:math:`\I64.\LOAD~\memarg`                         :math:`\hex{29}`            :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
+:math:`\F32.\LOAD~\memarg`                         :math:`\hex{2A}`            :math:`[\I32] \to [\F32]`                                        :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
+:math:`\F64.\LOAD~\memarg`                         :math:`\hex{2B}`            :math:`[\I32] \to [\F64]`                                        :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
+:math:`\I32.\LOAD\K{8\_s}~\memarg`                 :math:`\hex{2C}`            :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I32.\LOAD\K{8\_u}~\memarg`                 :math:`\hex{2D}`            :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I32.\LOAD\K{16\_s}~\memarg`                :math:`\hex{2E}`            :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I32.\LOAD\K{16\_u}~\memarg`                :math:`\hex{2F}`            :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I64.\LOAD\K{8\_s}~\memarg`                 :math:`\hex{30}`            :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I64.\LOAD\K{8\_u}~\memarg`                 :math:`\hex{31}`            :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I64.\LOAD\K{16\_s}~\memarg`                :math:`\hex{32}`            :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I64.\LOAD\K{16\_u}~\memarg`                :math:`\hex{33}`            :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I64.\LOAD\K{32\_s}~\memarg`                :math:`\hex{34}`            :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I64.\LOAD\K{32\_u}~\memarg`                :math:`\hex{35}`            :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I32.\STORE~\memarg`                        :math:`\hex{36}`            :math:`[\I32~\I32] \to []`                                       :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
+:math:`\I64.\STORE~\memarg`                        :math:`\hex{37}`            :math:`[\I32~\I64] \to []`                                       :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
+:math:`\F32.\STORE~\memarg`                        :math:`\hex{38}`            :math:`[\I32~\F32] \to []`                                       :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
+:math:`\F64.\STORE~\memarg`                        :math:`\hex{39}`            :math:`[\I32~\F64] \to []`                                       :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
+:math:`\I32.\STORE\K{8}~\memarg`                   :math:`\hex{3A}`            :math:`[\I32~\I32] \to []`                                       :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
+:math:`\I32.\STORE\K{16}~\memarg`                  :math:`\hex{3B}`            :math:`[\I32~\I32] \to []`                                       :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
+:math:`\I64.\STORE\K{8}~\memarg`                   :math:`\hex{3C}`            :math:`[\I32~\I64] \to []`                                       :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
+:math:`\I64.\STORE\K{16}~\memarg`                  :math:`\hex{3D}`            :math:`[\I32~\I64] \to []`                                       :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
+:math:`\I64.\STORE\K{32}~\memarg`                  :math:`\hex{3E}`            :math:`[\I32~\I64] \to []`                                       :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
+:math:`\MEMORYSIZE`                                :math:`\hex{3F}`            :math:`[] \to [\I32]`                                            :ref:`validation <valid-memory.size>`          :ref:`execution <exec-memory.size>`                               
+:math:`\MEMORYGROW`                                :math:`\hex{40}`            :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-memory.grow>`          :ref:`execution <exec-memory.grow>`                               
+:math:`\I32.\CONST~\i32`                           :math:`\hex{41}`            :math:`[] \to [\I32]`                                            :ref:`validation <valid-const>`                :ref:`execution <exec-const>`                                     
+:math:`\I64.\CONST~\i64`                           :math:`\hex{42}`            :math:`[] \to [\I64]`                                            :ref:`validation <valid-const>`                :ref:`execution <exec-const>`                                     
+:math:`\F32.\CONST~\f32`                           :math:`\hex{43}`            :math:`[] \to [\F32]`                                            :ref:`validation <valid-const>`                :ref:`execution <exec-const>`                                     
+:math:`\F64.\CONST~\f64`                           :math:`\hex{44}`            :math:`[] \to [\F64]`                                            :ref:`validation <valid-const>`                :ref:`execution <exec-const>`                                     
+:math:`\I32.\EQZ`                                  :math:`\hex{45}`            :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-testop>`               :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`         
+:math:`\I32.\EQ`                                   :math:`\hex{46}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`           
+:math:`\I32.\NE`                                   :math:`\hex{47}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`           
+:math:`\I32.\LT\K{\_s}`                            :math:`\hex{48}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`         
+:math:`\I32.\LT\K{\_u}`                            :math:`\hex{49}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`         
+:math:`\I32.\GT\K{\_s}`                            :math:`\hex{4A}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`         
+:math:`\I32.\GT\K{\_u}`                            :math:`\hex{4B}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`         
+:math:`\I32.\LE\K{\_s}`                            :math:`\hex{4C}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`         
+:math:`\I32.\LE\K{\_u}`                            :math:`\hex{4D}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`         
+:math:`\I32.\GE\K{\_s}`                            :math:`\hex{4E}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`         
+:math:`\I32.\GE\K{\_u}`                            :math:`\hex{4F}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`         
+:math:`\I64.\EQZ`                                  :math:`\hex{50}`            :math:`[\I64] \to [\I32]`                                        :ref:`validation <valid-testop>`               :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`         
+:math:`\I64.\EQ`                                   :math:`\hex{51}`            :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`           
+:math:`\I64.\NE`                                   :math:`\hex{52}`            :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`           
+:math:`\I64.\LT\K{\_s}`                            :math:`\hex{53}`            :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`         
+:math:`\I64.\LT\K{\_u}`                            :math:`\hex{54}`            :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`         
+:math:`\I64.\GT\K{\_s}`                            :math:`\hex{55}`            :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`         
+:math:`\I64.\GT\K{\_u}`                            :math:`\hex{56}`            :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`         
+:math:`\I64.\LE\K{\_s}`                            :math:`\hex{57}`            :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`         
+:math:`\I64.\LE\K{\_u}`                            :math:`\hex{58}`            :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`         
+:math:`\I64.\GE\K{\_s}`                            :math:`\hex{59}`            :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`         
+:math:`\I64.\GE\K{\_u}`                            :math:`\hex{5A}`            :math:`[\I64~\I64] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`         
+:math:`\F32.\EQ`                                   :math:`\hex{5B}`            :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`           
+:math:`\F32.\NE`                                   :math:`\hex{5C}`            :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`           
+:math:`\F32.\LT`                                   :math:`\hex{5D}`            :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`           
+:math:`\F32.\GT`                                   :math:`\hex{5E}`            :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`           
+:math:`\F32.\LE`                                   :math:`\hex{5F}`            :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`           
+:math:`\F32.\GE`                                   :math:`\hex{60}`            :math:`[\F32~\F32] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`           
+:math:`\F64.\EQ`                                   :math:`\hex{61}`            :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`           
+:math:`\F64.\NE`                                   :math:`\hex{62}`            :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`           
+:math:`\F64.\LT`                                   :math:`\hex{63}`            :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`           
+:math:`\F64.\GT`                                   :math:`\hex{64}`            :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`           
+:math:`\F64.\LE`                                   :math:`\hex{65}`            :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`           
+:math:`\F64.\GE`                                   :math:`\hex{66}`            :math:`[\F64~\F64] \to [\I32]`                                   :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`           
+:math:`\I32.\CLZ`                                  :math:`\hex{67}`            :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`           
+:math:`\I32.\CTZ`                                  :math:`\hex{68}`            :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`           
+:math:`\I32.\POPCNT`                               :math:`\hex{69}`            :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`        
+:math:`\I32.\ADD`                                  :math:`\hex{6A}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`          
+:math:`\I32.\SUB`                                  :math:`\hex{6B}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`          
+:math:`\I32.\MUL`                                  :math:`\hex{6C}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`          
+:math:`\I32.\DIV\K{\_s}`                           :math:`\hex{6D}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`        
+:math:`\I32.\DIV\K{\_u}`                           :math:`\hex{6E}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`        
+:math:`\I32.\REM\K{\_s}`                           :math:`\hex{6F}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`        
+:math:`\I32.\REM\K{\_u}`                           :math:`\hex{70}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`        
+:math:`\I32.\AND`                                  :math:`\hex{71}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`          
+:math:`\I32.\OR`                                   :math:`\hex{72}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`           
+:math:`\I32.\XOR`                                  :math:`\hex{73}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`          
+:math:`\I32.\SHL`                                  :math:`\hex{74}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`          
+:math:`\I32.\SHR\K{\_s}`                           :math:`\hex{75}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`        
+:math:`\I32.\SHR\K{\_u}`                           :math:`\hex{76}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`        
+:math:`\I32.\ROTL`                                 :math:`\hex{77}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`         
+:math:`\I32.\ROTR`                                 :math:`\hex{78}`            :math:`[\I32~\I32] \to [\I32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`         
+:math:`\I64.\CLZ`                                  :math:`\hex{79}`            :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`           
+:math:`\I64.\CTZ`                                  :math:`\hex{7A}`            :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`           
+:math:`\I64.\POPCNT`                               :math:`\hex{7B}`            :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`        
+:math:`\I64.\ADD`                                  :math:`\hex{7C}`            :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`          
+:math:`\I64.\SUB`                                  :math:`\hex{7D}`            :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`          
+:math:`\I64.\MUL`                                  :math:`\hex{7E}`            :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`          
+:math:`\I64.\DIV\K{\_s}`                           :math:`\hex{7F}`            :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`        
+:math:`\I64.\DIV\K{\_u}`                           :math:`\hex{80}`            :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`        
+:math:`\I64.\REM\K{\_s}`                           :math:`\hex{81}`            :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`        
+:math:`\I64.\REM\K{\_u}`                           :math:`\hex{82}`            :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`        
+:math:`\I64.\AND`                                  :math:`\hex{83}`            :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`          
+:math:`\I64.\OR`                                   :math:`\hex{84}`            :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`           
+:math:`\I64.\XOR`                                  :math:`\hex{85}`            :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`          
+:math:`\I64.\SHL`                                  :math:`\hex{86}`            :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`          
+:math:`\I64.\SHR\K{\_s}`                           :math:`\hex{87}`            :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`        
+:math:`\I64.\SHR\K{\_u}`                           :math:`\hex{88}`            :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`        
+:math:`\I64.\ROTL`                                 :math:`\hex{89}`            :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`         
+:math:`\I64.\ROTR`                                 :math:`\hex{8A}`            :math:`[\I64~\I64] \to [\I64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`         
+:math:`\F32.\ABS`                                  :math:`\hex{8B}`            :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`           
+:math:`\F32.\NEG`                                  :math:`\hex{8C}`            :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`           
+:math:`\F32.\CEIL`                                 :math:`\hex{8D}`            :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`          
+:math:`\F32.\FLOOR`                                :math:`\hex{8E}`            :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`         
+:math:`\F32.\TRUNC`                                :math:`\hex{8F}`            :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`         
+:math:`\F32.\NEAREST`                              :math:`\hex{90}`            :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`       
+:math:`\F32.\SQRT`                                 :math:`\hex{91}`            :math:`[\F32] \to [\F32]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`          
+:math:`\F32.\ADD`                                  :math:`\hex{92}`            :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`          
+:math:`\F32.\SUB`                                  :math:`\hex{93}`            :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`          
+:math:`\F32.\MUL`                                  :math:`\hex{94}`            :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`          
+:math:`\F32.\DIV`                                  :math:`\hex{95}`            :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`          
+:math:`\F32.\FMIN`                                 :math:`\hex{96}`            :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`          
+:math:`\F32.\FMAX`                                 :math:`\hex{97}`            :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`          
+:math:`\F32.\COPYSIGN`                             :math:`\hex{98}`            :math:`[\F32~\F32] \to [\F32]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`     
+:math:`\F64.\ABS`                                  :math:`\hex{99}`            :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`           
+:math:`\F64.\NEG`                                  :math:`\hex{9A}`            :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`           
+:math:`\F64.\CEIL`                                 :math:`\hex{9B}`            :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`          
+:math:`\F64.\FLOOR`                                :math:`\hex{9C}`            :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`         
+:math:`\F64.\TRUNC`                                :math:`\hex{9D}`            :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`         
+:math:`\F64.\NEAREST`                              :math:`\hex{9E}`            :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`       
+:math:`\F64.\SQRT`                                 :math:`\hex{9F}`            :math:`[\F64] \to [\F64]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`          
+:math:`\F64.\ADD`                                  :math:`\hex{A0}`            :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`          
+:math:`\F64.\SUB`                                  :math:`\hex{A1}`            :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`          
+:math:`\F64.\MUL`                                  :math:`\hex{A2}`            :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`          
+:math:`\F64.\DIV`                                  :math:`\hex{A3}`            :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`          
+:math:`\F64.\FMIN`                                 :math:`\hex{A4}`            :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`          
+:math:`\F64.\FMAX`                                 :math:`\hex{A5}`            :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`          
+:math:`\F64.\COPYSIGN`                             :math:`\hex{A6}`            :math:`[\F64~\F64] \to [\F64]`                                   :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`     
+:math:`\I32.\WRAP\K{\_}\I64`                       :math:`\hex{A7}`            :math:`[\I64] \to [\I32]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-wrap>`          
+:math:`\I32.\TRUNC\K{\_}\F32\K{\_s}`               :math:`\hex{A8}`            :math:`[\F32] \to [\I32]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`       
+:math:`\I32.\TRUNC\K{\_}\F32\K{\_u}`               :math:`\hex{A9}`            :math:`[\F32] \to [\I32]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`       
+:math:`\I32.\TRUNC\K{\_}\F64\K{\_s}`               :math:`\hex{AA}`            :math:`[\F64] \to [\I32]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`       
+:math:`\I32.\TRUNC\K{\_}\F64\K{\_u}`               :math:`\hex{AB}`            :math:`[\F64] \to [\I32]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`       
+:math:`\I64.\EXTEND\K{\_}\I32\K{\_s}`              :math:`\hex{AC}`            :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_s>`      
+:math:`\I64.\EXTEND\K{\_}\I32\K{\_u}`              :math:`\hex{AD}`            :math:`[\I32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_u>`      
+:math:`\I64.\TRUNC\K{\_}\F32\K{\_s}`               :math:`\hex{AE}`            :math:`[\F32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`       
+:math:`\I64.\TRUNC\K{\_}\F32\K{\_u}`               :math:`\hex{AF}`            :math:`[\F32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`       
+:math:`\I64.\TRUNC\K{\_}\F64\K{\_s}`               :math:`\hex{B0}`            :math:`[\F64] \to [\I64]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`       
+:math:`\I64.\TRUNC\K{\_}\F64\K{\_u}`               :math:`\hex{B1}`            :math:`[\F64] \to [\I64]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`       
+:math:`\F32.\CONVERT\K{\_}\I32\K{\_s}`             :math:`\hex{B2}`            :math:`[\I32] \to [\F32]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`     
+:math:`\F32.\CONVERT\K{\_}\I32\K{\_u}`             :math:`\hex{B3}`            :math:`[\I32] \to [\F32]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`     
+:math:`\F32.\CONVERT\K{\_}\I64\K{\_s}`             :math:`\hex{B4}`            :math:`[\I64] \to [\F32]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`     
+:math:`\F32.\CONVERT\K{\_}\I64\K{\_u}`             :math:`\hex{B5}`            :math:`[\I64] \to [\F32]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`     
+:math:`\F32.\DEMOTE\K{\_}\F64`                     :math:`\hex{B6}`            :math:`[\F64] \to [\F32]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-demote>`        
+:math:`\F64.\CONVERT\K{\_}\I32\K{\_s}`             :math:`\hex{B7}`            :math:`[\I32] \to [\F64]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`     
+:math:`\F64.\CONVERT\K{\_}\I32\K{\_u}`             :math:`\hex{B8}`            :math:`[\I32] \to [\F64]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`     
+:math:`\F64.\CONVERT\K{\_}\I64\K{\_s}`             :math:`\hex{B9}`            :math:`[\I64] \to [\F64]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`     
+:math:`\F64.\CONVERT\K{\_}\I64\K{\_u}`             :math:`\hex{BA}`            :math:`[\I64] \to [\F64]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`     
+:math:`\F64.\PROMOTE\K{\_}\F32`                    :math:`\hex{BB}`            :math:`[\F32] \to [\F64]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-promote>`       
+:math:`\I32.\REINTERPRET\K{\_}\F32`                :math:`\hex{BC}`            :math:`[\F32] \to [\I32]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`   
+:math:`\I64.\REINTERPRET\K{\_}\F64`                :math:`\hex{BD}`            :math:`[\F64] \to [\I64]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`   
+:math:`\F32.\REINTERPRET\K{\_}\I32`                :math:`\hex{BE}`            :math:`[\I32] \to [\F32]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`   
+:math:`\F64.\REINTERPRET\K{\_}\I64`                :math:`\hex{BF}`            :math:`[\I64] \to [\F64]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`   
+:math:`\I32.\EXTEND\K{8\_s}`                       :math:`\hex{C0}`            :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
+:math:`\I32.\EXTEND\K{16\_s}`                      :math:`\hex{C1}`            :math:`[\I32] \to [\I32]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
+:math:`\I64.\EXTEND\K{8\_s}`                       :math:`\hex{C2}`            :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
+:math:`\I64.\EXTEND\K{16\_s}`                      :math:`\hex{C3}`            :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
+:math:`\I64.\EXTEND\K{32\_s}`                      :math:`\hex{C4}`            :math:`[\I64] \to [\I64]`                                        :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
+(reserved)                                         :math:`\hex{C5}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{C6}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{C7}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{C8}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{C9}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{CA}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{CB}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{CC}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{CD}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{CE}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{CF}`                                                                                                                                                                                              
+:math:`\REFNULL~\X{ht}`                            :math:`\hex{D0}`            :math:`[] \to [(\REF~\NULL~\X{ht})]`                             :ref:`validation <valid-ref.null>`             :ref:`execution <exec-ref.null>`                                  
+:math:`\REFISNULL`                                 :math:`\hex{D1}`            :math:`[(\REF~\NULL~\X{ht})] \to [\I32]`                         :ref:`validation <valid-ref.is_null>`          :ref:`execution <exec-ref.is_null>`                               
+:math:`\REFFUNC~x`                                 :math:`\hex{D2}`            :math:`[] \to [\FUNCREF]`                                        :ref:`validation <valid-ref.func>`             :ref:`execution <exec-ref.func>`                                  
+:math:`\REFASNONNULL`                              :math:`\hex{D3}`            :math:`[(\REF~\NULL~\X{ht})] \to [(\REF~\X{ht})]`                :ref:`validation <valid-ref.as_non_null>`      :ref:`execution <exec-ref.as_non_null>`                           
+:math:`\BRONNULL~l`                                :math:`\hex{D4}`            :math:`[t^\ast~(\REF~\NULL~\X{ht})] \to [t^\ast~(\REF~\X{ht})]`  :ref:`validation <valid-br_on_null>`           :ref:`execution <exec-br_on_null>`                                
+(reserved)                                         :math:`\hex{D5}`                                                                                                                                                                                              
+:math:`\BRONNONNULL~l`                             :math:`\hex{D6}`            :math:`[t^\ast~(\REF~\NULL~\X{ht})] \to [t^\ast]`                :ref:`validation <valid-br_on_non_null>`       :ref:`execution <exec-br_on_non_null>`                            
+(reserved)                                         :math:`\hex{D7}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{D8}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{D9}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{DA}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{DB}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{DC}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{DD}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{DE}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{DF}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{E0}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{E1}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{E2}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{E3}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{E4}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{E5}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{E6}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{E7}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{E8}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{E9}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{EA}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{EB}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{EC}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{ED}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{EE}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{EF}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{F0}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{F1}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{F2}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{F3}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{F4}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{F5}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{F6}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{F7}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{F8}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{F9}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{FA}`                                                                                                                                                                                              
+(reserved)                                         :math:`\hex{FB}`                                                                                                                                                                                              
+:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_s}`          :math:`\hex{FC}~\hex{00}`   :math:`[\F32] \to [\I32]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
+:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_u}`          :math:`\hex{FC}~\hex{01}`   :math:`[\F32] \to [\I32]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
+:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_s}`          :math:`\hex{FC}~\hex{02}`   :math:`[\F64] \to [\I32]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
+:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_u}`          :math:`\hex{FC}~\hex{03}`   :math:`[\F64] \to [\I32]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
+:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_s}`          :math:`\hex{FC}~\hex{04}`   :math:`[\F32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
+:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_u}`          :math:`\hex{FC}~\hex{05}`   :math:`[\F32] \to [\I64]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
+:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_s}`          :math:`\hex{FC}~\hex{06}`   :math:`[\F64] \to [\I64]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
+:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_u}`          :math:`\hex{FC}~\hex{07}`   :math:`[\F64] \to [\I64]`                                        :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
+:math:`\MEMORYINIT~x`                              :math:`\hex{FC}~\hex{08}`   :math:`[\I32~\I32~\I32] \to []`                                  :ref:`validation <valid-memory.init>`          :ref:`execution <exec-memory.init>`                               
+:math:`\DATADROP~x`                                :math:`\hex{FC}~\hex{09}`   :math:`[] \to []`                                                :ref:`validation <valid-data.drop>`            :ref:`execution <exec-data.drop>`                                 
+:math:`\MEMORYCOPY`                                :math:`\hex{FC}~\hex{0A}`   :math:`[\I32~\I32~\I32] \to []`                                  :ref:`validation <valid-memory.copy>`          :ref:`execution <exec-memory.copy>`                               
+:math:`\MEMORYFILL`                                :math:`\hex{FC}~\hex{0B}`   :math:`[\I32~\I32~\I32] \to []`                                  :ref:`validation <valid-memory.fill>`          :ref:`execution <exec-memory.fill>`                               
+:math:`\TABLEINIT~x~y`                             :math:`\hex{FC}~\hex{0C}`   :math:`[\I32~\I32~\I32] \to []`                                  :ref:`validation <valid-table.init>`           :ref:`execution <exec-table.init>`                                
+:math:`\ELEMDROP~x`                                :math:`\hex{FC}~\hex{0D}`   :math:`[] \to []`                                                :ref:`validation <valid-elem.drop>`            :ref:`execution <exec-elem.drop>`                                 
+:math:`\TABLECOPY~x~y`                             :math:`\hex{FC}~\hex{0E}`   :math:`[\I32~\I32~\I32] \to []`                                  :ref:`validation <valid-table.copy>`           :ref:`execution <exec-table.copy>`                                
+:math:`\TABLEGROW~x`                               :math:`\hex{FC}~\hex{0F}`   :math:`[t~\I32] \to [\I32]`                                      :ref:`validation <valid-table.grow>`           :ref:`execution <exec-table.grow>`                                
+:math:`\TABLESIZE~x`                               :math:`\hex{FC}~\hex{10}`   :math:`[] \to [\I32]`                                            :ref:`validation <valid-table.size>`           :ref:`execution <exec-table.size>`                                
+:math:`\TABLEFILL~x`                               :math:`\hex{FC}~\hex{11}`   :math:`[\I32~t~\I32] \to []`                                     :ref:`validation <valid-table.fill>`           :ref:`execution <exec-table.fill>`                                
+:math:`\V128.\LOAD~\memarg`                        :math:`\hex{FD}~~\hex{00}`  :math:`[\I32] \to [\V128]`                                       :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
+:math:`\V128.\LOAD\K{8x8\_s}~\memarg`              :math:`\hex{FD}~~\hex{01}`  :math:`[\I32] \to [\V128]`                                       :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\V128.\LOAD\K{8x8\_u}~\memarg`              :math:`\hex{FD}~~\hex{02}`  :math:`[\I32] \to [\V128]`                                       :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\V128.\LOAD\K{16x4\_s}~\memarg`             :math:`\hex{FD}~~\hex{03}`  :math:`[\I32] \to [\V128]`                                       :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\V128.\LOAD\K{16x4\_u}~\memarg`             :math:`\hex{FD}~~\hex{04}`  :math:`[\I32] \to [\V128]`                                       :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\V128.\LOAD\K{32x2\_s}~\memarg`             :math:`\hex{FD}~~\hex{05}`  :math:`[\I32] \to [\V128]`                                       :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\V128.\LOAD\K{32x2\_u}~\memarg`             :math:`\hex{FD}~~\hex{06}`  :math:`[\I32] \to [\V128]`                                       :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\V128.\LOAD\K{\_splat}~\memarg`             :math:`\hex{FD}~~\hex{07}`  :math:`[\I32] \to [\V128]`                                       :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
+:math:`\V128.\LOAD\K{\_splat}~\memarg`             :math:`\hex{FD}~~\hex{08}`  :math:`[\I32] \to [\V128]`                                       :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
+:math:`\V128.\LOAD\K{\_splat}~\memarg`             :math:`\hex{FD}~~\hex{09}`  :math:`[\I32] \to [\V128]`                                       :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
+:math:`\V128.\LOAD\K{\_splat}~\memarg`             :math:`\hex{FD}~~\hex{0A}`  :math:`[\I32] \to [\V128]`                                       :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
+:math:`\V128.\STORE~\memarg`                       :math:`\hex{FD}~~\hex{0B}`  :math:`[\I32~\V128] \to []`                                      :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
+:math:`\V128.\VCONST~\i128`                        :math:`\hex{FD}~~\hex{0C}`  :math:`[] \to [\V128]`                                           :ref:`validation <valid-vconst>`               :ref:`execution <exec-vconst>`                                    
+:math:`\I8X16.\SHUFFLE~\laneidx^{16}`              :math:`\hex{FD}~~\hex{0D}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vec-shuffle>`          :ref:`execution <exec-vec-shuffle>`                               
+:math:`\I8X16.\SWIZZLE`                            :math:`\hex{FD}~~\hex{0E}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-swizzle>`                               
+:math:`\I8X16.\SPLAT`                              :math:`\hex{FD}~~\hex{0F}`  :math:`[\I32] \to [\V128]`                                       :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
+:math:`\I16X8.\SPLAT`                              :math:`\hex{FD}~~\hex{10}`  :math:`[\I32] \to [\V128]`                                       :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
+:math:`\I32X4.\SPLAT`                              :math:`\hex{FD}~~\hex{11}`  :math:`[\I32] \to [\V128]`                                       :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
+:math:`\I64X2.\SPLAT`                              :math:`\hex{FD}~~\hex{12}`  :math:`[\I64] \to [\V128]`                                       :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
+:math:`\F32X4.\SPLAT`                              :math:`\hex{FD}~~\hex{13}`  :math:`[\F32] \to [\V128]`                                       :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
+:math:`\F64X2.\SPLAT`                              :math:`\hex{FD}~~\hex{14}`  :math:`[\F64] \to [\V128]`                                       :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
+:math:`\I8X16.\EXTRACTLANE\K{\_s}~\laneidx`        :math:`\hex{FD}~~\hex{15}`  :math:`[\V128] \to [\I32]`                                       :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\I8X16.\EXTRACTLANE\K{\_u}~\laneidx`        :math:`\hex{FD}~~\hex{16}`  :math:`[\V128] \to [\I32]`                                       :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\I8X16.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{17}`  :math:`[\V128~\I32] \to [\V128]`                                 :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
+:math:`\I16X8.\EXTRACTLANE\K{\_s}~\laneidx`        :math:`\hex{FD}~~\hex{18}`  :math:`[\V128] \to [\I32]`                                       :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\I16X8.\EXTRACTLANE\K{\_u}~\laneidx`        :math:`\hex{FD}~~\hex{19}`  :math:`[\V128] \to [\I32]`                                       :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\I16X8.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{1A}`  :math:`[\V128~\I32] \to [\V128]`                                 :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
+:math:`\I32X4.\EXTRACTLANE~\laneidx`               :math:`\hex{FD}~~\hex{1B}`  :math:`[\V128] \to [\I32]`                                       :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\I32X4.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{1C}`  :math:`[\V128~\I32] \to [\V128]`                                 :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
+:math:`\I64X2.\EXTRACTLANE~\laneidx`               :math:`\hex{FD}~~\hex{1D}`  :math:`[\V128] \to [\I64]`                                       :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\I64X2.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{1E}`  :math:`[\V128~\I64] \to [\V128]`                                 :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
+:math:`\F32X4.\EXTRACTLANE~\laneidx`               :math:`\hex{FD}~~\hex{1F}`  :math:`[\V128] \to [\F32]`                                       :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\F32X4.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{20}`  :math:`[\V128~\F32] \to [\V128]`                                 :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
+:math:`\F64X2.\EXTRACTLANE~\laneidx`               :math:`\hex{FD}~~\hex{21}`  :math:`[\V128] \to [\F64]`                                       :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\F64X2.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{22}`  :math:`[\V128~\F64] \to [\V128]`                                 :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
+:math:`\I8X16.\VEQ`                                :math:`\hex{FD}~~\hex{23}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ieq>`          
+:math:`\I8X16.\VNE`                                :math:`\hex{FD}~~\hex{24}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ine>`          
+:math:`\I8X16.\VLT\K{\_s}`                         :math:`\hex{FD}~~\hex{25}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_s>`        
+:math:`\I8X16.\VLT\K{\_u}`                         :math:`\hex{FD}~~\hex{26}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_u>`        
+:math:`\I8X16.\VGT\K{\_s}`                         :math:`\hex{FD}~~\hex{27}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_s>`        
+:math:`\I8X16.\VGT\K{\_u}`                         :math:`\hex{FD}~~\hex{28}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_u>`        
+:math:`\I8X16.\VLE\K{\_s}`                         :math:`\hex{FD}~~\hex{29}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_s>`        
+:math:`\I8X16.\VLE\K{\_u}`                         :math:`\hex{FD}~~\hex{2A}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_u>`        
+:math:`\I8X16.\VGE\K{\_s}`                         :math:`\hex{FD}~~\hex{2B}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_s>`        
+:math:`\I8X16.\VGE\K{\_u}`                         :math:`\hex{FD}~~\hex{2C}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_u>`        
+:math:`\I16X8.\VEQ`                                :math:`\hex{FD}~~\hex{2D}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ieq>`          
+:math:`\I16X8.\VNE`                                :math:`\hex{FD}~~\hex{2E}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ine>`          
+:math:`\I16X8.\VLT\K{\_s}`                         :math:`\hex{FD}~~\hex{2F}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_s>`        
+:math:`\I16X8.\VLT\K{\_u}`                         :math:`\hex{FD}~~\hex{30}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_u>`        
+:math:`\I16X8.\VGT\K{\_s}`                         :math:`\hex{FD}~~\hex{31}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_s>`        
+:math:`\I16X8.\VGT\K{\_u}`                         :math:`\hex{FD}~~\hex{32}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_u>`        
+:math:`\I16X8.\VLE\K{\_s}`                         :math:`\hex{FD}~~\hex{33}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_s>`        
+:math:`\I16X8.\VLE\K{\_u}`                         :math:`\hex{FD}~~\hex{34}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_u>`        
+:math:`\I16X8.\VGE\K{\_s}`                         :math:`\hex{FD}~~\hex{35}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_s>`        
+:math:`\I16X8.\VGE\K{\_u}`                         :math:`\hex{FD}~~\hex{36}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_u>`        
+:math:`\I32X4.\VEQ`                                :math:`\hex{FD}~~\hex{37}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ieq>`          
+:math:`\I32X4.\VNE`                                :math:`\hex{FD}~~\hex{38}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ine>`          
+:math:`\I32X4.\VLT\K{\_s}`                         :math:`\hex{FD}~~\hex{39}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_s>`        
+:math:`\I32X4.\VLT\K{\_u}`                         :math:`\hex{FD}~~\hex{3A}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_u>`        
+:math:`\I32X4.\VGT\K{\_s}`                         :math:`\hex{FD}~~\hex{3B}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_s>`        
+:math:`\I32X4.\VGT\K{\_u}`                         :math:`\hex{FD}~~\hex{3C}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_u>`        
+:math:`\I32X4.\VLE\K{\_s}`                         :math:`\hex{FD}~~\hex{3D}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_s>`        
+:math:`\I32X4.\VLE\K{\_u}`                         :math:`\hex{FD}~~\hex{3E}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_u>`        
+:math:`\I32X4.\VGE\K{\_s}`                         :math:`\hex{FD}~~\hex{3F}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_s>`        
+:math:`\I32X4.\VGE\K{\_u}`                         :math:`\hex{FD}~~\hex{40}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_u>`        
+:math:`\F32X4.\VEQ`                                :math:`\hex{FD}~~\hex{41}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-feq>`          
+:math:`\F32X4.\VNE`                                :math:`\hex{FD}~~\hex{42}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fne>`          
+:math:`\F32X4.\VLT`                                :math:`\hex{FD}~~\hex{43}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-flt>`          
+:math:`\F32X4.\VGT`                                :math:`\hex{FD}~~\hex{44}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fgt>`          
+:math:`\F32X4.\VLE`                                :math:`\hex{FD}~~\hex{45}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fle>`          
+:math:`\F32X4.\VGE`                                :math:`\hex{FD}~~\hex{46}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fge>`          
+:math:`\F64X2.\VEQ`                                :math:`\hex{FD}~~\hex{47}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-feq>`          
+:math:`\F64X2.\VNE`                                :math:`\hex{FD}~~\hex{48}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fne>`          
+:math:`\F64X2.\VLT`                                :math:`\hex{FD}~~\hex{49}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-flt>`          
+:math:`\F64X2.\VGT`                                :math:`\hex{FD}~~\hex{4A}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fgt>`          
+:math:`\F64X2.\VLE`                                :math:`\hex{FD}~~\hex{4B}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fle>`          
+:math:`\F64X2.\VGE`                                :math:`\hex{FD}~~\hex{4C}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fge>`          
+:math:`\V128.\VNOT`                                :math:`\hex{FD}~~\hex{4D}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vvunop>`               :ref:`execution <exec-vvunop>`, :ref:`operator <op-inot>`         
+:math:`\V128.\VAND`                                :math:`\hex{FD}~~\hex{4E}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vvbinop>`              :ref:`execution <exec-vvbinop>`, :ref:`operator <op-iand>`        
+:math:`\V128.\VANDNOT`                             :math:`\hex{FD}~~\hex{4F}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vvbinop>`              :ref:`execution <exec-vvbinop>`, :ref:`operator <op-iandnot>`     
+:math:`\V128.\VOR`                                 :math:`\hex{FD}~~\hex{50}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vvbinop>`              :ref:`execution <exec-vvbinop>`, :ref:`operator <op-ior>`         
+:math:`\V128.\VXOR`                                :math:`\hex{FD}~~\hex{51}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vvbinop>`              :ref:`execution <exec-vvbinop>`, :ref:`operator <op-ixor>`        
+:math:`\V128.\BITSELECT`                           :math:`\hex{FD}~~\hex{52}`  :math:`[\V128~\V128~\V128] \to [\V128]`                          :ref:`validation <valid-vvternop>`             :ref:`execution <exec-vvternop>`, :ref:`operator <op-ibitselect>` 
+:math:`\V128.\ANYTRUE`                             :math:`\hex{FD}~~\hex{53}`  :math:`[\V128] \to [\I32]`                                       :ref:`validation <valid-vvtestop>`             :ref:`execution <exec-vvtestop>`                                  
+:math:`\V128.\LOAD\K{8\_lane}~\memarg~\laneidx`    :math:`\hex{FD}~~\hex{54}`  :math:`[\I32~\V128] \to [\V128]`                                 :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
+:math:`\V128.\LOAD\K{16\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{55}`  :math:`[\I32~\V128] \to [\V128]`                                 :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
+:math:`\V128.\LOAD\K{32\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{56}`  :math:`[\I32~\V128] \to [\V128]`                                 :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
+:math:`\V128.\LOAD\K{64\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{57}`  :math:`[\I32~\V128] \to [\V128]`                                 :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
+:math:`\V128.\STORE\K{8\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{58}`  :math:`[\I32~\V128] \to [\V128]`                                 :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
+:math:`\V128.\STORE\K{16\_lane}~\memarg~\laneidx`  :math:`\hex{FD}~~\hex{59}`  :math:`[\I32~\V128] \to [\V128]`                                 :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
+:math:`\V128.\STORE\K{32\_lane}~\memarg~\laneidx`  :math:`\hex{FD}~~\hex{5A}`  :math:`[\I32~\V128] \to [\V128]`                                 :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
+:math:`\V128.\STORE\K{64\_lane}~\memarg~\laneidx`  :math:`\hex{FD}~~\hex{5B}`  :math:`[\I32~\V128] \to [\V128]`                                 :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
+:math:`\V128.\LOAD\K{32\_zero}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{5C}`  :math:`[\I32] \to [\V128]`                                       :ref:`validation <valid-load-zero>`            :ref:`execution <exec-load-zero>`                                 
+:math:`\V128.\LOAD\K{64\_zero}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{5D}`  :math:`[\I32] \to [\V128]`                                       :ref:`validation <valid-load-zero>`            :ref:`execution <exec-load-zero>`                                 
+:math:`\F32X4.\VDEMOTE\K{\_f64x2\_zero}`           :math:`\hex{FD}~~\hex{5E}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-demote>`       
+:math:`\F64X2.\VPROMOTE\K{\_low\_f32x4}`           :math:`\hex{FD}~~\hex{5F}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-promote>`      
+:math:`\I8X16.\VABS`                               :math:`\hex{FD}~~\hex{60}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-iabs>`          
+:math:`\I8X16.\VNEG`                               :math:`\hex{FD}~~\hex{61}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ineg>`          
+:math:`\I8X16.\VPOPCNT`                            :math:`\hex{FD}~~\hex{62}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ipopcnt>`       
+:math:`\I8X16.\ALLTRUE`                            :math:`\hex{FD}~~\hex{63}`  :math:`[\V128] \to [\I32]`                                       :ref:`validation <valid-vtestop>`              :ref:`execution <exec-vtestop>`                                   
+:math:`\I8X16.\BITMASK`                            :math:`\hex{FD}~~\hex{64}`  :math:`[\V128] \to [\I32]`                                       :ref:`validation <valid-vec-bitmask>`          :ref:`execution <exec-vec-bitmask>`                               
+:math:`\I8X16.\NARROW\K{\_i16x8\_s}`               :math:`\hex{FD}~~\hex{65}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-narrow>`                                
+:math:`\I8X16.\NARROW\K{\_i16x8\_u}`               :math:`\hex{FD}~~\hex{66}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-narrow>`                                
+:math:`\F32X4.\VCEIL`                              :math:`\hex{FD}~~\hex{67}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fceil>`         
+:math:`\F32X4.\VFLOOR`                             :math:`\hex{FD}~~\hex{68}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ffloor>`        
+:math:`\F32X4.\VTRUNC`                             :math:`\hex{FD}~~\hex{69}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ftrunc>`        
+:math:`\F32X4.\VNEAREST`                           :math:`\hex{FD}~~\hex{6A}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fnearest>`      
+:math:`\I8X16.\VSHL`                               :math:`\hex{FD}~~\hex{6B}`  :math:`[\V128~\I32] \to [\V128]`                                 :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishl>`      
+:math:`\I8X16.\VSHR\K{\_s}`                        :math:`\hex{FD}~~\hex{6C}`  :math:`[\V128~\I32] \to [\V128]`                                 :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_s>`    
+:math:`\I8X16.\VSHR\K{\_u}`                        :math:`\hex{FD}~~\hex{6D}`  :math:`[\V128~\I32] \to [\V128]`                                 :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_u>`    
+:math:`\I8X16.\VADD`                               :math:`\hex{FD}~~\hex{6E}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd>`         
+:math:`\I8X16.\VADD\K{\_sat\_s}`                   :math:`\hex{FD}~~\hex{6F}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd_sat_s>`   
+:math:`\I8X16.\VADD\K{\_sat\_u}`                   :math:`\hex{FD}~~\hex{70}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd_sat_u>`   
+:math:`\I8X16.\VSUB`                               :math:`\hex{FD}~~\hex{71}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub>`         
+:math:`\I8X16.\VSUB\K{\_sat\_s}`                   :math:`\hex{FD}~~\hex{72}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub_sat_s>`   
+:math:`\I8X16.\VSUB\K{\_sat\_u}`                   :math:`\hex{FD}~~\hex{73}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub_sat_u>`   
+:math:`\F64X2.\VCEIL`                              :math:`\hex{FD}~~\hex{74}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fceil>`         
+:math:`\F64X2.\VFLOOR`                             :math:`\hex{FD}~~\hex{75}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ffloor>`        
+:math:`\I8X16.\VMIN\K{\_s}`                        :math:`\hex{FD}~~\hex{76}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_s>`       
+:math:`\I8X16.\VMIN\K{\_u}`                        :math:`\hex{FD}~~\hex{77}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_u>`       
+:math:`\I8X16.\VMAX\K{\_s}`                        :math:`\hex{FD}~~\hex{78}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_s>`       
+:math:`\I8X16.\VMAX\K{\_u}`                        :math:`\hex{FD}~~\hex{79}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_u>`       
+:math:`\F64X2.\VTRUNC`                             :math:`\hex{FD}~~\hex{7A}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ftrunc>`        
+:math:`\I8X16.\AVGR\K{\_u}`                        :math:`\hex{FD}~~\hex{7B}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iavgr_u>`      
+:math:`\I16X8.\EXTADDPAIRWISE\K{\_i8x16\_s}`       :math:`\hex{FD}~~\hex{7C}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vec-extadd_pairwise>`  :ref:`execution <exec-vec-extadd_pairwise>`                       
+:math:`\I16X8.\EXTADDPAIRWISE\K{\_i8x16\_u}`       :math:`\hex{FD}~~\hex{7D}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vec-extadd_pairwise>`  :ref:`execution <exec-vec-extadd_pairwise>`                       
+:math:`\I32X4.\EXTADDPAIRWISE\K{\_i16x8\_s}`       :math:`\hex{FD}~~\hex{7E}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vec-extadd_pairwise>`  :ref:`execution <exec-vec-extadd_pairwise>`                       
+:math:`\I32X4.\EXTADDPAIRWISE\K{\_i16x8\_u}`       :math:`\hex{FD}~~\hex{7F}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vec-extadd_pairwise>`  :ref:`execution <exec-vec-extadd_pairwise>`                       
+:math:`\I16X8.\VABS`                               :math:`\hex{FD}~~\hex{80}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-iabs>`          
+:math:`\I16X8.\VNEG`                               :math:`\hex{FD}~~\hex{81}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ineg>`          
+:math:`\I16X8.\Q15MULRSAT\K{\_s}`                  :math:`\hex{FD}~~\hex{82}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iq15mulrsat_s>`
+:math:`\I16X8.\ALLTRUE`                            :math:`\hex{FD}~~\hex{83}`  :math:`[\V128] \to [\I32]`                                       :ref:`validation <valid-vtestop>`              :ref:`execution <exec-vtestop>`                                   
+:math:`\I16X8.\BITMASK`                            :math:`\hex{FD}~~\hex{84}`  :math:`[\V128] \to [\I32]`                                       :ref:`validation <valid-vec-bitmask>`          :ref:`execution <exec-vec-bitmask>`                               
+:math:`\I16X8.\NARROW\K{\_i32x4\_s}`               :math:`\hex{FD}~~\hex{85}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-narrow>`                                
+:math:`\I16X8.\NARROW\K{\_i32x4\_u}`               :math:`\hex{FD}~~\hex{86}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-narrow>`                                
+:math:`\I16X8.\VEXTEND\K{\_low\_i8x16\_s}`         :math:`\hex{FD}~~\hex{87}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I16X8.\VEXTEND\K{\_high\_i8x16\_s}`        :math:`\hex{FD}~~\hex{88}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I16X8.\VEXTEND\K{\_low\_i8x16\_u}`         :math:`\hex{FD}~~\hex{89}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I16X8.\VEXTEND\K{\_high\_i8x16\_u}`        :math:`\hex{FD}~~\hex{8A}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I16X8.\VSHL`                               :math:`\hex{FD}~~\hex{8B}`  :math:`[\V128~\I32] \to [\V128]`                                 :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishl>`      
+:math:`\I16X8.\VSHR\K{\_s}`                        :math:`\hex{FD}~~\hex{8C}`  :math:`[\V128~\I32] \to [\V128]`                                 :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_s>`    
+:math:`\I16X8.\VSHR\K{\_u}`                        :math:`\hex{FD}~~\hex{8D}`  :math:`[\V128~\I32] \to [\V128]`                                 :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_u>`    
+:math:`\I16X8.\VADD`                               :math:`\hex{FD}~~\hex{8E}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd>`         
+:math:`\I16X8.\VADD\K{\_sat\_s}`                   :math:`\hex{FD}~~\hex{8F}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd_sat_s>`   
+:math:`\I16X8.\VADD\K{\_sat\_u}`                   :math:`\hex{FD}~~\hex{90}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd_sat_u>`   
+:math:`\I16X8.\VSUB`                               :math:`\hex{FD}~~\hex{91}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub>`         
+:math:`\I16X8.\VSUB\K{\_sat\_s}`                   :math:`\hex{FD}~~\hex{92}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub_sat_s>`   
+:math:`\I16X8.\VSUB\K{\_sat\_u}`                   :math:`\hex{FD}~~\hex{93}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub_sat_u>`   
+:math:`\F64X2.\VNEAREST`                           :math:`\hex{FD}~~\hex{94}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fnearest>`      
+:math:`\I16X8.\VMUL`                               :math:`\hex{FD}~~\hex{95}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imul>`         
+:math:`\I16X8.\VMIN\K{\_s}`                        :math:`\hex{FD}~~\hex{96}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_s>`       
+:math:`\I16X8.\VMIN\K{\_u}`                        :math:`\hex{FD}~~\hex{97}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_u>`       
+:math:`\I16X8.\VMAX\K{\_s}`                        :math:`\hex{FD}~~\hex{98}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_s>`       
+:math:`\I16X8.\VMAX\K{\_u}`                        :math:`\hex{FD}~~\hex{99}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_u>`       
+:math:`\I16X8.\AVGR\K{\_u}`                        :math:`\hex{FD}~~\hex{9B}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iavgr_u>`      
+:math:`\I16X8.\EXTMUL\K{\_low\_i8x16\_s}`          :math:`\hex{FD}~~\hex{9C}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I16X8.\EXTMUL\K{\_high\_i8x16\_s}`         :math:`\hex{FD}~~\hex{9D}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I16X8.\EXTMUL\K{\_low\_i8x16\_u}`          :math:`\hex{FD}~~\hex{9E}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I16X8.\EXTMUL\K{\_high\_i8x16\_u}`         :math:`\hex{FD}~~\hex{9F}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I32X4.\VABS`                               :math:`\hex{FD}~~\hex{A0}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-iabs>`          
+:math:`\I32X4.\VNEG`                               :math:`\hex{FD}~~\hex{A1}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ineg>`          
+:math:`\I32X4.\ALLTRUE`                            :math:`\hex{FD}~~\hex{A3}`  :math:`[\V128] \to [\I32]`                                       :ref:`validation <valid-vtestop>`              :ref:`execution <exec-vtestop>`                                   
+:math:`\I32X4.\BITMASK`                            :math:`\hex{FD}~~\hex{A4}`  :math:`[\V128] \to [\I32]`                                       :ref:`validation <valid-vec-bitmask>`          :ref:`execution <exec-vec-bitmask>`                               
+:math:`\I32X4.\VEXTEND\K{\_low\_i16x8\_s}`         :math:`\hex{FD}~~\hex{A7}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I32X4.\VEXTEND\K{\_high\_i16x8\_s}`        :math:`\hex{FD}~~\hex{A8}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I32X4.\VEXTEND\K{\_low\_i16x8\_u}`         :math:`\hex{FD}~~\hex{A9}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I32X4.\VEXTEND\K{\_high\_i16x8\_u}`        :math:`\hex{FD}~~\hex{AA}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I32X4.\VSHL`                               :math:`\hex{FD}~~\hex{AB}`  :math:`[\V128~\I32] \to [\V128]`                                 :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishl>`      
+:math:`\I32X4.\VSHR\K{\_s}`                        :math:`\hex{FD}~~\hex{AC}`  :math:`[\V128~\I32] \to [\V128]`                                 :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_s>`    
+:math:`\I32X4.\VSHR\K{\_u}`                        :math:`\hex{FD}~~\hex{AD}`  :math:`[\V128~\I32] \to [\V128]`                                 :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_u>`    
+:math:`\I32X4.\VADD`                               :math:`\hex{FD}~~\hex{AE}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd>`         
+:math:`\I32X4.\VSUB`                               :math:`\hex{FD}~~\hex{B1}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub>`         
+:math:`\I32X4.\VMUL`                               :math:`\hex{FD}~~\hex{B5}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imul>`         
+:math:`\I32X4.\VMIN\K{\_s}`                        :math:`\hex{FD}~~\hex{B6}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_s>`       
+:math:`\I32X4.\VMIN\K{\_u}`                        :math:`\hex{FD}~~\hex{B7}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_u>`       
+:math:`\I32X4.\VMAX\K{\_s}`                        :math:`\hex{FD}~~\hex{B8}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_s>`       
+:math:`\I32X4.\VMAX\K{\_u}`                        :math:`\hex{FD}~~\hex{B9}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_u>`       
+:math:`\I32X4.\DOT\K{\_i16x8\_s}`                  :math:`\hex{FD}~~\hex{BA}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vec-dot>`              :ref:`execution <exec-vec-dot>`                                   
+:math:`\I32X4.\EXTMUL\K{\_low\_i16x8\_s}`          :math:`\hex{FD}~~\hex{BC}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I32X4.\EXTMUL\K{\_high\_i16x8\_s}`         :math:`\hex{FD}~~\hex{BD}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I32X4.\EXTMUL\K{\_low\_i16x8\_u}`          :math:`\hex{FD}~~\hex{BE}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I32X4.\EXTMUL\K{\_high\_i16x8\_u}`         :math:`\hex{FD}~~\hex{BF}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I64X2.\VABS`                               :math:`\hex{FD}~~\hex{C0}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-iabs>`          
+:math:`\I64X2.\VNEG`                               :math:`\hex{FD}~~\hex{C1}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ineg>`          
+:math:`\I64X2.\ALLTRUE`                            :math:`\hex{FD}~~\hex{C3}`  :math:`[\V128] \to [\I32]`                                       :ref:`validation <valid-vtestop>`              :ref:`execution <exec-vtestop>`                                   
+:math:`\I64X2.\BITMASK`                            :math:`\hex{FD}~~\hex{C4}`  :math:`[\V128] \to [\I32]`                                       :ref:`validation <valid-vec-bitmask>`          :ref:`execution <exec-vec-bitmask>`                               
+:math:`\I64X2.\VEXTEND\K{\_low\_i32x4\_s}`         :math:`\hex{FD}~~\hex{C7}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I64X2.\VEXTEND\K{\_high\_i32x4\_s}`        :math:`\hex{FD}~~\hex{C8}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I64X2.\VEXTEND\K{\_low\_i32x4\_u}`         :math:`\hex{FD}~~\hex{C9}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I64X2.\VEXTEND\K{\_high\_i32x4\_u}`        :math:`\hex{FD}~~\hex{CA}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I64X2.\VSHL`                               :math:`\hex{FD}~~\hex{CB}`  :math:`[\V128~\I32] \to [\V128]`                                 :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishl>`      
+:math:`\I64X2.\VSHR\K{\_s}`                        :math:`\hex{FD}~~\hex{CC}`  :math:`[\V128~\I32] \to [\V128]`                                 :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_s>`    
+:math:`\I64X2.\VSHR\K{\_u}`                        :math:`\hex{FD}~~\hex{CD}`  :math:`[\V128~\I32] \to [\V128]`                                 :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_u>`    
+:math:`\I64X2.\VADD`                               :math:`\hex{FD}~~\hex{CE}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd>`         
+:math:`\I64X2.\VSUB`                               :math:`\hex{FD}~~\hex{D1}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub>`         
+:math:`\I64X2.\VMUL`                               :math:`\hex{FD}~~\hex{D5}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imul>`         
+:math:`\I64X2.\VEQ`                                :math:`\hex{FD}~~\hex{D6}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ieq>`          
+:math:`\I64X2.\VNE`                                :math:`\hex{FD}~~\hex{D7}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ine>`          
+:math:`\I64X2.\VLT\K{\_s}`                         :math:`\hex{FD}~~\hex{D8}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_s>`        
+:math:`\I64X2.\VGT\K{\_s}`                         :math:`\hex{FD}~~\hex{D9}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_s>`        
+:math:`\I64X2.\VLE\K{\_s}`                         :math:`\hex{FD}~~\hex{DA}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_s>`        
+:math:`\I64X2.\VGE\K{\_s}`                         :math:`\hex{FD}~~\hex{DB}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_s>`        
+:math:`\I64X2.\EXTMUL\K{\_low\_i32x4\_s}`          :math:`\hex{FD}~~\hex{DC}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I64X2.\EXTMUL\K{\_high\_i32x4\_s}`         :math:`\hex{FD}~~\hex{DD}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I64X2.\EXTMUL\K{\_low\_i32x4\_u}`          :math:`\hex{FD}~~\hex{DE}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I64X2.\EXTMUL\K{\_high\_i32x4\_u}`         :math:`\hex{FD}~~\hex{DF}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\F32X4.\VABS`                               :math:`\hex{FD}~~\hex{E0}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fabs>`          
+:math:`\F32X4.\VNEG`                               :math:`\hex{FD}~~\hex{E1}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fneg>`          
+:math:`\F32X4.\VSQRT`                              :math:`\hex{FD}~~\hex{E3}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fsqrt>`         
+:math:`\F32X4.\VADD`                               :math:`\hex{FD}~~\hex{E4}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fadd>`         
+:math:`\F32X4.\VSUB`                               :math:`\hex{FD}~~\hex{E5}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fsub>`         
+:math:`\F32X4.\VMUL`                               :math:`\hex{FD}~~\hex{E6}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmul>`         
+:math:`\F32X4.\VDIV`                               :math:`\hex{FD}~~\hex{E7}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fdiv>`         
+:math:`\F32X4.\VMIN`                               :math:`\hex{FD}~~\hex{E8}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmin>`         
+:math:`\F32X4.\VMAX`                               :math:`\hex{FD}~~\hex{E9}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmax>`         
+:math:`\F32X4.\VPMIN`                              :math:`\hex{FD}~~\hex{EA}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fpmin>`        
+:math:`\F32X4.\VPMAX`                              :math:`\hex{FD}~~\hex{EB}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fpmax>`        
+:math:`\F64X2.\VABS`                               :math:`\hex{FD}~~\hex{EC}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fabs>`          
+:math:`\F64X2.\VNEG`                               :math:`\hex{FD}~~\hex{ED}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fneg>`          
+:math:`\F64X2.\VSQRT`                              :math:`\hex{FD}~~\hex{EF}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fsqrt>`         
+:math:`\F64X2.\VADD`                               :math:`\hex{FD}~~\hex{F0}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fadd>`         
+:math:`\F64X2.\VSUB`                               :math:`\hex{FD}~~\hex{F1}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fsub>`         
+:math:`\F64X2.\VMUL`                               :math:`\hex{FD}~~\hex{F2}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmul>`         
+:math:`\F64X2.\VDIV`                               :math:`\hex{FD}~~\hex{F3}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fdiv>`         
+:math:`\F64X2.\VMIN`                               :math:`\hex{FD}~~\hex{F4}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmin>`         
+:math:`\F64X2.\VMAX`                               :math:`\hex{FD}~~\hex{F5}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmax>`         
+:math:`\F64X2.\VPMIN`                              :math:`\hex{FD}~~\hex{F6}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fpmin>`        
+:math:`\F64X2.\VPMAX`                              :math:`\hex{FD}~~\hex{F7}`  :math:`[\V128~\V128] \to [\V128]`                                :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fpmax>`        
+:math:`\I32X4.\TRUNC\K{\_sat\_f32x4\_s}`           :math:`\hex{FD}~~\hex{F8}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-trunc_sat_s>`  
+:math:`\I32X4.\TRUNC\K{\_sat\_f32x4\_u}`           :math:`\hex{FD}~~\hex{F9}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-trunc_sat_u>`  
+:math:`\F32X4.\VCONVERT\K{\_i32x4\_s}`             :math:`\hex{FD}~~\hex{FA}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_s>`    
+:math:`\F32X4.\VCONVERT\K{\_i32x4\_u}`             :math:`\hex{FD}~~\hex{FB}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_u>`    
+:math:`\I32X4.\VTRUNC\K{\_sat\_f64x2\_s\_zero}`    :math:`\hex{FD}~~\hex{FC}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-trunc_sat_s>`  
+:math:`\I32X4.\VTRUNC\K{\_sat\_f64x2\_u\_zero}`    :math:`\hex{FD}~~\hex{FD}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-trunc_sat_u>`  
+:math:`\F64X2.\VCONVERT\K{\_low\_i32x4\_s}`        :math:`\hex{FD}~~\hex{FE}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_s>`    
+:math:`\F64X2.\VCONVERT\K{\_low\_i32x4\_u}`        :math:`\hex{FD}~~\hex{FF}`  :math:`[\V128] \to [\V128]`                                      :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_u>`    
+=================================================  ==========================  ===============================================================  =============================================  ==================================================================
diff --git a/document/core/appendix/index-types.rst b/document/core/appendix/index-types.rst
index 90a411934..e8988f5f5 100644
--- a/document/core/appendix/index-types.rst
+++ b/document/core/appendix/index-types.rst
@@ -12,7 +12,8 @@ Category                                  Constructor
 :ref:`Number type <syntax-numtype>`       |I64|                                        :math:`\hex{7E}` (-2 as |Bs7|)
 :ref:`Number type <syntax-numtype>`       |F32|                                        :math:`\hex{7D}` (-3 as |Bs7|)
 :ref:`Number type <syntax-numtype>`       |F64|                                        :math:`\hex{7C}` (-4 as |Bs7|)
-(reserved)                                                                             :math:`\hex{7B}` .. :math:`\hex{71}`
+:ref:`Vector type <syntax-vectype>`       |V128|                                       :math:`\hex{7B}` (-5 as |Bs7|)
+(reserved)                                                                             :math:`\hex{7A}` .. :math:`\hex{71}`
 :ref:`Heap type <syntax-heaptype>`        |FUNC|                                       :math:`\hex{70}` (-16 as |Bs7|)
 :ref:`Heap type <syntax-heaptype>`        |EXTERN|                                     :math:`\hex{6F}` (-17 as |Bs7|)
 (reserved)                                                                             :math:`\hex{6E}` .. :math:`\hex{6D}`
diff --git a/document/core/binary/conventions.rst b/document/core/binary/conventions.rst
index cacd25134..83c80399f 100644
--- a/document/core/binary/conventions.rst
+++ b/document/core/binary/conventions.rst
@@ -63,11 +63,11 @@ In order to distinguish symbols of the binary syntax from symbols of the abstrac
   (This is a shorthand for a side condition requiring multiple different variables to be equal.)
 
 .. note::
-   For example, the :ref:`binary grammar <binary-valtype>` for :ref:`value types <syntax-valtype>` is given as follows:
+   For example, the :ref:`binary grammar <binary-numtype>` for :ref:`number types <syntax-numtype>` is given as follows:
 
    .. math::
      \begin{array}{llcll@{\qquad\qquad}l}
-     \production{value types} & \Bvaltype &::=&
+     \production{number types} & \Bnumtype &::=&
        \hex{7F} &\Rightarrow& \I32 \\ &&|&
        \hex{7E} &\Rightarrow& \I64 \\ &&|&
        \hex{7D} &\Rightarrow& \F32 \\ &&|&
@@ -76,7 +76,7 @@ In order to distinguish symbols of the binary syntax from symbols of the abstrac
 
    Consequently, the byte :math:`\hex{7F}` encodes the type |I32|,
    :math:`\hex{7E}` encodes the type |I64|, and so forth.
-   No other byte value is allowed as the encoding of a value type.
+   No other byte value is allowed as the encoding of a number type.
 
    The :ref:`binary grammar <binary-limits>` for :ref:`limits <syntax-limits>` is defined as follows:   
 
diff --git a/document/core/binary/instructions.rst b/document/core/binary/instructions.rst
index f6e8051fe..fc1c51296 100644
--- a/document/core/binary/instructions.rst
+++ b/document/core/binary/instructions.rst
@@ -470,6 +470,383 @@ whereas the actual opcode is encoded by a variable-length :ref:`unsigned integer
    \end{array}
 
 
+.. index:: vector instruction
+   pair: binary format; instruction
+.. _binary-instr-vec:
+
+Vector Instructions
+~~~~~~~~~~~~~~~~~~~
+
+All variants of :ref:`vector instructions <syntax-instr-vec>` are represented by separate byte codes.
+They all have a one byte prefix, whereas the actual opcode is encoded by a variable-length :ref:`unsigned integer <binary-uint>`.
+
+Vector loads and stores are followed by the encoding of their |memarg| immediate.
+
+.. _binary-laneidx:
+
+.. math::
+   \begin{array}{llclll}
+   \production{lane index} & \Blaneidx &::=&
+     l{:}\Bbyte &\Rightarrow& l \\
+   \production{instruction} & \Binstr &::=& \dots \\&&|&
+     \hex{FD}~~0{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD~m \\ &&|&
+     \hex{FD}~~1{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{8x8\_s}~m \\ &&|&
+     \hex{FD}~~2{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{8x8\_u}~m \\ &&|&
+     \hex{FD}~~3{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{16x4\_s}~m \\ &&|&
+     \hex{FD}~~4{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{16x4\_u}~m \\ &&|&
+     \hex{FD}~~5{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{32x2\_s}~m \\ &&|&
+     \hex{FD}~~6{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{32x2\_u}~m \\ &&|&
+     \hex{FD}~~7{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{8\_splat}~m \\ &&|&
+     \hex{FD}~~8{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{16\_splat}~m \\ &&|&
+     \hex{FD}~~9{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{32\_splat}~m \\ &&|&
+     \hex{FD}~~10{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{64\_splat}~m \\ &&|&
+     \hex{FD}~~92{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{32\_zero}~m \\ &&|&
+     \hex{FD}~~93{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\LOAD\K{64\_zero}~m \\ &&|&
+     \hex{FD}~~11{:}\Bu32~~m{:}\Bmemarg &\Rightarrow& \V128.\STORE~m \\ &&|&
+     \hex{FD}~~84{:}\Bu32~~m{:}\Bmemarg~l{:}\Blaneidx &\Rightarrow& \V128.\LOAD\K{8\_lane}~m~l \\ &&|&
+     \hex{FD}~~85{:}\Bu32~~m{:}\Bmemarg~l{:}\Blaneidx &\Rightarrow& \V128.\LOAD\K{16\_lane}~m~l \\ &&|&
+     \hex{FD}~~86{:}\Bu32~~m{:}\Bmemarg~l{:}\Blaneidx &\Rightarrow& \V128.\LOAD\K{32\_lane}~m~l \\ &&|&
+     \hex{FD}~~87{:}\Bu32~~m{:}\Bmemarg~l{:}\Blaneidx &\Rightarrow& \V128.\LOAD\K{64\_lane}~m~l \\ &&|&
+     \hex{FD}~~88{:}\Bu32~~m{:}\Bmemarg~l{:}\Blaneidx &\Rightarrow& \V128.\STORE\K{8\_lane}~m~l \\ &&|&
+     \hex{FD}~~89{:}\Bu32~~m{:}\Bmemarg~l{:}\Blaneidx &\Rightarrow& \V128.\STORE\K{16\_lane}~m~l \\ &&|&
+     \hex{FD}~~90{:}\Bu32~~m{:}\Bmemarg~l{:}\Blaneidx &\Rightarrow& \V128.\STORE\K{32\_lane}~m~l \\ &&|&
+     \hex{FD}~~91{:}\Bu32~~m{:}\Bmemarg~l{:}\Blaneidx &\Rightarrow& \V128.\STORE\K{64\_lane}~m~l \\
+   \end{array}
+
+The |VCONST| instruction is followed by 16 immediate bytes, which are converted into a |i128| in |littleendian| byte order:
+
+.. math::
+   \begin{array}{llclll}
+   \production{instruction} & \Binstr &::=& \dots \\&&|&
+     \hex{FD}~~12{:}\Bu32~~(b{:}\Bbyte)^{16} &\Rightarrow& \V128.\VCONST~
+     bytes_{\K{i128}}^{-1}(b_{0}~\dots~b_{15}) \\
+   \end{array}
+
+.. _binary-vternop:
+
+The |SHUFFLE| instruction is also followed by the encoding of 16 |laneidx| immediates.
+
+.. math::
+   \begin{array}{llclll}
+   \production{instruction} & \Binstr &::=& \dots \\&&|&
+     \hex{FD}~~13{:}\Bu32~~(l{:}\Blaneidx)^{16} &\Rightarrow& \I8X16.\SHUFFLE~l^{16} \\
+   \end{array}
+
+|EXTRACTLANE| and |REPLACELANE| instructions are followed by the encoding of a |laneidx| immediate.
+
+.. math::
+   \begin{array}{llclll}
+   \production{instruction} & \Binstr &::=& \dots \\&&|&
+     \hex{FD}~~21{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \I8X16.\EXTRACTLANE\K{\_s}~l \\ &&|&
+     \hex{FD}~~22{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \I8X16.\EXTRACTLANE\K{\_u}~l \\ &&|&
+     \hex{FD}~~23{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \I8X16.\REPLACELANE~l \\ &&|&
+     \hex{FD}~~24{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \I16X8.\EXTRACTLANE\K{\_s}~l \\ &&|&
+     \hex{FD}~~25{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \I16X8.\EXTRACTLANE\K{\_u}~l \\ &&|&
+     \hex{FD}~~26{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \I16X8.\REPLACELANE~l \\ &&|&
+     \hex{FD}~~27{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \I32X4.\EXTRACTLANE~l \\ &&|&
+     \hex{FD}~~28{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \I32X4.\REPLACELANE~l \\ &&|&
+     \hex{FD}~~29{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \I64X2.\EXTRACTLANE~l \\ &&|&
+     \hex{FD}~~30{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \I64X2.\REPLACELANE~l \\ &&|&
+     \hex{FD}~~31{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \F32X4.\EXTRACTLANE~l \\ &&|&
+     \hex{FD}~~32{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \F32X4.\REPLACELANE~l \\ &&|&
+     \hex{FD}~~33{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \F64X2.\EXTRACTLANE~l \\ &&|&
+     \hex{FD}~~34{:}\Bu32~~l{:}\Blaneidx &\Rightarrow& \F64X2.\REPLACELANE~l \\
+   \end{array}
+
+All other vector instructions are plain opcodes without any immediates.
+
+.. math::
+   \begin{array}{llclll}
+   \production{instruction} & \Binstr &::=& \dots && \phantom{vechaslongerinstructionnames} \\&&|&
+     \hex{FD}~~14{:}\Bu32 &\Rightarrow& \I8X16.\SWIZZLE \\ &&|&
+     \hex{FD}~~15{:}\Bu32 &\Rightarrow& \I8X16.\SPLAT \\ &&|&
+     \hex{FD}~~16{:}\Bu32 &\Rightarrow& \I16X8.\SPLAT \\ &&|&
+     \hex{FD}~~17{:}\Bu32 &\Rightarrow& \I32X4.\SPLAT \\ &&|&
+     \hex{FD}~~18{:}\Bu32 &\Rightarrow& \I64X2.\SPLAT \\ &&|&
+     \hex{FD}~~19{:}\Bu32 &\Rightarrow& \F32X4.\SPLAT \\ &&|&
+     \hex{FD}~~20{:}\Bu32 &\Rightarrow& \F64X2.\SPLAT \\
+   \end{array}
+
+.. _binary-virelop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~35{:}\Bu32 &\Rightarrow& \I8X16.\VEQ \\ &&|&
+     \hex{FD}~~36{:}\Bu32 &\Rightarrow& \I8X16.\VNE \\ &&|&
+     \hex{FD}~~37{:}\Bu32 &\Rightarrow& \I8X16.\VLT\K{\_s} \\ &&|&
+     \hex{FD}~~38{:}\Bu32 &\Rightarrow& \I8X16.\VLT\K{\_u} \\ &&|&
+     \hex{FD}~~39{:}\Bu32 &\Rightarrow& \I8X16.\VGT\K{\_s} \\ &&|&
+     \hex{FD}~~40{:}\Bu32 &\Rightarrow& \I8X16.\VGT\K{\_u} \\ &&|&
+     \hex{FD}~~41{:}\Bu32 &\Rightarrow& \I8X16.\VLE\K{\_s} \\ &&|&
+     \hex{FD}~~42{:}\Bu32 &\Rightarrow& \I8X16.\VLE\K{\_u} \\ &&|&
+     \hex{FD}~~43{:}\Bu32 &\Rightarrow& \I8X16.\VGE\K{\_s} \\ &&|&
+     \hex{FD}~~44{:}\Bu32 &\Rightarrow& \I8X16.\VGE\K{\_u} \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~45{:}\Bu32 &\Rightarrow& \I16X8.\VEQ \\ &&|&
+     \hex{FD}~~46{:}\Bu32 &\Rightarrow& \I16X8.\VNE \\ &&|&
+     \hex{FD}~~47{:}\Bu32 &\Rightarrow& \I16X8.\VLT\K{\_s} \\ &&|&
+     \hex{FD}~~48{:}\Bu32 &\Rightarrow& \I16X8.\VLT\K{\_u} \\ &&|&
+     \hex{FD}~~49{:}\Bu32 &\Rightarrow& \I16X8.\VGT\K{\_s} \\ &&|&
+     \hex{FD}~~50{:}\Bu32 &\Rightarrow& \I16X8.\VGT\K{\_u} \\ &&|&
+     \hex{FD}~~51{:}\Bu32 &\Rightarrow& \I16X8.\VLE\K{\_s} \\ &&|&
+     \hex{FD}~~52{:}\Bu32 &\Rightarrow& \I16X8.\VLE\K{\_u} \\ &&|&
+     \hex{FD}~~53{:}\Bu32 &\Rightarrow& \I16X8.\VGE\K{\_s} \\ &&|&
+     \hex{FD}~~54{:}\Bu32 &\Rightarrow& \I16X8.\VGE\K{\_u} \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~55{:}\Bu32 &\Rightarrow& \I32X4.\VEQ \\ &&|&
+     \hex{FD}~~56{:}\Bu32 &\Rightarrow& \I32X4.\VNE \\ &&|&
+     \hex{FD}~~57{:}\Bu32 &\Rightarrow& \I32X4.\VLT\K{\_s} \\ &&|&
+     \hex{FD}~~58{:}\Bu32 &\Rightarrow& \I32X4.\VLT\K{\_u} \\ &&|&
+     \hex{FD}~~59{:}\Bu32 &\Rightarrow& \I32X4.\VGT\K{\_s} \\ &&|&
+     \hex{FD}~~60{:}\Bu32 &\Rightarrow& \I32X4.\VGT\K{\_u} \\ &&|&
+     \hex{FD}~~61{:}\Bu32 &\Rightarrow& \I32X4.\VLE\K{\_s} \\ &&|&
+     \hex{FD}~~62{:}\Bu32 &\Rightarrow& \I32X4.\VLE\K{\_u} \\ &&|&
+     \hex{FD}~~63{:}\Bu32 &\Rightarrow& \I32X4.\VGE\K{\_s} \\ &&|&
+     \hex{FD}~~64{:}\Bu32 &\Rightarrow& \I32X4.\VGE\K{\_u} \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~214{:}\Bu32 &\Rightarrow& \I64X2.\VEQ \\ &&|&
+     \hex{FD}~~215{:}\Bu32 &\Rightarrow& \I64X2.\VNE \\ &&|&
+     \hex{FD}~~216{:}\Bu32 &\Rightarrow& \I64X2.\VLT\K{\_s} \\ &&|&
+     \hex{FD}~~217{:}\Bu32 &\Rightarrow& \I64X2.\VGT\K{\_s} \\ &&|&
+     \hex{FD}~~218{:}\Bu32 &\Rightarrow& \I64X2.\VLE\K{\_s} \\ &&|&
+     \hex{FD}~~219{:}\Bu32 &\Rightarrow& \I64X2.\VGE\K{\_s} \\ &&|&
+   \end{array}
+
+.. _binary-vfrelop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~65{:}\Bu32 &\Rightarrow& \F32X4.\VEQ \\ &&|&
+     \hex{FD}~~66{:}\Bu32 &\Rightarrow& \F32X4.\VNE \\ &&|&
+     \hex{FD}~~67{:}\Bu32 &\Rightarrow& \F32X4.\VLT \\ &&|&
+     \hex{FD}~~68{:}\Bu32 &\Rightarrow& \F32X4.\VGT \\ &&|&
+     \hex{FD}~~69{:}\Bu32 &\Rightarrow& \F32X4.\VLE \\ &&|&
+     \hex{FD}~~70{:}\Bu32 &\Rightarrow& \F32X4.\VGE \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~71{:}\Bu32 &\Rightarrow& \F64X2.\VEQ \\ &&|&
+     \hex{FD}~~72{:}\Bu32 &\Rightarrow& \F64X2.\VNE \\ &&|&
+     \hex{FD}~~73{:}\Bu32 &\Rightarrow& \F64X2.\VLT \\ &&|&
+     \hex{FD}~~74{:}\Bu32 &\Rightarrow& \F64X2.\VGT \\ &&|&
+     \hex{FD}~~75{:}\Bu32 &\Rightarrow& \F64X2.\VLE \\ &&|&
+     \hex{FD}~~76{:}\Bu32 &\Rightarrow& \F64X2.\VGE \\
+   \end{array}
+
+.. _binary-vsunop:
+.. _binary-vsbinop:
+.. _binary-vsternop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~77{:}\Bu32 &\Rightarrow& \V128.\VNOT \\ &&|&
+     \hex{FD}~~78{:}\Bu32 &\Rightarrow& \V128.\VAND \\ &&|&
+     \hex{FD}~~79{:}\Bu32 &\Rightarrow& \V128.\VANDNOT \\ &&|&
+     \hex{FD}~~80{:}\Bu32 &\Rightarrow& \V128.\VOR \\ &&|&
+     \hex{FD}~~81{:}\Bu32 &\Rightarrow& \V128.\VXOR \\ &&|&
+     \hex{FD}~~82{:}\Bu32 &\Rightarrow& \V128.\BITSELECT \\ &&|&
+     \hex{FD}~~83{:}\Bu32 &\Rightarrow& \V128.\ANYTRUE \\
+   \end{array}
+
+.. _binary-vitestop:
+.. _binary-vshiftop:
+.. _binary-viunop:
+.. _binary-vibinop:
+.. _binary-viminmaxop:
+.. _binary-vsatbinop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~96{:}\Bu32 &\Rightarrow& \I8X16.\VABS \\ &&|&
+     \hex{FD}~~97{:}\Bu32 &\Rightarrow& \I8X16.\VNEG \\ &&|&
+     \hex{FD}~~98{:}\Bu32 &\Rightarrow& \I8X16.\VPOPCNT \\ &&|&
+     \hex{FD}~~99{:}\Bu32 &\Rightarrow& \I8X16.\ALLTRUE \\ &&|&
+     \hex{FD}~~100{:}\Bu32 &\Rightarrow& \I8X16.\BITMASK \\ &&|&
+     \hex{FD}~~101{:}\Bu32 &\Rightarrow& \I8X16.\NARROW\K{\_i16x8\_s} \\ &&|&
+     \hex{FD}~~102{:}\Bu32 &\Rightarrow& \I8X16.\NARROW\K{\_i16x8\_u} \\ &&|&
+     \hex{FD}~~107{:}\Bu32 &\Rightarrow& \I8X16.\VSHL \\ &&|&
+     \hex{FD}~~108{:}\Bu32 &\Rightarrow& \I8X16.\VSHR\K{\_s} \\ &&|&
+     \hex{FD}~~109{:}\Bu32 &\Rightarrow& \I8X16.\VSHR\K{\_u} \\ &&|&
+     \hex{FD}~~110{:}\Bu32 &\Rightarrow& \I8X16.\VADD \\ &&|&
+     \hex{FD}~~111{:}\Bu32 &\Rightarrow& \I8X16.\VADD\K{\_sat\_s} \\ &&|&
+     \hex{FD}~~112{:}\Bu32 &\Rightarrow& \I8X16.\VADD\K{\_sat\_u} \\ &&|&
+     \hex{FD}~~113{:}\Bu32 &\Rightarrow& \I8X16.\VSUB \\ &&|&
+     \hex{FD}~~114{:}\Bu32 &\Rightarrow& \I8X16.\VSUB\K{\_sat\_s} \\ &&|&
+     \hex{FD}~~115{:}\Bu32 &\Rightarrow& \I8X16.\VSUB\K{\_sat\_u} \\ &&|&
+     \hex{FD}~~118{:}\Bu32 &\Rightarrow& \I8X16.\VMIN\K{\_s} \\ &&|&
+     \hex{FD}~~119{:}\Bu32 &\Rightarrow& \I8X16.\VMIN\K{\_u} \\ &&|&
+     \hex{FD}~~120{:}\Bu32 &\Rightarrow& \I8X16.\VMAX\K{\_s} \\ &&|&
+     \hex{FD}~~121{:}\Bu32 &\Rightarrow& \I8X16.\VMAX\K{\_u} \\ &&|&
+     \hex{FD}~~123{:}\Bu32 &\Rightarrow& \I8X16.\AVGR\K{\_u} \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~124{:}\Bu32 &\Rightarrow& \I16X8.\EXTADDPAIRWISE\K{\_i8x16\_s}\\ &&|&
+     \hex{FD}~~125{:}\Bu32 &\Rightarrow& \I16X8.\EXTADDPAIRWISE\K{\_i8x16\_u}\\ &&|&
+     \hex{FD}~~128{:}\Bu32 &\Rightarrow& \I16X8.\VABS \\ &&|&
+     \hex{FD}~~129{:}\Bu32 &\Rightarrow& \I16X8.\VNEG \\ &&|&
+     \hex{FD}~~130{:}\Bu32 &\Rightarrow& \I16X8.\Q15MULRSAT\K{\_s} \\ &&|&
+     \hex{FD}~~131{:}\Bu32 &\Rightarrow& \I16X8.\ALLTRUE \\ &&|&
+     \hex{FD}~~132{:}\Bu32 &\Rightarrow& \I16X8.\BITMASK \\ &&|&
+     \hex{FD}~~133{:}\Bu32 &\Rightarrow& \I16X8.\NARROW\K{\_i32x4\_s} \\ &&|&
+     \hex{FD}~~134{:}\Bu32 &\Rightarrow& \I16X8.\NARROW\K{\_i32x4\_u} \\ &&|&
+     \hex{FD}~~135{:}\Bu32 &\Rightarrow& \I16X8.\VEXTEND\K{\_low\_i8x16\_s} \\ &&|&
+     \hex{FD}~~136{:}\Bu32 &\Rightarrow& \I16X8.\VEXTEND\K{\_high\_i8x16\_s} \\ &&|&
+     \hex{FD}~~137{:}\Bu32 &\Rightarrow& \I16X8.\VEXTEND\K{\_low\_i8x16\_u} \\ &&|&
+     \hex{FD}~~138{:}\Bu32 &\Rightarrow& \I16X8.\VEXTEND\K{\_high\_i8x16\_u} \\ &&|&
+     \hex{FD}~~139{:}\Bu32 &\Rightarrow& \I16X8.\VSHL \\ &&|&
+     \hex{FD}~~140{:}\Bu32 &\Rightarrow& \I16X8.\VSHR\K{\_s} \\ &&|&
+     \hex{FD}~~141{:}\Bu32 &\Rightarrow& \I16X8.\VSHR\K{\_u} \\ &&|&
+     \hex{FD}~~142{:}\Bu32 &\Rightarrow& \I16X8.\VADD \\ &&|&
+     \hex{FD}~~143{:}\Bu32 &\Rightarrow& \I16X8.\VADD\K{\_sat\_s} \\ &&|&
+     \hex{FD}~~144{:}\Bu32 &\Rightarrow& \I16X8.\VADD\K{\_sat\_u} \\ &&|&
+     \hex{FD}~~145{:}\Bu32 &\Rightarrow& \I16X8.\VSUB \\ &&|&
+     \hex{FD}~~146{:}\Bu32 &\Rightarrow& \I16X8.\VSUB\K{\_sat\_s} \\ &&|&
+     \hex{FD}~~147{:}\Bu32 &\Rightarrow& \I16X8.\VSUB\K{\_sat\_u} \\ &&|&
+     \hex{FD}~~149{:}\Bu32 &\Rightarrow& \I16X8.\VMUL \\ &&|&
+     \hex{FD}~~150{:}\Bu32 &\Rightarrow& \I16X8.\VMIN\K{\_s} \\ &&|&
+     \hex{FD}~~151{:}\Bu32 &\Rightarrow& \I16X8.\VMIN\K{\_u} \\ &&|&
+     \hex{FD}~~152{:}\Bu32 &\Rightarrow& \I16X8.\VMAX\K{\_s} \\ &&|&
+     \hex{FD}~~153{:}\Bu32 &\Rightarrow& \I16X8.\VMAX\K{\_u} \\ &&|&
+     \hex{FD}~~155{:}\Bu32 &\Rightarrow& \I16X8.\AVGR\K{\_u} \\ &&|&
+     \hex{FD}~~156{:}\Bu32 &\Rightarrow& \I16X8.\EXTMUL\K{\_low\_i8x16\_s}\\ &&|&
+     \hex{FD}~~157{:}\Bu32 &\Rightarrow& \I16X8.\EXTMUL\K{\_high\_i8x16\_s}\\ &&|&
+     \hex{FD}~~158{:}\Bu32 &\Rightarrow& \I16X8.\EXTMUL\K{\_low\_i8x16\_u}\\ &&|&
+     \hex{FD}~~159{:}\Bu32 &\Rightarrow& \I16X8.\EXTMUL\K{\_high\_i8x16\_u}\\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~126{:}\Bu32 &\Rightarrow& \I32X4.\EXTADDPAIRWISE\K{\_i16x8\_s}\\ &&|&
+     \hex{FD}~~127{:}\Bu32 &\Rightarrow& \I32X4.\EXTADDPAIRWISE\K{\_i16x8\_u}\\ &&|&
+     \hex{FD}~~160{:}\Bu32 &\Rightarrow& \I32X4.\VABS \\ &&|&
+     \hex{FD}~~161{:}\Bu32 &\Rightarrow& \I32X4.\VNEG \\ &&|&
+     \hex{FD}~~163{:}\Bu32 &\Rightarrow& \I32X4.\ALLTRUE \\ &&|&
+     \hex{FD}~~164{:}\Bu32 &\Rightarrow& \I32X4.\BITMASK \\ &&|&
+     \hex{FD}~~167{:}\Bu32 &\Rightarrow& \I32X4.\VEXTEND\K{\_low\_i16x8\_s} \\ &&|&
+     \hex{FD}~~168{:}\Bu32 &\Rightarrow& \I32X4.\VEXTEND\K{\_high\_i16x8\_s} \\ &&|&
+     \hex{FD}~~169{:}\Bu32 &\Rightarrow& \I32X4.\VEXTEND\K{\_low\_i16x8\_u} \\ &&|&
+     \hex{FD}~~170{:}\Bu32 &\Rightarrow& \I32X4.\VEXTEND\K{\_high\_i16x8\_u} \\ &&|&
+     \hex{FD}~~171{:}\Bu32 &\Rightarrow& \I32X4.\VSHL \\ &&|&
+     \hex{FD}~~172{:}\Bu32 &\Rightarrow& \I32X4.\VSHR\K{\_s} \\ &&|&
+     \hex{FD}~~173{:}\Bu32 &\Rightarrow& \I32X4.\VSHR\K{\_u} \\ &&|&
+     \hex{FD}~~174{:}\Bu32 &\Rightarrow& \I32X4.\VADD \\ &&|&
+     \hex{FD}~~177{:}\Bu32 &\Rightarrow& \I32X4.\VSUB \\ &&|&
+     \hex{FD}~~181{:}\Bu32 &\Rightarrow& \I32X4.\VMUL \\ &&|&
+     \hex{FD}~~182{:}\Bu32 &\Rightarrow& \I32X4.\VMIN\K{\_s} \\ &&|&
+     \hex{FD}~~183{:}\Bu32 &\Rightarrow& \I32X4.\VMIN\K{\_u} \\ &&|&
+     \hex{FD}~~184{:}\Bu32 &\Rightarrow& \I32X4.\VMAX\K{\_s} \\ &&|&
+     \hex{FD}~~185{:}\Bu32 &\Rightarrow& \I32X4.\VMAX\K{\_u} \\ &&|&
+     \hex{FD}~~186{:}\Bu32 &\Rightarrow& \I32X4.\DOT\K{\_i16x8\_s}\\ &&|&
+     \hex{FD}~~188{:}\Bu32 &\Rightarrow& \I32X4.\EXTMUL\K{\_low\_i16x8\_s}\\ &&|&
+     \hex{FD}~~189{:}\Bu32 &\Rightarrow& \I32X4.\EXTMUL\K{\_high\_i16x8\_s}\\ &&|&
+     \hex{FD}~~190{:}\Bu32 &\Rightarrow& \I32X4.\EXTMUL\K{\_low\_i16x8\_u}\\ &&|&
+     \hex{FD}~~191{:}\Bu32 &\Rightarrow& \I32X4.\EXTMUL\K{\_high\_i16x8\_u}\\
+  \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~192{:}\Bu32 &\Rightarrow& \I64X2.\VABS \\ &&|&
+     \hex{FD}~~193{:}\Bu32 &\Rightarrow& \I64X2.\VNEG \\ &&|&
+     \hex{FD}~~195{:}\Bu32 &\Rightarrow& \I64X2.\ALLTRUE \\ &&|&
+     \hex{FD}~~196{:}\Bu32 &\Rightarrow& \I64X2.\BITMASK \\ &&|&
+     \hex{FD}~~199{:}\Bu32 &\Rightarrow& \I64X2.\VEXTEND\K{\_low\_i32x4\_s} \\ &&|&
+     \hex{FD}~~200{:}\Bu32 &\Rightarrow& \I64X2.\VEXTEND\K{\_high\_i32x4\_s} \\ &&|&
+     \hex{FD}~~201{:}\Bu32 &\Rightarrow& \I64X2.\VEXTEND\K{\_low\_i32x4\_u} \\ &&|&
+     \hex{FD}~~202{:}\Bu32 &\Rightarrow& \I64X2.\VEXTEND\K{\_high\_i32x4\_u} \\ &&|&
+     \hex{FD}~~203{:}\Bu32 &\Rightarrow& \I64X2.\VSHL \\ &&|&
+     \hex{FD}~~204{:}\Bu32 &\Rightarrow& \I64X2.\VSHR\K{\_s} \\ &&|&
+     \hex{FD}~~205{:}\Bu32 &\Rightarrow& \I64X2.\VSHR\K{\_u} \\ &&|&
+     \hex{FD}~~206{:}\Bu32 &\Rightarrow& \I64X2.\VADD \\ &&|&
+     \hex{FD}~~209{:}\Bu32 &\Rightarrow& \I64X2.\VSUB \\ &&|&
+     \hex{FD}~~213{:}\Bu32 &\Rightarrow& \I64X2.\VMUL \\ &&|&
+     \hex{FD}~~220{:}\Bu32 &\Rightarrow& \I64X2.\EXTMUL\K{\_low\_i32x4\_s}\\ &&|&
+     \hex{FD}~~221{:}\Bu32 &\Rightarrow& \I64X2.\EXTMUL\K{\_high\_i32x4\_s}\\ &&|&
+     \hex{FD}~~222{:}\Bu32 &\Rightarrow& \I64X2.\EXTMUL\K{\_low\_i32x4\_u}\\ &&|&
+     \hex{FD}~~223{:}\Bu32 &\Rightarrow& \I64X2.\EXTMUL\K{\_high\_i32x4\_u}\\
+  \end{array}
+
+.. _binary-vfunop:
+.. _binary-vfbinop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~103{:}\Bu32 &\Rightarrow& \F32X4.\VCEIL \\ &&|&
+     \hex{FD}~~104{:}\Bu32 &\Rightarrow& \F32X4.\VFLOOR \\ &&|&
+     \hex{FD}~~105{:}\Bu32 &\Rightarrow& \F32X4.\VTRUNC \\ &&|&
+     \hex{FD}~~106{:}\Bu32 &\Rightarrow& \F32X4.\VNEAREST \\ &&|&
+     \hex{FD}~~224{:}\Bu32 &\Rightarrow& \F32X4.\VABS \\ &&|&
+     \hex{FD}~~225{:}\Bu32 &\Rightarrow& \F32X4.\VNEG \\ &&|&
+     \hex{FD}~~227{:}\Bu32 &\Rightarrow& \F32X4.\VSQRT \\ &&|&
+     \hex{FD}~~228{:}\Bu32 &\Rightarrow& \F32X4.\VADD \\ &&|&
+     \hex{FD}~~229{:}\Bu32 &\Rightarrow& \F32X4.\VSUB \\ &&|&
+     \hex{FD}~~230{:}\Bu32 &\Rightarrow& \F32X4.\VMUL \\ &&|&
+     \hex{FD}~~231{:}\Bu32 &\Rightarrow& \F32X4.\VDIV \\ &&|&
+     \hex{FD}~~232{:}\Bu32 &\Rightarrow& \F32X4.\VMIN \\ &&|&
+     \hex{FD}~~233{:}\Bu32 &\Rightarrow& \F32X4.\VMAX \\ &&|&
+     \hex{FD}~~234{:}\Bu32 &\Rightarrow& \F32X4.\VPMIN \\ &&|&
+     \hex{FD}~~235{:}\Bu32 &\Rightarrow& \F32X4.\VPMAX \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~116{:}\Bu32 &\Rightarrow& \F64X2.\VCEIL \\ &&|&
+     \hex{FD}~~117{:}\Bu32 &\Rightarrow& \F64X2.\VFLOOR \\ &&|&
+     \hex{FD}~~122{:}\Bu32 &\Rightarrow& \F64X2.\VTRUNC \\ &&|&
+     \hex{FD}~~148{:}\Bu32 &\Rightarrow& \F64X2.\VNEAREST \\ &&|&
+     \hex{FD}~~236{:}\Bu32 &\Rightarrow& \F64X2.\VABS \\ &&|&
+     \hex{FD}~~237{:}\Bu32 &\Rightarrow& \F64X2.\VNEG \\ &&|&
+     \hex{FD}~~239{:}\Bu32 &\Rightarrow& \F64X2.\VSQRT \\ &&|&
+     \hex{FD}~~240{:}\Bu32 &\Rightarrow& \F64X2.\VADD \\ &&|&
+     \hex{FD}~~241{:}\Bu32 &\Rightarrow& \F64X2.\VSUB \\ &&|&
+     \hex{FD}~~242{:}\Bu32 &\Rightarrow& \F64X2.\VMUL \\ &&|&
+     \hex{FD}~~243{:}\Bu32 &\Rightarrow& \F64X2.\VDIV \\ &&|&
+     \hex{FD}~~244{:}\Bu32 &\Rightarrow& \F64X2.\VMIN \\ &&|&
+     \hex{FD}~~245{:}\Bu32 &\Rightarrow& \F64X2.\VMAX \\ &&|&
+     \hex{FD}~~246{:}\Bu32 &\Rightarrow& \F64X2.\VPMIN \\ &&|&
+     \hex{FD}~~247{:}\Bu32 &\Rightarrow& \F64X2.\VPMAX \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{vechaslongerinstructionnames} \\[-2ex] &&|&
+     \hex{FD}~~248{:}\Bu32 &\Rightarrow& \I32X4.\TRUNC\K{\_sat\_f32x4\_s} \\ &&|&
+     \hex{FD}~~249{:}\Bu32 &\Rightarrow& \I32X4.\TRUNC\K{\_sat\_f32x4\_u} \\ &&|&
+     \hex{FD}~~250{:}\Bu32 &\Rightarrow& \F32X4.\CONVERT\K{\_i32x4\_s} \\ &&|&
+     \hex{FD}~~251{:}\Bu32 &\Rightarrow& \F32X4.\CONVERT\K{\_i32x4\_u} \\ &&|&
+     \hex{FD}~~252{:}\Bu32 &\Rightarrow& \I32X4.\VTRUNC\K{\_sat\_f64x2\_s\_zero}\\ &&|&
+     \hex{FD}~~253{:}\Bu32 &\Rightarrow& \I32X4.\VTRUNC\K{\_sat\_f64x2\_u\_zero}\\ &&|&
+     \hex{FD}~~254{:}\Bu32 &\Rightarrow& \F64X2.\VCONVERT\K{\_low\_i32x4\_s}\\  &&|&
+     \hex{FD}~~255{:}\Bu32 &\Rightarrow& \F64X2.\VCONVERT\K{\_low\_i32x4\_u}\\ &&|&
+     \hex{FD}~~94{:}\Bu32 &\Rightarrow& \F32X4.\VDEMOTE\K{\_f64x2\_zero}\\ &&|&
+     \hex{FD}~~95{:}\Bu32 &\Rightarrow& \F64X2.\VPROMOTE\K{\_low\_f32x4}\\
+   \end{array}
+
+
 .. index:: expression
    pair: binary format; expression
    single: expression; constant
diff --git a/document/core/binary/types.rst b/document/core/binary/types.rst
index e9adc4df9..ddaffdc4c 100644
--- a/document/core/binary/types.rst
+++ b/document/core/binary/types.rst
@@ -29,6 +29,22 @@ Number Types
    \end{array}
 
 
+.. index:: vector type
+   pair: binary format; vector type
+.. _binary-vectype:
+
+Vector Types
+~~~~~~~~~~~~
+
+:ref:`Vector types <syntax-vectype>` are also encoded by a single byte.
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{vector type} & \Bvectype &::=&
+     \hex{7B} &\Rightarrow& \V128 \\
+   \end{array}
+
+
 .. index:: heap type
    pair: binary format; heap type
 .. _binary-heaptype:
diff --git a/document/core/conf.py b/document/core/conf.py
index 6e6523f4f..09930022e 100644
--- a/document/core/conf.py
+++ b/document/core/conf.py
@@ -18,8 +18,9 @@
 import os
 import sys
 from datetime import date
+
 pwd = os.path.abspath('.')
-sys.path.insert(0, pwd + '/util')
+sys.path.insert(0, pwd)
 
 # -- General configuration ------------------------------------------------
 
@@ -36,8 +37,8 @@
   'sphinx.ext.mathjax',
   'sphinx.ext.ifconfig',
   'sphinx.ext.githubpages',
-  'mathdef',
-  'pseudo-lexer'
+  'util.mathdef',
+  'util.pseudo-lexer'
 ]
 
 # Add any paths that contain templates here, relative to this directory.
@@ -251,7 +252,7 @@
 # If this is not None, a ‘Last updated on:’ timestamp is inserted at every
 # page bottom, using the given strftime() format.
 #
-html_last_updated_fmt = '%F'
+html_last_updated_fmt = '%Y-%m-%d'
 
 # If true, an OpenSearch description file will be output, and all pages will
 # contain a <link> tag referring to it.  The value of this option must be the
@@ -491,8 +492,9 @@
 .. include:: /""" + pwd + """/util/macros.def
 """
 
-# https://www.sphinx-doc.org/en/master/usage/extensions/math.html#confval-mathjax_config
-# http://docs.mathjax.org/en/v2.7-latest/options/input-processors/TeX.html
-mathjax_config = {
-    'TeX': { 'MAXBUFFER': 30*1024 },
+# https://www.sphinx-doc.org/en/master/usage/extensions/math.html#confval-mathjax3_config
+# https://docs.mathjax.org/en/latest/web/configuration.html#configuration
+# https://docs.mathjax.org/en/latest/options/input/tex.html#tex-maxbuffer
+mathjax3_config = {
+    'tex': { 'maxBuffer': 30*1024 },
 }
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 572c6d9cc..f51e522e1 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -271,6 +271,705 @@ Reference Instructions
    \end{array}
 
 
+.. index:: vector instruction
+   pair: execution; instruction
+   single: abstract syntax; instruction
+.. _exec-instr-vec:
+
+Vector Instructions
+~~~~~~~~~~~~~~~~~~~
+
+Most vector instructions are defined in terms of generic numeric operators applied lane-wise based on the :ref:`shape <syntax-vec-shape>`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \X{op}_{t\K{x}N}(n_1,\dots,n_k) &=&
+     \lanes^{-1}_{t\K{x}N}(op_t(\lanes_{t\K{x}N}(n_1) ~\dots~ \lanes_{t\K{x}N}(n_k))
+   \end{array}
+
+.. note::
+   For example, the result of instruction :math:`\K{i32x4}.\ADD` applied to operands :math:`i_1, i_2`
+   invokes :math:`\ADD_{\K{i32x4}}(i_1, i_2)`, which maps to
+   :math:`\lanes^{-1}_{\K{i32x4}}(\ADD_{\I32}(i_1^+, i_2^+))`,
+   where :math:`i_1^+` and :math:`i_2^+` are sequences resulting from invoking
+   :math:`\lanes_{\K{i32x4}}(i_1)` and :math:`\lanes_{\K{i32x4}}(i_2)`
+   respectively.
+
+
+.. _exec-vconst:
+
+:math:`\V128\K{.}\VCONST~c`
+...........................
+
+1. Push the value :math:`\V128.\VCONST~c` to the stack.
+
+.. note::
+   No formal reduction rule is required for this instruction, since |VCONST| instructions coincide with :ref:`values <syntax-val>`.
+
+
+.. _exec-vvunop:
+
+:math:`\V128\K{.}\vvunop`
+.........................
+
+1. Assert: due to :ref:`validation <valid-vvunop>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+3. Let :math:`c` be the result of computing :math:`\vvunop_{\I128}(c_1)`.
+
+4. Push the value :math:`\V128.\VCONST~c` to the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~\V128\K{.}\vvunop &\stepto& (\V128\K{.}\VCONST~c)
+     & (\iff c = \vvunop_{\I128}(c_1)) \\
+   \end{array}
+
+
+.. _exec-vvbinop:
+
+:math:`\V128\K{.}\vvbinop`
+..........................
+
+1. Assert: due to :ref:`validation <valid-vvbinop>`, two values of :ref:`value type <syntax-valtype>` |V128| are on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
+
+3. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+4. Let :math:`c` be the result of computing :math:`\vvbinop_{\I128}(c_1, c_2)`.
+
+5. Push the value :math:`\V128.\VCONST~c` to the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~\V128\K{.}\vvbinop &\stepto& (\V128\K{.}\VCONST~c)
+     & (\iff c = \vvbinop_{\I128}(c_1, c_2)) \\
+   \end{array}
+
+
+.. _exec-vvternop:
+
+:math:`\V128\K{.}\vvternop`
+...........................
+
+1. Assert: due to :ref:`validation <valid-vvternop>`, three values of :ref:`value type <syntax-valtype>` |V128| are on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_3` from the stack.
+
+3. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
+
+4. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+5. Let :math:`c` be the result of computing :math:`\vvternop_{\I128}(c_1, c_2, c_3)`.
+
+6. Push the value :math:`\V128.\VCONST~c` to the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~(\V128\K{.}\VCONST~c_3)~\V128\K{.}\vvternop &\stepto& (\V128\K{.}\VCONST~c)
+     & (\iff c = \vvternop_{\I128}(c_1, c_2, c_3)) \\
+   \end{array}
+
+
+.. _exec-vvtestop:
+.. _exec-vec-any_true:
+
+:math:`\V128\K{.}\ANYTRUE`
+..........................
+
+1. Assert: due to :ref:`validation <valid-vvtestop>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+3. Let :math:`i` be the result of computing :math:`\ine_{128}(c_1, 0)`.
+
+4. Push the value :math:`\I32.\CONST~i` onto the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~\V128\K{.}\ANYTRUE &\stepto& (\I32\K{.}\CONST~i)
+     & (\iff i = \ine_{128}(c_1, 0)) \\
+   \end{array}
+
+
+.. _exec-vec-swizzle:
+
+:math:`\K{i8x16.}\SWIZZLE`
+..........................
+
+1. Assert: due to :ref:`validation <valid-vbinop>`, two values of :ref:`value type <syntax-valtype>` |V128| are on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
+
+3. Let :math:`i^\ast` be the sequence :math:`\lanes_{i8x16}(c_2)`.
+
+4. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+5. Let :math:`j^\ast` be the sequence :math:`\lanes_{i8x16}(c_1)`.
+
+6. Let :math:`c^\ast` be the concatenation of the two sequences :math:`j^\ast~0^{240}`
+
+7. Let :math:`c'` be the result of :math:`\lanes^{-1}_{i8x16}(c^\ast[ i^\ast[0] ] \dots c^\ast[ i^\ast[15] ])`.
+
+8. Push the value :math:`\V128.\VCONST~c'` onto the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~\V128\K{.}\SWIZZLE &\stepto& (\V128\K{.}\VCONST~c')
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+      (\iff & i^\ast = \lanes_{i8x16}(c_2) \\
+      \wedge & c^\ast = \lanes_{i8x16}(c_1)~0^{240} \\
+      \wedge & c' = \lanes^{-1}_{i8x16}(c^\ast[ i^\ast[0] ] \dots c^\ast[ i^\ast[15] ])
+     \end{array}
+   \end{array}
+
+
+.. _exec-vec-shuffle:
+
+:math:`\K{i8x16.}\SHUFFLE~x^\ast`
+.................................
+
+1. Assert: due to :ref:`validation <valid-vec-shuffle>`, two values of :ref:`value type <syntax-valtype>` |V128| are on the top of the stack.
+
+2. Assert: due to :ref:`validation <valid-vec-shuffle>`, for all :math:`x_i` in :math:`x^\ast` it holds that :math:`x_i < 32`.
+
+3. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
+
+4. Let :math:`i_2^\ast` be the sequence :math:`\lanes_{i8x16}(c_2)`.
+
+5. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+6. Let :math:`i_1^\ast` be the sequence :math:`\lanes_{i8x16}(c_1)`.
+
+7. Let :math:`i^\ast` be the concatenation of the two sequences :math:`i_1^\ast~i_2^\ast`.
+
+8. Let :math:`c` be the result of :math:`\lanes^{-1}_{i8x16}(i^\ast[x^\ast[0]] \dots i^\ast[x^\ast[15]])`.
+
+9. Push the value :math:`\V128.\VCONST~c` onto the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~\V128\K{.}\SHUFFLE~x^\ast &\stepto& (\V128\K{.}\VCONST~c)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+      (\iff & i^\ast = \lanes_{i8x16}(c_1)~\lanes_{i8x16}(c_2) \\
+      \wedge & c = \lanes^{-1}_{i8x16}(i^\ast[x^\ast[0]] \dots i^\ast[x^\ast[15]])
+     \end{array}
+   \end{array}
+
+
+.. _exec-vec-splat:
+
+:math:`\shape\K{.}\SPLAT`
+.........................
+
+1. Let :math:`t` be the type :math:`\unpacked(\shape)`.
+
+2. Assert: due to :ref:`validation <valid-vec-splat>`, a value of :ref:`value type <syntax-valtype>` :math:`t` is on the top of the stack.
+
+3. Pop the value :math:`t.\CONST~c_1` from the stack.
+
+4. Let :math:`N` be the integer :math:`\dim(\shape)`.
+
+5. Let :math:`c` be the result of :math:`\lanes^{-1}_{\shape}(c_1^N)`.
+
+6. Push the value :math:`\V128.\VCONST~c` to the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (t\K{.}\CONST~c_1)~\shape\K{.}\SPLAT &\stepto& (\V128\K{.}\VCONST~c)
+     & (\iff t = \unpacked(\shape)
+       \wedge c = \lanes^{-1}_{\shape}(c_1^{\dim(\shape)}))
+     \\
+   \end{array}
+
+
+.. _exec-vec-extract_lane:
+
+:math:`t_1\K{x}N\K{.}\EXTRACTLANE\K{\_}\sx^?~x`
+...............................................
+
+1. Assert: due to :ref:`validation <valid-vec-extract_lane>`, :math:`x < N`.
+
+2. Assert: due to :ref:`validation <valid-vec-extract_lane>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+3. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+4. Let :math:`i^\ast` be the sequence :math:`\lanes_{t_1\K{x}N}(c_1)`.
+
+5. Let :math:`t_2` be the type :math:`\unpacked(t_1\K{x}N)`.
+
+6. Let :math:`c_2` be the result of computing :math:`\extend^{sx^?}_{t_1,t_2}(i^\ast[x])`.
+
+7. Push the value :math:`t_2.\CONST~c_2` to the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~t_1\K{x}N\K{.}\EXTRACTLANE~x &\stepto& (t_2\K{.}\CONST~c_2)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+      (\iff & t_2 = \unpacked(t_1\K{x}N) \\
+       \wedge & c_2 = \extend^{sx^?}_{t_1,t_2}(\lanes_{t_1\K{x}N}(c_1)[x])
+     \end{array}
+   \end{array}
+
+
+.. _exec-vec-replace_lane:
+
+:math:`\shape\K{.}\REPLACELANE~x`
+.................................
+
+1. Assert: due to :ref:`validation <valid-vec-replace_lane>`, :math:`x < \dim(\shape)`.
+
+2. Let :math:`t_1` be the type :math:`\unpacked(\shape)`.
+
+3. Assert: due to :ref:`validation <valid-vec-replace_lane>`, a value of :ref:`value type <syntax-valtype>` :math:`t_1` is on the top of the stack.
+
+4. Pop the value :math:`t_1.\CONST~c_1` from the stack.
+
+5. Assert: due to :ref:`validation <valid-vec-replace_lane>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+6. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
+
+7. Let :math:`i^\ast` be the sequence :math:`\lanes_{\shape}(c_2)`.
+
+8. Let :math:`c` be the result of computing :math:`\lanes^{-1}_{\shape}(i^\ast \with [x] = c_1)`
+
+9. Push :math:`\V128.\VCONST~c` on the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (t_1\K{.}\CONST~c_1)~(\V128\K{.}\VCONST~c_2)~\shape\K{.}\REPLACELANE~x &\stepto& (\V128\K{.}\VCONST~c)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+      (\iff & i^\ast = \lanes_{\shape}(c_2)) \\
+       \wedge & c = \lanes^{-1}_{\shape}(i^\ast \with [x] = c_1)
+     \end{array}
+   \end{array}
+
+
+.. _exec-vunop:
+
+:math:`\shape\K{.}\vunop`
+.........................
+
+1. Assert: due to :ref:`validation <valid-vunop>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+3. Let :math:`c` be the result of computing :math:`\vunop_{\shape}(c_1)`.
+
+4. Push the value :math:`\V128.\VCONST~c` to the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~\V128\K{.}\vunop &\stepto& (\V128\K{.}\VCONST~c)
+     & (\iff c = \vunop_{\shape}(c_1))
+   \end{array}
+
+
+.. _exec-vbinop:
+
+:math:`\shape\K{.}\vbinop`
+..........................
+
+1. Assert: due to :ref:`validation <valid-vbinop>`, two values of :ref:`value type <syntax-valtype>` |V128| are on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
+
+3. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+4. If :math:`\vbinop_{\shape}(c_1, c_2)` is defined:
+
+   a. Let :math:`c` be a possible result of computing :math:`\vbinop_{\shape}(c_1, c_2)`.
+
+   b. Push the value :math:`\V128.\VCONST~c` to the stack.
+
+5. Else:
+
+   a. Trap.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~\shape\K{.}\vbinop &\stepto& (\V128\K{.}\VCONST~c)
+     & (\iff c \in \vbinop_{\shape}(c_1, c_2)) \\
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~\shape\K{.}\vbinop &\stepto& \TRAP
+     & (\iff \vbinop_{\shape}(c_1, c_2) = \{\})
+   \end{array}
+
+
+.. _exec-vrelop:
+
+:math:`t\K{x}N\K{.}\vrelop`
+...........................
+
+1. Assert: due to :ref:`validation <valid-vrelop>`, two values of :ref:`value type <syntax-valtype>` |V128| are on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
+
+3. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+4. Let :math:`i^\ast` be the sequence :math:`\lanes_{t\K{x}N}(c_1)`.
+
+5. Let :math:`j^\ast` be the sequence :math:`\lanes_{t\K{x}N}(c_2)`.
+
+6. Let :math:`c` be the result of computing :math:`\lanes^{-1}_{t\K{x}N}(\extends_{1,|t|}(\vrelop_t(i^\ast, j^\ast)))`.
+
+7. Push the value :math:`\V128.\VCONST~c` to the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~t\K{x}N\K{.}\vrelop &\stepto& (\V128\K{.}\VCONST~c)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff c = \lanes^{-1}_{t\K{x}N}(\extends_{1,|t|}(\vrelop_t(\lanes_{t\K{x}N}(c_1), \lanes_{t\K{x}N}(c_2)))))
+     \end{array}
+   \end{array}
+
+
+.. _exec-vishiftop:
+
+:math:`t\K{x}N\K{.}\vishiftop`
+..............................
+
+1. Assert: due to :ref:`validation <valid-vishiftop>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+
+2. Pop the value :math:`\I32.\CONST~s` from the stack.
+
+3. Assert: due to :ref:`validation <valid-vishiftop>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+4. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+5. Let :math:`i^\ast` be the sequence :math:`\lanes_{t\K{x}N}(c_1)`.
+
+6. Let :math:`c` be :math:`\lanes^{-1}_{t\K{x}N}(\vishiftop_{t}(i^\ast, s^N))`.
+
+7. Push the value :math:`\V128.\VCONST~c` to the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~(\I32\K{.}\CONST~s)~t\K{x}N\K{.}\vishiftop &\stepto& (\V128\K{.}\VCONST~c)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & i^\ast = \lanes_{t\K{x}N}(c_1) \\
+     \wedge & c = \lanes^{-1}_{t\K{x}N}(\vishiftop_{t}(i^\ast, s^N)))
+     \end{array}
+   \end{array}
+
+
+.. _exec-vtestop:
+.. _exec-vec-all_true:
+
+:math:`\shape\K{.}\ALLTRUE`
+...........................
+
+1. Assert: due to :ref:`validation <valid-vtestop>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+3. Let :math:`i_1^\ast` be the sequence :math:`\lanes_{\shape}(c_1)`
+
+4. Let :math:`i` be the result of computing :math:`\bool(\bigwedge(i_1 \neq 0)^\ast)`.
+
+5. Push the value :math:`\I32.\CONST~i` onto the stack.
+
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~\shape\K{.}\ALLTRUE &\stepto& (\I32\K{.}\CONST~i)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & i_1^\ast = \lanes_{\shape}(c) \\
+     \wedge & i = \bool(\bigwedge(i_1 \neq 0)^\ast)
+     \end{array}
+   \end{array}
+
+
+.. _exec-vec-bitmask:
+
+:math:`t\K{x}N\K{.}\BITMASK`
+............................
+
+1. Assert: due to :ref:`validation <valid-vec-bitmask>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+3. Let :math:`i_1^N` be the sequence :math:`\lanes_{t\K{x}N}(c)`.
+
+4. Let :math:`B` be the :ref:`bit width <syntax-valtype>` :math:`|t|` of :ref:`value type <syntax-valtype>` :math:`t`.
+
+5. Let :math:`i_2^N` be the sequence as a result of computing :math:`\ilts_{B}(i_1^N, 0^N)`.
+
+6. Let :math:`c` be the integer :math:`\ibits_{32}^{-1}(i_2^N~0^{32-N})`.
+
+7. Push the value :math:`\I32.\CONST~c` onto the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~t\K{x}N\K{.}\BITMASK &\stepto& (\I32\K{.}\CONST~c)
+     & (\iff c = \ibits_{32}^{-1}(\ilts_{|t|}(\lanes_{t\K{x}N}(c), 0^N)))
+     \\
+   \end{array}
+
+
+.. _exec-vec-narrow:
+
+:math:`t_2\K{x}N\K{.}\NARROW\K{\_}t_1\K{x}M\K{\_}\sx`
+.....................................................
+
+1. Assert: due to :ref:`syntax <syntax-instr-vec>`, :math:`N = 2\cdot M`.
+
+2. Assert: due to :ref:`validation <valid-vec-narrow>`, two values of :ref:`value type <syntax-valtype>` |V128| are on the top of the stack.
+
+3. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
+
+4. Let :math:`d_2^M` be the result of computing :math:`\narrow^{\sx}_{|t_1|,|t_2|}(\lanes_{t_1\K{x}M}(c_2))`.
+
+5. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+6. Let :math:`d_1^M` be the result of computing :math:`\narrow^{\sx}_{|t_1|,|t_2|}(\lanes_{t_1\K{x}M}(c_1))`.
+
+7. Let :math:`c` be the result of :math:`\lanes^{-1}_{t_2\K{x}N}(d_1^M~d_2^M)`.
+
+8. Push the value :math:`\V128.\VCONST~c` onto the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~t_2\K{x}N\K{.}\NARROW\_t_1\K{x}M\_\sx &\stepto& (\V128\K{.}\VCONST~c)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & d_1^M = \narrow^{\sx}_{|t_1|,|t_2|}( \lanes_{t_1\K{x}M}(c_1)) \\
+     \wedge & d_2^M = \narrow^{\sx}_{|t_1|,|t_2|}( \lanes_{t_1\K{x}M}(c_2)) \\
+     \wedge & c = \lanes^{-1}_{t_2\K{x}N}(d_1^M~d_2^M)
+     \end{array}
+   \end{array}
+
+
+.. _exec-vcvtop:
+
+:math:`t_2\K{x}N\K{.}\vcvtop\K{\_}t_1\K{x}M\K{\_}\sx`
+.....................................................
+
+1. Assert: due to :ref:`validation <valid-vcvtop>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+3. Let :math:`i^\ast` be the sequence :math:`\lanes_{t_1\K{x}M}(c_1)`.
+
+4. Let :math:`c` be the result of computing :math:`\lanes^{-1}_{t_2\K{x}N}(\vcvtop^{\sx}_{|t_1|,|t_2|}(i^\ast))`
+
+5. Push the value :math:`\V128.\VCONST~c` onto the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~t_2\K{x}N\K{.}\vcvtop\K{\_}t_1\K{x}M\K{\_}\sx &\stepto& (\V128\K{.}\VCONST~c) \\
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & c = \lanes^{-1}_{t_2\K{x}N}(\vcvtop^{\sx}_{|t_1|,|t_2|}(\lanes_{t_1\K{x}M}(c_1)))
+     \end{array}
+   \end{array}
+
+
+:math:`t_2\K{x}N\K{.}\vcvtop\K{\_}\half\K{\_}t_1\K{x}M\K{\_}\sx^?`
+..................................................................
+
+1. Assert: due to :ref:`validation <valid-vcvtop>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+3. If :math:`\half` is :math:`\K{low}`, then:
+
+   a. Let :math:`i^\ast` be the sequence :math:`\lanes_{t_1\K{x}M}(c_1)[0 \slice N]`.
+
+4. Else:
+
+   a. Let :math:`i^\ast` be the sequence :math:`\lanes_{t_1\K{x}M}(c_1)[N \slice N]`.
+
+5. Let :math:`j^\ast` be the result of computing :math:`\vcvtop^{\sx^?}_{|t_1|,|t_2|}(i^\ast)`.
+
+6. Let :math:`c` be the result of computing :math:`\lanes^{-1}_{t_2\K{x}N}(j^\ast)`.
+
+7. Push the value :math:`\V128.\VCONST~c` onto the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~t_2\K{x}N\K{.}\vcvtop\K{\_}\half\K{\_}t_1\K{x}M\K{\_}\sx^? &\stepto& (\V128\K{.}\VCONST~c) \\
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & c = \lanes^{-1}_{t_2\K{x}N}(\vcvtop^{\sx^?}_{|t_1|,|t_2|}(\lanes_{t_1\K{x}M}(c_1)[\half(0, N) \slice N]))
+     \end{array}
+   \end{array}
+
+where:
+
+.. math::
+   \begin{array}{lcl}
+   \K{low}(x, y) &=& x \\
+   \K{high}(x, y) &=& y \\
+   \end{array}
+
+
+:math:`t_2\K{x}N\K{.}\vcvtop\K{\_}t_1\K{x}M\K{\_}\sx\K{\_zero}`
+...............................................................
+
+1. Assert: due to :ref:`validation <valid-vcvtop>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+3. Let :math:`i^\ast` be the sequence :math:`\lanes_{t_1\K{x}M}(c_1)`.
+
+4. Let :math:`j^\ast` be the result of computing :math:`\vcvtop^{\sx}_{|t_1|,|t_2|}(i^\ast)` concatenated with the vector :math:`0^M`.
+
+5. Let :math:`c` be the result of computing :math:`\lanes^{-1}_{t_2\K{x}N}(j^\ast)`.
+
+6. Push the value :math:`\V128.\VCONST~c` onto the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~t_2\K{x}N\K{.}\vcvtop\K{\_}t_1\K{x}M\K{\_}\sx\K{\_zero} &\stepto& (\V128\K{.}\VCONST~c) \\
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & c = \lanes^{-1}_{t_2\K{x}N}(\vcvtop^{\sx}_{|t_1|,|t_2|}(\lanes_{t_1\K{x}M}(c_1))~0^M)
+     \end{array}
+   \end{array}
+
+
+.. _exec-vec-dot:
+
+:math:`\K{i32x4.}\DOT\K{\_i16x8\_s}`
+....................................
+
+1. Assert: due to :ref:`validation <valid-vec-dot>`, two values of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
+
+3. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+4. Let :math:`(i_1~i_2)^\ast` be the result of computing :math:`\imul_{32}(\extends_{16,32}(\lanes_{\I16X8}(c_1)), \extends_{16,32}(\lanes_{\I16X8}(c_2)))`
+
+5. Let :math:`j^\ast` be the result of computing :math:`\iadd_{32}(i_1, i_2)^\ast`.
+
+6. Let :math:`c` be the result of computing :math:`\lanes^{-1}_{\I32X4}(j^\ast)`.
+
+7. Push the value :math:`\V128.\VCONST~c` onto the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~\K{i32x4.}\DOT\K{\_i16x8\_s} &\stepto& (\V128\K{.}\VCONST~c) \\
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & (i_1~i_2)^\ast = \imul_{32}(\extends_{16,32}(\lanes_{\I16X8}(c_1)), \extends_{16,32}(\lanes_{\I16X8}(c_2))) \\
+     \wedge & j^\ast = \iadd_{32}(i_1, i_2)^\ast \\
+     \wedge & c = \lanes^{-1}_{\I32X4}(j^\ast)
+     \end{array}
+   \end{array}
+
+
+.. _exec-vec-extmul:
+
+:math:`t_2\K{x}N\K{.}\EXTMUL\K{\_}\half\K{\_}t_1\K{x}M\K{\_}\sx`
+................................................................
+
+1. Assert: due to :ref:`validation <valid-vec-extmul>`, two values of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
+
+3. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+4. If :math:`\half` is :math:`\K{low}`, then:
+
+   a. Let :math:`i^\ast` be the sequence :math:`\lanes_{t_1\K{x}M}(c_1)[0 \slice N]`.
+
+   b. Let :math:`j^\ast` be the sequence :math:`\lanes_{t_1\K{x}M}(c_2)[0 \slice N]`.
+
+5. Else:
+
+   a. Let :math:`i^\ast` be the sequence :math:`\lanes_{t_1\K{x}M}(c_1)[N \slice N]`.
+
+   b. Let :math:`j^\ast` be the sequence :math:`\lanes_{t_1\K{x}M}(c_2)[N \slice N]`.
+
+6. Let :math:`c` be the result of computing :math:`\lanes^{-1}_{t_2\K{x}N}(\imul_{t_2\K{x}N}(\extend^{\sx}_{|t_1|,|t_2|}(i^\ast), \extend^{\sx}_{|t_1|,|t_2|}(j^\ast)))`
+
+7. Push the value :math:`\V128.\VCONST~c` onto the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~t_2\K{x}N\K{.}\EXTMUL\K{\_}\half\K{\_}t_1\K{x}M\_\sx &\stepto& (\V128\K{.}\VCONST~c) \\
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & i^\ast = \lanes_{t_1\K{x}M}(c_1)[\half(0, N) \slice N] \\
+     \wedge & j^\ast = \lanes_{t_1\K{x}M}(c_2)[\half(0, N) \slice N] \\
+     \wedge & c = \lanes^{-1}_{t_2\K{x}N}(\imul_{t_2\K{x}N}(\extend^{\sx}_{|t_1|,|t_2|}(i^\ast), \extend^{\sx}_{|t_1|,|t_2|}(j^\ast)))
+     \end{array}
+
+where:
+
+.. math::
+   \begin{array}{lcl}
+   \K{low}(x, y) &=& x \\
+   \K{high}(x, y) &=& y \\
+   \end{array}
+
+
+.. _exec-vec-extadd_pairwise:
+
+:math:`t_2\K{x}N\K{.}\EXTADDPAIRWISE\_t_1\K{x}M\_\sx`
+.....................................................
+
+1. Assert: due to :ref:`validation <valid-vec-extadd_pairwise>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+2. Pop the value :math:`\V128.\VCONST~c_1` from the stack.
+
+3. Let :math:`(i_1~i_2)^\ast` be the sequence :math:`\extend^{\sx}_{|t_1|,|t_2|}(\lanes_{t_1\K{x}M}(c_1))`.
+
+4. Let :math:`j^\ast` be the result of computing :math:`\iadd_{N}(i_1, i_2)^\ast`.
+
+5. Let `c` be the result of computing :math:`\lanes^{-1}_{t_2\K{x}N}(j^\ast)`.
+
+6. Push the value :math:`\V128.\VCONST~c` to the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   (\V128\K{.}\VCONST~c_1)~t_2\K{x}N\K{.}\EXTADDPAIRWISE\_t_1\K{x}M\_\sx &\stepto& (\V128\K{.}\VCONST~c) \\
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & (i_1~i_2)^\ast = \extend^{\sx}_{|t_1|,|t_2|}(\lanes_{t_1\K{x}M}(c_1)) \\
+     \wedge & j^\ast = \iadd_{N}(i_1, i_2)^\ast \\
+     \wedge & c = \lanes^{-1}_{t_2\K{x}N}(j^\ast)
+     \end{array}
+   \end{array}
+
+
 .. index:: parametric instructions, value
    pair: execution; instruction
    single: abstract syntax; instruction
@@ -1054,6 +1753,241 @@ Memory Instructions
    \end{array}
 
 
+.. _exec-load-extend:
+
+:math:`\V128\K{.}\LOAD{M}\K{x}N\_\sx~\memarg`
+.............................................
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-load-extend>`, :math:`F.\AMODULE.\MIMEMS[0]` exists.
+
+3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\AMODULE.\MIMEMS[0]`.
+
+4. Assert: due to :ref:`validation <valid-load-extend>`, :math:`S.\SMEMS[a]` exists.
+
+5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\SMEMS[a]`.
+
+6. Assert: due to :ref:`validation <valid-load-extend>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+
+7. Pop the value :math:`\I32.\CONST~i` from the stack.
+
+8. Let :math:`\X{ea}` be the integer :math:`i + \memarg.\OFFSET`.
+
+9. If :math:`\X{ea} + M \cdot N /8` is larger than the length of :math:`\X{mem}.\MIDATA`, then:
+
+    a. Trap.
+
+10. Let :math:`b^\ast` be the byte sequence :math:`\X{mem}.\MIDATA[\X{ea} \slice M \cdot N /8]`.
+
+11. Let :math:`m_k` be the integer for which :math:`\bytes_{\iM}(m_k) = b^\ast[k \cdot M/8 \slice M/8]`.
+
+12. Let :math:`W` be the integer :math:`M \cdot 2`.
+
+13. Let :math:`n_k` be the result of :math:`\extend^{\sx}_{M,W}(m_k)`.
+
+14. Let :math:`c` be the result of computing :math:`\lanes^{-1}_{\X{i}W\K{x}N}(n_0 \dots n_{N-1})`.
+
+15. Push the value :math:`\V128.\CONST~c` to the stack.
+
+.. math::
+   ~\\[-1ex]
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~i)~(\V128.\LOAD{M}\K{x}N\_\sx~\memarg) &\stepto&
+     S; F; (\V128.\CONST~c)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & \X{ea} = i + \memarg.\OFFSET \\
+     \wedge & \X{ea} + M \cdot N / 8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
+     \wedge & \bytes_{\iM}(m_k) = S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} + k \cdot M/8 \slice M/8]) \\
+     \wedge & W = M \cdot 2 \\
+     \wedge & c = \lanes^{-1}_{\X{i}W\K{x}N}(\extend^{\sx}_{M,W}(m_0) \dots \extend^{\sx}_{M,W}(m_{N-1}))
+     \end{array}
+   \\[1ex]
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~k)~(\V128.\LOAD{M}\K{x}N\K{\_}\sx~\memarg) &\stepto& S; F; \TRAP
+   \end{array}
+   \\ \qquad
+     (\otherwise) \\
+   \end{array}
+
+
+.. _exec-load-splat:
+
+:math:`\V128\K{.}\LOAD{N}\K{\_splat}~\memarg`
+.............................................
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-load-extend>`, :math:`F.\AMODULE.\MIMEMS[0]` exists.
+
+3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\AMODULE.\MIMEMS[0]`.
+
+4. Assert: due to :ref:`validation <valid-load-extend>`, :math:`S.\SMEMS[a]` exists.
+
+5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\SMEMS[a]`.
+
+6. Assert: due to :ref:`validation <valid-load-extend>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+
+7. Pop the value :math:`\I32.\CONST~i` from the stack.
+
+8. Let :math:`\X{ea}` be the integer :math:`i + \memarg.\OFFSET`.
+
+9. If :math:`\X{ea} + N/8` is larger than the length of :math:`\X{mem}.\MIDATA`, then:
+
+    a. Trap.
+
+10. Let :math:`b^\ast` be the byte sequence :math:`\X{mem}.\MIDATA[\X{ea} \slice N/8]`.
+
+11. Let :math:`n` be the integer for which :math:`\bytes_{\iN}(n) = b^\ast`.
+
+12. Let :math:`L` be the integer :math:`128 / N`.
+
+13. Let :math:`c` be the result of computing :math:`\lanes^{-1}_{\iN\K{x}L}(n^L)`.
+
+14. Push the value :math:`\V128.\CONST~c` to the stack.
+
+.. math::
+   ~\\[-1ex]
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~i)~(\V128\K{.}\LOAD{N}\K{\_splat}~\memarg) &\stepto& S; F; (\V128.\CONST~c)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & \X{ea} = i + \memarg.\OFFSET \\
+     \wedge & \X{ea} + N/8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
+     \wedge & \bytes_{\iN}(n) = S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8]) \\
+     \wedge & c = \lanes^{-1}_{\iN\K{x}L}(n^L)
+     \end{array}
+   \\[1ex]
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~k)~(\V128.\LOAD{N}\K{\_splat}~\memarg) &\stepto& S; F; \TRAP
+   \end{array}
+   \\ \qquad
+     (\otherwise) \\
+   \end{array}
+
+
+.. _exec-load-zero:
+
+:math:`\V128\K{.}\LOAD{N}\K{\_zero}~\memarg`
+.............................................
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-load-extend>`, :math:`F.\AMODULE.\MIMEMS[0]` exists.
+
+3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\AMODULE.\MIMEMS[0]`.
+
+4. Assert: due to :ref:`validation <valid-load-extend>`, :math:`S.\SMEMS[a]` exists.
+
+5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\SMEMS[a]`.
+
+6. Assert: due to :ref:`validation <valid-load-extend>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+
+7. Pop the value :math:`\I32.\CONST~i` from the stack.
+
+8. Let :math:`\X{ea}` be the integer :math:`i + \memarg.\OFFSET`.
+
+9. If :math:`\X{ea} + N/8` is larger than the length of :math:`\X{mem}.\MIDATA`, then:
+
+    a. Trap.
+
+10. Let :math:`b^\ast` be the byte sequence :math:`\X{mem}.\MIDATA[\X{ea} \slice N/8]`.
+
+11. Let :math:`n` be the integer for which :math:`\bytes_{\iN}(n) = b^\ast`.
+
+12. Let :math:`c` be the result of :math:`\extendu_{N,128}(n)`.
+
+13. Push the value :math:`\V128.\CONST~c` to the stack.
+
+.. math::
+   ~\\[-1ex]
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~i)~(\V128\K{.}\LOAD{N}\K{\_zero}~\memarg) &\stepto& S; F; (\V128.\CONST~c)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & \X{ea} = i + \memarg.\OFFSET \\
+     \wedge & \X{ea} + N/8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
+     \wedge & \bytes_{\iN}(n) = S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8]) \\
+     \wedge & c = \extendu_{N,128}(n)
+     \end{array}
+   \\[1ex]
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~k)~(\V128.\LOAD{N}\K{\_zero}~\memarg) &\stepto& S; F; \TRAP
+   \end{array}
+   \\ \qquad
+     (\otherwise) \\
+   \end{array}
+
+
+.. _exec-load-lane:
+
+:math:`\V128\K{.}\LOAD{N}\K{\_lane}~\memarg~x`
+.....................................................
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-load-extend>`, :math:`F.\AMODULE.\MIMEMS[0]` exists.
+
+3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\AMODULE.\MIMEMS[0]`.
+
+4. Assert: due to :ref:`validation <valid-load-extend>`, :math:`S.\SMEMS[a]` exists.
+
+5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\SMEMS[a]`.
+
+6. Assert: due to :ref:`validation <valid-load-extend>`, a value of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+
+7. Pop the value :math:`\V128.\CONST~v` from the stack.
+
+8. Assert: due to :ref:`validation <valid-load-extend>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+
+9. Pop the value :math:`\I32.\CONST~i` from the stack.
+
+10. Let :math:`\X{ea}` be the integer :math:`i + \memarg.\OFFSET`.
+
+11. If :math:`\X{ea} + N/8` is larger than the length of :math:`\X{mem}.\MIDATA`, then:
+
+    a. Trap.
+
+12. Let :math:`b^\ast` be the byte sequence :math:`\X{mem}.\MIDATA[\X{ea} \slice N/8]`.
+
+13. Let :math:`r` be the constant for which :math:`\bytes_{\iN}(r) = b^\ast`.
+
+14. Let :math:`L` be :math:`128 / N`.
+
+15. Let :math:`c` be the result of computing :math:`\lanes^{-1}_{\K{i}N\K{x}L}(\lanes_{\K{i}N\K{x}L}(v) \with [x] = r)`.
+
+16. Push the value :math:`\V128.\CONST~c` to the stack.
+
+.. math::
+   ~\\[-1ex]
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~i)~(\V128.\CONST~v)~(\V128\K{.}\LOAD{N}\K{\_lane}~\memarg~x) &\stepto& S; F; (\V128.\CONST~c)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & \X{ea} = i + \memarg.\OFFSET \\
+     \wedge & \X{ea} + N/8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
+     \wedge & \bytes_{\iN}(r) = S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8]) \\
+     \wedge & L = 128/N \\
+     \wedge & c = \lanes^{-1}_{\K{i}N\K{x}L}(\lanes_{\K{i}N\K{x}L}(v) \with [x] = r)
+     \end{array}
+   \\[1ex]
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~k)~(\V128.\CONST~v)~(\V128.\LOAD{N}\K{\_lane}~\memarg~x) &\stepto& S; F; \TRAP
+   \end{array}
+   \\ \qquad
+     (\otherwise) \\
+   \end{array}
+
+
 .. _exec-store:
 .. _exec-storen:
 
@@ -1131,6 +2065,63 @@ Memory Instructions
    \end{array}
 
 
+.. _exec-store-lane:
+
+:math:`\V128\K{.}\STORE{N}\K{\_lane}~\memarg~x`
+......................................................
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-storen>`, :math:`F.\AMODULE.\MIMEMS[0]` exists.
+
+3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\AMODULE.\MIMEMS[0]`.
+
+4. Assert: due to :ref:`validation <valid-storen>`, :math:`S.\SMEMS[a]` exists.
+
+5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\SMEMS[a]`.
+
+6. Assert: due to :ref:`validation <valid-storen>`, a value of :ref:`value type <syntax-valtype>` :math:`\V128` is on the top of the stack.
+
+7. Pop the value :math:`\V128.\CONST~c` from the stack.
+
+8. Assert: due to :ref:`validation <valid-storen>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+
+9. Pop the value :math:`\I32.\CONST~i` from the stack.
+
+10. Let :math:`\X{ea}` be the integer :math:`i + \memarg.\OFFSET`.
+
+11. If :math:`\X{ea} + N/8` is larger than the length of :math:`\X{mem}.\MIDATA`, then:
+
+    a. Trap.
+
+12. Let :math:`L` be :math:`128/N`.
+
+13. Let :math:`b^\ast` be the byte sequence :math:`\bytes_{\iN}(\lanes_{\K{i}N\K{x}L}(c)[x])`.
+
+14. Replace the bytes :math:`\X{mem}.\MIDATA[\X{ea} \slice N/8]` with :math:`b^\ast`.
+
+.. math::
+   ~\\[-1ex]
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~i)~(\V128.\CONST~c)~(\V128.\STORE{N}\K{\_lane}~\memarg~x) &\stepto& S'; F; \epsilon
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & \X{ea} = i + \memarg.\OFFSET \\
+     \wedge & \X{ea} + N \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
+     \wedge & L = 128/N \\
+     \wedge & S' = S \with \SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8] = \bytes_{\iN}(\lanes_{\K{i}N\K{x}L}(c)[x])
+     \end{array}
+   \\[1ex]
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~k)~(\V128.\CONST~c)~(\V128.\STORE{N}\K{\_lane}~\memarg~x) &\stepto& S; F; \TRAP
+   \end{array}
+   \\ \qquad
+     (\otherwise) \\
+   \end{array}
+
+
 .. _exec-memory.size:
 
 :math:`\MEMORYSIZE`
@@ -1436,15 +2427,15 @@ Memory Instructions
 
 10. Assert: due to :ref:`validation <valid-memory.init>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
 
-11. Pop the value :math:`\I32.\CONST~cnt` from the stack.
+11. Pop the value :math:`\I32.\CONST~n` from the stack.
 
 12. Assert: due to :ref:`validation <valid-memory.init>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
 
-13. Pop the value :math:`\I32.\CONST~src` from the stack.
+13. Pop the value :math:`\I32.\CONST~s` from the stack.
 
 14. Assert: due to :ref:`validation <valid-memory.init>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
 
-15. Pop the value :math:`\I32.\CONST~dst` from the stack.
+15. Pop the value :math:`\I32.\CONST~d` from the stack.
 
 16. If :math:`s + n` is larger than the length of :math:`\X{data}.\DIDATA` or :math:`d + n` is larger than the length of :math:`\X{mem}.\MIDATA`, then:
 
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index 2547aa49a..b876dd7d3 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -468,17 +468,17 @@ and list of :ref:`reference <syntax-ref>` vectors for the module's :ref:`element
 
    a. Let :math:`\dataaddr_i` be the :ref:`data address <syntax-dataaddr>` resulting from :ref:`allocating <alloc-data>` a :ref:`data instance <syntax-datainst>` with contents :math:`\data_i.\DINIT`.
 
-8. Let :math:`\funcaddr^\ast` be the the concatenation of the :ref:`function addresses <syntax-funcaddr>` :math:`\funcaddr_i` in index order.
+8. Let :math:`\funcaddr^\ast` be the concatenation of the :ref:`function addresses <syntax-funcaddr>` :math:`\funcaddr_i` in index order.
 
-9. Let :math:`\tableaddr^\ast` be the the concatenation of the :ref:`table addresses <syntax-tableaddr>` :math:`\tableaddr_i` in index order.
+9. Let :math:`\tableaddr^\ast` be the concatenation of the :ref:`table addresses <syntax-tableaddr>` :math:`\tableaddr_i` in index order.
 
-10. Let :math:`\memaddr^\ast` be the the concatenation of the :ref:`memory addresses <syntax-memaddr>` :math:`\memaddr_i` in index order.
+10. Let :math:`\memaddr^\ast` be the concatenation of the :ref:`memory addresses <syntax-memaddr>` :math:`\memaddr_i` in index order.
 
-11. Let :math:`\globaladdr^\ast` be the the concatenation of the :ref:`global addresses <syntax-globaladdr>` :math:`\globaladdr_i` in index order.
+11. Let :math:`\globaladdr^\ast` be the concatenation of the :ref:`global addresses <syntax-globaladdr>` :math:`\globaladdr_i` in index order.
 
-12. Let :math:`\elemaddr^\ast` be the the concatenation of the :ref:`element addresses <syntax-elemaddr>` :math:`\elemaddr_i` in index order.
+12. Let :math:`\elemaddr^\ast` be the concatenation of the :ref:`element addresses <syntax-elemaddr>` :math:`\elemaddr_i` in index order.
 
-13. Let :math:`\dataaddr^\ast` be the the concatenation of the :ref:`data addresses <syntax-dataaddr>` :math:`\dataaddr_i` in index order.
+13. Let :math:`\dataaddr^\ast` be the concatenation of the :ref:`data addresses <syntax-dataaddr>` :math:`\dataaddr_i` in index order.
 
 14. Let :math:`\funcaddr_{\F{mod}}^\ast` be the list of :ref:`function addresses <syntax-funcaddr>` extracted from :math:`\externval_{\F{im}}^\ast`, concatenated with :math:`\funcaddr^\ast`.
 
@@ -500,7 +500,7 @@ and list of :ref:`reference <syntax-ref>` vectors for the module's :ref:`element
 
     e. Let :math:`\exportinst_i` be the :ref:`export instance <syntax-exportinst>` :math:`\{\EINAME~(\export_i.\ENAME), \EIVALUE~\externval_i\}`.
 
-19. Let :math:`\exportinst^\ast` be the the concatenation of the :ref:`export instances <syntax-exportinst>` :math:`\exportinst_i` in index order.
+19. Let :math:`\exportinst^\ast` be the concatenation of the :ref:`export instances <syntax-exportinst>` :math:`\exportinst_i` in index order.
 
 20. Let :math:`\moduleinst` be the :ref:`module instance <syntax-moduleinst>` :math:`\{\MITYPES~(\module.\MTYPES),` :math:`\MIFUNCS~\funcaddr_{\F{mod}}^\ast,` :math:`\MITABLES~\tableaddr_{\F{mod}}^\ast,` :math:`\MIMEMS~\memaddr_{\F{mod}}^\ast,` :math:`\MIGLOBALS~\globaladdr_{\F{mod}}^\ast,` :math:`\MIEXPORTS~\exportinst^\ast\}`.
 
@@ -635,7 +635,7 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
    b. Assert: due to :ref:`validation <valid-module>`, the frame :math:`F_{\F{init}}` is now on the top of the stack.
 
-   c. Let :math:`\val^\ast` be the conatenation of :math:`\val_i` in index order.
+   c. Let :math:`\val^\ast` be the concatenation of :math:`\val_i` in index order.
 
 9. Let :math:`(\reff^\ast)^\ast` be the list of :ref:`reference <syntax-ref>` vectors determined by the :ref:`element segments <syntax-elem>` in :math:`\module`. These may be calculated as follows.
 
diff --git a/document/core/exec/numerics.rst b/document/core/exec/numerics.rst
index 748ca605a..b60416874 100644
--- a/document/core/exec/numerics.rst
+++ b/document/core/exec/numerics.rst
@@ -38,6 +38,28 @@ When several of these placeholders occur in a single clause, then they must be r
       \fcopysign_N(- p_1, + p_2) &=& + p_1 \\
       \end{array}
 
+Numeric operators are lifted to input sequences by applying the operator element-wise, returning a sequence of results. When there are multiple inputs, they must be of equal length.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   op(c_1^n, \dots, c_k^n) &=& op(c_1^n[0], \dots, c_k^n[0])~\dots~op(c_1^n[n-1], \dots, c_k^n[n-1])
+   \end{array}
+
+.. note::
+   For example, the unary operator |fabs|, when given a sequence of floating-point values, return a sequence of floating-point results:
+
+   .. math::
+      \begin{array}{lll@{\qquad}l}
+      \fabs_N(z^n) &=& \fabs_N(z[0])~\dots~\fabs_N(z[n])
+      \end{array}
+
+   The binary operator |iadd|, when given two sequences of integers of the same length, :math:`n`, return a sequence of integer results:
+
+   .. math::
+      \begin{array}{lll@{\qquad}l}
+      \iadd_N(i_1^n, i_2^n) &=& \iadd_N(i_1[0], i_2[0])~\dots~\iadd_N(i_1[n], i_2[n])
+      \end{array}
+
 .. _aux-trunc:
 
 Conventions:
@@ -57,6 +79,30 @@ Conventions:
      \trunc(\pm q) &=& \pm i & (\iff i \in \mathbb{N} \wedge +q - 1 < i \leq +q) \\
      \end{array}
 
+.. _aux-sat_u:
+.. _aux-sat_s:
+
+* Saturation of integers is written :math:`\satu_N(i)` and :math:`\sats_N(i)`. The arguments to these two functions range over arbitrary signed integers.
+
+  * Unsigned saturation, :math:`\satu_N(i)` clamps :math:`i` to between :math:`0` and :math:`2^N-1`:
+
+    .. math::
+       \begin{array}{lll@{\qquad}l}
+       \satu_N(i) &=& 2^N-1 & (\iff i > 2^N-1)\\
+       \satu_N(i) &=& 0 & (\iff i < 0) \\
+       \satu_N(i) &=& i & (\otherwise) \\
+       \end{array}
+
+  * Signed saturation, :math:`\sats_N(i)` clamps :math:`i` to between :math:`-2^{N-1}` and :math:`2^{N-1}-1`:
+
+  .. math::
+     \begin{array}{lll@{\qquad}l}
+     \sats_N(i) &=& \signed_N^{-1}(-2^{N-1}) & (\iff i < -2^{N-1})\\
+     \sats_N(i) &=& \signed_N^{-1}(2^{N-1}-1) & (\iff i > 2^{N-1}-1)\\
+     \sats_N(i) &=& i & (\otherwise)
+     \end{array}
+
+
 
 .. index:: bit, integer, floating-point
 .. _aux-bits:
@@ -134,6 +180,31 @@ When a number is stored into :ref:`memory <syntax-mem>`, it is converted into a
 Again these functions are invertable bijections.
 
 
+.. index:: numeric vectors, shape
+.. _aux-lanes:
+
+Vectors
+.......
+
+Numeric vectors have the same underlying representation as an |i128|. They can also be interpreted as a sequence of numeric values packed into a |V128| with a particular |shape|.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lll@{\qquad}l}
+   \lanes_{t\K{x}N}(c) &=&
+     c_0~\dots~c_{N-1} \\
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\where & B = |t| / 8 \\
+     \wedge & b^{16} = bytes_{\i128}(c) \\
+     \wedge & c_i = \bytes_{t}^{-1}(b^{16}[i \cdot B \slice B]))
+     \end{array}
+   \end{array}
+
+These functions are bijections, so they are invertible.
+
+
 .. index:: integer
 .. _int-ops:
 
@@ -302,6 +373,18 @@ The integer result of predicates -- i.e., :ref:`tests <syntax-testop>` and :ref:
    it holds that :math:`i_1 = i_2\cdot\idivs(i_1, i_2) + \irems(i_1, i_2)`.
 
 
+.. _op-inot:
+
+:math:`\inot_N(i)`
+..................
+
+* Return the bitwise negation of :math:`i`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \inot_N(i) &=& \ibits_N^{-1}(\ibits_N(i) \veebar \ibits_N(2^N-1))
+   \end{array}
+
 .. _op-iand:
 
 :math:`\iand_N(i_1, i_2)`
@@ -314,6 +397,18 @@ The integer result of predicates -- i.e., :ref:`tests <syntax-testop>` and :ref:
    \iand_N(i_1, i_2) &=& \ibits_N^{-1}(\ibits_N(i_1) \wedge \ibits_N(i_2))
    \end{array}
 
+.. _op-iandnot:
+
+:math:`\iandnot_N(i_1, i_2)`
+............................
+
+* Return the bitwise conjunction of :math:`i_1` and the bitwise negation of :math:`i_2`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \iandnot_N(i_1, i_2) &=& \iand_N(i_1, \inot_N(i2))
+   \end{array}
+
 .. _op-ior:
 
 :math:`\ior_N(i_1, i_2)`
@@ -625,6 +720,208 @@ The integer result of predicates -- i.e., :ref:`tests <syntax-testop>` and :ref:
    \end{array}
 
 
+.. _op-ibitselect:
+
+:math:`\ibitselect_N(i_1, i_2, i_3)`
+....................................
+
+* Let :math:`j_1` be the bitwise conjunction of :math:`i_1` and :math:`i_3`.
+
+* Let :math:`j_3'` be the bitwise negation of :math:`i_3`.
+
+* Let :math:`j_2` be the bitwise conjunction of :math:`i_2` and :math:`j_3'`.
+
+* Return the bitwise disjunction of :math:`j_1` and :math:`j_2`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \ibitselect_N(i_1, i_2, i_3) &=& \ior_N(\iand_N(i_1, i_3), \iand_N(i_2, \inot_N(i_3)))
+   \end{array}
+
+
+.. _op-iabs:
+
+:math:`\iabs_N(i)`
+..................
+
+* Let :math:`j` be the :ref:`signed interpretation <aux-signed>` of :math:`i`.
+
+* If :math:`j` greater than or equal to :math:`0`, then return :math:`i`.
+
+* Else return the negation of `j`, modulo :math:`2^N`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \iabs_N(i) &=& i & (\iff \signed_N(i) \ge 0) \\
+   \iabs_N(i) &=& -\signed_N(i) \mod 2^N & (\otherwise) \\
+   \end{array}
+
+
+.. _op-ineg:
+
+:math:`\ineg_N(i)`
+..................
+
+* Return the result of negating :math:`i`, modulo :math:`2^N`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \ineg_N(i) &=& (2^N - i) \mod 2^N
+   \end{array}
+
+
+.. _op-imin_u:
+
+:math:`\iminu_N(i_1, i_2)`
+..........................
+
+* Return :math:`i_1` if :math:`\iltu_N(i_1, i_2)` is :math:`1`, return :math:`i_2` otherwise.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \iminu_N(i_1, i_2) &=& i_1 & (\iff \iltu_N(i_1, i_2) = 1)\\
+   \iminu_N(i_1, i_2) &=& i_2 & (\otherwise)
+   \end{array}
+
+
+.. _op-imin_s:
+
+:math:`\imins_N(i_1, i_2)`
+..........................
+
+* Return :math:`i_1` if :math:`\ilts_N(i_1, i_2)` is :math:`1`, return :math:`i_2` otherwise.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \iminu_N(i_1, i_2) &=& i_1 & (\iff \ilts_N(i_1, i_2) = 1)\\
+   \iminu_N(i_1, i_2) &=& i_2 & (\otherwise)
+   \end{array}
+
+
+.. _op-imax_u:
+
+:math:`\imaxu_N(i_1, i_2)`
+..........................
+
+* Return :math:`i_1` if :math:`\igtu_N(i_1, i_2)` is :math:`1`, return :math:`i_2` otherwise.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \iminu_N(i_1, i_2) &=& i_1 & (\iff \igtu_N(i_1, i_2) = 1)\\
+   \iminu_N(i_1, i_2) &=& i_2 & (\otherwise)
+   \end{array}
+
+
+.. _op-imax_s:
+
+:math:`\imaxs_N(i_1, i_2)`
+..........................
+
+* Return :math:`i_1` if :math:`\igts_N(i_1, i_2)` is :math:`1`, return :math:`i_2` otherwise.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \iminu_N(i_1, i_2) &=& i_1 & (\iff \igts_N(i_1, i_2) = 1)\\
+   \iminu_N(i_1, i_2) &=& i_2 & (\otherwise)
+   \end{array}
+
+
+.. _op-iadd_sat_u:
+
+:math:`\iaddsatu_N(i_1, i_2)`
+.............................
+
+* Let :math:`i` be the result of adding :math:`i_1` and :math:`i_2`.
+
+* Return :math:`\satu_N(i)`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \iaddsatu_N(i_1, i_2) &=& \satu_N(i_1 + i_2)
+   \end{array}
+
+
+.. _op-iadd_sat_s:
+
+:math:`\iaddsats_N(i_1, i_2)`
+.............................
+
+* Let :math:`j_1` be the signed interpretation of :math:`i_1`
+
+* Let :math:`j_2` be the signed interpretation of :math:`i_2`
+
+* Let :math:`j` be the result of adding :math:`j_1` and :math:`j_2`.
+
+* Return :math:`\sats_N(j)`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \iaddsats_N(i_1, i_2) &=& \sats_N(\signed_N(i_1) + \signed_N(i_2))
+   \end{array}
+
+
+.. _op-isub_sat_u:
+
+:math:`\isubsatu_N(i_1, i_2)`
+.............................
+
+* Let :math:`i` be the result of subtracting :math:`i_2` from :math:`i_1`.
+
+* Return :math:`\satu_N(i)`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \isubsatu_N(i_1, i_2) &=& \satu_N(i_1 - i_2)
+   \end{array}
+
+
+.. _op-isub_sat_s:
+
+:math:`\isubsats_N(i_1, i_2)`
+.............................
+
+* Let :math:`j_1` be the signed interpretation of :math:`i_1`
+
+* Let :math:`j_2` be the signed interpretation of :math:`i_2`
+
+* Let :math:`j` be the result of subtracting :math:`j_2` from :math:`j_1`.
+
+* Return :math:`\sats_N(j)`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \isubsats_N(i_1, i_2) &=& \sats_N(\signed_N(i_1) - \signed_N(i_2))
+   \end{array}
+
+
+.. _op-iavgr_u:
+
+:math:`\iavgru_N(i_1, i_2)`
+...........................
+
+* Let :math:`j` be the result of adding :math:`i_1`, :math:`i_2`, and :math:`1`.
+
+* Return the result of dividing :math:`j` by :math:`2`, truncated toward zero.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \iavgru_N(i_1, i_2) &=& \trunc((i_1 + i_2 + 1) / 2)
+   \end{array}
+
+
+.. _op-iq15mulrsat_s:
+
+:math:`\iq15mulrsats_N(i_1, i_2)`
+.................................
+
+* Return the result of :math:`\sats_N(\ishrs_N(i_1 \cdot i_2 + 2^{14}, 15))`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \iq15mulrsats_N(i_1, i_2) &=& \sats_N(\ishrs_N(i_1 \cdot i_2 + 2^{14}, 15))
+   \end{array}
+
+
 .. index:: floating-point, IEEE 754
 .. _float-ops:
 
@@ -1378,6 +1675,38 @@ This non-deterministic result is expressed by the following auxiliary function p
    \end{array}
 
 
+.. _op-fpmin:
+
+:math:`\fpmin_N(z_1, z_2)`
+..........................
+
+* If :math:`z_2` is less than :math:`z_1` then return :math:`z_2`.
+
+* Else return :math:`z_1`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \fpmin_N(z_1, z_2) &=& z_2 & (\iff \flt_N(z_2, z_1) = 1) \\
+   \fpmin_N(z_1, z_2) &=& z_1 & (\otherwise)
+   \end{array}
+
+
+.. _op-fpmax:
+
+:math:`\fpmax_N(z_1, z_2)`
+..........................
+
+* If :math:`z_1` is less than :math:`z_2` then return :math:`z_2`.
+
+* Else return :math:`z_1`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \fpmax_N(z_1, z_2) &=& z_2 & (\iff \flt_N(z_1, z_2) = 1) \\
+   \fpmax_N(z_1, z_2) &=& z_1 & (\otherwise)
+   \end{array}
+
+
 .. _convert-ops:
 
 Conversions
@@ -1490,20 +1819,14 @@ Conversions
 
 * Else if :math:`z` is positive infinity, then return :math:`2^N - 1`.
 
-* Else if :math:`\trunc(z)` is less than :math:`0`, then return :math:`0`.
-
-* Else if :math:`\trunc(z)` is greater than :math:`2^N - 1`, then return :math:`2^N - 1`.
-
-* Else, return :math:`\trunc(z)`.
+* Else, return :math:`\satu_N(\trunc(z))`.
 
 .. math::
    \begin{array}{lll@{\qquad}l}
    \truncsatu_{M,N}(\pm \NAN(n)) &=& 0 \\
    \truncsatu_{M,N}(- \infty) &=& 0 \\
    \truncsatu_{M,N}(+ \infty) &=& 2^N - 1 \\
-   \truncsatu_{M,N}(- q) &=& 0 & (\iff \trunc(- q) < 0) \\
-   \truncsatu_{M,N}(+ q) &=& 2^N - 1 & (\iff \trunc(+ q) > 2^N - 1) \\
-   \truncsatu_{M,N}(\pm q) &=& \trunc(\pm q) & (otherwise) \\
+   \truncsatu_{M,N}(z) &=& \satu_N(\trunc(z)) \\
    \end{array}
 
 
@@ -1518,20 +1841,14 @@ Conversions
 
 * Else if :math:`z` is positive infinity, then return :math:`2^{N-1} - 1`.
 
-* Else if :math:`\trunc(z)` is less than :math:`-2^{N-1}`, then return :math:`-2^{N-1}`.
-
-* Else if :math:`\trunc(z)` is greater than :math:`2^{N-1} - 1`, then return :math:`2^{N-1} - 1`.
-
-* Else, return :math:`\trunc(z)`.
+* Else, return :math:`\sats_N(\trunc(z))`.
 
 .. math::
    \begin{array}{lll@{\qquad}l}
    \truncsats_{M,N}(\pm \NAN(n)) &=& 0 \\
    \truncsats_{M,N}(- \infty) &=& -2^{N-1} \\
    \truncsats_{M,N}(+ \infty) &=& 2^{N-1}-1 \\
-   \truncsats_{M,N}(- q) &=& -2^{N-1} & (\iff \trunc(- q) < -2^{N-1}) \\
-   \truncsats_{M,N}(+ q) &=& 2^{N-1} - 1 & (\iff \trunc(+ q) > 2^{N-1} - 1) \\
-   \truncsats_{M,N}(\pm q) &=& \trunc(\pm q) & (otherwise) \\
+   \truncsats_{M,N}(z) &=& \sats_N(\trunc(z)) \\
    \end{array}
 
 
@@ -1620,3 +1937,33 @@ Conversions
    \begin{array}{lll@{\qquad}l}
    \reinterpret_{t_1,t_2}(c) &=& \bits_{t_2}^{-1}(\bits_{t_1}(c)) \\
    \end{array}
+
+
+.. _op-narrow_s:
+
+:math:`\narrows_{M,N}(i)`
+.........................
+
+* Let :math:`j` be the :ref:`signed interpretation <aux-signed>` of :math:`i` of size :math:`M`.
+
+* Return :math:`\sats_N(j)`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \narrows_{M,N}(i) &=& \sats_N(\signed_M(i))
+   \end{array}
+
+
+.. _op-narrow_u:
+
+:math:`\narrowu_{M,N}(i)`
+.........................
+
+* Let :math:`j` be the :ref:`signed interpretation <aux-signed>` of :math:`i` of size :math:`M`.
+
+* Return :math:`\satu_N(j)`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \narrowu_{M,N}(i) &=& \satu_N(\signed_M(i))
+   \end{array}
diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index 5f042cd55..4ea7739fd 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -7,9 +7,10 @@ Runtime Structure
 :ref:`Store <store>`, :ref:`stack <stack>`, and other *runtime structure* forming the WebAssembly abstract machine, such as :ref:`values <syntax-val>` or :ref:`module instances <syntax-moduleinst>`, are made precise in terms of additional auxiliary syntax.
 
 
-.. index:: ! value, number, reference, constant, number type, reference type, ! host address, value type, integer, floating-point, ! default value
+.. index:: ! value, number, reference, constant, number type, vector type, reference type, ! host address, value type, integer, floating-point, vector number, ! default value
    pair: abstract syntax; value
 .. _syntax-num:
+.. _syntax-vecc:
 .. _syntax-ref:
 .. _syntax-ref.extern:
 .. _syntax-val:
@@ -18,7 +19,7 @@ Runtime Structure
 Values
 ~~~~~~
 
-WebAssembly computations manipulate *values* of either the four basic :ref:`number types <syntax-numtype>`, i.e., :ref:`integers <syntax-int>` and :ref:`floating-point data <syntax-float>` of 32 or 64 bit width each, or of :ref:`reference type <syntax-reftype>`.
+WebAssembly computations manipulate *values* of either the four basic :ref:`number types <syntax-numtype>`, i.e., :ref:`integers <syntax-int>` and :ref:`floating-point data <syntax-float>` of 32 or 64 bit width each, of :ref:`vectors <syntax-vecnum>` of 128 bit width, or of :ref:`reference type <syntax-reftype>`.
 
 In most places of the semantics, values of different types can occur.
 In order to avoid ambiguities, values are therefore represented with an abstract syntax that makes their type explicit.
@@ -35,12 +36,14 @@ or *external references* pointing to an uninterpreted form of :ref:`extern addre
      \I64.\CONST~\i64 \\&&|&
      \F32.\CONST~\f32 \\&&|&
      \F64.\CONST~\f64 \\
+   \production{(vector)} & \vecc &::=&
+     \V128.\CONST~\i128 \\
    \production{(reference)} & \reff &::=&
      \REFNULL~t \\&&|&
      \REFFUNCADDR~\funcaddr \\&&|&
      \REFEXTERNADDR~\externaddr \\
    \production{(value)} & \val &::=&
-     \num ~|~ \reff \\
+     \num ~|~ \vecc ~|~ \reff \\
    \end{array}
 
 .. note::
diff --git a/document/core/index.rst b/document/core/index.rst
index 94bd4b218..0179df7be 100644
--- a/document/core/index.rst
+++ b/document/core/index.rst
@@ -29,7 +29,11 @@ WebAssembly Specification
       appendix/index-instructions
       appendix/index-rules
 
-.. only:: html
+..
+   Only include these links when using (multi-page) html builder.
+   (The singlepage html builder is called builder_singlehtml.)
+
+.. only:: builder_html
 
    * :ref:`index-type`
    * :ref:`index-instr`
diff --git a/document/core/intro/overview.rst b/document/core/intro/overview.rst
index 6973396c0..b9e858ccc 100644
--- a/document/core/intro/overview.rst
+++ b/document/core/intro/overview.rst
@@ -13,7 +13,7 @@ This language is structured around the following concepts.
 .. _value:
 
 **Values**
-  WebAssembly provides only four basic *value types*.
+  WebAssembly provides only four basic *number types*.
   These are integers and |IEEE754|_ numbers,
   each in 32 and 64 bit width.
   32 bit integers also serve as Booleans and as memory addresses.
@@ -23,6 +23,16 @@ This language is structured around the following concepts.
   Instead, integers are interpreted by respective operations
   as either unsigned or signed in two’s complement representation.
 
+  In addition to these basic number types, there is a single 128 bit wide
+  vector type representing different types of packed data.
+  The supported representations are 4 32-bit, or 2 64-bit
+  |IEEE754|_ numbers, or different widths of packed integer values
+  specifically 2 64-bit integers, 4 32-bit integers, 8
+  16-bit integers, or 16 8-bit integers.
+
+  Finally, values can consist of opaque *references* that represent pointers towards different sorts of entities.
+  Unlike with other types, their size or representation is not observable.
+
 .. _instruction:
 
 **Instructions**
@@ -50,7 +60,7 @@ This language is structured around the following concepts.
 **Functions**
   Code is organized into separate *functions*.
   Each function takes a sequence of values as parameters
-  and returns a sequence of values as results. [#arity]_
+  and returns a sequence of values as results.
   Functions can call each other, including recursively,
   resulting in an implicit call stack that cannot be accessed directly.
   Functions may also declare mutable *local variables* that are usable as virtual registers.
@@ -96,8 +106,6 @@ This language is structured around the following concepts.
 
 .. [#stackmachine] In practice, implementations need not maintain an actual operand stack. Instead, the stack can be viewed as a set of anonymous registers that are implicitly referenced by instructions. The :ref:`type system <validation>` ensures that the stack height, and thus any referenced register, is always known statically.
 
-.. [#arity] In the current version of WebAssembly, there may be at most one result value.
-
 
 .. index:: phases, decoding, validation, execution, instantiation, invocation
 
diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index 23f0ef5b9..7a84d2935 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -171,6 +171,242 @@ Occasionally, it is convenient to group operators together according to the foll
    \end{array}
 
 
+.. index:: ! vector instruction, numeric vectors, number, value, value type, SIMD
+   pair: abstract syntax; instruction
+.. _syntax-laneidx:
+.. _syntax-shape:
+.. _syntax-half:
+.. _syntax-vvunop:
+.. _syntax-vvbinop:
+.. _syntax-vvternop:
+.. _syntax-vvtestop:
+.. _syntax-vitestop:
+.. _syntax-virelop:
+.. _syntax-vfrelop:
+.. _syntax-vishiftop:
+.. _syntax-viunop:
+.. _syntax-vibinop:
+.. _syntax-viminmaxop:
+.. _syntax-visatbinop:
+.. _syntax-vfunop:
+.. _syntax-vfbinop:
+.. _syntax-instr-vec:
+
+Vector Instructions
+~~~~~~~~~~~~~~~~~~~
+
+Vector instructions (also known as *SIMD* instructions, single data multiple value) provide basic operations over :ref:`values <syntax-value>` of :ref:`vector type <syntax-vectype>`.
+
+.. math::
+   \begin{array}{llcl}
+   \production{ishape} & \ishape &::=&
+     \K{i8x16} ~|~ \K{i16x8} ~|~ \K{i32x4} ~|~ \K{i64x2} \\
+   \production{fshape} & \fshape &::=&
+     \K{f32x4} ~|~ \K{f64x2} \\
+   \production{shape} & \shape &::=&
+     \ishape ~|~ \fshape \\
+   \production{half} & \half &::=&
+     \K{low} ~|~ \K{high} \\
+   \production{lane index} & \laneidx &::=& \u8 \\
+   \production{instruction} & \instr &::=&
+     \dots \\&&|&
+     \K{v128.}\VCONST~\i128 \\&&|&
+     \K{v128.}\vvunop \\&&|&
+     \K{v128.}\vvbinop \\&&|&
+     \K{v128.}\vvternop \\&&|&
+     \K{v128.}\vvtestop \\&&|&
+     \K{i8x16.}\SHUFFLE~\laneidx^{16} \\&&|&
+     \K{i8x16.}\SWIZZLE \\&&|&
+     \shape\K{.}\SPLAT \\&&|&
+     \K{i8x16.}\EXTRACTLANE\K{\_}\sx~\laneidx ~|~
+     \K{i16x8.}\EXTRACTLANE\K{\_}\sx~\laneidx \\&&|&
+     \K{i32x4.}\EXTRACTLANE~\laneidx ~|~
+     \K{i64x2.}\EXTRACTLANE~\laneidx \\&&|&
+     \fshape\K{.}\EXTRACTLANE~\laneidx \\&&|&
+     \shape\K{.}\REPLACELANE~\laneidx \\&&|&
+     \K{i8x16}\K{.}\virelop ~|~
+     \K{i16x8}\K{.}\virelop ~|~
+     \K{i32x4}\K{.}\virelop \\&&|&
+     \K{i64x2.}\K{eq} ~|~
+     \K{i64x2.}\K{ne} ~|~
+     \K{i64x2.}\K{lt\_s} ~|~
+     \K{i64x2.}\K{gt\_s} ~|~
+     \K{i64x2.}\K{le\_s} ~|~
+     \K{i64x2.}\K{ge\_s} \\&&|&
+     \fshape\K{.}\vfrelop \\&&|&
+     \ishape\K{.}\viunop ~|~
+     \K{i8x16.}\VPOPCNT \\&&|&
+     \K{i16x8.}\Q15MULRSAT\K{\_s} \\ &&|&
+     \K{i32x4.}\DOT\K{\_i16x8\_s} \\ &&|&
+     \fshape\K{.}\vfunop \\&&|&
+     \ishape\K{.}\vitestop \\ &&|&
+     \ishape\K{.}\BITMASK \\ &&|&
+     \K{i8x16.}\NARROW\K{\_i16x8\_}\sx ~|~
+     \K{i16x8.}\NARROW\K{\_i32x4\_}\sx \\&&|&
+     \K{i16x8.}\VEXTEND\K{\_}\half\K{\_i8x16\_}\sx ~|~
+     \K{i32x4.}\VEXTEND\K{\_}\half\K{\_i16x8\_}\sx \\&&|&
+     \K{i64x2.}\VEXTEND\K{\_}\half\K{\_i32x4\_}\sx \\&&|&
+     \ishape\K{.}\vishiftop \\&&|&
+     \ishape\K{.}\vibinop \\&&|&
+     \K{i8x16.}\viminmaxop ~|~
+     \K{i16x8.}\viminmaxop ~|~
+     \K{i32x4.}\viminmaxop \\&&|&
+     \K{i8x16.}\visatbinop ~|~
+     \K{i16x8.}\visatbinop \\&&|&
+     \K{i16x8.}\K{mul} ~|~
+     \K{i32x4.}\K{mul} ~|~
+     \K{i64x2.}\K{mul} \\&&|&
+     \K{i8x16.}\AVGR\K{\_u} ~|~
+     \K{i16x8.}\AVGR\K{\_u} \\&&|&
+     \K{i16x8.}\EXTMUL\K{\_}\half\K{\_i8x16\_}\sx ~|~
+     \K{i32x4.}\EXTMUL\K{\_}\half\K{\_i16x8\_}\sx ~|~
+     \K{i64x2.}\EXTMUL\K{\_}\half\K{\_i32x4\_}\sx \\ &&|&
+     \K{i16x8.}\EXTADDPAIRWISE\K{\_i8x16\_}\sx ~|~
+     \K{i32x4.}\EXTADDPAIRWISE\K{\_i16x8\_}\sx \\ &&|&
+     \fshape\K{.}\vfbinop \\&&|&
+     \K{i32x4.}\VTRUNC\K{\_sat\_f32x4\_}\sx ~|~
+     \K{i32x4.}\VTRUNC\K{\_sat\_f64x2\_}\sx\K{\_zero} \\&&|&
+     \K{f32x4.}\VCONVERT\K{\_i32x4\_}\sx ~|~
+     \K{f32x4.}\VDEMOTE\K{\_f64x2\_zero} \\&&|&
+     \K{f64x2.}\VCONVERT\K{\_low\_i32x4\_}\sx ~|~
+     \K{f64x2.}\VPROMOTE\K{\_low\_f32x4} \\&&|&
+     \dots \\
+   \production{vector bitwise unary operator} & \vvunop &::=&
+     \K{not} \\
+   \production{vector bitwise binary operator} & \vvbinop &::=&
+     \K{and} ~|~
+     \K{andnot} ~|~
+     \K{or} ~|~
+     \K{xor} \\
+   \production{vector bitwise ternary operator} & \vvternop &::=&
+     \K{bitselect} \\
+   \production{vector bitwise test operator} & \vvtestop &::=&
+     \K{any\_true} \\
+   \production{vector integer test operator} & \vitestop &::=&
+     \K{all\_true} \\
+   \production{vector integer relational operator} & \virelop &::=&
+     \K{eq} ~|~
+     \K{ne} ~|~
+     \K{lt\_}\sx ~|~
+     \K{gt\_}\sx ~|~
+     \K{le\_}\sx ~|~
+     \K{ge\_}\sx \\
+   \production{vector floating-point relational operator} & \vfrelop &::=&
+     \K{eq} ~|~
+     \K{ne} ~|~
+     \K{lt} ~|~
+     \K{gt} ~|~
+     \K{le} ~|~
+     \K{ge} \\
+   \production{vector integer unary operator} & \viunop &::=&
+     \K{abs} ~|~
+     \K{neg} \\
+   \production{vector integer binary operator} & \vibinop &::=&
+     \K{add} ~|~
+     \K{sub} \\
+   \production{vector integer binary min/max operator} & \viminmaxop &::=&
+     \K{min\_}\sx ~|~
+     \K{max\_}\sx \\
+   \production{vector integer saturating binary operator} & \visatbinop &::=&
+     \K{add\_sat\_}\sx ~|~
+     \K{sub\_sat\_}\sx \\
+   \production{vector integer shift operator} & \vishiftop &::=&
+     \K{shl} ~|~
+     \K{shr\_}\sx \\
+   \production{vector floating-point unary operator} & \vfunop &::=&
+     \K{abs} ~|~
+     \K{neg} ~|~
+     \K{sqrt} ~|~
+     \K{ceil} ~|~
+     \K{floor} ~|~
+     \K{trunc} ~|~
+     \K{nearest} \\
+   \production{vector floating-point binary operator} & \vfbinop &::=&
+     \K{add} ~|~
+     \K{sub} ~|~
+     \K{mul} ~|~
+     \K{div} ~|~
+     \K{min} ~|~
+     \K{max} ~|~
+     \K{pmin} ~|~
+     \K{pmax} \\
+   \end{array}
+
+.. _syntax-vec-shape:
+
+Vector instructions have a naming convention involving a prefix that
+determines how their operands will be interpreted.
+This prefix describes the *shape* of the operand,
+written :math:`t\K{x}N`, and consisting of a packed :ref:`numeric type <syntax-numtype>` :math:`t` and the number of *lanes* :math:`N` of that type.
+Operations are performed point-wise on the values of each lane.
+
+.. note::
+   For example, the shape :math:`\K{i32x4}` interprets the operand
+   as four |i32| values, packed into an |i128|.
+   The bitwidth of the numeric type :math:`t` times :math:`N` always is 128.
+
+Instructions prefixed with :math:`\K{v128}` do not involve a specific interpretation, and treat the |V128| as an |i128| value or a vector of 128 individual bits.
+
+Vector instructions can be grouped into several subcategories:
+
+* *Constants*: return a static constant.
+
+* *Unary Operations*: consume one |V128| operand and produce one |V128| result.
+
+* *Binary Operations*: consume two |V128| operands and produce one |V128| result.
+
+* *Ternary Operations*: consume three |V128| operands and produce one |V128| result.
+
+* *Tests*: consume one |V128| operand and produce a Boolean integer result.
+
+* *Shifts*: consume a |v128| operand and a |i32| operand, producing one |V128| result.
+
+* *Splats*: consume a value of numeric type and produce a |V128| result of a specified shape.
+
+* *Extract lanes*: consume a |V128| operand and return the numeric value in a given lane.
+
+* *Replace lanes*: consume a |V128| operand and a numeric value for a given lane, and produce a |V128| result.
+
+Some vector instructions have a signedness annotation |sx| which distinguishes whether the elements in the operands are to be :ref:`interpreted <aux-signed>` as :ref:`unsigned <syntax-uint>` or :ref:`signed <syntax-sint>` integers.
+For the other vector instructions, the use of two's complement for the signed interpretation means that they behave the same regardless of signedness.
+
+
+.. _syntax-vunop:
+.. _syntax-vbinop:
+.. _syntax-vrelop:
+.. _syntax-vtestop:
+.. _syntax-vcvtop:
+
+Conventions
+...........
+
+Occasionally, it is convenient to group operators together according to the following grammar shorthands:
+
+.. math::
+   \begin{array}{llll}
+   \production{unary operator} & \vunop &::=&
+     \viunop ~|~
+     \vfunop ~|~
+     \VPOPCNT \\
+   \production{binary operator} & \vbinop &::=&
+     \vibinop ~|~ \vfbinop \\&&|&
+     \viminmaxop ~|~ \visatbinop \\&&|&
+     \VMUL ~|~
+     \AVGR\K{\_u} ~|~
+     \Q15MULRSAT\K{\_s} \\
+   \production{test operator} & \vtestop &::=&
+     \vitestop \\
+   \production{relational operator} & \vrelop &::=&
+     \virelop ~|~ \vfrelop \\
+   \production{conversion operator} & \vcvtop &::=&
+     \VEXTEND ~|~
+     \VTRUNC\K{\_sat} ~|~
+     \VCONVERT ~|~
+     \VDEMOTE ~|~
+     \VPROMOTE \\
+   \end{array}
+
+
 .. index:: ! reference instruction, reference, null
    pair: abstract syntax; instruction
 .. _syntax-ref.null:
@@ -296,6 +532,7 @@ An additional instruction that accesses a table is the :ref:`control instruction
 .. _syntax-loadn:
 .. _syntax-storen:
 .. _syntax-memarg:
+.. _syntax-lanewidth:
 .. _syntax-instr-memory:
 
 Memory Instructions
@@ -307,18 +544,30 @@ Instructions in this group are concerned with linear :ref:`memory <syntax-mem>`.
    \begin{array}{llcl}
    \production{memory immediate} & \memarg &::=&
      \{ \OFFSET~\u32, \ALIGN~\u32 \} \\
+   \production{lane width} & \X{ww} &::=&
+     8 ~|~ 16 ~|~ 32 ~|~ 64 \\
    \production{instruction} & \instr &::=&
      \dots \\&&|&
      \K{i}\X{nn}\K{.}\LOAD~\memarg ~|~
-     \K{f}\X{nn}\K{.}\LOAD~\memarg \\&&|&
+     \K{f}\X{nn}\K{.}\LOAD~\memarg ~|~
+     \K{v128.}\LOAD~\memarg \\&&|&
      \K{i}\X{nn}\K{.}\STORE~\memarg ~|~
-     \K{f}\X{nn}\K{.}\STORE~\memarg \\&&|&
+     \K{f}\X{nn}\K{.}\STORE~\memarg ~|~
+     \K{v128.}\STORE~\memarg \\&&|&
      \K{i}\X{nn}\K{.}\LOAD\K{8\_}\sx~\memarg ~|~
      \K{i}\X{nn}\K{.}\LOAD\K{16\_}\sx~\memarg ~|~
      \K{i64.}\LOAD\K{32\_}\sx~\memarg \\&&|&
      \K{i}\X{nn}\K{.}\STORE\K{8}~\memarg ~|~
      \K{i}\X{nn}\K{.}\STORE\K{16}~\memarg ~|~
      \K{i64.}\STORE\K{32}~\memarg \\&&|&
+     \K{v128.}\LOAD\K{8x8\_}\sx~\memarg ~|~
+     \K{v128.}\LOAD\K{16x4\_}\sx~\memarg ~|~
+     \K{v128.}\LOAD\K{32x2\_}\sx~\memarg \\&&|&
+     \K{v128.}\LOAD\K{32\_zero}~\memarg ~|~
+     \K{v128.}\LOAD\K{64\_zero}~\memarg \\&&|&
+     \K{v128.}\LOAD\X{ww}\K{\_splat}~\memarg \\&&|&
+     \K{v128.}\LOAD\X{ww}\K{\_lane}~\memarg~\laneidx ~|~
+     \K{v128.}\STORE\X{ww}\K{\_lane}~\memarg~\laneidx \\&&|&
      \MEMORYSIZE \\&&|&
      \MEMORYGROW \\&&|&
      \MEMORYFILL \\&&|&
@@ -332,6 +581,9 @@ They all take a *memory immediate* |memarg| that contains an address *offset* an
 Integer loads and stores can optionally specify a *storage size* that is smaller than the :ref:`bit width <syntax-numtype>` of the respective value type.
 In the case of loads, a sign extension mode |sx| is then required to select appropriate behavior.
 
+Vector loads can specify a shape that is half the :ref:`bit width <syntax-valtype>` of |V128|. Each lane is half its usual size, and the sign extension mode |sx| then specifies how the smaller lane is extended to the larger lane.
+Alternatively, vector loads can perform a *splat*, such that only a single lane of the specified storage size is loaded, and the result is duplicated to all lanes.
+
 The static address offset is added to the dynamic address operand, yielding a 33 bit *effective address* that is the zero-based index at which the memory is accessed.
 All values are read and written in |LittleEndian|_ byte order.
 A :ref:`trap <trap>` results if any of the accessed memory bytes lies outside the address range implied by the memory's current size.
diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index ac8b224c5..e675be3c7 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -34,6 +34,8 @@ They correspond to the respective binary floating-point representations, also kn
 Number types are *transparent*, meaning that their bit patterns can be observed.
 Values of number type can be stored in :ref:`memories <syntax-mem>`.
 
+.. _bitwidth:
+
 Conventions
 ...........
 
@@ -41,10 +43,40 @@ Conventions
   That is, :math:`|\I32| = |\F32| = 32` and :math:`|\I64| = |\F64| = 64`.
 
 
+.. index:: ! vector type, integer, floating-point, IEEE 754, bit width, memory, SIMD
+   pair: abstract syntax; number type
+   pair: number; type
+.. _syntax-vectype:
+
+Vector Types
+~~~~~~~~~~~~
+
+*Vector types* classify vectors of :ref:`numeric <syntax-numtype>` values processed by vector instructions (also known as *SIMD* instructions, single instruction multiple data).
+
+.. math::
+   \begin{array}{llll}
+   \production{vector type} & \vectype &::=&
+     \V128 \\
+   \end{array}
+
+The type |V128| corresponds to a 128 bit vector of packed integer or floating-point data. The packed data
+can be interpreted as signed or unsigned integers, single or double precision floating-point
+values, or a single 128 bit type. The interpretation is determined by individual operations.
+
+Vector types, like :ref:`number types <syntax-numtype>` are *transparent*, meaning that their bit patterns can be observed.
+Values of vector type can be stored in :ref:`memories <syntax-mem>`.
+
+Conventions
+...........
+
+* The notation :math:`|t|` for :ref:`bit width <bitwidth>` extends to vector types as well, that is, :math:`|\V128| = 128`.
+
+
 .. index:: ! heap type, store, type index
    pair: abstract syntax; heap type
 .. _syntax-heaptype:
 
+
 Heap Types
 ~~~~~~~~~~
 
@@ -88,7 +120,7 @@ Reference types are *opaque*, meaning that neither their size nor their bit patt
 Values of reference type can be stored in :ref:`tables <syntax-table>`.
 
 
-.. index:: ! value type, number type, reference type, ! bottom type
+.. index:: ! value type, number type, vector type, reference type, ! bottom type
    pair: abstract syntax; value type
    pair: value; type
 .. _syntax-valtype:
@@ -98,7 +130,7 @@ Value Types
 ~~~~~~~~~~~
 
 *Value types* classify the individual values that WebAssembly code can compute with and the values that a variable accepts.
-They are either :ref:`number types <syntax-numtype>`, :ref:`reference type <syntax-reftype>`, or the unique *bottom type*, written :math:`\BOT`.
+They are either :ref:`number types <syntax-numtype>`, :ref:`vector types <syntax-vectype>`, :ref:`reference types <syntax-reftype>`, or the unique *bottom type*, written :math:`\BOT`.
 
 The type :math:`\BOT` is a :ref:`subtype <match-valtype>` of all other types.
 By virtue of being representable in neither the :ref:`binary format <binary-valtype>` nor the :ref:`text format <text-valtype>`, it cannot be used in a program;
@@ -107,7 +139,7 @@ it only occurs during :ref:`validation <valid>`, as a possible operand type for
 .. math::
    \begin{array}{llll}
    \production{value type} & \valtype &::=&
-     \numtype ~|~ \reftype ~|~ \BOT \\
+     \numtype ~|~ \vectype ~|~ \reftype ~|~ \BOT \\
    \end{array}
 
 Conventions
diff --git a/document/core/syntax/values.rst b/document/core/syntax/values.rst
index 744384274..c4e7f89c3 100644
--- a/document/core/syntax/values.rst
+++ b/document/core/syntax/values.rst
@@ -94,7 +94,7 @@ Floating-Point
 *Floating-point* data represents 32 or 64 bit values that correspond to the respective binary formats of the |IEEE754|_ standard (Section 3.3).
 
 Every value has a *sign* and a *magnitude*.
-Magnitudes can either be expressed as *normal* numbers of the form :math:`m_0.m_1m_2\dots m_M \cdot2^e`, where :math:`e` is the exponent and :math:`m` is the *significand* whose most signifcant bit :math:`m_0` is :math:`1`,
+Magnitudes can either be expressed as *normal* numbers of the form :math:`m_0.m_1m_2\dots m_M \cdot2^e`, where :math:`e` is the exponent and :math:`m` is the *significand* whose most significant bit :math:`m_0` is :math:`1`,
 or as a *subnormal* number where the exponent is fixed to the smallest possible value and :math:`m_0` is :math:`0`; among the subnormals are positive and negative zero values.
 Since the significands are binary values, normals are represented in the form :math:`(1 + m\cdot 2^{-M}) \cdot 2^e`, where :math:`M` is the bit width of :math:`m`; similarly for subnormals.
 
@@ -146,6 +146,17 @@ Conventions
 * The meta variable :math:`z` ranges over floating-point values where clear from context.
 
 
+.. index:: ! numeric vectors, integer, floating-point, lane, SIMD
+   pair: abstract syntax; vector
+.. _syntax-vecnum:
+
+Vectors
+~~~~~~~
+
+*Numeric vectors* are 128-bit values that are processed by vector instructions (also known as *SIMD* instructions, single instruction multiple data).
+They are represented in the abstract syntax using |i128|. The interpretation of lane types (:ref:`integer <syntax-int>` or :ref:`floating-point <syntax-float>` numbers) and lane sizes are determined by the specific instruction operating on them.
+
+
 .. index:: ! name, byte, Unicode, UTF-8, character, binary format
    pair: abstract syntax; name
 .. _syntax-char:
diff --git a/document/core/text/conventions.rst b/document/core/text/conventions.rst
index ea62cc4b7..ddcd8e780 100644
--- a/document/core/text/conventions.rst
+++ b/document/core/text/conventions.rst
@@ -10,7 +10,7 @@ A text string is a well-formed description of a module if and only if it is gene
 Each production of this grammar has at most one synthesized attribute: the abstract syntax that the respective character sequence expresses.
 Thus, the attribute grammar implicitly defines a *parsing* function.
 Some productions also take a :ref:`context <text-context>` as an inherited attribute
-that records bound :ref:`identifers <text-id>`.
+that records bound :ref:`identifiers <text-id>`.
 
 Except for a few exceptions, the core of the text grammar closely mirrors the grammar of the abstract syntax.
 However, it also defines a number of *abbreviations* that are "syntactic sugar" over the core syntax.
@@ -61,11 +61,11 @@ In order to distinguish symbols of the textual syntax from symbols of the abstra
 * A distinction is made between *lexical* and *syntactic* productions. For the latter, arbitrary :ref:`white space <text-space>` is allowed in any place where the grammar contains spaces. The productions defining :ref:`lexical syntax <text-lexical>` and the syntax of :Ref:`values <text-value>` are considered lexical, all others are syntactic.
 
 .. note::
-   For example, the :ref:`textual grammar <text-valtype>` for :ref:`value types <syntax-valtype>` is given as follows:
+   For example, the :ref:`textual grammar <text-numtype>` for :ref:`number types <syntax-numtype>` is given as follows:
 
    .. math::
      \begin{array}{llcll@{\qquad\qquad}l}
-     \production{value types} & \Tvaltype &::=&
+     \production{number types} & \Tnumtype &::=&
        \text{i32} &\Rightarrow& \I32 \\ &&|&
        \text{i64} &\Rightarrow& \I64 \\ &&|&
        \text{f32} &\Rightarrow& \F32 \\ &&|&
diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index d116523d8..6f0f18502 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -541,6 +541,363 @@ Numeric Instructions
    \end{array}
 
 
+.. index:: vector instruction
+   pair: text format; instruction
+.. _text-instr-vec:
+
+Vector Instructions
+~~~~~~~~~~~~~~~~~~~
+
+Vector memory instructions have optional offset and alignment immediates, like the :ref:`memory instructions <text-memarg>`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{instruction} & \Tplaininstr_I &::=& \dots \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\ &&|&
+     \text{v128.load}~~m{:}\Tmemarg_{16} &\Rightarrow& \V128.\LOAD~m \\ &&|&
+     \text{v128.load8x8\_s}~~m{:}\Tmemarg_8 &\Rightarrow& \V128.\LOAD\K{8x8\_s}~m \\ &&|&
+     \text{v128.load8x8\_u}~~m{:}\Tmemarg_8 &\Rightarrow& \V128.\LOAD\K{8x8\_u}~m \\ &&|&
+     \text{v128.load16x4\_s}~~m{:}\Tmemarg_8 &\Rightarrow& \V128.\LOAD\K{16x4\_s}~m \\ &&|&
+     \text{v128.load16x4\_u}~~m{:}\Tmemarg_8 &\Rightarrow& \V128.\LOAD\K{16x4\_u}~m \\ &&|&
+     \text{v128.load32x2\_s}~~m{:}\Tmemarg_8 &\Rightarrow& \V128.\LOAD\K{32x2\_s}~m \\ &&|&
+     \text{v128.load32x2\_u}~~m{:}\Tmemarg_8 &\Rightarrow& \V128.\LOAD\K{32x2\_u}~m \\ &&|&
+     \text{v128.load8\_splat}~~m{:}\Tmemarg_1 &\Rightarrow& \V128.\LOAD\K{8\_splat}~m \\ &&|&
+     \text{v128.load16\_splat}~~m{:}\Tmemarg_2 &\Rightarrow& \V128.\LOAD\K{16\_splat}~m \\ &&|&
+     \text{v128.load32\_splat}~~m{:}\Tmemarg_4 &\Rightarrow& \V128.\LOAD\K{32\_splat}~m \\ &&|&
+     \text{v128.load64\_splat}~~m{:}\Tmemarg_8 &\Rightarrow& \V128.\LOAD\K{64\_splat}~m \\ &&|&
+     \text{v128.load32\_zero}~~m{:}\Tmemarg_4 &\Rightarrow& \V128.\LOAD\K{32\_zero}~m \\ &&|&
+     \text{v128.load64\_zero}~~m{:}\Tmemarg_8 &\Rightarrow& \V128.\LOAD\K{64\_zero}~m \\ &&|&
+     \text{v128.store}~~m{:}\Tmemarg_{16} &\Rightarrow& \V128.\STORE~m \\ &&|&
+     \text{v128.load8\_lane}~~m{:}\Tmemarg_1~~laneidx{:}\Tu8 &\Rightarrow& \V128.\LOAD\K{8\_lane}~m~laneidx \\ &&|&
+     \text{v128.load16\_lane}~~m{:}\Tmemarg_2~~laneidx{:}\Tu8 &\Rightarrow& \V128.\LOAD\K{16\_lane}~m~laneidx \\ &&|&
+     \text{v128.load32\_lane}~~m{:}\Tmemarg_4~~laneidx{:}\Tu8 &\Rightarrow& \V128.\LOAD\K{32\_lane}~m~laneidx \\ &&|&
+     \text{v128.load64\_lane}~~m{:}\Tmemarg_8~~laneidx{:}\Tu8 &\Rightarrow& \V128.\LOAD\K{64\_lane}~m~laneidx \\ &&|&
+     \text{v128.store8\_lane}~~m{:}\Tmemarg_1~~laneidx{:}\Tu8 &\Rightarrow& \V128.\STORE\K{8\_lane}~m~laneidx \\ &&|&
+     \text{v128.store16\_lane}~~m{:}\Tmemarg_2~~laneidx{:}\Tu8 &\Rightarrow& \V128.\STORE\K{16\_lane}~m~laneidx \\ &&|&
+     \text{v128.store32\_lane}~~m{:}\Tmemarg_4~~laneidx{:}\Tu8 &\Rightarrow& \V128.\STORE\K{32\_lane}~m~laneidx \\ &&|&
+     \text{v128.store64\_lane}~~m{:}\Tmemarg_8~~laneidx{:}\Tu8 &\Rightarrow& \V128.\STORE\K{64\_lane}~m~laneidx \\
+   \end{array}
+
+Vector constant instructions have a mandatory :ref:`shape <syntax-vec-shape>` descriptor, which determines how the following values are parsed.
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{v128.const}~~\text{i8x16}~~(n{:}\Ti8)^{16} &\Rightarrow& \V128.\VCONST~\bytes_{i128}^{-1}(\bytes_{i8}(n)^{16}) \\ &&|&
+     \text{v128.const}~~\text{i16x8}~~(n{:}\Ti16)^{8} &\Rightarrow& \V128.\VCONST~\bytes_{i128}^{-1}(\bytes_{i16}(n)^8) \\ &&|&
+     \text{v128.const}~~\text{i32x4}~~(n{:}\Ti32)^{4} &\Rightarrow& \V128.\VCONST~\bytes_{i128}^{-1}(\bytes_{i32}(n)^4) \\ &&|&
+     \text{v128.const}~~\text{i64x2}~~(n{:}\Ti64)^{2} &\Rightarrow& \V128.\VCONST~\bytes_{i128}^{-1}(\bytes_{i64}(n)^2) \\ &&|&
+     \text{v128.const}~~\text{f32x4}~~(z{:}\Tf32)^{4} &\Rightarrow& \V128.\VCONST~\bytes_{i128}^{-1}(\bytes_{f32}(z)^4) \\ &&|&
+     \text{v128.const}~~\text{f64x2}~~(z{:}\Tf64)^{2} &\Rightarrow& \V128.\VCONST~\bytes_{i128}^{-1}(\bytes_{f64}(z)^2)
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i8x16.shuffle}~~(laneidx{:}\Tu8)^{16} &\Rightarrow& \I8X16.\SHUFFLE~laneidx^{16} \\ &&|&
+     \text{i8x16.swizzle} &\Rightarrow& \I8X16.\SWIZZLE
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i8x16.splat} &\Rightarrow& \I8X16.\SPLAT\\ &&|&
+     \text{i16x8.splat} &\Rightarrow& \I16X8.\SPLAT\\ &&|&
+     \text{i32x4.splat} &\Rightarrow& \I32X4.\SPLAT\\ &&|&
+     \text{i64x2.splat} &\Rightarrow& \I64X2.\SPLAT\\ &&|&
+     \text{f32x4.splat} &\Rightarrow& \F32X4.\SPLAT\\ &&|&
+     \text{f64x2.splat} &\Rightarrow& \F64X2.\SPLAT\\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i8x16.extract\_lane\_s}~~laneidx{:}\Tu8 &\Rightarrow& \I8X16.\EXTRACTLANE\K{\_s}~laneidx \\ &&|&
+     \text{i8x16.extract\_lane\_u}~~laneidx{:}\Tu8 &\Rightarrow& \I8X16.\EXTRACTLANE\K{\_u}~laneidx \\ &&|&
+     \text{i8x16.replace\_lane}~~laneidx{:}\Tu8 &\Rightarrow& \I8X16.\REPLACELANE~laneidx \\ &&|&
+     \text{i16x8.extract\_lane\_s}~~laneidx{:}\Tu8 &\Rightarrow& \I16X8.\EXTRACTLANE\K{\_s}~laneidx \\ &&|&
+     \text{i16x8.extract\_lane\_u}~~laneidx{:}\Tu8 &\Rightarrow& \I16X8.\EXTRACTLANE\K{\_u}~laneidx \\ &&|&
+     \text{i16x8.replace\_lane}~~laneidx{:}\Tu8 &\Rightarrow& \I16X8.\REPLACELANE~laneidx \\ &&|&
+     \text{i32x4.extract\_lane}~~laneidx{:}\Tu8 &\Rightarrow& \I32X4.\EXTRACTLANE~laneidx \\ &&|&
+     \text{i32x4.replace\_lane}~~laneidx{:}\Tu8 &\Rightarrow& \I32X4.\REPLACELANE~laneidx \\ &&|&
+     \text{i64x2.extract\_lane}~~laneidx{:}\Tu8 &\Rightarrow& \I64X2.\EXTRACTLANE~laneidx \\ &&|&
+     \text{i64x2.replace\_lane}~~laneidx{:}\Tu8 &\Rightarrow& \I64X2.\REPLACELANE~laneidx \\ &&|&
+     \text{f32x4.extract\_lane}~~laneidx{:}\Tu8 &\Rightarrow& \F32X4.\EXTRACTLANE~laneidx \\ &&|&
+     \text{f32x4.replace\_lane}~~laneidx{:}\Tu8 &\Rightarrow& \F32X4.\REPLACELANE~laneidx \\ &&|&
+     \text{f64x2.extract\_lane}~~laneidx{:}\Tu8 &\Rightarrow& \F64X2.\EXTRACTLANE~laneidx \\ &&|&
+     \text{f64x2.replace\_lane}~~laneidx{:}\Tu8 &\Rightarrow& \F64X2.\REPLACELANE~laneidx \\
+   \end{array}
+
+.. _text-virelop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i8x16.eq} &\Rightarrow& \I8X16.\VEQ\\ &&|&
+     \text{i8x16.ne} &\Rightarrow& \I8X16.\VNE\\ &&|&
+     \text{i8x16.lt\_s} &\Rightarrow& \I8X16.\VLT\K{\_s}\\ &&|&
+     \text{i8x16.lt\_u} &\Rightarrow& \I8X16.\VLT\K{\_u}\\ &&|&
+     \text{i8x16.gt\_s} &\Rightarrow& \I8X16.\VGT\K{\_s}\\ &&|&
+     \text{i8x16.gt\_u} &\Rightarrow& \I8X16.\VGT\K{\_u}\\ &&|&
+     \text{i8x16.le\_s} &\Rightarrow& \I8X16.\VLE\K{\_s}\\ &&|&
+     \text{i8x16.le\_u} &\Rightarrow& \I8X16.\VLE\K{\_u}\\ &&|&
+     \text{i8x16.ge\_s} &\Rightarrow& \I8X16.\VGE\K{\_s}\\ &&|&
+     \text{i8x16.ge\_u} &\Rightarrow& \I8X16.\VGE\K{\_u}\\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i16x8.eq} &\Rightarrow& \I16X8.\VEQ\\ &&|&
+     \text{i16x8.ne} &\Rightarrow& \I16X8.\VNE\\ &&|&
+     \text{i16x8.lt\_s} &\Rightarrow& \I16X8.\VLT\K{\_s}\\ &&|&
+     \text{i16x8.lt\_u} &\Rightarrow& \I16X8.\VLT\K{\_u}\\ &&|&
+     \text{i16x8.gt\_s} &\Rightarrow& \I16X8.\VGT\K{\_s}\\ &&|&
+     \text{i16x8.gt\_u} &\Rightarrow& \I16X8.\VGT\K{\_u}\\ &&|&
+     \text{i16x8.le\_s} &\Rightarrow& \I16X8.\VLE\K{\_s}\\ &&|&
+     \text{i16x8.le\_u} &\Rightarrow& \I16X8.\VLE\K{\_u}\\ &&|&
+     \text{i16x8.ge\_s} &\Rightarrow& \I16X8.\VGE\K{\_s}\\ &&|&
+     \text{i16x8.ge\_u} &\Rightarrow& \I16X8.\VGE\K{\_u}\\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i32x4.eq} &\Rightarrow& \I32X4.\VEQ\\ &&|&
+     \text{i32x4.ne} &\Rightarrow& \I32X4.\VNE\\ &&|&
+     \text{i32x4.lt\_s} &\Rightarrow& \I32X4.\VLT\K{\_s}\\ &&|&
+     \text{i32x4.lt\_u} &\Rightarrow& \I32X4.\VLT\K{\_u}\\ &&|&
+     \text{i32x4.gt\_s} &\Rightarrow& \I32X4.\VGT\K{\_s}\\ &&|&
+     \text{i32x4.gt\_u} &\Rightarrow& \I32X4.\VGT\K{\_u}\\ &&|&
+     \text{i32x4.le\_s} &\Rightarrow& \I32X4.\VLE\K{\_s}\\ &&|&
+     \text{i32x4.le\_u} &\Rightarrow& \I32X4.\VLE\K{\_u}\\ &&|&
+     \text{i32x4.ge\_s} &\Rightarrow& \I32X4.\VGE\K{\_s}\\ &&|&
+     \text{i32x4.ge\_u} &\Rightarrow& \I32X4.\VGE\K{\_u}\\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i64x2.eq} &\Rightarrow& \I64X2.\VEQ\\ &&|&
+     \text{i64x2.ne} &\Rightarrow& \I64X2.\VNE\\ &&|&
+     \text{i64x2.lt\_s} &\Rightarrow& \I64X2.\VLT\K{\_s}\\ &&|&
+     \text{i64x2.gt\_s} &\Rightarrow& \I64X2.\VGT\K{\_s}\\ &&|&
+     \text{i64x2.le\_s} &\Rightarrow& \I64X2.\VLE\K{\_s}\\ &&|&
+     \text{i64x2.ge\_s} &\Rightarrow& \I64X2.\VGE\K{\_s}\\ &&|&
+   \end{array}
+
+.. _text-vfrelop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{f32x4.eq} &\Rightarrow& \F32X4.\VEQ\\ &&|&
+     \text{f32x4.ne} &\Rightarrow& \F32X4.\VNE\\ &&|&
+     \text{f32x4.lt} &\Rightarrow& \F32X4.\VLT\\ &&|&
+     \text{f32x4.gt} &\Rightarrow& \F32X4.\VGT\\ &&|&
+     \text{f32x4.le} &\Rightarrow& \F32X4.\VLE\\ &&|&
+     \text{f32x4.ge} &\Rightarrow& \F32X4.\VGE\\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{f64x2.eq} &\Rightarrow& \F64X2.\VEQ\\ &&|&
+     \text{f64x2.ne} &\Rightarrow& \F64X2.\VNE\\ &&|&
+     \text{f64x2.lt} &\Rightarrow& \F64X2.\VLT\\ &&|&
+     \text{f64x2.gt} &\Rightarrow& \F64X2.\VGT\\ &&|&
+     \text{f64x2.le} &\Rightarrow& \F64X2.\VLE\\ &&|&
+     \text{f64x2.ge} &\Rightarrow& \F64X2.\VGE\\
+   \end{array}
+
+.. _text-vvunop:
+.. _text-vvbinop:
+.. _text-vvternop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{v128.not} &\Rightarrow& \V128.\VNOT\\ &&|&
+     \text{v128.and} &\Rightarrow& \V128.\VAND\\ &&|&
+     \text{v128.andnot} &\Rightarrow& \V128.\VANDNOT\\ &&|&
+     \text{v128.or} &\Rightarrow& \V128.\VOR\\ &&|&
+     \text{v128.xor} &\Rightarrow& \V128.\VXOR\\ &&|&
+     \text{v128.bitselect} &\Rightarrow& \V128.\BITSELECT\\ &&|&
+     \text{v128.any\_true} &\Rightarrow& \V128.\ANYTRUE
+   \end{array}
+
+.. _text-vitestop:
+.. _text-vishiftop:
+.. _text-viunop:
+.. _text-vibinop:
+.. _text-viminmaxop:
+.. _text-visatbinop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i8x16.abs} &\Rightarrow& \I8X16.\VABS\\ &&|&
+     \text{i8x16.neg} &\Rightarrow& \I8X16.\VNEG\\ &&|&
+     \text{i8x16.all\_true} &\Rightarrow& \I8X16.\ALLTRUE\\ &&|&
+     \text{i8x16.bitmask} &\Rightarrow& \I8X16.\BITMASK\\ &&|&
+     \text{i8x16.narrow\_i16x8\_s} &\Rightarrow& \I8X16.\NARROW\K{\_i16x8\_s}\\ &&|&
+     \text{i8x16.narrow\_i16x8\_u} &\Rightarrow& \I8X16.\NARROW\K{\_i16x8\_u}\\ &&|&
+     \text{i8x16.shl} &\Rightarrow& \I8X16.\VSHL\\ &&|&
+     \text{i8x16.shr\_s} &\Rightarrow& \I8X16.\VSHR\K{\_s}\\ &&|&
+     \text{i8x16.shr\_u} &\Rightarrow& \I8X16.\VSHR\K{\_u}\\ &&|&
+     \text{i8x16.add} &\Rightarrow& \I8X16.\VADD\\ &&|&
+     \text{i8x16.add\_sat\_s} &\Rightarrow& \I8X16.\VADD\K{\_sat\_s}\\ &&|&
+     \text{i8x16.add\_sat\_u} &\Rightarrow& \I8X16.\VADD\K{\_sat\_u}\\ &&|&
+     \text{i8x16.sub} &\Rightarrow& \I8X16.\VSUB\\ &&|&
+     \text{i8x16.sub\_sat\_s} &\Rightarrow& \I8X16.\VSUB\K{\_sat\_s}\\ &&|&
+     \text{i8x16.sub\_sat\_u} &\Rightarrow& \I8X16.\VSUB\K{\_sat\_u}\\ &&|&
+     \text{i8x16.min\_s} &\Rightarrow& \I8X16.\VMIN\K{\_s}\\ &&|&
+     \text{i8x16.min\_u} &\Rightarrow& \I8X16.\VMIN\K{\_u}\\ &&|&
+     \text{i8x16.max\_s} &\Rightarrow& \I8X16.\VMAX\K{\_s}\\ &&|&
+     \text{i8x16.max\_u} &\Rightarrow& \I8X16.\VMAX\K{\_u}\\ &&|&
+     \text{i8x16.avgr\_u} &\Rightarrow& \I8X16.\AVGR\K{\_u}\\ &&|&
+     \text{i8x16.popcnt} &\Rightarrow& \I8X16.\VPOPCNT\\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i16x8.abs} &\Rightarrow& \I16X8.\VABS\\ &&|&
+     \text{i16x8.neg} &\Rightarrow& \I16X8.\VNEG\\ &&|&
+     \text{i16x8.all\_true} &\Rightarrow& \I16X8.\ALLTRUE\\ &&|&
+     \text{i16x8.bitmask} &\Rightarrow& \I16X8.\BITMASK\\ &&|&
+     \text{i16x8.narrow\_i32x4\_s} &\Rightarrow& \I16X8.\NARROW\K{\_i32x4\_s}\\ &&|&
+     \text{i16x8.narrow\_i32x4\_u} &\Rightarrow& \I16X8.\NARROW\K{\_i32x4\_u}\\ &&|&
+     \text{i16x8.extend\_low\_i8x16\_s} &\Rightarrow& \I16X8.\VEXTEND\K{\_low\_i8x16\_s}\\ &&|&
+     \text{i16x8.extend\_high\_i8x16\_s} &\Rightarrow& \I16X8.\VEXTEND\K{\_high\_i8x16\_s}\\ &&|&
+     \text{i16x8.extend\_low\_i8x16\_u} &\Rightarrow& \I16X8.\VEXTEND\K{\_low\_i8x16\_u}\\ &&|&
+     \text{i16x8.extend\_high\_i8x16\_u} &\Rightarrow& \I16X8.\VEXTEND\K{\_high\_i8x16\_u}\\ &&|&
+     \text{i16x8.shl} &\Rightarrow& \I16X8.\VSHL\\ &&|&
+     \text{i16x8.shr\_s} &\Rightarrow& \I16X8.\VSHR\K{\_s}\\ &&|&
+     \text{i16x8.shr\_u} &\Rightarrow& \I16X8.\VSHR\K{\_u}\\ &&|&
+     \text{i16x8.add} &\Rightarrow& \I16X8.\VADD\\ &&|&
+     \text{i16x8.add\_sat\_s} &\Rightarrow& \I16X8.\VADD\K{\_sat\_s}\\ &&|&
+     \text{i16x8.add\_sat\_u} &\Rightarrow& \I16X8.\VADD\K{\_sat\_u}\\ &&|&
+     \text{i16x8.sub} &\Rightarrow& \I16X8.\VSUB\\ &&|&
+     \text{i16x8.sub\_sat\_s} &\Rightarrow& \I16X8.\VSUB\K{\_sat\_s}\\ &&|&
+     \text{i16x8.sub\_sat\_u} &\Rightarrow& \I16X8.\VSUB\K{\_sat\_u}\\ &&|&
+     \text{i16x8.mul} &\Rightarrow& \I16X8.\VMUL\\ &&|&
+     \text{i16x8.min\_s} &\Rightarrow& \I16X8.\VMIN\K{\_s}\\ &&|&
+     \text{i16x8.min\_u} &\Rightarrow& \I16X8.\VMIN\K{\_u}\\ &&|&
+     \text{i16x8.max\_s} &\Rightarrow& \I16X8.\VMAX\K{\_s}\\ &&|&
+     \text{i16x8.max\_u} &\Rightarrow& \I16X8.\VMAX\K{\_u}\\ &&|&
+     \text{i16x8.avgr\_u} &\Rightarrow& \I16X8.\AVGR\K{\_u}\\ &&|&
+     \text{i16x8.q15mulr\_sat\_s} &\Rightarrow& \I16X8.\Q15MULRSAT\K{\_s}\\ &&|&
+     \text{i16x8.extmul\_low\_i8x16\_s} &\Rightarrow& \I16X8.\EXTMUL\K{\_low\_i8x16\_s}\\ &&|&
+     \text{i16x8.extmul\_high\_i8x16\_s} &\Rightarrow& \I16X8.\EXTMUL\K{\_high\_i8x16\_s}\\ &&|&
+     \text{i16x8.extmul\_low\_i8x16\_u} &\Rightarrow& \I16X8.\EXTMUL\K{\_low\_i8x16\_u}\\ &&|&
+     \text{i16x8.extmul\_high\_i8x16\_u} &\Rightarrow& \I16X8.\EXTMUL\K{\_high\_i8x16\_u}\\ &&|&
+     \text{i16x8.extadd\_pairwise\_i8x16\_s} &\Rightarrow& \I16X8.\EXTADDPAIRWISE\K{\_i8x16\_s}\\ &&|&
+     \text{i16x8.extadd\_pairwise\_i8x16\_u} &\Rightarrow& \I16X8.\EXTADDPAIRWISE\K{\_i8x16\_u}\\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i32x4.abs} &\Rightarrow& \I32X4.\VABS\\ &&|&
+     \text{i32x4.neg} &\Rightarrow& \I32X4.\VNEG\\ &&|&
+     \text{i32x4.all\_true} &\Rightarrow& \I32X4.\ALLTRUE\\ &&|&
+     \text{i32x4.bitmask} &\Rightarrow& \I32X4.\BITMASK\\ &&|&
+     \text{i32x4.extadd\_pairwise\_i16x8\_s} &\Rightarrow& \I32X4.\EXTADDPAIRWISE\K{\_i16x8\_s}\\ &&|&
+     \text{i32x4.extend\_low\_i16x8\_s} &\Rightarrow& \I32X4.\VEXTEND\K{\_low\_i16x8\_s}\\ &&|&
+     \text{i32x4.extend\_high\_i16x8\_s} &\Rightarrow& \I32X4.\VEXTEND\K{\_high\_i16x8\_s}\\ &&|&
+     \text{i32x4.extend\_low\_i16x8\_u} &\Rightarrow& \I32X4.\VEXTEND\K{\_low\_i16x8\_u}\\ &&|&
+     \text{i32x4.extend\_high\_i16x8\_u} &\Rightarrow& \I32X4.\VEXTEND\K{\_high\_i16x8\_u}\\ &&|&
+     \text{i32x4.shl} &\Rightarrow& \I32X4.\VSHL\\ &&|&
+     \text{i32x4.shr\_s} &\Rightarrow& \I32X4.\VSHR\K{\_s}\\ &&|&
+     \text{i32x4.shr\_u} &\Rightarrow& \I32X4.\VSHR\K{\_u}\\ &&|&
+     \text{i32x4.add} &\Rightarrow& \I32X4.\VADD\\ &&|&
+     \text{i32x4.sub} &\Rightarrow& \I32X4.\VSUB\\ &&|&
+     \text{i32x4.mul} &\Rightarrow& \I32X4.\VMUL\\ &&|&
+     \text{i32x4.min\_s} &\Rightarrow& \I32X4.\VMIN\K{\_s}\\ &&|&
+     \text{i32x4.min\_u} &\Rightarrow& \I32X4.\VMIN\K{\_u}\\ &&|&
+     \text{i32x4.max\_s} &\Rightarrow& \I32X4.\VMAX\K{\_s}\\ &&|&
+     \text{i32x4.max\_u} &\Rightarrow& \I32X4.\VMAX\K{\_u}\\ &&|&
+     \text{i32x4.dot\_i16x8\_s} &\Rightarrow& \I32X4.\DOT\K{\_i16x8\_s}\\ &&|&
+     \text{i32x4.extmul\_low\_i16x8\_s} &\Rightarrow& \I32X4.\EXTMUL\K{\_low\_i16x8\_s}\\ &&|&
+     \text{i32x4.extmul\_high\_i16x8\_s} &\Rightarrow& \I32X4.\EXTMUL\K{\_high\_i16x8\_s}\\ &&|&
+     \text{i32x4.extmul\_low\_i16x8\_u} &\Rightarrow& \I32X4.\EXTMUL\K{\_low\_i16x8\_u}\\ &&|&
+     \text{i32x4.extmul\_high\_i16x8\_u} &\Rightarrow& \I32X4.\EXTMUL\K{\_high\_i16x8\_u}\\
+  \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i64x2.abs} &\Rightarrow& \I64X2.\VABS\\ &&|&
+     \text{i64x2.neg} &\Rightarrow& \I64X2.\VNEG\\ &&|&
+     \text{i64x2.all\_true} &\Rightarrow& \I64X2.\ALLTRUE\\ &&|&
+     \text{i64x2.bitmask} &\Rightarrow& \I64X2.\BITMASK\\ &&|&
+     \text{i64x2.extend\_low\_i32x4\_s} &\Rightarrow& \I64X2.\VEXTEND\K{\_low\_i32x4\_s} \\ &&|&
+     \text{i64x2.extend\_high\_i32x4\_s} &\Rightarrow& \I64X2.\VEXTEND\K{\_high\_i32x4\_s} \\ &&|&
+     \text{i64x2.extend\_low\_i32x4\_u} &\Rightarrow& \I64X2.\VEXTEND\K{\_low\_i32x4\_u} \\ &&|&
+     \text{i64x2.extend\_high\_i32x4\_u} &\Rightarrow& \I64X2.\VEXTEND\K{\_high\_i32x4\_u} \\ &&|&
+     \text{i64x2.shl} &\Rightarrow& \I64X2.\VSHL\\ &&|&
+     \text{i64x2.shr\_s} &\Rightarrow& \I64X2.\VSHR\K{\_s}\\ &&|&
+     \text{i64x2.shr\_u} &\Rightarrow& \I64X2.\VSHR\K{\_u}\\ &&|&
+     \text{i64x2.add} &\Rightarrow& \I64X2.\VADD\\ &&|&
+     \text{i64x2.sub} &\Rightarrow& \I64X2.\VSUB\\ &&|&
+     \text{i64x2.mul} &\Rightarrow& \I64X2.\VMUL\\ &&|&
+     \text{i64x2.extmul\_low\_i32x4\_s} &\Rightarrow& \I64X2.\EXTMUL\K{\_low\_i32x4\_s}\\ &&|&
+     \text{i64x2.extmul\_high\_i32x4\_s} &\Rightarrow& \I64X2.\EXTMUL\K{\_high\_i32x4\_s}\\ &&|&
+     \text{i64x2.extmul\_low\_i32x4\_u} &\Rightarrow& \I64X2.\EXTMUL\K{\_low\_i32x4\_u}\\ &&|&
+     \text{i64x2.extmul\_high\_i32x4\_u} &\Rightarrow& \I64X2.\EXTMUL\K{\_high\_i32x4\_u}\\
+  \end{array}
+
+.. _text-vfunop:
+.. _text-vfbinop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{f32x4.abs} &\Rightarrow& \F32X4.\VABS\\ &&|&
+     \text{f32x4.neg} &\Rightarrow& \F32X4.\VNEG\\ &&|&
+     \text{f32x4.sqrt} &\Rightarrow& \F32X4.\VSQRT\\ &&|&
+     \text{f32x4.add} &\Rightarrow& \F32X4.\VADD\\ &&|&
+     \text{f32x4.sub} &\Rightarrow& \F32X4.\VSUB\\ &&|&
+     \text{f32x4.mul} &\Rightarrow& \F32X4.\VMUL\\ &&|&
+     \text{f32x4.div} &\Rightarrow& \F32X4.\VDIV\\ &&|&
+     \text{f32x4.min} &\Rightarrow& \F32X4.\VMIN\\ &&|&
+     \text{f32x4.max} &\Rightarrow& \F32X4.\VMAX\\ &&|&
+     \text{f32x4.pmin} &\Rightarrow& \F32X4.\VPMIN\\ &&|&
+     \text{f32x4.pmax} &\Rightarrow& \F32X4.\VPMAX\\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{f64x2.abs} &\Rightarrow& \F64X2.\VABS\\ &&|&
+     \text{f64x2.neg} &\Rightarrow& \F64X2.\VNEG\\ &&|&
+     \text{f64x2.sqrt} &\Rightarrow& \F64X2.\VSQRT\\ &&|&
+     \text{f64x2.add} &\Rightarrow& \F64X2.\VADD\\ &&|&
+     \text{f64x2.sub} &\Rightarrow& \F64X2.\VSUB\\ &&|&
+     \text{f64x2.mul} &\Rightarrow& \F64X2.\VMUL\\ &&|&
+     \text{f64x2.div} &\Rightarrow& \F64X2.\VDIV\\ &&|&
+     \text{f64x2.min} &\Rightarrow& \F64X2.\VMIN\\ &&|&
+     \text{f64x2.max} &\Rightarrow& \F64X2.\VMAX\\ &&|&
+     \text{f64x2.pmin} &\Rightarrow& \F64X2.\VPMIN\\ &&|&
+     \text{f64x2.pmax} &\Rightarrow& \F64X2.\VPMAX\\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{averylonginstructionnameforvectext} && \phantom{vechasreallylonginstructionnames} \\[-2ex] &&|&
+     \text{i32x4.trunc\_sat\_f32x4\_s} &\Rightarrow& \I32X4.\VTRUNC\K{\_sat\_f32x4\_s}\\ &&|&
+     \text{i32x4.trunc\_sat\_f32x4\_u} &\Rightarrow& \I32X4.\VTRUNC\K{\_sat\_f32x4\_u}\\ &&|&
+     \text{i32x4.trunc\_sat\_f64x2\_s\_zero} &\Rightarrow& \I32X4.\VTRUNC\K{\_sat\_f64x2\_s\_zero}\\ &&|&
+     \text{i32x4.trunc\_sat\_f64x2\_u\_zero} &\Rightarrow& \I32X4.\VTRUNC\K{\_sat\_f64x2\_u\_zero}\\ &&|&
+     \text{f32x4.convert\_i32x4\_s} &\Rightarrow& \F32X4.\CONVERT\K{\_i32x4\_s}\\ &&|&
+     \text{f32x4.convert\_i32x4\_u} &\Rightarrow& \F32X4.\CONVERT\K{\_i32x4\_u}\\ &&|&
+     \text{f64x2.convert\_low\_i32x4\_s} &\Rightarrow& \F64X2.\VCONVERT\K{\_low\_i32x4\_s}\\  &&|&
+     \text{f64x2.convert\_low\_i32x4\_u} &\Rightarrow& \F64X2.\VCONVERT\K{\_low\_i32x4\_u}\\ &&|&
+     \text{f32x4.demote\_f64x2\_zero} &\Rightarrow& \F32X4.\VDEMOTE\K{\_f64x2\_zero}\\ &&|&
+     \text{f64x2.promote\_low\_f32x4} &\Rightarrow& \F64X2.\VPROMOTE\K{\_low\_f32x4}\\ &&|&
+   \end{array}
+
+
 .. index:: ! folded instruction, S-expression
 .. _text-foldedinstr:
 
diff --git a/document/core/text/types.rst b/document/core/text/types.rst
index 17a3f46a6..ea2507bef 100644
--- a/document/core/text/types.rst
+++ b/document/core/text/types.rst
@@ -22,6 +22,20 @@ Number Types
    \end{array}
 
 
+.. index:: vector type
+   pair: text format; vector type
+.. _text-vectype:
+
+Vector Types
+~~~~~~~~~~~~
+
+.. math::
+   \begin{array}{llcll@{\qquad\qquad}l}
+   \production{vector type} & \Tvectype_I &::=&
+     \text{v128} &\Rightarrow& \V128 \\
+   \end{array}
+
+
 .. index:: heap type
    pair: text format; heap type
 .. _text-heaptype:
@@ -67,7 +81,7 @@ There are shorthands for references to abstract heap types.
    \end{array}
 
 
-.. index:: value type, number type, reference type
+.. index:: value type, number type, vector type, reference type
    pair: text format; value type
 .. _text-valtype:
 
@@ -78,6 +92,7 @@ Value Types
    \begin{array}{llcll@{\qquad\qquad}l}
    \production{value type} & \Tvaltype_I &::=&
      t{:}\Tnumtype_I &\Rightarrow& t \\ &&|&
+     t{:}\Tvectype_I &\Rightarrow& t \\ &&|&
      t{:}\Treftype_I &\Rightarrow& t \\
    \end{array}
 
@@ -104,6 +119,10 @@ Function Types
        &\Rightarrow& t \\
    \end{array}
 
+.. note::
+   The optional identifier names for parameters in a function type only have documentation purpose.
+   They cannot be referenced from anywhere.
+
 
 Abbreviations
 .............
diff --git a/document/core/util/bikeshed/conf.py b/document/core/util/bikeshed/conf.py
index 930d47191..af725bd7e 100644
--- a/document/core/util/bikeshed/conf.py
+++ b/document/core/util/bikeshed/conf.py
@@ -1,470 +1,41 @@
 # -*- coding: utf-8 -*-
 #
-# WebAssembly documentation build configuration file, created by
-# sphinx-quickstart on Mon Nov 21 11:32:49 2016.
-#
-# This file is execfile()d with the current directory set to its
-# containing dir.
-#
-# Note that not all possible configuration values are present in this
-# autogenerated file.
-#
-# All configuration values have a default; values that are commented out
-# serve to show the default.
+# Sphinx configuration for bikeshed builds (make bikeshed).
+# This imports the main document/core/conf.py, then overwrites certain config
+# values for the bikeshed build.
 
-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
 import os
 import sys
-pwd = os.path.abspath('../..')
-sys.path.insert(0, pwd + '/util')
-
-# -- General configuration ------------------------------------------------
-
-# If your documentation needs a minimal Sphinx version, state it here.
-#
-needs_sphinx = '1.4'
-
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
-# ones.
-extensions = [
-  'sphinx.ext.todo',
-  'sphinx.ext.coverage',
-  'sphinx.ext.mathjax',
-  'sphinx.ext.ifconfig',
-  'sphinx.ext.githubpages',
-  'mathdefbs',
-  'pseudo-lexer'
-]
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
-
-# The suffix(es) of source filenames.
-# You can specify multiple suffix as a list of string:
-#
-source_suffix = ['.rst']
-
-# The encoding of source files.
-#
-# source_encoding = 'utf-8-sig'
-
-# The master toctree document.
-master_doc = 'index'
-
-# General information about the project.
-name = 'WebAssembly'
-project = u'WebAssembly'
-title = u'WebAssembly Specification'
-copyright = u'2017, WebAssembly Community Group'
-author = u'WebAssembly Community Group'
-logo = 'static/webassembly.png'
-
-# The version info for the project you're documenting, acts as replacement for
-# |version| and |release|, also used in various other places throughout the
-# built documents.
-#
-# The short X.Y version.
-version = u'1.1'
-# The full version, including alpha/beta/rc tags.
-release = version + ''
-
-# The language for content autogenerated by Sphinx. Refer to documentation
-# for a list of supported languages.
-#
-# This is also used if you do content translation via gettext catalogs.
-# Usually you set "language" from the command line for these cases.
-language = None
-
-# There are two options for replacing |today|: either, you set today to some
-# non-false value, then it is used:
-#
-# today = ''
-#
-# Else, today_fmt is used as the format for a strftime call.
-#
-# today_fmt = '%B %d, %Y'
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-# This patterns also effect to html_static_path and html_extra_path
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
-
-# The reST default role (used for this markup: `text`) to use for all
-# documents.
-#
-# default_role = None
-
-# If true, '()' will be appended to :func: etc. cross-reference text.
-#
-# add_function_parentheses = True
-
-# If true, the current module name will be prepended to all description
-# unit titles (such as .. function::).
-#
-# add_module_names = True
-
-# If true, sectionauthor and moduleauthor directives will be shown in the
-# output. They are ignored by default.
-#
-# show_authors = False
-
-# The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
-
-# A list of ignored prefixes for module index sorting.
-# modindex_common_prefix = []
+original_pwd = os.path.abspath('../..')
+# Change sys.path so that we can find the main 'conf.py'.
+sys.path.insert(0, original_pwd)
+from conf import *
+main_conf_pwd = pwd
 
-# If true, keep warnings as "system message" paragraphs in the built documents.
-# keep_warnings = False
+# Now that we have imported all the settings, we need to overwrite some of
+# them.
 
-# If true, `todo` and `todoList` produce output, else they produce nothing.
-todo_include_todos = True
+# The first is `pwd`, we want to reset it to document/core, because rst_prolog
+# below depends on this to find macros.def.
+pwd = original_pwd
 
+# The bikeshed build requires the mathdefbs extension.
+extensions[extensions.index('util.mathdef')] = 'util.mathdefbs'
 
-# -- Options for HTML output ----------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-#
+# Overwrite html themes and configurations.
 html_theme = 'classic'
 html_permalinks = False
-
-# Theme options are theme-specific and customize the look and feel of a theme
-# further.  For a list of options available for each theme, see the
-# documentation.
-#
 html_theme_options = {
   'nosidebar': True,
 }
-
-html_sidebars = {
-  '**': [
-    # 'about.html',
-    'navigation.html',
-    # 'relations.html',
-    'searchbox.html',
-  ]
-}
-
-
-# Add any paths that contain custom themes here, relative to this directory.
-# html_theme_path = []
-
-# The name for this set of Sphinx documents.
-# "<project> v<release> documentation" by default.
-#
-html_title = project + u' ' + release
-
-# A shorter title for the navigation bar.  Default is the same as html_title.
-#
-# html_short_title = None
-
-# The name of an image file (relative to this directory) to place at the top
-# of the sidebar.
-#
-html_logo = logo
-
-# The name of an image file (relative to this directory) to use as a favicon of
-# the docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
-# pixels large.
-#
-# html_favicon = None
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-# html_static_path = ['_static', 'static/custom.css']
-
-# Add any extra paths that contain custom files (such as robots.txt or
-# .htaccess) here, relative to this directory. These files are copied
-# directly to the root of the documentation.
-#
-# html_extra_path = []
-
-# If not None, a 'Last updated on:' timestamp is inserted at every page
-# bottom, using the given strftime format.
-# The empty string is equivalent to '%b %d, %Y'.
-#
-# html_last_updated_fmt = None
-
-# If true, SmartyPants will be used to convert quotes and dashes to
-# typographically correct entities.
-#
-# html_use_smartypants = True
-
-# Additional templates that should be rendered to pages, maps page names to
-# template names.
-#
-# html_additional_pages = {}
-
-# If false, no module index is generated.
-#
-html_domain_indices = False
-
-# If false, no index is generated.
-#
-html_use_index = True
-
-# If true, the index is split into individual pages for each letter.
-#
-html_split_index = False
-
-# If true, the reST sources are included in the HTML build as _sources/name. The default is True.
-#
-html_copy_source = False
-
-# If true, links to the reST sources are added to the pages.
-#
-html_show_sourcelink = False
-
-# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
-#
-html_show_sphinx = False
-
-# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
-#
 html_show_copyright = False
 
-# If this is not None, a ‘Last updated on:’ timestamp is inserted at every
-# page bottom, using the given strftime() format.
-#
-html_last_updated_fmt = None
-
-# If true, an OpenSearch description file will be output, and all pages will
-# contain a <link> tag referring to it.  The value of this option must be the
-# base URL from which the finished HTML is served.
-#
-# html_use_opensearch = ''
-
-# This is the file name suffix for HTML files (e.g. ".xhtml").
-#
-# html_file_suffix = None
+# Overwrite the prolog to make sure the include directive has the correct path.
 
-# Language to be used for generating the HTML full-text search index.
-# Sphinx supports the following languages:
-#   'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
-#   'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr', 'zh'
-#
-# html_search_language = 'en'
-
-# A dictionary with options for the search language support, empty by default.
-# 'ja' uses this config value.
-# 'zh' user can custom change `jieba` dictionary path.
-#
-# html_search_options = {'type': 'default'}
-
-# The name of a javascript file (relative to the configuration directory) that
-# implements a search results scorer. If empty, the default will be used.
-#
-# html_search_scorer = 'scorer.js'
-
-# Output file base name for HTML help builder.
-#
-htmlhelp_basename = 'WebAssemblydoc'
-
-
-# -- Options for LaTeX output ---------------------------------------------
-
-latex_elements = {
-   # The paper size ('a4paper' or 'letterpaper').
-  'papersize': 'a4paper',
-
-   # The font size ('10pt', '11pt' or '12pt').
-  'pointsize': '10pt',
-
-   # Additional stuff for the LaTeX preamble.
-   'preamble': '',
-
-   # Latex figure (float) alignment
-  'figure_align': 'htbp',
-
-   # Fancy chapters [Bjarne, Sonny, Lenny, Glenn, Conny, Rejne]
-   'fncychap': '\\usepackage[Sonny]{fncychap}',
-}
-
-# Grouping the document tree into LaTeX files. List of tuples
-# (source start file, target name, title,
-#  author, documentclass [howto, manual, or own class]).
-latex_documents = [
-  ( master_doc,
-    name + '.tex',
-    title,
-    author,
-    'manual'
-  ),
-]
-
-# The name of an image file (relative to this directory) to place at the top of
-# the title page.
-#
-latex_logo = logo
-
-# For "manual" documents [part, chapter, or section].
-#
-latex_toplevel_sectioning = 'chapter'
-
-# If true, show page references after internal links.
-#
-latex_show_pagerefs = False
-
-# How to show URL addresses after external links [no, footnote, inline].
-#
-latex_show_urls = 'footnote'
-
-# Documents to append as an appendix to all manuals.
-#
-# latex_appendices = []
-
-# It false, will not define \strong, \code, \titleref, \crossref ... but only
-# \sphinxstrong, ..., \sphinxtitleref, ... To help avoid clash with user added
-# packages.
-#
-# latex_keep_old_macro_names = True
-
-# If false, no module index is generated.
-#
-latex_domain_indices = False
-
-
-# -- Options for manual page output ---------------------------------------
-
-# One entry per manual page. List of tuples
-# (source start file, name, description, authors, manual section).
-man_pages = [
-  ( master_doc,
-    name,
-    title,
-    [author],
-    1
-  )
-]
-
-# If true, show URL addresses after external links.
-#
-# man_show_urls = False
-
-
-# -- Options for Texinfo output -------------------------------------------
-
-# Grouping the document tree into Texinfo files. List of tuples
-# (source start file, target name, title, author,
-#  dir menu entry, description, category)
-texinfo_documents = [
-  ( master_doc,
-    name,
-    title,
-    author,
-    name,
-    'A portable low-level execution format.',
-    'Virtual Machine'
-  ),
-]
-
-# Documents to append as an appendix to all manuals.
-#
-# texinfo_appendices = []
-
-# If false, no module index is generated.
-#
-texinfo_domain_indices = False
-
-# How to display URL addresses: 'footnote', 'no', or 'inline'.
-#
-# texinfo_show_urls = 'footnote'
-
-# If true, do not generate a @detailmenu in the "Top" node's menu.
-#
-# texinfo_no_detailmenu = False
-
-
-# -- Options for Epub output ----------------------------------------------
-
-# Bibliographic Dublin Core info.
-epub_title = project
-epub_author = author
-epub_publisher = author
-epub_copyright = copyright
-
-# The basename for the epub file. It defaults to the project name.
-# epub_basename = project
-
-# The HTML theme for the epub output. Since the default themes are not
-# optimized for small screen space, using the same theme for HTML and epub
-# output is usually not wise. This defaults to 'epub', a theme designed to save
-# visual space.
-#
-# epub_theme = 'epub'
-
-# The language of the text. It defaults to the language option
-# or 'en' if the language is not set.
-#
-# epub_language = ''
-
-# The scheme of the identifier. Typical schemes are ISBN or URL.
-# epub_scheme = ''
-
-# The unique identifier of the text. This can be a ISBN number
-# or the project homepage.
-#
-# epub_identifier = ''
-
-# A unique identification for the text.
-#
-# epub_uid = ''
-
-# A tuple containing the cover image and cover page html template filenames.
-#
-# epub_cover = ()
-
-# A sequence of (type, uri, title) tuples for the guide element of content.opf.
-#
-# epub_guide = ()
-
-# HTML files that should be inserted before the pages created by sphinx.
-# The format is a list of tuples containing the path and title.
-#
-# epub_pre_files = []
-
-# HTML files that should be inserted after the pages created by sphinx.
-# The format is a list of tuples containing the path and title.
-#
-# epub_post_files = []
-
-# A list of files that should not be packed into the epub file.
-epub_exclude_files = ['search.html']
-
-# The depth of the table of contents in toc.ncx.
-#
-# epub_tocdepth = 3
-
-# Allow duplicate toc entries.
-#
-# epub_tocdup = True
-
-# Choose between 'default' and 'includehidden'.
-#
-# epub_tocscope = 'default'
-
-# Fix unsupported image types using the Pillow.
-#
-# epub_fix_images = False
-
-# Scale large images.
-#
-# epub_max_image_width = 0
-
-# How to display URL addresses: 'footnote', 'no', or 'inline'.
-#
-# epub_show_urls = 'inline'
-
-# If false, no index is generated.
-#
-# epub_use_index = True
+main_macros_def = "/" + main_conf_pwd + "/util/macros.def"
+# If we hit this assertion, the configuration files probably moved, or files
+# are renamed, and we have to update rst_prolog accordingly.
+assert(main_macros_def in rst_prolog)
+rst_prolog  = rst_prolog.replace(main_macros_def, "/" + pwd + "/util/macros.def")
 
-# Macros
-rst_prolog = """
-.. include:: /""" + pwd + """/util/macros.def
-"""
+del mathjax3_config
diff --git a/document/core/util/katex b/document/core/util/katex
index b9deec098..e751278cf 160000
--- a/document/core/util/katex
+++ b/document/core/util/katex
@@ -1 +1 @@
-Subproject commit b9deec098f35919b9ad77baa6b11b7593473d488
+Subproject commit e751278cff42fada16dba6df331fda52aaa90f73
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index 6d49a2395..eb1e80936 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -129,6 +129,7 @@
 .. |sX#1| mathdef:: {\X{s#1}}
 .. |iX#1| mathdef:: {\X{i#1}}
 .. |fX#1| mathdef:: {\X{f#1}}
+.. |vX#1| mathdef:: {\X{v#1}}
 
 .. |uN| mathdef:: \xref{syntax/values}{syntax-int}{\X{u}N}
 .. |uM| mathdef:: \xref{syntax/values}{syntax-int}{\X{u}M}
@@ -144,11 +145,13 @@
 .. |s32| mathdef:: \xref{syntax/values}{syntax-int}{\X{s32}}
 .. |s64| mathdef:: \xref{syntax/values}{syntax-int}{\X{s64}}
 
+.. |iM| mathdef:: \xref{syntax/values}{syntax-int}{\X{i}M}
 .. |iN| mathdef:: \xref{syntax/values}{syntax-int}{\X{i}N}
 .. |i8| mathdef:: \xref{syntax/values}{syntax-int}{\X{i8}}
 .. |i16| mathdef:: \xref{syntax/values}{syntax-int}{\X{i16}}
 .. |i32| mathdef:: \xref{syntax/values}{syntax-int}{\X{i32}}
 .. |i64| mathdef:: \xref{syntax/values}{syntax-int}{\X{i64}}
+.. |i128| mathdef:: \xref{syntax/values}{syntax-int}{\X{i128}}
 
 .. |fN| mathdef:: \xref{syntax/values}{syntax-float}{\X{f}N}
 .. |fNmag| mathdef:: \xref{syntax/values}{syntax-float}{\X{f}\X{Nmag}}
@@ -178,6 +181,14 @@
 .. |I64| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{i64}}
 .. |F32| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{f32}}
 .. |F64| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{f64}}
+.. |V128| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{v128}}
+.. |I8X16| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{i8x16}}
+.. |I16X8| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{i16x8}}
+.. |I32X4| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{i32x4}}
+.. |I64X2| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{i64x2}}
+.. |F32X4| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{f32x4}}
+.. |F64X2| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{f64x2}}
+.. |I128| mathdef:: \K{i128}
 
 .. |REF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{ref}}
 .. |NULL| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{null}}
@@ -201,6 +212,7 @@
 .. Types, non-terminals
 
 .. |numtype| mathdef:: \xref{syntax/types}{syntax-numtype}{\X{numtype}}
+.. |vectype| mathdef:: \xref{syntax/types}{syntax-vectype}{\X{vectype}}
 .. |heaptype| mathdef:: \xref{syntax/types}{syntax-heaptype}{\X{heaptype}}
 .. |reftype| mathdef:: \xref{syntax/types}{syntax-reftype}{\X{reftype}}
 .. |valtype| mathdef:: \xref{syntax/types}{syntax-valtype}{\X{valtype}}
@@ -431,6 +443,56 @@
 .. |DEMOTE| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{demote}}
 .. |REINTERPRET| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{reinterpret}}
 
+.. |VCONST| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{const}}
+.. |SHUFFLE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{shuffle}}
+.. |SWIZZLE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{swizzle}}
+.. |SPLAT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{splat}}
+.. |EXTRACTLANE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{extract\_lane}}
+.. |REPLACELANE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{replace\_lane}}
+.. |VNOT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{not}}
+.. |VAND| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{and}}
+.. |VANDNOT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{andnot}}
+.. |VOR| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{or}}
+.. |VXOR| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{xor}}
+.. |BITSELECT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{bitselect}}
+.. |VEQ| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{eq}}
+.. |VNE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{ne}}
+.. |VLT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{lt}}
+.. |VGT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{gt}}
+.. |VLE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{le}}
+.. |VGE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{ge}}
+.. |VABS| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{abs}}
+.. |VNEG| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{neg}}
+.. |VCEIL| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{ceil}}
+.. |VFLOOR| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{floor}}
+.. |VTRUNC| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{trunc}}
+.. |VNEAREST| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{nearest}}
+.. |VPOPCNT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{popcnt}}
+.. |ANYTRUE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{any\_true}}
+.. |ALLTRUE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{all\_true}}
+.. |BITMASK| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{bitmask}}
+.. |VSHL| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{shl}}
+.. |VSHR| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{shr}}
+.. |VSQRT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{sqrt}}
+.. |VADD| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{add}}
+.. |VSUB| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{sub}}
+.. |VMUL| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{mul}}
+.. |VDIV| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{div}}
+.. |VMIN| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{min}}
+.. |VMAX| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{max}}
+.. |VPMIN| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{pmin}}
+.. |VPMAX| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{pmax}}
+.. |NARROW| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{narrow}}
+.. |VEXTEND| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{extend}}
+.. |AVGR| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{avgr}}
+.. |DOT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{dot}}
+.. |EXTMUL| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{extmul}}
+.. |VCONVERT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{convert}}
+.. |Q15MULRSAT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{q15mulr\_sat}}
+.. |EXTADDPAIRWISE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{extadd\_pairwise}}
+.. |VDEMOTE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{demote}}
+.. |VPROMOTE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{promote}}
+
 
 .. Instructions, non-terminals
 
@@ -450,7 +512,36 @@
 .. |ftestop| mathdef:: \xref{syntax/instructions}{syntax-ftestop}{\X{ftestop}}
 .. |frelop| mathdef:: \xref{syntax/instructions}{syntax-frelop}{\X{frelop}}
 
+.. |ishape| mathdef:: \xref{syntax/instructions}{syntax-shape}{\X{ishape}}
+.. |fshape| mathdef:: \xref{syntax/instructions}{syntax-shape}{\X{fshape}}
+.. |shape| mathdef:: \xref{syntax/instructions}{syntax-shape}{\X{shape}}
+
+.. |vunop| mathdef:: \xref{syntax/instructions}{syntax-vunop}{\X{vunop}}
+.. |vbinop| mathdef:: \xref{syntax/instructions}{syntax-vbinop}{\X{vbinop}}
+.. |vrelop| mathdef:: \xref{syntax/instructions}{syntax-vrelop}{\X{vrelop}}
+.. |vternop| mathdef:: \xref{syntax/instructions}{syntax-vternop}{\X{vternop}}
+.. |vcvtop| mathdef:: \xref{syntax/instructions}{syntax-vcvtop}{\X{vcvtop}}
+.. |vextmul| mathdef:: \xref{syntax/instructions}{syntax-vextmul}{\X{vextmul}}
+
+.. |laneidx| mathdef:: \xref{syntax/instructions}{syntax-laneidx}{\X{laneidx}}
+.. |vvunop| mathdef:: \xref{syntax/instructions}{syntax-vvunop}{\X{vvunop}}
+.. |vvbinop| mathdef:: \xref{syntax/instructions}{syntax-vvbinop}{\X{vvbinop}}
+.. |vvternop| mathdef:: \xref{syntax/instructions}{syntax-vvternop}{\X{vvternop}}
+.. |vvtestop| mathdef:: \xref{syntax/instructions}{syntax-vvtestop}{\X{vvtestop}}
+.. |vishiftop| mathdef:: \xref{syntax/instructions}{syntax-vishiftop}{\X{vishiftop}}
+.. |viunop| mathdef:: \xref{syntax/instructions}{syntax-viunop}{\X{viunop}}
+.. |vibinop| mathdef:: \xref{syntax/instructions}{syntax-vibinop}{\X{vibinop}}
+.. |viminmaxop| mathdef:: \xref{syntax/instructions}{syntax-viminmaxop}{\X{viminmaxop}}
+.. |visatbinop| mathdef:: \xref{syntax/instructions}{syntax-visatbinop}{\X{visatbinop}}
+.. |vfunop| mathdef:: \xref{syntax/instructions}{syntax-vfunop}{\X{vfunop}}
+.. |vfbinop| mathdef:: \xref{syntax/instructions}{syntax-vfbinop}{\X{vfbinop}}
+.. |virelop| mathdef:: \xref{syntax/instructions}{syntax-virelop}{\X{virelop}}
+.. |vfrelop| mathdef:: \xref{syntax/instructions}{syntax-vfrelop}{\X{vfrelop}}
+.. |vitestop| mathdef:: \xref{syntax/instructions}{syntax-vitestop}{\X{vitestop}}
+.. |vtestop| mathdef:: \xref{syntax/instructions}{syntax-vtestop}{\X{vtestop}}
+
 .. |sx| mathdef:: \xref{syntax/instructions}{syntax-sx}{\X{sx}}
+.. |half| mathdef:: \xref{syntax/instructions}{syntax-half}{\X{half}}
 .. |memarg| mathdef:: \xref{syntax/instructions}{syntax-memarg}{\X{memarg}}
 
 .. |blocktype| mathdef:: \xref{syntax/instructions}{syntax-blocktype}{\X{blocktype}}
@@ -509,6 +600,7 @@
 .. Types, non-terminals
 
 .. |Bnumtype| mathdef:: \xref{binary/types}{binary-numtype}{\B{numtype}}
+.. |Bvectype| mathdef:: \xref{binary/types}{binary-vectype}{\B{vectype}}
 .. |Bheaptype| mathdef:: \xref{binary/types}{binary-heaptype}{\B{heaptype}}
 .. |Breftype| mathdef:: \xref{binary/types}{binary-reftype}{\B{reftype}}
 .. |Bvaltype| mathdef:: \xref{binary/types}{binary-valtype}{\B{valtype}}
@@ -583,6 +675,7 @@
 .. |Binstr| mathdef:: \xref{binary/instructions}{binary-instr}{\B{instr}}
 .. |Bexpr| mathdef:: \xref{binary/instructions}{binary-expr}{\B{expr}}
 
+.. |Blaneidx| mathdef:: \xref{binary/instructions}{binary-laneidx}{\B{laneidx}}
 
 
 .. Text Format
@@ -651,6 +744,8 @@
 .. |Ts64| mathdef:: \xref{text/values}{text-int}{\TsX{\T{64}}}
 
 .. |TiN| mathdef:: \xref{text/values}{text-int}{\TiX{N}}
+.. |Ti8| mathdef:: \xref{text/values}{text-int}{\TiX{\T{8}}}
+.. |Ti16| mathdef:: \xref{text/values}{text-int}{\TiX{\T{16}}}
 .. |Ti32| mathdef:: \xref{text/values}{text-int}{\TiX{\T{32}}}
 .. |Ti64| mathdef:: \xref{text/values}{text-int}{\TiX{\T{64}}}
 
@@ -671,6 +766,7 @@
 .. Types, non-terminals
 
 .. |Tnumtype| mathdef:: \xref{text/types}{text-numtype}{\T{numtype}}
+.. |Tvectype| mathdef:: \xref{text/types}{text-vectype}{\T{vectype}}
 .. |Theaptype| mathdef:: \xref{text/types}{text-heaptype}{\T{heaptype}}
 .. |Treftype| mathdef:: \xref{text/types}{text-reftype}{\T{reftype}}
 .. |Tvaltype| mathdef:: \xref{text/types}{text-valtype}{\T{valtype}}
@@ -815,6 +911,7 @@
 .. Judgments
 
 .. |vdashnumtype| mathdef:: \xref{valid/types}{valid-numtype}{\vdash}
+.. |vdashvectype| mathdef:: \xref{valid/types}{valid-vectype}{\vdash}
 .. |vdashheaptype| mathdef:: \xref{valid/types}{valid-heaptype}{\vdash}
 .. |vdashreftype| mathdef:: \xref{valid/types}{valid-reftype}{\vdash}
 .. |vdashvaltype| mathdef:: \xref{valid/types}{valid-valtype}{\vdash}
@@ -861,6 +958,9 @@
 .. |vdashimportdesc| mathdef:: \xref{valid/modules}{valid-importdesc}{\vdash}
 .. |vdashmodule| mathdef:: \xref{valid/modules}{valid-module}{\vdash}
 
+.. |unpacked| mathdef:: \xref{valid/instructions}{aux-unpacked}{\F{unpacked}}
+.. |dim| mathdef:: \xref{valid/instructions}{aux-dim}{\F{dim}}
+
 
 .. Execution
 .. ---------
@@ -1005,6 +1105,7 @@
 .. Values & Results, non-terminals
 
 .. |num| mathdef:: \xref{exec/runtime}{syntax-num}{\X{num}}
+.. |vecc| mathdef:: \xref{exec/runtime}{syntax-vec}{\X{vec}}
 .. |reff| mathdef:: \xref{exec/runtime}{syntax-ref}{\X{ref}}
 .. |val| mathdef:: \xref{exec/runtime}{syntax-val}{\X{val}}
 .. |result| mathdef:: \xref{exec/runtime}{syntax-result}{\X{result}}
@@ -1035,7 +1136,9 @@
 .. |idivs| mathdef:: \xref{exec/numerics}{op-idiv_s}{\F{idiv\_s}}
 .. |iremu| mathdef:: \xref{exec/numerics}{op-irem_u}{\F{irem\_u}}
 .. |irems| mathdef:: \xref{exec/numerics}{op-irem_s}{\F{irem\_s}}
+.. |inot| mathdef:: \xref{exec/numerics}{op-inot}{\F{inot}}
 .. |iand| mathdef:: \xref{exec/numerics}{op-iand}{\F{iand}}
+.. |iandnot| mathdef:: \xref{exec/numerics}{op-iandnot}{\F{iandnot}}
 .. |ior| mathdef:: \xref{exec/numerics}{op-ior}{\F{ior}}
 .. |ixor| mathdef:: \xref{exec/numerics}{op-ixor}{\F{ixor}}
 .. |ishl| mathdef:: \xref{exec/numerics}{op-ishl}{\F{ishl}}
@@ -1058,6 +1161,19 @@
 .. |igeu| mathdef:: \xref{exec/numerics}{op-ige_u}{\F{ige\_u}}
 .. |iges| mathdef:: \xref{exec/numerics}{op-ige_s}{\F{ige\_s}}
 .. |iextendMs| mathdef:: \xref{exec/numerics}{op-iextendn_s}{\F{iextend}M\F{\_s}}
+.. |ibitselect| mathdef:: \xref{exec/numerics}{op-ibitselect}{\F{ibitselect}}
+.. |iabs| mathdef:: \xref{exec/numerics}{op-iabs}{\F{iabs}}
+.. |ineg| mathdef:: \xref{exec/numerics}{op-ineg}{\F{ineg}}
+.. |iminu| mathdef:: \xref{exec/numerics}{op-imin_u}{\F{imin\_u}}
+.. |imins| mathdef:: \xref{exec/numerics}{op-imin_s}{\F{imin\_s}}
+.. |imaxu| mathdef:: \xref{exec/numerics}{op-imax_u}{\F{imax\_u}}
+.. |imaxs| mathdef:: \xref{exec/numerics}{op-imax_s}{\F{imax\_s}}
+.. |iaddsatu| mathdef:: \xref{exec/numerics}{op-iaddsat_u}{\F{iaddsat\_u}}
+.. |iaddsats| mathdef:: \xref{exec/numerics}{op-iaddsat_s}{\F{iaddsat\_s}}
+.. |isubsatu| mathdef:: \xref{exec/numerics}{op-isubsat_u}{\F{isubsat\_u}}
+.. |isubsats| mathdef:: \xref{exec/numerics}{op-isubsat_s}{\F{isubsat\_s}}
+.. |iavgru| mathdef:: \xref{exec/numerics}{op-iavgr_u}{\F{iavgr\_u}}
+.. |iq15mulrsats| mathdef:: \xref{exec/numerics}{op-iq15mulrsat_s}{\F{iq15mulrsat\_s}}
 
 .. |fadd| mathdef:: \xref{exec/numerics}{op-fadd}{\F{fadd}}
 .. |fsub| mathdef:: \xref{exec/numerics}{op-fsub}{\F{fsub}}
@@ -1079,6 +1195,8 @@
 .. |fgt| mathdef:: \xref{exec/numerics}{op-fgt}{\F{fgt}}
 .. |fle| mathdef:: \xref{exec/numerics}{op-fle}{\F{fle}}
 .. |fge| mathdef:: \xref{exec/numerics}{op-fge}{\F{fge}}
+.. |fpmin| mathdef:: \xref{exec/numerics}{op-fpmin}{\F{fpmin}}
+.. |fpmax| mathdef:: \xref{exec/numerics}{op-fpmax}{\F{fpmax}}
 
 .. |extend| mathdef:: \xref{exec/numerics}{op-extend_u}{\F{extend}}
 .. |extendu| mathdef:: \xref{exec/numerics}{op-extend_u}{\F{extend}^{\K{u}}}
@@ -1093,6 +1211,9 @@
 .. |convertu| mathdef:: \xref{exec/numerics}{op-convert_u}{\F{convert}^{\K{u}}}
 .. |converts| mathdef:: \xref{exec/numerics}{op-convert_s}{\F{convert}^{\K{s}}}
 .. |reinterpret| mathdef:: \xref{exec/numerics}{op-reinterpret}{\F{reinterpret}}
+.. |narrow| mathdef:: \xref{exec/numerics}{op-narrow_u}{\F{narrow}}
+.. |narrowu| mathdef:: \xref{exec/numerics}{op-narrow_u}{\F{narrow}^{\K{u}}}
+.. |narrows| mathdef:: \xref{exec/numerics}{op-narrow_s}{\F{narrow}^{\K{s}}}
 
 
 .. Numerics, meta functions
@@ -1110,6 +1231,10 @@
 .. |ieee| mathdef:: \xref{exec/numerics}{aux-ieee}{\F{float}}
 .. |nans| mathdef:: \xref{exec/numerics}{aux-nans}{\F{nans}}
 .. |trunc| mathdef:: \xref{exec/numerics}{aux-trunc}{\F{trunc}}
+.. |satu| mathdef:: \xref{exec/numerics}{aux-sat_u}{\F{sat}^{\K{u}}}
+.. |sats| mathdef:: \xref{exec/numerics}{aux-sat_s}{\F{sat}^{\K{s}}}
+
+.. |lanes| mathdef:: \xref{exec/numerics}{aux-lanes}{\F{lanes}}
 
 
 .. Other meta functions
diff --git a/document/core/util/mathjax2katex.py b/document/core/util/mathjax2katex.py
index f9e709f80..fabd08283 100755
--- a/document/core/util/mathjax2katex.py
+++ b/document/core/util/mathjax2katex.py
@@ -106,7 +106,7 @@ def ReplaceMath(cache, data):
         break
       data = data[:start] + v.replace('#1', data[start+len(k):end]) + data[end:]
   p = subprocess.Popen(
-      ['node', os.path.join(SCRIPT_DIR, 'katex/cli.js'), '--display-mode'],
+      ['node', os.path.join(SCRIPT_DIR, 'katex/cli.js'), '--display-mode', '--trust'],
       stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
   ret = p.communicate(input=data)[0]
   if p.returncode != 0:
@@ -160,19 +160,6 @@ def ExtractMath(match):
   data = data.replace(
       '<li class="nav-item nav-item-0"><a href="index.html#document-index">'
       'WebAssembly 1.0</a> »', '')
-  # Drop Index links.
-  data = data.replace(
-      '<li><a class="reference internal" href="index.html#index-type">'
-      '<span class="std std-ref">Index of Types</span></a>', '')
-  data = data.replace(
-      '<li><a class="reference internal" href="index.html#index-instr">'
-      '<span class="std std-ref">Index of Instructions</span></a>', '')
-  data = data.replace(
-      '<li><a class="reference internal" href="index.html#index-rules">'
-      '<span class="std std-ref">Index of Semantic Rules</span></a>', '')
-  data = data.replace(
-      '<li><a class="reference internal" href="genindex.html">'
-      '<span class="std std-ref">Index</span></a>', '')
   # Drop sphinx css.
   data = data.replace(
       '<link href="_static/classic.css" rel="stylesheet" type="text/css">', '')
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 2626650d2..4d725c633 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -230,6 +230,342 @@ Reference Instructions
      C \vdashinstr \REFASNONNULL : [(\REF~\NULL~\X{ht})] \to [(\REF~\X{ht})]
    }
 
+.. index:: vector instruction
+   pair: validation; instruction
+   single: abstract syntax; instruction
+
+.. _valid-instr-vec:
+.. _aux-unpacked:
+
+Vector Instructions
+~~~~~~~~~~~~~~~~~~~
+
+Vector instructions can have a prefix to describe the :ref:`shape <syntax-vec-shape>` of the operand. Packed numeric types, |I8| and |I16|, are not :ref:`value type <syntax-valtype>`, we define an auxiliary function to map such packed types into value types:
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \unpacked(\K{i8x16}) &=& \I32 \\
+   \unpacked(\K{i16x8}) &=& \I32 \\
+   \unpacked(t\K{x}N) &=& t
+   \end{array}
+
+
+We also define an auxiliary function to get number of packed numeric types in a |V128|, *dimension*:
+
+.. _aux-dim:
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \dim(t\K{x}N) &=& N
+   \end{array}
+
+
+.. _valid-vconst:
+
+:math:`\V128\K{.}\VCONST~c`
+...........................
+
+* The instruction is valid with type :math:`[] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \V128\K{.}\VCONST~c : [] \to [\V128]
+   }
+
+
+.. _valid-vvunop:
+
+:math:`\V128\K{.}\vvunop`
+.........................
+
+* The instruction is valid with type :math:`[\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \V128\K{.}\vvunop : [\V128] \to [\V128]
+   }
+
+
+.. _valid-vvbinop:
+
+:math:`\V128\K{.}\vvbinop`
+..........................
+
+* The instruction is valid with type :math:`[\V128~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \V128\K{.}\vvbinop : [\V128~\V128] \to [\V128]
+   }
+
+
+.. _valid-vvternop:
+
+:math:`\V128\K{.}\vvternop`
+...........................
+
+* The instruction is valid with type :math:`[\V128~\V128~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \V128\K{.}\vvternop : [\V128~\V128~\V128] \to [\V128]
+   }
+
+
+.. _valid-vvtestop:
+
+:math:`\V128\K{.}\vvtestop`
+...........................
+
+* The instruction is valid with type :math:`[\V128] \to [\I32]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \V128\K{.}\vvtestop : [\V128] \to [\I32]
+   }
+
+
+.. _valid-vec-swizzle:
+
+:math:`\K{i8x16.}\SWIZZLE`
+..........................
+
+* The instruction is valid with type :math:`[\V128~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \K{i8x16.}\SWIZZLE : [\V128~\V128] \to [\V128]
+   }
+
+
+.. _valid-vec-shuffle:
+
+:math:`\K{i8x16.}\SHUFFLE~\laneidx^{16}`
+........................................
+
+* For all :math:`\laneidx_i`, in :math:`\laneidx^{16}`, :math:`\laneidx_i` must be smaller than :math:`32`.
+
+* The instruction is valid with type :math:`[\V128~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+     (\laneidx < 32)^{16}
+   }{
+     C \vdashinstr \K{i8x16.}\SHUFFLE~\laneidx^{16} : [\V128~\V128] \to [\V128]
+   }
+
+
+.. _valid-vec-splat:
+
+:math:`\shape\K{.}\SPLAT`
+.........................
+
+* Let :math:`t` be :math:`\unpacked(\shape)`.
+
+* The instruction is valid with type :math:`[t] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \shape\K{.}\SPLAT : [\unpacked(\shape)] \to [\V128]
+   }
+
+
+.. _valid-vec-extract_lane:
+
+:math:`\shape\K{.}\EXTRACTLANE\K{\_}\sx^?~\laneidx`
+...................................................
+
+* The lane index :math:`\laneidx` must be smaller than :math:`\dim(\shape)`.
+
+* The instruction is valid with type :math:`[\V128] \to [\unpacked(\shape)]`.
+
+.. math::
+   \frac{
+     \laneidx < \dim(\shape)
+   }{
+     C \vdashinstr t\K{x}N\K{.}\EXTRACTLANE\K{\_}\sx^?~\laneidx : [\V128] \to [\unpacked(\shape)]
+   }
+
+
+.. _valid-vec-replace_lane:
+
+:math:`\shape\K{.}\REPLACELANE~\laneidx`
+........................................
+
+* The lane index :math:`\laneidx` must be smaller than :math:`\dim(\shape)`.
+
+* Let :math:`t` be :math:`\unpacked(\shape)`.
+
+* The instruction is valid with type :math:`[\V128~t] \to [\V128]`.
+
+.. math::
+   \frac{
+     \laneidx < \dim(\shape)
+   }{
+     C \vdashinstr \shape\K{.}\REPLACELANE~\laneidx : [\V128~\unpacked(\shape)] \to [\V128]
+   }
+
+
+.. _valid-vunop:
+
+:math:`\shape\K{.}\vunop`
+.........................
+
+* The instruction is valid with type :math:`[\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \shape\K{.}\vunop : [\V128] \to [\V128]
+   }
+
+
+.. _valid-vbinop:
+
+:math:`\shape\K{.}\vbinop`
+..........................
+
+* The instruction is valid with type :math:`[\V128~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \shape\K{.}\vbinop : [\V128~\V128] \to [\V128]
+   }
+
+
+.. _valid-vrelop:
+
+:math:`\shape\K{.}\vrelop`
+..........................
+
+* The instruction is valid with type :math:`[\V128~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \shape\K{.}\vrelop : [\V128~\V128] \to [\V128]
+   }
+
+
+.. _valid-vishiftop:
+
+:math:`\ishape\K{.}\vishiftop`
+..............................
+
+* The instruction is valid with type :math:`[\V128~\I32] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \ishape\K{.}\vishiftop : [\V128~\I32] \to [\V128]
+   }
+
+
+.. _valid-vtestop:
+
+:math:`\shape\K{.}\vtestop`
+...........................
+
+* The instruction is valid with type :math:`[\V128] \to [\I32]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \shape\K{.}\vtestop : [\V128] \to [\I32]
+   }
+
+
+.. _valid-vcvtop:
+
+:math:`\shape\K{.}\vcvtop\K{\_}\half^?\K{\_}\shape\K{\_}\sx^?\K{\_zero}^?`
+..........................................................................
+
+* The instruction is valid with type :math:`[\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \shape\K{.}\vcvtop\K{\_}\half^?\K{\_}\shape\K{\_}\sx^?\K{\_zero}^? : [\V128] \to [\V128]
+   }
+
+
+.. _valid-vec-narrow:
+
+:math:`\ishape_1\K{.}\NARROW\K{\_}\ishape_2\K{\_}\sx`
+.....................................................
+
+* The instruction is valid with type :math:`[\V128~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \ishape_1\K{.}\NARROW\K{\_}\ishape_2\K{\_}\sx : [\V128~\V128] \to [\V128]
+   }
+
+
+.. _valid-vec-bitmask:
+
+:math:`\ishape\K{.}\BITMASK`
+............................
+
+* The instruction is valid with type :math:`[\V128] \to [\I32]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \ishape\K{.}\BITMASK : [\V128] \to [\I32]
+   }
+
+
+.. _valid-vec-dot:
+
+:math:`\ishape_1\K{.}\DOT\K{\_}\ishape_2\K{\_s}`
+................................................
+
+* The instruction is valid with type :math:`[\V128~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \ishape_1\K{.}\DOT\K{\_}\ishape_2\K{\_s} : [\V128~\V128] \to [\V128]
+   }
+
+
+.. _valid-vec-extmul:
+
+:math:`\ishape_1\K{.}\EXTMUL\K{\_}\half\K{\_}\ishape_2\K{\_}\sx`
+................................................................
+
+* The instruction is valid with type :math:`[\V128~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \ishape_1\K{.}\EXTMUL\K{\_}\half\K{\_}\ishape_2\K{\_}\sx : [\V128~\V128] \to [\V128]
+   }
+
+
+.. _valid-vec-extadd_pairwise:
+
+:math:`\ishape_1\K{.}\EXTADDPAIRWISE\K{\_}\ishape_2\K{\_}\sx`
+.............................................................
+
+* The instruction is valid with type :math:`[\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+   }{
+     C \vdashinstr \ishape_1\K{.}\EXTADDPAIRWISE\K{\_}\ishape_2\K{\_}\sx : [\V128] \to [\V128]
+   }
+
 
 .. index:: parametric instructions, value type, polymorphism
    pair: validation; instruction
@@ -257,7 +593,6 @@ Parametric Instructions
    Both |DROP| and |SELECT| without annotation are :ref:`value-polymorphic <polymorphism>` instructions.
 
 
-
 .. _valid-select:
 
 :math:`\SELECT~(t^\ast)^?`
@@ -273,7 +608,7 @@ Parametric Instructions
 
 * Else:
 
-  * The instruction is valid with type :math:`[t~t~\I32] \to [t]`, for any :ref:`valid <valid-valtype>` :ref:`value type <syntax-valtype>` :math:`t` that :ref:`matches <match-valtype>` some :ref:`number type <syntax-numtype>`.
+  * The instruction is valid with type :math:`[t~t~\I32] \to [t]`, for any :ref:`valid <valid-valtype>` :ref:`value type <syntax-valtype>` :math:`t` that :ref:`matches <match-valtype>` some :ref:`number type <syntax-numtype>` or :ref:`vector type <syntax-vectype>`.
 
 .. math::
    \frac{
@@ -289,6 +624,12 @@ Parametric Instructions
    }{
      C \vdashinstr \SELECT : [t~t~\I32] \to [t]
    }
+   \qquad
+   \frac{
+     \vdash t \leq \vectype
+   }{
+     C \vdashinstr \SELECT : [t~t~\I32] \to [t]
+   }
 
 .. note::
    In future versions of WebAssembly, |SELECT| may allow more than one value per choice.
@@ -666,6 +1007,118 @@ Memory Instructions
    }
 
 
+.. _valid-load-extend:
+
+:math:`\K{v128.}\LOAD{N}\K{x}M\_\sx~\memarg`
+...............................................
+
+* The memory :math:`C.\CMEMS[0]` must be defined in the context.
+
+* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than :math:`N/8 \cdot M`.
+
+* Then the instruction is valid with type :math:`[\I32] \to [\V128]`.
+
+.. math::
+   \frac{
+     C.\CMEMS[0] = \memtype
+     \qquad
+     2^{\memarg.\ALIGN} \leq N/8 \cdot M
+   }{
+     C \vdashinstr \K{v128.}\K{.}\LOAD{N}\K{x}M\_\sx~\memarg : [\I32] \to [\V128]
+   }
+
+
+.. _valid-load-splat:
+
+:math:`\K{v128.}\LOAD{N}\K{\_splat}~\memarg`
+...............................................
+
+* The memory :math:`C.\CMEMS[0]` must be defined in the context.
+
+* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than :math:`N/8`.
+
+* Then the instruction is valid with type :math:`[\I32] \to [\V128]`.
+
+.. math::
+   \frac{
+     C.\CMEMS[0] = \memtype
+     \qquad
+     2^{\memarg.\ALIGN} \leq N/8
+   }{
+     C \vdashinstr \K{v128.}\LOAD{N}\K{\_splat}~\memarg : [\I32] \to [\V128]
+   }
+
+
+.. _valid-load-zero:
+
+:math:`\K{v128.}\LOAD{N}\K{\_zero}~\memarg`
+...........................................
+
+* The memory :math:`C.\CMEMS[0]` must be defined in the context.
+
+* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than :math:`N/8`.
+
+* Then the instruction is valid with type :math:`[\I32] \to [\V128]`.
+
+.. math::
+   \frac{
+     C.\CMEMS[0] = \memtype
+     \qquad
+     2^{\memarg.\ALIGN} \leq N/8
+   }{
+     C \vdashinstr \K{v128.}\LOAD{N}\K{\_zero}~\memarg : [\I32] \to [\V128]
+   }
+
+
+.. _valid-load-lane:
+
+:math:`\K{v128.}\LOAD{N}\K{\_lane}~\memarg~\laneidx`
+....................................................
+
+* The lane index :math:`\laneidx` must be smaller than :math:`128/N`.
+
+* The memory :math:`C.\CMEMS[0]` must be defined in the context.
+
+* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than :math:`N/8`.
+
+* Then the instruction is valid with type :math:`[\I32~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+     \laneidx < 128/N
+     \qquad
+     C.\CMEMS[0] = \memtype
+     \qquad
+     2^{\memarg.\ALIGN} < N/8
+   }{
+     C \vdashinstr \K{v128.}\LOAD{N}\K{\_lane}~\memarg~\laneidx : [\I32~\V128] \to [\V128]
+   }
+
+.. _valid-store-lane:
+
+:math:`\K{v128.}\STORE{N}\K{\_lane}~\memarg~\laneidx`
+.....................................................
+
+* The lane index :math:`\laneidx` must be smaller than :math:`128/N`.
+
+* The memory :math:`C.\CMEMS[0]` must be defined in the context.
+
+* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than :math:`N/8`.
+
+* Then the instruction is valid with type :math:`[\I32~\V128] \to [\V128]`.
+
+.. math::
+   \frac{
+     \laneidx < 128/N
+     \qquad
+     C.\CMEMS[0] = \memtype
+     \qquad
+     2^{\memarg.\ALIGN} < N/8
+   }{
+     C \vdashinstr \K{v128.}\STORE{N}\K{\_lane}~\memarg~\laneidx : [\I32~\V128] \to []
+   }
+
+
 .. _valid-memory.size:
 
 :math:`\MEMORYSIZE`
@@ -955,8 +1408,6 @@ Control Instructions
 
 * The label :math:`C.\CLABELS[l_N]` must be defined in the context.
 
-* Let :math:`[t^\ast]` be the :ref:`result type <syntax-resulttype>` :math:`C.\CLABELS[l_N]`.
-
 * For all :math:`l_i` in :math:`l^\ast`,
   the label :math:`C.\CLABELS[l_i]` must be defined in the context.
 
diff --git a/document/core/valid/types.rst b/document/core/valid/types.rst
index 7db800d17..0b48eed46 100644
--- a/document/core/valid/types.rst
+++ b/document/core/valid/types.rst
@@ -24,6 +24,23 @@ Number Types
    }
 
 
+.. index:: vector type
+   pair: validation; vector type
+   single: abstract syntax; vector type
+.. _valid-vectype:
+
+Vector Types
+~~~~~~~~~~~~
+
+:ref:`Vector types <syntax-vectype>` are always valid.
+
+.. math::
+   \frac{
+   }{
+     C \vdashvectype \vectype \ok
+   }
+
+
 .. index:: heap type
    pair: validation; heap type
    single: abstract syntax; heap type
diff --git a/document/deploy.sh b/document/deploy.sh
index 66bba483e..9c86b2600 100755
--- a/document/deploy.sh
+++ b/document/deploy.sh
@@ -177,7 +177,7 @@ incremental_deploy() {
 		0) echo No changes to files in $deploy_directory. Skipping commit.;;
 		1) commit_and_push;;
 		*)
-			echo git diff exited with code $diff. Aborting. Staying on branch $deploy_branch so you can debug. To switch back to master, use: git symbolic-ref HEAD refs/heads/master && git reset --mixed >&2
+			echo git diff exited with code $diff. Aborting. Staying on branch $deploy_branch so you can debug. To switch back to main, use: git symbolic-ref HEAD refs/heads/main && git reset --mixed >&2
 			return $diff
 			;;
 	esac
diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index ff36c930c..1c6e2ce90 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -52,7 +52,6 @@ urlPrefix: https://tc39.github.io/ecma262/; spec: ECMASCRIPT
         url: sec-well-known-intrinsic-objects
             text: %ErrorPrototype%
         text: %ObjectPrototype%; url: sec-properties-of-the-object-prototype-object
-        text: %FunctionPrototype%; url: sec-properties-of-the-function-prototype-object
         text: %Promise%; url: sec-promise-constructor
         text: Property Descriptor; url: sec-property-descriptor-specification-type
         text: array index; url: sec-array-exotic-objects
@@ -110,6 +109,7 @@ urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: df
         text: i32.const
         text: f32.const
         text: f64.const
+        text: v128.const
         text: ref.null
         text: ref.func
         text: ref.extern
@@ -154,6 +154,7 @@ urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: df
         text: i64
         text: f32
         text: f64
+        text: v128
     url: syntax/types.html#syntax-reftype
         text: reftype
         text: funcref
@@ -372,6 +373,8 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
                     1. Throw a {{LinkError}} exception.
                 1. If |valtype| is not [=i64=] and [=Type=](|v|) is BigInt,
                     1. Throw a {{LinkError}} exception.
+                1. If |valtype| is [=v128=],
+                    1. Throw a {{LinkError}} exception.
                 1. Let |value| be [=ToWebAssemblyValue=](|v|, |valtype|).
                 1. Let |store| be the [=surrounding agent=]'s [=associated store=].
                 1. Let (|store|, |globaladdr|) be [=global_alloc=](|store|, [=const=] |valtype|, |value|).
@@ -839,6 +842,7 @@ enum ValueType {
   "i64",
   "f32",
   "f64",
+  "v128",
   "externref",
   "anyfunc",
 };
@@ -890,6 +894,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. If |s| equals "i64", return [=i64=].
     1. If |s| equals "f32", return [=f32=].
     1. If |s| equals "f64", return [=f64=].
+    1. If |s| equals "v128", return [=v128=].
     1. If |s| equals "anyfunc", return [=funcref=].
     1. If |s| equals "externref", return [=externref=].
     1. Assert: This step is not reached.
@@ -910,6 +915,8 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     The <dfn constructor for="Global">Global(|descriptor|, |v|)</dfn> constructor, when invoked, performs the following steps:
     1. Let |mutable| be |descriptor|["mutable"].
     1. Let |valuetype| be [=ToValueType=](|descriptor|["value"]).
+    1. If |valuetype| is [=v128=],
+        1. Throw a {{LinkError}} exception.
     1. If |v| is missing,
         1. Let |value| be [=DefaultValue=](|valuetype|).
     1. Otherwise,
@@ -925,6 +932,8 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     The algorithm <dfn>GetGlobalValue</dfn>({{Global}} |global|) performs the following steps:
     1. Let |store| be the current agent's [=associated store=].
     1. Let |globaladdr| be |global|.\[[Global]].
+    1. Let |globaltype| be [=global_type=](|store|, |globaladdr|).
+    1. If |globaltype| is of the form <var ignore>mut</var> [=v128=], throw a {{TypeError}}.
     1. Let |value| be [=global_read=](|store|, |globaladdr|).
     1. Return [=ToJSValue=](|value|).
 </div>
@@ -937,6 +946,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. Let |store| be the current agent's [=associated store=].
     1. Let |globaladdr| be **this**.\[[Global]].
     1. Let |mut| |valuetype| be [=global_type=](|store|, |globaladdr|).
+    1. If |valuetype| is [=v128=], throw a {{TypeError}}.
     1. If |mut| is [=const=], throw a {{TypeError}}.
     1. Let |value| be [=ToWebAssemblyValue=](**the given value**, |valuetype|).
     1. Let |store| be [=global_write=](|store|, |globaladdr|, |value|).
@@ -978,15 +988,13 @@ This slot holds a [=function address=] relative to the [=surrounding agent=]'s [
         1. Return |map|[|funcaddr|].
     1. Let |steps| be "[=call an Exported Function|call the Exported Function=] |funcaddr| with arguments."
     1. Let |realm| be the [=current Realm=].
-    1. Let |function| be [=CreateBuiltinFunction=](|realm|, |steps|, [=%FunctionPrototype%=], &laquo; \[[FunctionAddress]] &raquo;).
-    1. Set |function|.\[[FunctionAddress]] to |funcaddr|.
     1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let |functype| be [=func_type=](|store|, |funcaddr|).
     1. Let [|paramTypes|] → [<var ignore>resultTypes</var>] be |functype|.
     1. Let |arity| be |paramTypes|'s [=list/size=].
-    1. Perform ! [=SetFunctionLength=](|function|, |arity|).
     1. Let |name| be the [=name of the WebAssembly function=] |funcaddr|.
-    1. Perform ! [=SetFunctionName=](|function|, |name|).
+    1. Let |function| be [=!=] [=CreateBuiltinFunction=](|steps|, |arity|, |name|, « \[[FunctionAddress]] », |realm|).
+    1. Set |function|.\[[FunctionAddress]] to |funcaddr|.
     1. [=map/Set=] |map|[|funcaddr|] to |function|.
     1. Return |function|.
 </div>
@@ -997,6 +1005,9 @@ This slot holds a [=function address=] relative to the [=surrounding agent=]'s [
     1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let |functype| be [=func_type=](|store|, |funcaddr|).
     1. Let [|parameters|] → [<var ignore>results</var>] be |functype|.
+    1. If |parameters| or |results| contain [=v128=], throw a {{TypeError}}.
+
+        Note: the above error is thrown each time the \[[Call]] method is invoked.
     1. Let |args| be « ».
     1. Let |i| be 0.
     1. [=list/iterate|For each=] |t| of |parameters|,
@@ -1025,6 +1036,7 @@ Note: Exported Functions do not have a \[[Construct]] method and thus it is not
   To <dfn>run a host function</dfn> from the JavaScript object |func|, type |functype|, and [=list=] of [=WebAssembly values=] |arguments|, perform the following steps:
 
     1. Let [<var ignore>parameters</var>] → [|results|] be |functype|.
+    1. If |parameters| or |results| contain [=v128=], throw a {{TypeError}}.
     1. Let |jsArguments| be « ».
     1. [=list/iterate|For each=] |arg| of |arguments|,
         1. [=list/Append=] ! [=ToJSValue=](|arg|) to |jsArguments|.
@@ -1068,6 +1080,7 @@ Note: Exported Functions do not have a \[[Construct]] method and thus it is not
 <div algorithm>
 The algorithm <dfn>ToJSValue</dfn>(|w|) coerces a [=WebAssembly value=] to a JavaScript value by performing the following steps:
 
+1. Assert: |w| is not of  the form [=v128.const=] <var ignore>v128</var>.
 1. If |w| is of the form [=i64.const=] |i64|,
     1. Let |v| be [=signed_64=](|i64|).
     1. Return a [=BigInt=] representing the mathematical value |v|.
@@ -1094,6 +1107,7 @@ For <dfn>retrieving an extern value</dfn> from an [=extern address=] |externaddr
 <div algorithm>
 The algorithm <dfn>ToWebAssemblyValue</dfn>(|v|, |type|) coerces a JavaScript value to a [=WebAssembly value=] by performing the following steps:
 
+1. Assert: |type| is not [=v128=].
 1. If |type| is [=i64=],
     1. Let |i64| be ? [=ToBigInt64=](|v|).
     1. Return [=i64.const=] |i64|.
diff --git a/interpreter/Makefile b/interpreter/Makefile
index 175a9493a..4ff333d17 100644
--- a/interpreter/Makefile
+++ b/interpreter/Makefile
@@ -17,7 +17,7 @@ ZIP =		$(NAME).zip
 JSLIB =		wast.js
 WINMAKE =	winmake.bat
 
-DIRS =		util syntax binary text valid runtime exec script host main
+DIRS =		util syntax binary text valid runtime exec script host main tests
 LIBS =		bigarray
 FLAGS = 	-lexflags -ml -cflags '-w +a-4-27-42-44-45 -warn-error +a-3'
 OCBA =		ocamlbuild $(FLAGS) $(DIRS:%=-I %)
@@ -27,7 +27,7 @@ JS =		# set to JS shell command to run JS tests
 
 # Main targets
 
-.PHONY:		default opt unopt libopt libunopt jslib all land zip
+.PHONY:		default opt unopt libopt libunopt jslib all land zip smallint
 
 default:	opt
 debug:		unopt
@@ -39,6 +39,7 @@ jslib:		$(JSLIB)
 all:		unopt opt libunopt libopt test
 land:		$(WINMAKE) all
 zip: 		$(ZIP)
+smallint:	smallint.native
 
 
 # Building executable
@@ -66,6 +67,12 @@ main.byte:	_tags
 main.native:	_tags
 		$(OCB) -quiet $@
 
+.PHONY:		smallint.byte smallint.native
+smallint.byte: _tags
+		$(OCB) -quiet $@
+smallint.native: _tags
+		$(OCB) -quiet $@
+
 
 # Building library
 
@@ -125,36 +132,41 @@ $(WINMAKE):	clean
 # Executing test suite
 
 TESTDIR =	../test/core
-TESTFILES =	$(shell cd $(TESTDIR); ls *.wast)
+# Skip _output directory, since that's a tmp directory, and list all other wast files.
+TESTFILES =	$(shell cd $(TESTDIR); ls *.wast; ls [a-z]*/*.wast)
 TESTS =		$(TESTFILES:%.wast=%)
 
 .PHONY:		test debugtest partest
 
-test:		$(OPT)
+test:		$(OPT) smallint
 		$(TESTDIR)/run.py --wasm `pwd`/$(OPT) $(if $(JS),--js '$(JS)',)
-debugtest:	$(UNOPT)
+		./smallint.native
+debugtest:	$(UNOPT) smallint
 		$(TESTDIR)/run.py --wasm `pwd`/$(UNOPT) $(if $(JS),--js '$(JS)',)
+		./smallint.native
 
 test/%:		$(OPT)
-		$(TESTDIR)/run.py --wasm `pwd`/$(OPT) $(if $(JS),--js '$(JS)',) $(TESTDIR)/$(@F).wast
+		$(TESTDIR)/run.py --wasm `pwd`/$(OPT) $(if $(JS),--js '$(JS)',) $(TESTDIR)/$*.wast
 debugtest/%:	$(UNOPT)
-		$(TESTDIR)/run.py --wasm `pwd`/$(UNOPT) $(if $(JS),--js '$(JS)',) $(TESTDIR)/$(@F).wast
+		$(TESTDIR)/run.py --wasm `pwd`/$(UNOPT) $(if $(JS),--js '$(JS)',) $(TESTDIR)/$*.wast
 
 run/%:		$(OPT)
-		./$(OPT) $(TESTDIR)/$(@F).wast
+		./$(OPT) $(TESTDIR)/$*.wast
 debug/%:	$(UNOPT)
-		./$(UNOPT) $(TESTDIR)/$(@F).wast
+		./$(UNOPT) $(TESTDIR)/$*.wast
 
 partest: 	$(TESTS:%=quiettest/%)
 		@echo All tests passed.
 
 quiettest/%:	$(OPT)
 		@ ( \
-		  $(TESTDIR)/run.py 2>$(@F).out --wasm `pwd`/$(OPT) $(if $(JS),--js '$(JS)',) $(@F:%=$(TESTDIR)/%.wast) && \
+		  $(TESTDIR)/run.py 2>$(@F).out --wasm `pwd`/$(OPT) $(if $(JS),--js '$(JS)',) $(TESTDIR)/$*.wast && \
 		  rm $(@F).out \
 		) || \
 		cat $(@F).out || rm $(@F).out || exit 1
 
+smallinttest:	smallint
+		@./smallint.native
 
 # Miscellaneous targets
 
diff --git a/interpreter/README.md b/interpreter/README.md
index 759e1afa0..e6e51329b 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -15,7 +15,7 @@ The text format defines modules in S-expression syntax. Moreover, it is generali
 
 ## Building
 
-You'll need OCaml 4.07 or higher. Instructions for installing a recent version of OCaml on multiple platforms are available [here](https://ocaml.org/docs/install.html). On most platforms, the recommended way is through [OPAM](https://ocaml.org/docs/install.html#OPAM).
+You'll need OCaml 4.08 or higher. Instructions for installing a recent version of OCaml on multiple platforms are available [here](https://ocaml.org/docs/install.html). On most platforms, the recommended way is through [OPAM](https://ocaml.org/docs/install.html#OPAM).
 
 Once you have OCaml, simply do
 
@@ -163,7 +163,7 @@ WebAssemblyText.decode(binary)
 
 ## S-Expression Syntax
 
-The implementation consumes a WebAssembly AST given in S-expression syntax. Here is an overview of the grammar of types, expressions, functions, and modules, mirroring what's described in the [design doc](https://github.com/WebAssembly/design/blob/master/Semantics.md).
+The implementation consumes a WebAssembly AST given in S-expression syntax. Here is an overview of the grammar of types, expressions, functions, and modules, mirroring what's described in the [design doc](https://github.com/WebAssembly/design/blob/main/Semantics.md).
 
 Note: The grammar is shown here for convenience, the definite source is the [specification of the text format](https://webassembly.github.io/spec/core/text/).
 ```
@@ -175,32 +175,41 @@ float:  <num>.<num>?(e|E <num>)? | 0x<hexnum>.<hexnum>?(p|P <num>)?
 name:   $(<letter> | <digit> | _ | . | + | - | * | / | \ | ^ | ~ | = | < | > | ! | ? | @ | # | $ | % | & | | | : | ' | `)+
 string: "(<char> | \n | \t | \\ | \' | \" | \<hex><hex> | \u{<hex>+})*"
 
-num: <int> | <float>
-var: <nat> | <name>
-
-unop:  ctz | clz | popcnt | ...
-binop: add | sub | mul | ...
-relop: eq | ne | lt | ...
-sign:  s | u
-offset: offset=<nat>
-align: align=(1|2|4|8|...)
-cvtop: trunc | extend | wrap | ...
-
 num_type: i32 | i64 | f32 | f64
+vec_type: v128
+vec_shape: i8x16 | i16x8 | i32x4 | i64x2 | f32x4 | f64x2 | v128
 heap_type: func | extern | (type <var>)
 ref_type:
   ( ref null? <heap_type> )
   ( ref null? <var> )         ;; = (ref null (type <var>))
   funcref                     ;; = (ref null func)
   externref                   ;; = (ref null extern)
-
-val_type: num_type | ref_type
+val_type: <num_type> | <vec_type> | <ref_type>
 block_type : ( result <val_type>* )*
 func_type:   ( type <var> )? <param>* <result>*
 global_type: <val_type> | ( mut <val_type> )
 table_type:  <nat> <nat>? <ref_type>
 memory_type: <nat> <nat>?
 
+num: <int> | <float>
+var: <nat> | <name>
+
+unop:  ctz | clz | popcnt | ...
+binop: add | sub | mul | ...
+testop: eqz
+relop: eq | ne | lt | ...
+sign:  s | u
+offset: offset=<nat>
+align: align=(1|2|4|8|...)
+cvtop: trunc | extend | wrap | ...
+vecunop: abs | neg | ...
+vecbinop: add | sub | min_<sign> | ...
+vecternop: bitselect
+vectestop: all_true | any_true
+vecrelop: eq | ne | lt | ...
+veccvtop: extend_low | extend_high | trunc_sat | ...
+vecshiftop: shl | shr_<sign>
+
 expr:
   ( <op> )
   ( <op> <expr>+ )                                                   ;; = <expr>+ (<op>)
@@ -249,6 +258,10 @@ op:
   elem.drop <var>
   <num_type>.load((8|16|32)_<sign>)? <offset>? <align>?
   <num_type>.store(8|16|32)? <offset>? <align>?
+  <vec_type>.load((8x8|16x4|32x2)_<sign>)? <offset>? <align>?
+  <vec_type>.store <offset>? <align>?
+  <vec_type>.load(8|16|32|64)_(lane|splat|zero) <offset>? <align>?
+  <vec_type>.store(8|16|32|64)_lane <offset>? <align>?
   memory.size
   memory.grow
   memory.fill
@@ -259,12 +272,24 @@ op:
   ref.is_null <heap_type>
   ref_as_non_null <heap_type>
   ref.func <var>
-  <num_type>.const <value>
+  <num_type>.const <num>
   <num_type>.<unop>
   <num_type>.<binop>
   <num_type>.<testop>
   <num_type>.<relop>
   <num_type>.<cvtop>_<num_type>(_<sign>)?
+  <vec_type>.const <vec_shape> <num>+
+  <vec_shape>.<vecunop>
+  <vec_shape>.<vecbinop>
+  <vec_shape>.<vecternop>
+  <vec_shape>.<vectestop>
+  <vec_shape>.<vecrelop>
+  <vec_shape>.<veccvtop>_<vec_shape>(_<sign>)?(_<zero>)?
+  <vec_shape>.<vecshiftop>
+  <vec_shape>.bitmask
+  <vec_shape>.splat
+  <vec_shape>.extract_lane(_<sign>)? <nat>
+  <vec_shape>.replace_lane <nat>
 
 func:    ( func <name>? <func_type> <local>* <instr>* )
          ( func <name>? ( export <string> ) <...> )                         ;; = (export <string> (func <N>)) (func <name>? <...>)
@@ -364,8 +389,9 @@ action:
 
 const:
   ( <num_type>.const <num> )                 ;; number value
+  ( <vec_type> <vec_shape> <num>+ )          ;; vector value
   ( ref.null <ref_kind> )                    ;; null reference
-  ( ref.host <nat> )                         ;; host reference
+  ( ref.extern <nat> )                       ;; host reference
 
 assertion:
   ( assert_return <action> <result_pat>* )   ;; assert action has expected results
@@ -378,12 +404,13 @@ assertion:
 
 result_pat:
   ( <num_type>.const <num_pat> )
+  ( <vec_type>.const <vec_shape> <num_pat>+ )
   ( ref.extern )
   ( ref.func )
   ( ref.null )
 
 num_pat:
-  <value>                                    ;; literal result
+  <num>                                      ;; literal result
   nan:canonical                              ;; NaN in canonical form
   nan:arithmetic                             ;; NaN with 1 in MSB of payload
 
@@ -432,7 +459,7 @@ When running scripts, the interpreter predefines a simple host module named `"sp
   (func (export "print_f64_f64") (param f64 f64))
 )
 ```
-The `print` functions are assumes to print their respective argument values to stdout (followed by a newline) and can be used to produce observable output.
+The `print` functions are assumed to print their respective argument values to stdout (followed by a newline) and can be used to produce observable output.
 
 Note: This module predates the `register` command and should no longer be needed for new tests.
 We might remove it in the future, so consider it deprecated.
@@ -493,7 +520,7 @@ Moreover, float values are required to be precise, that is, they may not contain
 
 ## Abstract Syntax
 
-The abstract WebAssembly syntax, as described above and in the [design doc](https://github.com/WebAssembly/design/blob/master/Semantics.md), is defined in [ast.ml](syntax/ast.ml).
+The abstract WebAssembly syntax, as described above and in the [design doc](https://github.com/WebAssembly/design/blob/main/Semantics.md), is defined in [ast.ml](syntax/ast.ml).
 
 However, to simplify the implementation, this AST representation represents some of the inner structure of the operators more explicitly. The mapping from the operators as given in the design doc to their structured form is defined in [operators.ml](syntax/operators.ml).
 
diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 471e11d76..4237c2301 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -106,6 +106,7 @@ let vs33 s = I32_convert.wrap_i64 (vsN 33 s)
 let vs64 s = vsN 64 s
 let f32 s = F32.of_bits (u32 s)
 let f64 s = F64.of_bits (u64 s)
+let v128 s = V128.of_bits (get_string (Types.vec_size Types.V128Type) s)
 
 let len32 s =
   let pos = pos s in
@@ -118,8 +119,13 @@ let string s = let n = len32 s in get_string n s
 let rec list f n s = if n = 0 then [] else let x = f s in x :: list f (n - 1) s
 let opt f b s = if b then Some (f s) else None
 let vec f s = let n = len32 s in list f n s
-let either f1 f2 s =
-  let pos = pos s in try f1 s with Code _ -> reset s pos; f2 s
+
+let rec either fs s =
+  match fs with
+  | [] -> assert false
+  | [f] -> f s
+  | f::fs' ->
+    let pos = pos s in try f s with Code _ -> reset s pos; either fs' s
 
 let name s =
   let pos = pos s in
@@ -146,6 +152,11 @@ let num_type s =
   | -0x04 -> F64Type
   | _ -> error s (pos s - 1) "malformed number type"
 
+let vec_type s =
+  match vs7 s with
+  | -0x05 -> V128Type
+  | _ -> error s (pos s - 1) "malformed vector type"
+
 let heap_type s =
   let pos = pos s in
   match peek s with
@@ -170,7 +181,11 @@ let ref_type s =
   | _ -> error s pos "malformed reference type"
 
 let value_type s =
-  either (fun s -> NumType (num_type s)) (fun s -> RefType (ref_type s)) s
+  either [
+    (fun s -> NumType (num_type s));
+    (fun s -> VecType (vec_type s));
+    (fun s -> RefType (ref_type s));
+  ] s
 
 let result_type s = vec value_type s
 
@@ -543,6 +558,271 @@ let rec instr s =
     | n -> illegal2 s pos b n
     )
 
+  | 0xfd ->
+    (match vu32 s with
+    | 0x00l -> let a, o = memop s in v128_load a o
+    | 0x01l -> let a, o = memop s in v128_load8x8_s a o
+    | 0x02l -> let a, o = memop s in v128_load8x8_u a o
+    | 0x03l -> let a, o = memop s in v128_load16x4_s a o
+    | 0x04l -> let a, o = memop s in v128_load16x4_u a o
+    | 0x05l -> let a, o = memop s in v128_load32x2_s a o
+    | 0x06l -> let a, o = memop s in v128_load32x2_u a o
+    | 0x07l -> let a, o = memop s in v128_load8_splat a o
+    | 0x08l -> let a, o = memop s in v128_load16_splat a o
+    | 0x09l -> let a, o = memop s in v128_load32_splat a o
+    | 0x0al -> let a, o = memop s in v128_load64_splat a o
+    | 0x0bl -> let a, o = memop s in v128_store a o
+    | 0x0cl -> v128_const (at v128 s)
+    | 0x0dl -> i8x16_shuffle (List.init 16 (fun x -> u8 s))
+    | 0x0el -> i8x16_swizzle
+    | 0x0fl -> i8x16_splat
+    | 0x10l -> i16x8_splat
+    | 0x11l -> i32x4_splat
+    | 0x12l -> i64x2_splat
+    | 0x13l -> f32x4_splat
+    | 0x14l -> f64x2_splat
+    | 0x15l -> let i = u8 s in i8x16_extract_lane_s i
+    | 0x16l -> let i = u8 s in i8x16_extract_lane_u i
+    | 0x17l -> let i = u8 s in i8x16_replace_lane i
+    | 0x18l -> let i = u8 s in i16x8_extract_lane_s i
+    | 0x19l -> let i = u8 s in i16x8_extract_lane_u i
+    | 0x1al -> let i = u8 s in i16x8_replace_lane i
+    | 0x1bl -> let i = u8 s in i32x4_extract_lane i
+    | 0x1cl -> let i = u8 s in i32x4_replace_lane i
+    | 0x1dl -> let i = u8 s in i64x2_extract_lane i
+    | 0x1el -> let i = u8 s in i64x2_replace_lane i
+    | 0x1fl -> let i = u8 s in f32x4_extract_lane i
+    | 0x20l -> let i = u8 s in f32x4_replace_lane i
+    | 0x21l -> let i = u8 s in f64x2_extract_lane i
+    | 0x22l -> let i = u8 s in f64x2_replace_lane i
+    | 0x23l -> i8x16_eq
+    | 0x24l -> i8x16_ne
+    | 0x25l -> i8x16_lt_s
+    | 0x26l -> i8x16_lt_u
+    | 0x27l -> i8x16_gt_s
+    | 0x28l -> i8x16_gt_u
+    | 0x29l -> i8x16_le_s
+    | 0x2al -> i8x16_le_u
+    | 0x2bl -> i8x16_ge_s
+    | 0x2cl -> i8x16_ge_u
+    | 0x2dl -> i16x8_eq
+    | 0x2el -> i16x8_ne
+    | 0x2fl -> i16x8_lt_s
+    | 0x30l -> i16x8_lt_u
+    | 0x31l -> i16x8_gt_s
+    | 0x32l -> i16x8_gt_u
+    | 0x33l -> i16x8_le_s
+    | 0x34l -> i16x8_le_u
+    | 0x35l -> i16x8_ge_s
+    | 0x36l -> i16x8_ge_u
+    | 0x37l -> i32x4_eq
+    | 0x38l -> i32x4_ne
+    | 0x39l -> i32x4_lt_s
+    | 0x3al -> i32x4_lt_u
+    | 0x3bl -> i32x4_gt_s
+    | 0x3cl -> i32x4_gt_u
+    | 0x3dl -> i32x4_le_s
+    | 0x3el -> i32x4_le_u
+    | 0x3fl -> i32x4_ge_s
+    | 0x40l -> i32x4_ge_u
+    | 0x41l -> f32x4_eq
+    | 0x42l -> f32x4_ne
+    | 0x43l -> f32x4_lt
+    | 0x44l -> f32x4_gt
+    | 0x45l -> f32x4_le
+    | 0x46l -> f32x4_ge
+    | 0x47l -> f64x2_eq
+    | 0x48l -> f64x2_ne
+    | 0x49l -> f64x2_lt
+    | 0x4al -> f64x2_gt
+    | 0x4bl -> f64x2_le
+    | 0x4cl -> f64x2_ge
+    | 0x4dl -> v128_not
+    | 0x4el -> v128_and
+    | 0x4fl -> v128_andnot
+    | 0x50l -> v128_or
+    | 0x51l -> v128_xor
+    | 0x52l -> v128_bitselect
+    | 0x53l -> v128_any_true
+    | 0x54l ->
+      let a, o = memop s in
+      let lane = u8 s in
+      v128_load8_lane a o lane
+    | 0x55l ->
+      let a, o = memop s in
+      let lane = u8 s in
+      v128_load16_lane a o lane
+    | 0x56l ->
+      let a, o = memop s in
+      let lane = u8 s in
+      v128_load32_lane a o lane
+    | 0x57l ->
+      let a, o = memop s in
+      let lane = u8 s in
+      v128_load64_lane a o lane
+    | 0x58l ->
+      let a, o = memop s in
+      let lane = u8 s in
+      v128_store8_lane a o lane
+    | 0x59l ->
+      let a, o = memop s in
+      let lane = u8 s in
+      v128_store16_lane a o lane
+    | 0x5al ->
+      let a, o = memop s in
+      let lane = u8 s in
+      v128_store32_lane a o lane
+    | 0x5bl ->
+      let a, o = memop s in
+      let lane = u8 s in
+      v128_store64_lane a o lane
+    | 0x5cl -> let a, o = memop s in v128_load32_zero a o
+    | 0x5dl -> let a, o = memop s in v128_load64_zero a o
+    | 0x5el -> f32x4_demote_f64x2_zero
+    | 0x5fl -> f64x2_promote_low_f32x4
+    | 0x60l -> i8x16_abs
+    | 0x61l -> i8x16_neg
+    | 0x62l -> i8x16_popcnt
+    | 0x63l -> i8x16_all_true
+    | 0x64l -> i8x16_bitmask
+    | 0x65l -> i8x16_narrow_i16x8_s
+    | 0x66l -> i8x16_narrow_i16x8_u
+    | 0x67l -> f32x4_ceil
+    | 0x68l -> f32x4_floor
+    | 0x69l -> f32x4_trunc
+    | 0x6al -> f32x4_nearest
+    | 0x6bl -> i8x16_shl
+    | 0x6cl -> i8x16_shr_s
+    | 0x6dl -> i8x16_shr_u
+    | 0x6el -> i8x16_add
+    | 0x6fl -> i8x16_add_sat_s
+    | 0x70l -> i8x16_add_sat_u
+    | 0x71l -> i8x16_sub
+    | 0x72l -> i8x16_sub_sat_s
+    | 0x73l -> i8x16_sub_sat_u
+    | 0x74l -> f64x2_ceil
+    | 0x75l -> f64x2_floor
+    | 0x76l -> i8x16_min_s
+    | 0x77l -> i8x16_min_u
+    | 0x78l -> i8x16_max_s
+    | 0x79l -> i8x16_max_u
+    | 0x7al -> f64x2_trunc
+    | 0x7bl -> i8x16_avgr_u
+    | 0x7cl -> i16x8_extadd_pairwise_i8x16_s
+    | 0x7dl -> i16x8_extadd_pairwise_i8x16_u
+    | 0x7el -> i32x4_extadd_pairwise_i16x8_s
+    | 0x7fl -> i32x4_extadd_pairwise_i16x8_u
+    | 0x80l -> i16x8_abs
+    | 0x81l -> i16x8_neg
+    | 0x82l -> i16x8_q15mulr_sat_s
+    | 0x83l -> i16x8_all_true
+    | 0x84l -> i16x8_bitmask
+    | 0x85l -> i16x8_narrow_i32x4_s
+    | 0x86l -> i16x8_narrow_i32x4_u
+    | 0x87l -> i16x8_extend_low_i8x16_s
+    | 0x88l -> i16x8_extend_high_i8x16_s
+    | 0x89l -> i16x8_extend_low_i8x16_u
+    | 0x8al -> i16x8_extend_high_i8x16_u
+    | 0x8bl -> i16x8_shl
+    | 0x8cl -> i16x8_shr_s
+    | 0x8dl -> i16x8_shr_u
+    | 0x8el -> i16x8_add
+    | 0x8fl -> i16x8_add_sat_s
+    | 0x90l -> i16x8_add_sat_u
+    | 0x91l -> i16x8_sub
+    | 0x92l -> i16x8_sub_sat_s
+    | 0x93l -> i16x8_sub_sat_u
+    | 0x94l -> f64x2_nearest
+    | 0x95l -> i16x8_mul
+    | 0x96l -> i16x8_min_s
+    | 0x97l -> i16x8_min_u
+    | 0x98l -> i16x8_max_s
+    | 0x99l -> i16x8_max_u
+    | 0x9bl -> i16x8_avgr_u
+    | 0x9cl -> i16x8_extmul_low_i8x16_s
+    | 0x9dl -> i16x8_extmul_high_i8x16_s
+    | 0x9el -> i16x8_extmul_low_i8x16_u
+    | 0x9fl -> i16x8_extmul_high_i8x16_u
+    | 0xa0l -> i32x4_abs
+    | 0xa1l -> i32x4_neg
+    | 0xa3l -> i32x4_all_true
+    | 0xa4l -> i32x4_bitmask
+    | 0xa7l -> i32x4_extend_low_i16x8_s
+    | 0xa8l -> i32x4_extend_high_i16x8_s
+    | 0xa9l -> i32x4_extend_low_i16x8_u
+    | 0xaal -> i32x4_extend_high_i16x8_u
+    | 0xabl -> i32x4_shl
+    | 0xacl -> i32x4_shr_s
+    | 0xadl -> i32x4_shr_u
+    | 0xael -> i32x4_add
+    | 0xb1l -> i32x4_sub
+    | 0xb5l -> i32x4_mul
+    | 0xb6l -> i32x4_min_s
+    | 0xb7l -> i32x4_min_u
+    | 0xb8l -> i32x4_max_s
+    | 0xb9l -> i32x4_max_u
+    | 0xbal -> i32x4_dot_i16x8_s
+    | 0xbcl -> i32x4_extmul_low_i16x8_s
+    | 0xbdl -> i32x4_extmul_high_i16x8_s
+    | 0xbel -> i32x4_extmul_low_i16x8_u
+    | 0xbfl -> i32x4_extmul_high_i16x8_u
+    | 0xc0l -> i64x2_abs
+    | 0xc1l -> i64x2_neg
+    | 0xc3l -> i64x2_all_true
+    | 0xc4l -> i64x2_bitmask
+    | 0xc7l -> i64x2_extend_low_i32x4_s
+    | 0xc8l -> i64x2_extend_high_i32x4_s
+    | 0xc9l -> i64x2_extend_low_i32x4_u
+    | 0xcal -> i64x2_extend_high_i32x4_u
+    | 0xcbl -> i64x2_shl
+    | 0xccl -> i64x2_shr_s
+    | 0xcdl -> i64x2_shr_u
+    | 0xcel -> i64x2_add
+    | 0xd1l -> i64x2_sub
+    | 0xd5l -> i64x2_mul
+    | 0xd6l -> i64x2_eq
+    | 0xd7l -> i64x2_ne
+    | 0xd8l -> i64x2_lt_s
+    | 0xd9l -> i64x2_gt_s
+    | 0xdal -> i64x2_le_s
+    | 0xdbl -> i64x2_ge_s
+    | 0xdcl -> i64x2_extmul_low_i32x4_s
+    | 0xddl -> i64x2_extmul_high_i32x4_s
+    | 0xdel -> i64x2_extmul_low_i32x4_u
+    | 0xdfl -> i64x2_extmul_high_i32x4_u
+    | 0xe0l -> f32x4_abs
+    | 0xe1l -> f32x4_neg
+    | 0xe3l -> f32x4_sqrt
+    | 0xe4l -> f32x4_add
+    | 0xe5l -> f32x4_sub
+    | 0xe6l -> f32x4_mul
+    | 0xe7l -> f32x4_div
+    | 0xe8l -> f32x4_min
+    | 0xe9l -> f32x4_max
+    | 0xeal -> f32x4_pmin
+    | 0xebl -> f32x4_pmax
+    | 0xecl -> f64x2_abs
+    | 0xedl -> f64x2_neg
+    | 0xefl -> f64x2_sqrt
+    | 0xf0l -> f64x2_add
+    | 0xf1l -> f64x2_sub
+    | 0xf2l -> f64x2_mul
+    | 0xf3l -> f64x2_div
+    | 0xf4l -> f64x2_min
+    | 0xf5l -> f64x2_max
+    | 0xf6l -> f64x2_pmin
+    | 0xf7l -> f64x2_pmax
+    | 0xf8l -> i32x4_trunc_sat_f32x4_s
+    | 0xf9l -> i32x4_trunc_sat_f32x4_u
+    | 0xfal -> f32x4_convert_i32x4_s
+    | 0xfbl -> f32x4_convert_i32x4_u
+    | 0xfcl -> i32x4_trunc_sat_f64x2_s_zero
+    | 0xfdl -> i32x4_trunc_sat_f64x2_u_zero
+    | 0xfel -> f64x2_convert_low_i32x4_s
+    | 0xffl -> f64x2_convert_low_i32x4_u
+    | n -> illegal s pos (I32.to_int_u n)
+    )
+
   | b -> illegal s pos b
 
 and instr_block s = List.rev (instr_block' s [])
@@ -850,7 +1130,7 @@ let module_ s =
   iterate custom_section s;
   let datas = data_section s in
   iterate custom_section s;
-  require (pos s = len s) s (len s) "junk after last section";
+  require (pos s = len s) s (len s) "unexpected content after last section";
   require (List.length func_types = List.length func_bodies)
     s (len s) "function and code section have inconsistent lengths";
   require (data_count = None || data_count = Some (Lib.List32.length datas))
diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index 051606d9c..403e9b842 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -63,6 +63,7 @@ struct
   let vs33 i = vs64 (I64_convert.extend_i32_s i)
   let f32 x = u32 (F32.to_bits x)
   let f64 x = u64 (F64.to_bits x)
+  let v128 v = String.iter (put s) (V128.to_bits v)
 
   let len i =
     if Int32.to_int (Int32.of_int i) <> i then
@@ -101,6 +102,9 @@ struct
     | F32Type -> vs7 (-0x03)
     | F64Type -> vs7 (-0x04)
 
+  let vec_type = function
+    | V128Type -> vs7 (-0x05)
+
   let heap_type = function
     | FuncHeapType -> vs7 (-0x10)
     | ExternHeapType -> vs7 (-0x11)
@@ -115,6 +119,7 @@ struct
 
   let value_type = function
     | NumType t -> num_type t
+    | VecType t -> vec_type t
     | RefType t -> ref_type t
     | BotType -> assert false
 
@@ -146,8 +151,10 @@ struct
   open Source
   open Ast
   open Value
+  open V128
 
   let op n = u8 n
+  let vecop n = op 0xfd; vu32 n
   let end_ () = op 0x0b
 
   let memop {align; offset; _} = vu32 (Int32.of_int align); vu32 offset
@@ -212,46 +219,97 @@ struct
     | TableInit (x, y) -> op 0xfc; vu32 0x0cl; var y; var x
     | ElemDrop x -> op 0xfc; vu32 0x0dl; var x
 
-    | Load ({ty = I32Type; sz = None; _} as mo) -> op 0x28; memop mo
-    | Load ({ty = I64Type; sz = None; _} as mo) -> op 0x29; memop mo
-    | Load ({ty = F32Type; sz = None; _} as mo) -> op 0x2a; memop mo
-    | Load ({ty = F64Type; sz = None; _} as mo) -> op 0x2b; memop mo
-    | Load ({ty = I32Type; sz = Some (Pack8, SX); _} as mo) ->
+    | Load ({ty = I32Type; pack = None; _} as mo) -> op 0x28; memop mo
+    | Load ({ty = I64Type; pack = None; _} as mo) -> op 0x29; memop mo
+    | Load ({ty = F32Type; pack = None; _} as mo) -> op 0x2a; memop mo
+    | Load ({ty = F64Type; pack = None; _} as mo) -> op 0x2b; memop mo
+    | Load ({ty = I32Type; pack = Some (Pack8, SX); _} as mo) ->
       op 0x2c; memop mo
-    | Load ({ty = I32Type; sz = Some (Pack8, ZX); _} as mo) ->
+    | Load ({ty = I32Type; pack = Some (Pack8, ZX); _} as mo) ->
       op 0x2d; memop mo
-    | Load ({ty = I32Type; sz = Some (Pack16, SX); _} as mo) ->
+    | Load ({ty = I32Type; pack = Some (Pack16, SX); _} as mo) ->
       op 0x2e; memop mo
-    | Load ({ty = I32Type; sz = Some (Pack16, ZX); _} as mo) ->
+    | Load ({ty = I32Type; pack = Some (Pack16, ZX); _} as mo) ->
       op 0x2f; memop mo
-    | Load {ty = I32Type; sz = Some (Pack32, _); _} ->
+    | Load {ty = I32Type; pack = Some (Pack32, _); _} ->
       assert false
-    | Load ({ty = I64Type; sz = Some (Pack8, SX); _} as mo) ->
+    | Load ({ty = I64Type; pack = Some (Pack8, SX); _} as mo) ->
       op 0x30; memop mo
-    | Load ({ty = I64Type; sz = Some (Pack8, ZX); _} as mo) ->
+    | Load ({ty = I64Type; pack = Some (Pack8, ZX); _} as mo) ->
       op 0x31; memop mo
-    | Load ({ty = I64Type; sz = Some (Pack16, SX); _} as mo) ->
+    | Load ({ty = I64Type; pack = Some (Pack16, SX); _} as mo) ->
       op 0x32; memop mo
-    | Load ({ty = I64Type; sz = Some (Pack16, ZX); _} as mo) ->
+    | Load ({ty = I64Type; pack = Some (Pack16, ZX); _} as mo) ->
       op 0x33; memop mo
-    | Load ({ty = I64Type; sz = Some (Pack32, SX); _} as mo) ->
+    | Load ({ty = I64Type; pack = Some (Pack32, SX); _} as mo) ->
       op 0x34; memop mo
-    | Load ({ty = I64Type; sz = Some (Pack32, ZX); _} as mo) ->
+    | Load ({ty = I64Type; pack = Some (Pack32, ZX); _} as mo) ->
       op 0x35; memop mo
-    | Load {ty = F32Type | F64Type; sz = Some _; _} ->
+    | Load {ty = F32Type | F64Type; pack = Some _; _} ->
+      assert false
+    | Load {ty = I32Type | I64Type; pack = Some (Pack64, _); _} ->
       assert false
 
-    | Store ({ty = I32Type; sz = None; _} as mo) -> op 0x36; memop mo
-    | Store ({ty = I64Type; sz = None; _} as mo) -> op 0x37; memop mo
-    | Store ({ty = F32Type; sz = None; _} as mo) -> op 0x38; memop mo
-    | Store ({ty = F64Type; sz = None; _} as mo) -> op 0x39; memop mo
-    | Store ({ty = I32Type; sz = Some Pack8; _} as mo) -> op 0x3a; memop mo
-    | Store ({ty = I32Type; sz = Some Pack16; _} as mo) -> op 0x3b; memop mo
-    | Store {ty = I32Type; sz = Some Pack32; _} -> assert false
-    | Store ({ty = I64Type; sz = Some Pack8; _} as mo) -> op 0x3c; memop mo
-    | Store ({ty = I64Type; sz = Some Pack16; _} as mo) -> op 0x3d; memop mo
-    | Store ({ty = I64Type; sz = Some Pack32; _} as mo) -> op 0x3e; memop mo
-    | Store {ty = F32Type | F64Type; sz = Some _; _} -> assert false
+    | Store ({ty = I32Type; pack = None; _} as mo) -> op 0x36; memop mo
+    | Store ({ty = I64Type; pack = None; _} as mo) -> op 0x37; memop mo
+    | Store ({ty = F32Type; pack = None; _} as mo) -> op 0x38; memop mo
+    | Store ({ty = F64Type; pack = None; _} as mo) -> op 0x39; memop mo
+    | Store ({ty = I32Type; pack = Some Pack8; _} as mo) -> op 0x3a; memop mo
+    | Store ({ty = I32Type; pack = Some Pack16; _} as mo) -> op 0x3b; memop mo
+    | Store {ty = I32Type; pack = Some Pack32; _} -> assert false
+    | Store ({ty = I64Type; pack = Some Pack8; _} as mo) -> op 0x3c; memop mo
+    | Store ({ty = I64Type; pack = Some Pack16; _} as mo) -> op 0x3d; memop mo
+    | Store ({ty = I64Type; pack = Some Pack32; _} as mo) -> op 0x3e; memop mo
+    | Store {ty = F32Type | F64Type; pack = Some _; _} -> assert false
+    | Store {ty = (I32Type | I64Type); pack = Some Pack64; _} -> assert false
+
+    | VecLoad ({ty = V128Type; pack = None; _} as mo) ->
+      vecop 0x00l; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtLane (Pack8x8, SX)); _} as mo) ->
+      vecop 0x01l; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtLane (Pack8x8, ZX)); _} as mo) ->
+      vecop 0x02l; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtLane (Pack16x4, SX)); _} as mo) ->
+      vecop 0x03l; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtLane (Pack16x4, ZX)); _} as mo) ->
+      vecop 0x04l; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtLane (Pack32x2, SX)); _} as mo) ->
+      vecop 0x05l; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtLane (Pack32x2, ZX)); _} as mo) ->
+      vecop 0x06l; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack8, ExtSplat); _} as mo) ->
+      vecop 0x07l; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack16, ExtSplat); _} as mo) ->
+      vecop 0x08l; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack32, ExtSplat); _} as mo) ->
+      vecop 0x09l; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtSplat); _} as mo) ->
+      vecop 0x0al; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack32, ExtZero); _} as mo) ->
+      vecop 0x5cl; memop mo
+    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtZero); _} as mo) ->
+      vecop 0x5dl; memop mo
+    | VecLoad _ -> assert false
+
+    | VecLoadLane ({ty = V128Type; pack = Pack8; _} as mo, i) ->
+      vecop 0x54l; memop mo; u8 i;
+    | VecLoadLane ({ty = V128Type; pack = Pack16; _} as mo, i) ->
+      vecop 0x55l; memop mo; u8 i;
+    | VecLoadLane ({ty = V128Type; pack = Pack32; _} as mo, i) ->
+      vecop 0x56l; memop mo; u8 i;
+    | VecLoadLane ({ty = V128Type; pack = Pack64; _} as mo, i) ->
+      vecop 0x57l; memop mo; u8 i;
+
+    | VecStore ({ty = V128Type; _} as mo) -> vecop 0x0bl; memop mo
+
+    | VecStoreLane ({ty = V128Type; pack = Pack8; _} as mo, i) ->
+      vecop 0x58l; memop mo; u8 i;
+    | VecStoreLane ({ty = V128Type; pack = Pack16; _} as mo, i) ->
+      vecop 0x59l; memop mo; u8 i;
+    | VecStoreLane ({ty = V128Type; pack = Pack32; _} as mo, i) ->
+      vecop 0x5al; memop mo; u8 i;
+    | VecStoreLane ({ty = V128Type; pack = Pack64; _} as mo, i) ->
+      vecop 0x5bl; memop mo; u8 i;
 
     | MemorySize -> op 0x3f; u8 0x00
     | MemoryGrow -> op 0x40; u8 0x00
@@ -272,8 +330,7 @@ struct
 
     | Test (I32 I32Op.Eqz) -> op 0x45
     | Test (I64 I64Op.Eqz) -> op 0x50
-    | Test (F32 _) -> assert false
-    | Test (F64 _) -> assert false
+    | Test (F32 _ | F64 _) -> .
 
     | Compare (I32 I32Op.Eq) -> op 0x46
     | Compare (I32 I32Op.Ne) -> op 0x47
@@ -316,7 +373,7 @@ struct
     | Unary (I32 I32Op.Popcnt) -> op 0x69
     | Unary (I32 (I32Op.ExtendS Pack8)) -> op 0xc0
     | Unary (I32 (I32Op.ExtendS Pack16)) -> op 0xc1
-    | Unary (I32 (I32Op.ExtendS Pack32)) -> assert false
+    | Unary (I32 (I32Op.ExtendS (Pack32 | Pack64))) -> assert false
 
     | Unary (I64 I64Op.Clz) -> op 0x79
     | Unary (I64 I64Op.Ctz) -> op 0x7a
@@ -324,6 +381,7 @@ struct
     | Unary (I64 (I64Op.ExtendS Pack8)) -> op 0xc2
     | Unary (I64 (I64Op.ExtendS Pack16)) -> op 0xc3
     | Unary (I64 (I64Op.ExtendS Pack32)) -> op 0xc4
+    | Unary (I64 (I64Op.ExtendS Pack64)) -> assert false
 
     | Unary (F32 F32Op.Abs) -> op 0x8b
     | Unary (F32 F32Op.Neg) -> op 0x8c
@@ -431,6 +489,248 @@ struct
     | Convert (F64 F64Op.DemoteF64) -> assert false
     | Convert (F64 F64Op.ReinterpretInt) -> op 0xbf
 
+    | VecConst {it = V128 c; _} -> vecop 0x0cl; v128 c
+
+    | VecTest (V128 (I8x16 V128Op.AllTrue)) -> vecop 0x63l
+    | VecTest (V128 (I16x8 V128Op.AllTrue)) -> vecop 0x83l
+    | VecTest (V128 (I32x4 V128Op.AllTrue)) -> vecop 0xa3l
+    | VecTest (V128 (I64x2 V128Op.AllTrue)) -> vecop 0xc3l
+    | VecTest (V128 _) -> .
+
+    | VecUnary (V128 (I8x16 V128Op.Abs)) -> vecop 0x60l
+    | VecUnary (V128 (I8x16 V128Op.Neg)) -> vecop 0x61l
+    | VecUnary (V128 (I8x16 V128Op.Popcnt)) -> vecop 0x62l
+    | VecUnary (V128 (I16x8 V128Op.Abs)) -> vecop 0x80l
+    | VecUnary (V128 (I16x8 V128Op.Neg)) -> vecop 0x81l
+    | VecUnary (V128 (I16x8 V128Op.Popcnt)) -> assert false
+    | VecUnary (V128 (I32x4 V128Op.Abs)) -> vecop 0xa0l
+    | VecUnary (V128 (I32x4 V128Op.Neg)) -> vecop 0xa1l
+    | VecUnary (V128 (I32x4 V128Op.Popcnt)) -> assert false
+    | VecUnary (V128 (I64x2 V128Op.Abs)) -> vecop 0xc0l
+    | VecUnary (V128 (I64x2 V128Op.Neg)) -> vecop 0xc1l
+    | VecUnary (V128 (I64x2 V128Op.Popcnt)) -> assert false
+    | VecUnary (V128 (F32x4 V128Op.Ceil)) -> vecop 0x67l
+    | VecUnary (V128 (F32x4 V128Op.Floor)) -> vecop 0x68l
+    | VecUnary (V128 (F32x4 V128Op.Trunc)) -> vecop 0x69l
+    | VecUnary (V128 (F32x4 V128Op.Nearest)) -> vecop 0x6al
+    | VecUnary (V128 (F64x2 V128Op.Ceil)) -> vecop 0x74l
+    | VecUnary (V128 (F64x2 V128Op.Floor)) -> vecop 0x75l
+    | VecUnary (V128 (F64x2 V128Op.Trunc)) -> vecop 0x7al
+    | VecUnary (V128 (F64x2 V128Op.Nearest)) -> vecop 0x94l
+    | VecUnary (V128 (F32x4 V128Op.Abs)) -> vecop 0xe0l
+    | VecUnary (V128 (F32x4 V128Op.Neg)) -> vecop 0xe1l
+    | VecUnary (V128 (F32x4 V128Op.Sqrt)) -> vecop 0xe3l
+    | VecUnary (V128 (F64x2 V128Op.Abs)) -> vecop 0xecl
+    | VecUnary (V128 (F64x2 V128Op.Neg)) -> vecop 0xedl
+    | VecUnary (V128 (F64x2 V128Op.Sqrt)) -> vecop 0xefl
+
+    | VecCompare (V128 (I8x16 V128Op.Eq)) -> vecop 0x23l
+    | VecCompare (V128 (I8x16 V128Op.Ne)) -> vecop 0x24l
+    | VecCompare (V128 (I8x16 V128Op.LtS)) -> vecop 0x25l
+    | VecCompare (V128 (I8x16 V128Op.LtU)) -> vecop 0x26l
+    | VecCompare (V128 (I8x16 V128Op.GtS)) -> vecop 0x27l
+    | VecCompare (V128 (I8x16 V128Op.GtU)) -> vecop 0x28l
+    | VecCompare (V128 (I8x16 V128Op.LeS)) -> vecop 0x29l
+    | VecCompare (V128 (I8x16 V128Op.LeU)) -> vecop 0x2al
+    | VecCompare (V128 (I8x16 V128Op.GeS)) -> vecop 0x2bl
+    | VecCompare (V128 (I8x16 V128Op.GeU)) -> vecop 0x2cl
+    | VecCompare (V128 (I16x8 V128Op.Eq)) -> vecop 0x2dl
+    | VecCompare (V128 (I16x8 V128Op.Ne)) -> vecop 0x2el
+    | VecCompare (V128 (I16x8 V128Op.LtS)) -> vecop 0x2fl
+    | VecCompare (V128 (I16x8 V128Op.LtU)) -> vecop 0x30l
+    | VecCompare (V128 (I16x8 V128Op.GtS)) -> vecop 0x31l
+    | VecCompare (V128 (I16x8 V128Op.GtU)) -> vecop 0x32l
+    | VecCompare (V128 (I16x8 V128Op.LeS)) -> vecop 0x33l
+    | VecCompare (V128 (I16x8 V128Op.LeU)) -> vecop 0x34l
+    | VecCompare (V128 (I16x8 V128Op.GeS)) -> vecop 0x35l
+    | VecCompare (V128 (I16x8 V128Op.GeU)) -> vecop 0x36l
+    | VecCompare (V128 (I32x4 V128Op.Eq)) -> vecop 0x37l
+    | VecCompare (V128 (I32x4 V128Op.Ne)) -> vecop 0x38l
+    | VecCompare (V128 (I32x4 V128Op.LtS)) -> vecop 0x39l
+    | VecCompare (V128 (I32x4 V128Op.LtU)) -> vecop 0x3al
+    | VecCompare (V128 (I32x4 V128Op.GtS)) -> vecop 0x3bl
+    | VecCompare (V128 (I32x4 V128Op.GtU)) -> vecop 0x3cl
+    | VecCompare (V128 (I32x4 V128Op.LeS)) -> vecop 0x3dl
+    | VecCompare (V128 (I32x4 V128Op.LeU)) -> vecop 0x3el
+    | VecCompare (V128 (I32x4 V128Op.GeS)) -> vecop 0x3fl
+    | VecCompare (V128 (I32x4 V128Op.GeU)) -> vecop 0x40l
+    | VecCompare (V128 (I64x2 V128Op.Eq)) -> vecop 0xd6l
+    | VecCompare (V128 (I64x2 V128Op.Ne)) -> vecop 0xd7l
+    | VecCompare (V128 (I64x2 V128Op.LtS)) -> vecop 0xd8l
+    | VecCompare (V128 (I64x2 V128Op.LtU)) -> assert false
+    | VecCompare (V128 (I64x2 V128Op.GtS)) -> vecop 0xd9l
+    | VecCompare (V128 (I64x2 V128Op.GtU)) -> assert false
+    | VecCompare (V128 (I64x2 V128Op.LeS)) -> vecop 0xdal
+    | VecCompare (V128 (I64x2 V128Op.LeU)) -> assert false
+    | VecCompare (V128 (I64x2 V128Op.GeS)) -> vecop 0xdbl
+    | VecCompare (V128 (I64x2 V128Op.GeU)) -> assert false
+    | VecCompare (V128 (F32x4 V128Op.Eq)) -> vecop 0x41l
+    | VecCompare (V128 (F32x4 V128Op.Ne)) -> vecop 0x42l
+    | VecCompare (V128 (F32x4 V128Op.Lt)) -> vecop 0x43l
+    | VecCompare (V128 (F32x4 V128Op.Gt)) -> vecop 0x44l
+    | VecCompare (V128 (F32x4 V128Op.Le)) -> vecop 0x45l
+    | VecCompare (V128 (F32x4 V128Op.Ge)) -> vecop 0x46l
+    | VecCompare (V128 (F64x2 V128Op.Eq)) -> vecop 0x47l
+    | VecCompare (V128 (F64x2 V128Op.Ne)) -> vecop 0x48l
+    | VecCompare (V128 (F64x2 V128Op.Lt)) -> vecop 0x49l
+    | VecCompare (V128 (F64x2 V128Op.Gt)) -> vecop 0x4al
+    | VecCompare (V128 (F64x2 V128Op.Le)) -> vecop 0x4bl
+    | VecCompare (V128 (F64x2 V128Op.Ge)) -> vecop 0x4cl
+
+    | VecBinary (V128 (I8x16 (V128Op.Shuffle is))) -> vecop 0x0dl; List.iter u8 is
+    | VecBinary (V128 (I8x16 V128Op.Swizzle)) -> vecop 0x0el
+    | VecBinary (V128 (I8x16 V128Op.NarrowS)) -> vecop 0x65l
+    | VecBinary (V128 (I8x16 V128Op.NarrowU)) -> vecop 0x66l
+    | VecBinary (V128 (I8x16 V128Op.Add)) -> vecop 0x6el
+    | VecBinary (V128 (I8x16 V128Op.AddSatS)) -> vecop 0x6fl
+    | VecBinary (V128 (I8x16 V128Op.AddSatU)) -> vecop 0x70l
+    | VecBinary (V128 (I8x16 V128Op.Sub)) -> vecop 0x71l
+    | VecBinary (V128 (I8x16 V128Op.SubSatS)) -> vecop 0x72l
+    | VecBinary (V128 (I8x16 V128Op.SubSatU)) -> vecop 0x73l
+    | VecBinary (V128 (I8x16 V128Op.MinS)) -> vecop 0x76l
+    | VecBinary (V128 (I8x16 V128Op.MinU)) -> vecop 0x77l
+    | VecBinary (V128 (I8x16 V128Op.MaxS)) -> vecop 0x78l
+    | VecBinary (V128 (I8x16 V128Op.MaxU)) -> vecop 0x79l
+    | VecBinary (V128 (I8x16 V128Op.AvgrU)) -> vecop 0x7bl
+    | VecBinary (V128 (I16x8 V128Op.NarrowS)) -> vecop 0x85l
+    | VecBinary (V128 (I16x8 V128Op.NarrowU)) -> vecop 0x86l
+    | VecBinary (V128 (I16x8 V128Op.Add)) -> vecop 0x8el
+    | VecBinary (V128 (I16x8 V128Op.AddSatS)) -> vecop 0x8fl
+    | VecBinary (V128 (I16x8 V128Op.AddSatU)) -> vecop 0x90l
+    | VecBinary (V128 (I16x8 V128Op.Sub)) -> vecop 0x91l
+    | VecBinary (V128 (I16x8 V128Op.SubSatS)) -> vecop 0x92l
+    | VecBinary (V128 (I16x8 V128Op.SubSatU)) -> vecop 0x93l
+    | VecBinary (V128 (I16x8 V128Op.Mul)) -> vecop 0x95l
+    | VecBinary (V128 (I16x8 V128Op.MinS)) -> vecop 0x96l
+    | VecBinary (V128 (I16x8 V128Op.MinU)) -> vecop 0x97l
+    | VecBinary (V128 (I16x8 V128Op.MaxS)) -> vecop 0x98l
+    | VecBinary (V128 (I16x8 V128Op.MaxU)) -> vecop 0x99l
+    | VecBinary (V128 (I16x8 V128Op.AvgrU)) -> vecop 0x9bl
+    | VecBinary (V128 (I16x8 V128Op.ExtMulLowS)) -> vecop 0x9cl
+    | VecBinary (V128 (I16x8 V128Op.ExtMulHighS)) -> vecop 0x9dl
+    | VecBinary (V128 (I16x8 V128Op.ExtMulLowU)) -> vecop 0x9el
+    | VecBinary (V128 (I16x8 V128Op.ExtMulHighU)) -> vecop 0x9fl
+    | VecBinary (V128 (I16x8 V128Op.Q15MulRSatS)) -> vecop 0x82l
+    | VecBinary (V128 (I32x4 V128Op.Add)) -> vecop 0xael
+    | VecBinary (V128 (I32x4 V128Op.Sub)) -> vecop 0xb1l
+    | VecBinary (V128 (I32x4 V128Op.MinS)) -> vecop 0xb6l
+    | VecBinary (V128 (I32x4 V128Op.MinU)) -> vecop 0xb7l
+    | VecBinary (V128 (I32x4 V128Op.MaxS)) -> vecop 0xb8l
+    | VecBinary (V128 (I32x4 V128Op.MaxU)) -> vecop 0xb9l
+    | VecBinary (V128 (I32x4 V128Op.DotS)) -> vecop 0xbal
+    | VecBinary (V128 (I32x4 V128Op.Mul)) -> vecop 0xb5l
+    | VecBinary (V128 (I32x4 V128Op.ExtMulLowS)) -> vecop 0xbcl
+    | VecBinary (V128 (I32x4 V128Op.ExtMulHighS)) -> vecop 0xbdl
+    | VecBinary (V128 (I32x4 V128Op.ExtMulLowU)) -> vecop 0xbel
+    | VecBinary (V128 (I32x4 V128Op.ExtMulHighU)) -> vecop 0xbfl
+    | VecBinary (V128 (I64x2 V128Op.Add)) -> vecop 0xcel
+    | VecBinary (V128 (I64x2 V128Op.Sub)) -> vecop 0xd1l
+    | VecBinary (V128 (I64x2 V128Op.Mul)) -> vecop 0xd5l
+    | VecBinary (V128 (I64x2 V128Op.ExtMulLowS)) -> vecop 0xdcl
+    | VecBinary (V128 (I64x2 V128Op.ExtMulHighS)) -> vecop 0xddl
+    | VecBinary (V128 (I64x2 V128Op.ExtMulLowU)) -> vecop 0xdel
+    | VecBinary (V128 (I64x2 V128Op.ExtMulHighU)) -> vecop 0xdfl
+    | VecBinary (V128 (F32x4 V128Op.Add)) -> vecop 0xe4l
+    | VecBinary (V128 (F32x4 V128Op.Sub)) -> vecop 0xe5l
+    | VecBinary (V128 (F32x4 V128Op.Mul)) -> vecop 0xe6l
+    | VecBinary (V128 (F32x4 V128Op.Div)) -> vecop 0xe7l
+    | VecBinary (V128 (F32x4 V128Op.Min)) -> vecop 0xe8l
+    | VecBinary (V128 (F32x4 V128Op.Max)) -> vecop 0xe9l
+    | VecBinary (V128 (F32x4 V128Op.Pmin)) -> vecop 0xeal
+    | VecBinary (V128 (F32x4 V128Op.Pmax)) -> vecop 0xebl
+    | VecBinary (V128 (F64x2 V128Op.Add)) -> vecop 0xf0l
+    | VecBinary (V128 (F64x2 V128Op.Sub)) -> vecop 0xf1l
+    | VecBinary (V128 (F64x2 V128Op.Mul)) -> vecop 0xf2l
+    | VecBinary (V128 (F64x2 V128Op.Div)) -> vecop 0xf3l
+    | VecBinary (V128 (F64x2 V128Op.Min)) -> vecop 0xf4l
+    | VecBinary (V128 (F64x2 V128Op.Max)) -> vecop 0xf5l
+    | VecBinary (V128 (F64x2 V128Op.Pmin)) -> vecop 0xf6l
+    | VecBinary (V128 (F64x2 V128Op.Pmax)) -> vecop 0xf7l
+    | VecBinary (V128 _) -> assert false
+
+    | VecConvert (V128 (I8x16 _)) -> assert false
+    | VecConvert (V128 (I16x8 V128Op.ExtendLowS)) -> vecop 0x87l
+    | VecConvert (V128 (I16x8 V128Op.ExtendHighS)) -> vecop 0x88l
+    | VecConvert (V128 (I16x8 V128Op.ExtendLowU)) -> vecop 0x89l
+    | VecConvert (V128 (I16x8 V128Op.ExtendHighU)) -> vecop 0x8al
+    | VecConvert (V128 (I16x8 V128Op.ExtAddPairwiseS)) -> vecop 0x7cl
+    | VecConvert (V128 (I16x8 V128Op.ExtAddPairwiseU)) -> vecop 0x7dl
+    | VecConvert (V128 (I16x8 _)) -> assert false
+    | VecConvert (V128 (I32x4 V128Op.ExtendLowS)) -> vecop 0xa7l
+    | VecConvert (V128 (I32x4 V128Op.ExtendHighS)) -> vecop 0xa8l
+    | VecConvert (V128 (I32x4 V128Op.ExtendLowU)) -> vecop 0xa9l
+    | VecConvert (V128 (I32x4 V128Op.ExtendHighU)) -> vecop 0xaal
+    | VecConvert (V128 (I32x4 V128Op.ExtAddPairwiseS)) -> vecop 0x7el
+    | VecConvert (V128 (I32x4 V128Op.ExtAddPairwiseU)) -> vecop 0x7fl
+    | VecConvert (V128 (I32x4 V128Op.TruncSatSF32x4)) -> vecop 0xf8l
+    | VecConvert (V128 (I32x4 V128Op.TruncSatUF32x4)) -> vecop 0xf9l
+    | VecConvert (V128 (I32x4 V128Op.TruncSatSZeroF64x2)) -> vecop 0xfcl
+    | VecConvert (V128 (I32x4 V128Op.TruncSatUZeroF64x2)) -> vecop 0xfdl
+    | VecConvert (V128 (I64x2 V128Op.ExtendLowS)) -> vecop 0xc7l
+    | VecConvert (V128 (I64x2 V128Op.ExtendHighS)) -> vecop 0xc8l
+    | VecConvert (V128 (I64x2 V128Op.ExtendLowU)) -> vecop 0xc9l
+    | VecConvert (V128 (I64x2 V128Op.ExtendHighU)) -> vecop 0xcal
+    | VecConvert (V128 (I64x2 _)) -> assert false
+    | VecConvert (V128 (F32x4 V128Op.DemoteZeroF64x2)) -> vecop 0x5el
+    | VecConvert (V128 (F32x4 V128Op.PromoteLowF32x4)) -> assert false
+    | VecConvert (V128 (F32x4 V128Op.ConvertSI32x4)) -> vecop 0xfal
+    | VecConvert (V128 (F32x4 V128Op.ConvertUI32x4)) -> vecop 0xfbl
+    | VecConvert (V128 (F64x2 V128Op.DemoteZeroF64x2)) -> assert false
+    | VecConvert (V128 (F64x2 V128Op.PromoteLowF32x4)) -> vecop 0x5fl
+    | VecConvert (V128 (F64x2 V128Op.ConvertSI32x4)) -> vecop 0xfel
+    | VecConvert (V128 (F64x2 V128Op.ConvertUI32x4)) -> vecop 0xffl
+
+    | VecShift (V128 (I8x16 V128Op.Shl)) -> vecop 0x6bl
+    | VecShift (V128 (I8x16 V128Op.ShrS)) -> vecop 0x6cl
+    | VecShift (V128 (I8x16 V128Op.ShrU)) -> vecop 0x6dl
+    | VecShift (V128 (I16x8 V128Op.Shl)) -> vecop 0x8bl
+    | VecShift (V128 (I16x8 V128Op.ShrS)) -> vecop 0x8cl
+    | VecShift (V128 (I16x8 V128Op.ShrU)) -> vecop 0x8dl
+    | VecShift (V128 (I32x4 V128Op.Shl)) -> vecop 0xabl
+    | VecShift (V128 (I32x4 V128Op.ShrS)) -> vecop 0xacl
+    | VecShift (V128 (I32x4 V128Op.ShrU)) -> vecop 0xadl
+    | VecShift (V128 (I64x2 V128Op.Shl)) -> vecop 0xcbl
+    | VecShift (V128 (I64x2 V128Op.ShrS)) -> vecop 0xccl
+    | VecShift (V128 (I64x2 V128Op.ShrU)) -> vecop 0xcdl
+    | VecShift (V128 _) -> .
+
+    | VecBitmask (V128 (I8x16 V128Op.Bitmask)) -> vecop 0x64l
+    | VecBitmask (V128 (I16x8 V128Op.Bitmask)) -> vecop 0x84l
+    | VecBitmask (V128 (I32x4 V128Op.Bitmask)) -> vecop 0xa4l
+    | VecBitmask (V128 (I64x2 V128Op.Bitmask)) -> vecop 0xc4l
+    | VecBitmask (V128 _) -> .
+
+    | VecTestBits (V128 V128Op.AnyTrue) -> vecop 0x53l
+    | VecUnaryBits (V128 V128Op.Not) -> vecop 0x4dl
+    | VecBinaryBits (V128 V128Op.And) -> vecop 0x4el
+    | VecBinaryBits (V128 V128Op.AndNot) -> vecop 0x4fl
+    | VecBinaryBits (V128 V128Op.Or) -> vecop 0x50l
+    | VecBinaryBits (V128 V128Op.Xor) -> vecop 0x51l
+    | VecTernaryBits (V128 V128Op.Bitselect) -> vecop 0x52l
+
+    | VecSplat (V128 ((I8x16 V128Op.Splat))) -> vecop 0x0fl
+    | VecSplat (V128 ((I16x8 V128Op.Splat))) -> vecop 0x10l
+    | VecSplat (V128 ((I32x4 V128Op.Splat))) -> vecop 0x11l
+    | VecSplat (V128 ((I64x2 V128Op.Splat))) -> vecop 0x12l
+    | VecSplat (V128 ((F32x4 V128Op.Splat))) -> vecop 0x13l
+    | VecSplat (V128 ((F64x2 V128Op.Splat))) -> vecop 0x14l
+
+    | VecExtract (V128 (I8x16 (V128Op.Extract (i, SX)))) -> vecop 0x15l; u8 i
+    | VecExtract (V128 (I8x16 (V128Op.Extract (i, ZX)))) -> vecop 0x16l; u8 i
+    | VecExtract (V128 (I16x8 (V128Op.Extract (i, SX)))) -> vecop 0x18l; u8 i
+    | VecExtract (V128 (I16x8 (V128Op.Extract (i, ZX)))) -> vecop 0x19l; u8 i
+    | VecExtract (V128 (I32x4 (V128Op.Extract (i, ())))) -> vecop 0x1bl; u8 i
+    | VecExtract (V128 (I64x2 (V128Op.Extract (i, ())))) -> vecop 0x1dl; u8 i
+    | VecExtract (V128 (F32x4 (V128Op.Extract (i, ())))) -> vecop 0x1fl; u8 i
+    | VecExtract (V128 (F64x2 (V128Op.Extract (i, ())))) -> vecop 0x21l; u8 i
+
+    | VecReplace (V128 (I8x16 (V128Op.Replace i))) -> vecop 0x17l; u8 i
+    | VecReplace (V128 (I16x8 (V128Op.Replace i))) -> vecop 0x1al; u8 i
+    | VecReplace (V128 (I32x4 (V128Op.Replace i))) -> vecop 0x1cl; u8 i
+    | VecReplace (V128 (I64x2 (V128Op.Replace i))) -> vecop 0x1el; u8 i
+    | VecReplace (V128 (F32x4 (V128Op.Replace i))) -> vecop 0x20l; u8 i
+    | VecReplace (V128 (F64x2 (V128Op.Replace i))) -> vecop 0x22l; u8 i
+
   let const c =
     list instr c.it; end_ ()
 
diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index 9737e71e6..6e9ec7788 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -32,10 +32,10 @@ let memory_error at = function
   | exn -> raise exn
 
 let numeric_error at = function
-  | Numeric_error.IntegerOverflow -> "integer overflow"
-  | Numeric_error.IntegerDivideByZero -> "integer divide by zero"
-  | Numeric_error.InvalidConversionToInteger -> "invalid conversion to integer"
-  | Eval_numeric.TypeError (i, v, t) ->
+  | Ixx.Overflow -> "integer overflow"
+  | Ixx.DivideByZero -> "integer divide by zero"
+  | Ixx.InvalidConversion -> "invalid conversion to integer"
+  | Value.TypeError (i, v, t) ->
     Crash.error at
       ("type error, expected " ^ string_of_num_type t ^ " as operand " ^
        string_of_int i ^ ", got " ^ string_of_num_type (type_of_num v))
@@ -383,27 +383,86 @@ let rec step (c : config) : config =
         seg := [];
         vs, []
 
-      | Load {offset; ty; sz; _}, Num (I32 i) :: vs' ->
+      | Load {offset; ty; pack; _}, Num (I32 i) :: vs' ->
         let mem = memory c.frame.inst (0l @@ e.at) in
         let a = I64_convert.extend_i32_u i in
         (try
           let n =
-            match sz with
+            match pack with
             | None -> Memory.load_num mem a offset ty
-            | Some (sz, ext) -> Memory.load_packed sz ext mem a offset ty
+            | Some (sz, ext) -> Memory.load_num_packed sz ext mem a offset ty
           in Num n :: vs', []
         with exn -> vs', [Trapping (memory_error e.at exn) @@ e.at])
 
-      | Store {offset; sz; _}, Num n :: Num (I32 i) :: vs' ->
+      | Store {offset; pack; _}, Num n :: Num (I32 i) :: vs' ->
         let mem = memory c.frame.inst (0l @@ e.at) in
         let a = I64_convert.extend_i32_u i in
         (try
-          (match sz with
+          (match pack with
           | None -> Memory.store_num mem a offset n
-          | Some sz -> Memory.store_packed sz mem a offset n
+          | Some sz -> Memory.store_num_packed sz mem a offset n
           );
           vs', []
         with exn -> vs', [Trapping (memory_error e.at exn) @@ e.at]);
+
+      | VecLoad {offset; ty; pack; _}, Num (I32 i) :: vs' ->
+        let mem = memory c.frame.inst (0l @@ e.at) in
+        let addr = I64_convert.extend_i32_u i in
+        (try
+          let v =
+            match pack with
+            | None -> Memory.load_vec mem addr offset ty
+            | Some (sz, ext) ->
+              Memory.load_vec_packed sz ext mem addr offset ty
+          in Vec v :: vs', []
+        with exn -> vs', [Trapping (memory_error e.at exn) @@ e.at])
+
+      | VecStore {offset; _}, Vec v :: Num (I32 i) :: vs' ->
+        let mem = memory c.frame.inst (0l @@ e.at) in
+        let addr = I64_convert.extend_i32_u i in
+        (try
+          Memory.store_vec mem addr offset v;
+          vs', []
+        with exn -> vs', [Trapping (memory_error e.at exn) @@ e.at]);
+
+      | VecLoadLane ({offset; ty; pack; _}, j), Vec (V128 v) :: Num (I32 i) :: vs' ->
+        let mem = memory c.frame.inst (0l @@ e.at) in
+        let addr = I64_convert.extend_i32_u i in
+        (try
+          let v =
+            match pack with
+            | Pack8 ->
+              V128.I8x16.replace_lane j v
+                (I32Num.of_num 0 (Memory.load_num_packed Pack8 SX mem addr offset I32Type))
+            | Pack16 ->
+              V128.I16x8.replace_lane j v
+                (I32Num.of_num 0 (Memory.load_num_packed Pack16 SX mem addr offset I32Type))
+            | Pack32 ->
+              V128.I32x4.replace_lane j v
+                (I32Num.of_num 0 (Memory.load_num mem addr offset I32Type))
+            | Pack64 ->
+              V128.I64x2.replace_lane j v
+                (I64Num.of_num 0 (Memory.load_num mem addr offset I64Type))
+          in Vec (V128 v) :: vs', []
+        with exn -> vs', [Trapping (memory_error e.at exn) @@ e.at])
+
+      | VecStoreLane ({offset; ty; pack; _}, j), Vec (V128 v) :: Num (I32 i) :: vs' ->
+        let mem = memory c.frame.inst (0l @@ e.at) in
+        let addr = I64_convert.extend_i32_u i in
+        (try
+          (match pack with
+          | Pack8 ->
+            Memory.store_num_packed Pack8 mem addr offset (I32 (V128.I8x16.extract_lane_s j v))
+          | Pack16 ->
+            Memory.store_num_packed Pack16 mem addr offset (I32 (V128.I16x8.extract_lane_s j v))
+          | Pack32 ->
+            Memory.store_num mem addr offset (I32 (V128.I32x4.extract_lane_s j v))
+          | Pack64 ->
+            Memory.store_num mem addr offset (I64 (V128.I64x2.extract_lane_s j v))
+          );
+          vs', []
+        with exn -> vs', [Trapping (memory_error e.at exn) @@ e.at])
+
       | MemorySize, vs ->
         let mem = memory c.frame.inst (0l @@ e.at) in
         Num (I32 (Memory.size mem)) :: vs, []
@@ -426,7 +485,7 @@ let rec step (c : config) : config =
             Plain (Const (I32 i @@ e.at));
             Plain (Const (k @@ e.at));
             Plain (Store
-              {ty = I32Type; align = 0; offset = 0l; sz = Some Pack8});
+              {ty = I32Type; align = 0; offset = 0l; pack = Some Pack8});
             Plain (Const (I32 (I32.add i 1l) @@ e.at));
             Plain (Const (k @@ e.at));
             Plain (Const (I32 (I32.sub n 1l) @@ e.at));
@@ -443,9 +502,9 @@ let rec step (c : config) : config =
             Plain (Const (I32 d @@ e.at));
             Plain (Const (I32 s @@ e.at));
             Plain (Load
-              {ty = I32Type; align = 0; offset = 0l; sz = Some (Pack8, ZX)});
+              {ty = I32Type; align = 0; offset = 0l; pack = Some (Pack8, ZX)});
             Plain (Store
-              {ty = I32Type; align = 0; offset = 0l; sz = Some Pack8});
+              {ty = I32Type; align = 0; offset = 0l; pack = Some Pack8});
             Plain (Const (I32 (I32.add d 1l) @@ e.at));
             Plain (Const (I32 (I32.add s 1l) @@ e.at));
             Plain (Const (I32 (I32.sub n 1l) @@ e.at));
@@ -460,9 +519,9 @@ let rec step (c : config) : config =
             Plain (Const (I32 d @@ e.at));
             Plain (Const (I32 s @@ e.at));
             Plain (Load
-              {ty = I32Type; align = 0; offset = 0l; sz = Some (Pack8, ZX)});
+              {ty = I32Type; align = 0; offset = 0l; pack = Some (Pack8, ZX)});
             Plain (Store
-              {ty = I32Type; align = 0; offset = 0l; sz = Some Pack8});
+              {ty = I32Type; align = 0; offset = 0l; pack = Some Pack8});
           ]
 
       | MemoryInit x, Num (I32 n) :: Num (I32 s) :: Num (I32 d) :: vs' ->
@@ -477,7 +536,7 @@ let rec step (c : config) : config =
             Plain (Const (I32 d @@ e.at));
             Plain (Const (I32 b @@ e.at));
             Plain (Store
-              {ty = I32Type; align = 0; offset = 0l; sz = Some Pack8});
+              {ty = I32Type; align = 0; offset = 0l; pack = Some Pack8});
             Plain (Const (I32 (I32.add d 1l) @@ e.at));
             Plain (Const (I32 (I32.add s 1l) @@ e.at));
             Plain (Const (I32 (I32.sub n 1l) @@ e.at));
@@ -516,23 +575,82 @@ let rec step (c : config) : config =
         Num n.it :: vs, []
 
       | Test testop, Num n :: vs' ->
-        (try value_of_bool (Eval_numeric.eval_testop testop n) :: vs', []
+        (try value_of_bool (Eval_num.eval_testop testop n) :: vs', []
         with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
 
       | Compare relop, Num n2 :: Num n1 :: vs' ->
-        (try value_of_bool (Eval_numeric.eval_relop relop n1 n2) :: vs', []
+        (try value_of_bool (Eval_num.eval_relop relop n1 n2) :: vs', []
         with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
 
       | Unary unop, Num n :: vs' ->
-        (try Num (Eval_numeric.eval_unop unop n) :: vs', []
+        (try Num (Eval_num.eval_unop unop n) :: vs', []
         with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
 
       | Binary binop, Num n2 :: Num n1 :: vs' ->
-        (try Num (Eval_numeric.eval_binop binop n1 n2) :: vs', []
+        (try Num (Eval_num.eval_binop binop n1 n2) :: vs', []
         with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
 
       | Convert cvtop, Num n :: vs' ->
-        (try Num (Eval_numeric.eval_cvtop cvtop n) :: vs', []
+        (try Num (Eval_num.eval_cvtop cvtop n) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecConst v, vs ->
+        Vec v.it :: vs, []
+
+      | VecTest testop, Vec n :: vs' ->
+        (try value_of_bool (Eval_vec.eval_testop testop n) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecUnary unop, Vec n :: vs' ->
+        (try Vec (Eval_vec.eval_unop unop n) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecBinary binop, Vec n2 :: Vec n1 :: vs' ->
+        (try Vec (Eval_vec.eval_binop binop n1 n2) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecCompare relop, Vec n2 :: Vec n1 :: vs' ->
+        (try Vec (Eval_vec.eval_relop relop n1 n2) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecConvert cvtop, Vec n :: vs' ->
+        (try Vec (Eval_vec.eval_cvtop cvtop n) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecShift shiftop, Num s :: Vec v :: vs' ->
+        (try Vec (Eval_vec.eval_shiftop shiftop v s) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecBitmask bitmaskop, Vec v :: vs' ->
+        (try Num (Eval_vec.eval_bitmaskop bitmaskop v) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecTestBits vtestop, Vec n :: vs' ->
+        (try value_of_bool (Eval_vec.eval_vtestop vtestop n) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecUnaryBits vunop, Vec n :: vs' ->
+        (try Vec (Eval_vec.eval_vunop vunop n) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecBinaryBits vbinop, Vec n2 :: Vec n1 :: vs' ->
+        (try Vec (Eval_vec.eval_vbinop vbinop n1 n2) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecTernaryBits vternop, Vec v3 :: Vec v2 :: Vec v1 :: vs' ->
+        (try Vec (Eval_vec.eval_vternop vternop v1 v2 v3) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecSplat splatop, Num n :: vs' ->
+        (try Vec (Eval_vec.eval_splatop splatop n) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecExtract extractop, Vec v :: vs' ->
+        (try Num (Eval_vec.eval_extractop extractop v) :: vs', []
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
+
+      | VecReplace replaceop, Num r :: Vec v :: vs' ->
+        (try Vec (Eval_vec.eval_replaceop replaceop v r) :: vs', []
         with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
 
       | _ ->
diff --git a/interpreter/exec/eval_numeric.ml b/interpreter/exec/eval_num.ml
similarity index 88%
rename from interpreter/exec/eval_numeric.ml
rename to interpreter/exec/eval_num.ml
index 41059c787..29730b37b 100644
--- a/interpreter/exec/eval_numeric.ml
+++ b/interpreter/exec/eval_num.ml
@@ -2,46 +2,6 @@ open Types
 open Value
 
 
-(* Injection & projection *)
-
-exception TypeError of int * num * num_type
-
-module type NumType =
-sig
-  type t
-  val to_num : t -> num
-  val of_num : int -> num -> t
-end
-
-module I32Num =
-struct
-  type t = I32.t
-  let to_num i = I32 i
-  let of_num n = function I32 i -> i | v -> raise (TypeError (n, v, I32Type))
-end
-
-module I64Num =
-struct
-  type t = I64.t
-  let to_num i = I64 i
-  let of_num n = function I64 i -> i | v -> raise (TypeError (n, v, I64Type))
-end
-
-module F32Num =
-struct
-  type t = F32.t
-  let to_num i = F32 i
-  let of_num n = function F32 z -> z | v -> raise (TypeError (n, v, F32Type))
-end
-
-module F64Num =
-struct
-  type t = F64.t
-  let to_num i = F64 i
-  let of_num n = function F64 z -> z | v -> raise (TypeError (n, v, F64Type))
-end
-
-
 (* Int operators *)
 
 module IntOp (IXX : Ixx.S) (Num : NumType with type t = IXX.t) =
@@ -222,7 +182,6 @@ struct
     in F64Num.to_num z
 end
 
-
 (* Dispatch *)
 
 let op i32 i64 f32 f64 = function
@@ -236,3 +195,4 @@ let eval_binop = op I32Op.binop I64Op.binop F32Op.binop F64Op.binop
 let eval_testop = op I32Op.testop I64Op.testop F32Op.testop F64Op.testop
 let eval_relop = op I32Op.relop I64Op.relop F32Op.relop F64Op.relop
 let eval_cvtop = op I32CvtOp.cvtop I64CvtOp.cvtop F32CvtOp.cvtop F64CvtOp.cvtop
+
diff --git a/interpreter/exec/eval_numeric.mli b/interpreter/exec/eval_num.mli
similarity index 82%
rename from interpreter/exec/eval_numeric.mli
rename to interpreter/exec/eval_num.mli
index 941936512..e5c53f11e 100644
--- a/interpreter/exec/eval_numeric.mli
+++ b/interpreter/exec/eval_num.mli
@@ -1,7 +1,5 @@
 open Value
 
-exception TypeError of int * num * Types.num_type
-
 val eval_unop : Ast.unop -> num -> num
 val eval_binop : Ast.binop -> num -> num -> num
 val eval_testop : Ast.testop -> num -> bool
diff --git a/interpreter/exec/eval_vec.ml b/interpreter/exec/eval_vec.ml
new file mode 100644
index 000000000..746bbc2b5
--- /dev/null
+++ b/interpreter/exec/eval_vec.ml
@@ -0,0 +1,314 @@
+open Types
+open Value
+
+module V128Op =
+struct
+  open Ast.V128Op
+  open V128Vec
+  open V128
+
+  let testop (op : testop) =
+    let f = match op with
+      | I8x16 AllTrue -> V128.I8x16.all_true
+      | I16x8 AllTrue -> V128.I16x8.all_true
+      | I32x4 AllTrue -> V128.I32x4.all_true
+      | I64x2 AllTrue -> V128.I64x2.all_true
+      | _ -> .
+    in fun v -> f (of_vec 1 v)
+
+  let unop (op : unop) =
+    let f = match op with
+      | I8x16 Neg -> V128.I8x16.neg
+      | I8x16 Abs -> V128.I8x16.abs
+      | I8x16 Popcnt -> V128.I8x16.popcnt
+      | I16x8 Neg -> V128.I16x8.neg
+      | I16x8 Abs -> V128.I16x8.abs
+      | I32x4 Abs -> V128.I32x4.abs
+      | I32x4 Neg -> V128.I32x4.neg
+      | I64x2 Abs -> V128.I64x2.abs
+      | I64x2 Neg -> V128.I64x2.neg
+      | F32x4 Abs -> V128.F32x4.abs
+      | F32x4 Neg -> V128.F32x4.neg
+      | F32x4 Sqrt -> V128.F32x4.sqrt
+      | F32x4 Ceil -> V128.F32x4.ceil
+      | F32x4 Floor -> V128.F32x4.floor
+      | F32x4 Trunc -> V128.F32x4.trunc
+      | F32x4 Nearest -> V128.F32x4.nearest
+      | F64x2 Abs -> V128.F64x2.abs
+      | F64x2 Neg -> V128.F64x2.neg
+      | F64x2 Sqrt -> V128.F64x2.sqrt
+      | F64x2 Ceil -> V128.F64x2.ceil
+      | F64x2 Floor -> V128.F64x2.floor
+      | F64x2 Trunc -> V128.F64x2.trunc
+      | F64x2 Nearest -> V128.F64x2.nearest
+      | _ -> assert false
+    in fun v -> to_vec (f (of_vec 1 v))
+
+  let binop (op : binop) =
+    let f = match op with
+      | I8x16 Swizzle -> V128.V8x16.swizzle
+      | I8x16 (Shuffle is) -> fun a b -> V128.V8x16.shuffle a b is
+      | I8x16 NarrowS -> V128.I8x16_convert.narrow_s
+      | I8x16 NarrowU -> V128.I8x16_convert.narrow_u
+      | I8x16 Add -> V128.I8x16.add
+      | I8x16 AddSatS -> V128.I8x16.add_sat_s
+      | I8x16 AddSatU -> V128.I8x16.add_sat_u
+      | I8x16 Sub -> V128.I8x16.sub
+      | I8x16 SubSatS -> V128.I8x16.sub_sat_s
+      | I8x16 SubSatU -> V128.I8x16.sub_sat_u
+      | I8x16 MinS -> V128.I8x16.min_s
+      | I8x16 MinU -> V128.I8x16.min_u
+      | I8x16 MaxS -> V128.I8x16.max_s
+      | I8x16 MaxU -> V128.I8x16.max_u
+      | I8x16 AvgrU -> V128.I8x16.avgr_u
+      | I16x8 NarrowS -> V128.I16x8_convert.narrow_s
+      | I16x8 NarrowU -> V128.I16x8_convert.narrow_u
+      | I16x8 Add -> V128.I16x8.add
+      | I16x8 AddSatS -> V128.I16x8.add_sat_s
+      | I16x8 AddSatU -> V128.I16x8.add_sat_u
+      | I16x8 Sub -> V128.I16x8.sub
+      | I16x8 SubSatS -> V128.I16x8.sub_sat_s
+      | I16x8 SubSatU -> V128.I16x8.sub_sat_u
+      | I16x8 Mul -> V128.I16x8.mul
+      | I16x8 MinS -> V128.I16x8.min_s
+      | I16x8 MinU -> V128.I16x8.min_u
+      | I16x8 MaxS -> V128.I16x8.max_s
+      | I16x8 MaxU -> V128.I16x8.max_u
+      | I16x8 AvgrU -> V128.I16x8.avgr_u
+      | I16x8 ExtMulLowS -> V128.I16x8_convert.extmul_low_s
+      | I16x8 ExtMulHighS -> V128.I16x8_convert.extmul_high_s
+      | I16x8 ExtMulLowU -> V128.I16x8_convert.extmul_low_u
+      | I16x8 ExtMulHighU -> V128.I16x8_convert.extmul_high_u
+      | I16x8 Q15MulRSatS -> V128.I16x8.q15mulr_sat_s
+      | I32x4 Add -> V128.I32x4.add
+      | I32x4 Sub -> V128.I32x4.sub
+      | I32x4 MinS -> V128.I32x4.min_s
+      | I32x4 MinU -> V128.I32x4.min_u
+      | I32x4 MaxS -> V128.I32x4.max_s
+      | I32x4 MaxU -> V128.I32x4.max_u
+      | I32x4 Mul -> V128.I32x4.mul
+      | I32x4 ExtMulLowS -> V128.I32x4_convert.extmul_low_s
+      | I32x4 ExtMulHighS -> V128.I32x4_convert.extmul_high_s
+      | I32x4 ExtMulLowU -> V128.I32x4_convert.extmul_low_u
+      | I32x4 ExtMulHighU -> V128.I32x4_convert.extmul_high_u
+      | I64x2 Add -> V128.I64x2.add
+      | I64x2 Sub -> V128.I64x2.sub
+      | I64x2 Mul -> V128.I64x2.mul
+      | I32x4 DotS -> V128.I32x4_convert.dot_s
+      | I64x2 ExtMulLowS -> V128.I64x2_convert.extmul_low_s
+      | I64x2 ExtMulHighS -> V128.I64x2_convert.extmul_high_s
+      | I64x2 ExtMulLowU -> V128.I64x2_convert.extmul_low_u
+      | I64x2 ExtMulHighU -> V128.I64x2_convert.extmul_high_u
+      | F32x4 Add -> V128.F32x4.add
+      | F32x4 Sub -> V128.F32x4.sub
+      | F32x4 Mul -> V128.F32x4.mul
+      | F32x4 Div -> V128.F32x4.div
+      | F32x4 Min -> V128.F32x4.min
+      | F32x4 Max -> V128.F32x4.max
+      | F32x4 Pmin -> V128.F32x4.pmin
+      | F32x4 Pmax -> V128.F32x4.pmax
+      | F64x2 Add -> V128.F64x2.add
+      | F64x2 Sub -> V128.F64x2.sub
+      | F64x2 Mul -> V128.F64x2.mul
+      | F64x2 Div -> V128.F64x2.div
+      | F64x2 Min -> V128.F64x2.min
+      | F64x2 Max -> V128.F64x2.max
+      | F64x2 Pmin -> V128.F64x2.pmin
+      | F64x2 Pmax -> V128.F64x2.pmax
+      | _ -> assert false
+    in fun v1 v2 -> to_vec (f (of_vec 1 v1) (of_vec 2 v2))
+
+  let relop (op : relop) =
+    let f = match op with
+      | I8x16 Eq -> V128.I8x16.eq
+      | I8x16 Ne -> V128.I8x16.ne
+      | I8x16 LtS -> V128.I8x16.lt_s
+      | I8x16 LtU -> V128.I8x16.lt_u
+      | I8x16 LeS -> V128.I8x16.le_s
+      | I8x16 LeU -> V128.I8x16.le_u
+      | I8x16 GtS -> V128.I8x16.gt_s
+      | I8x16 GtU -> V128.I8x16.gt_u
+      | I8x16 GeS -> V128.I8x16.ge_s
+      | I8x16 GeU -> V128.I8x16.ge_u
+      | I16x8 Eq -> V128.I16x8.eq
+      | I16x8 Ne -> V128.I16x8.ne
+      | I16x8 LtS -> V128.I16x8.lt_s
+      | I16x8 LtU -> V128.I16x8.lt_u
+      | I16x8 LeS -> V128.I16x8.le_s
+      | I16x8 LeU -> V128.I16x8.le_u
+      | I16x8 GtS -> V128.I16x8.gt_s
+      | I16x8 GtU -> V128.I16x8.gt_u
+      | I16x8 GeS -> V128.I16x8.ge_s
+      | I16x8 GeU -> V128.I16x8.ge_u
+      | I32x4 Eq -> V128.I32x4.eq
+      | I32x4 Ne -> V128.I32x4.ne
+      | I32x4 LtS -> V128.I32x4.lt_s
+      | I32x4 LtU -> V128.I32x4.lt_u
+      | I32x4 LeS -> V128.I32x4.le_s
+      | I32x4 LeU -> V128.I32x4.le_u
+      | I32x4 GtS -> V128.I32x4.gt_s
+      | I32x4 GtU -> V128.I32x4.gt_u
+      | I32x4 GeS -> V128.I32x4.ge_s
+      | I32x4 GeU -> V128.I32x4.ge_u
+      | I64x2 Eq -> V128.I64x2.eq
+      | I64x2 Ne -> V128.I64x2.ne
+      | I64x2 LtS -> V128.I64x2.lt_s
+      | I64x2 LeS -> V128.I64x2.le_s
+      | I64x2 GtS -> V128.I64x2.gt_s
+      | I64x2 GeS -> V128.I64x2.ge_s
+      | F32x4 Eq -> V128.F32x4.eq
+      | F32x4 Ne -> V128.F32x4.ne
+      | F32x4 Lt -> V128.F32x4.lt
+      | F32x4 Le -> V128.F32x4.le
+      | F32x4 Gt -> V128.F32x4.gt
+      | F32x4 Ge -> V128.F32x4.ge
+      | F64x2 Eq -> V128.F64x2.eq
+      | F64x2 Ne -> V128.F64x2.ne
+      | F64x2 Lt -> V128.F64x2.lt
+      | F64x2 Le -> V128.F64x2.le
+      | F64x2 Gt -> V128.F64x2.gt
+      | F64x2 Ge -> V128.F64x2.ge
+      | _ -> assert false
+    in fun v1 v2 -> to_vec (f (of_vec 1 v1) (of_vec 2 v2))
+
+  let cvtop (op : cvtop) =
+    let f = match op with
+      | I16x8 ExtendLowS -> V128.I16x8_convert.extend_low_s
+      | I16x8 ExtendHighS -> V128.I16x8_convert.extend_high_s
+      | I16x8 ExtendLowU -> V128.I16x8_convert.extend_low_u
+      | I16x8 ExtendHighU -> V128.I16x8_convert.extend_high_u
+      | I16x8 ExtAddPairwiseS -> V128.I16x8_convert.extadd_pairwise_s
+      | I16x8 ExtAddPairwiseU -> V128.I16x8_convert.extadd_pairwise_u
+      | I32x4 ExtendLowS -> V128.I32x4_convert.extend_low_s
+      | I32x4 ExtendHighS -> V128.I32x4_convert.extend_high_s
+      | I32x4 ExtendLowU -> V128.I32x4_convert.extend_low_u
+      | I32x4 ExtendHighU -> V128.I32x4_convert.extend_high_u
+      | I32x4 TruncSatSF32x4 -> V128.I32x4_convert.trunc_sat_f32x4_s
+      | I32x4 TruncSatUF32x4 -> V128.I32x4_convert.trunc_sat_f32x4_u
+      | I32x4 TruncSatSZeroF64x2 -> V128.I32x4_convert.trunc_sat_f64x2_s_zero
+      | I32x4 TruncSatUZeroF64x2 -> V128.I32x4_convert.trunc_sat_f64x2_u_zero
+      | I32x4 ExtAddPairwiseS -> V128.I32x4_convert.extadd_pairwise_s
+      | I32x4 ExtAddPairwiseU -> V128.I32x4_convert.extadd_pairwise_u
+      | I64x2 ExtendLowS -> V128.I64x2_convert.extend_low_s
+      | I64x2 ExtendHighS -> V128.I64x2_convert.extend_high_s
+      | I64x2 ExtendLowU -> V128.I64x2_convert.extend_low_u
+      | I64x2 ExtendHighU -> V128.I64x2_convert.extend_high_u
+      | F32x4 ConvertSI32x4 -> V128.F32x4_convert.convert_i32x4_s
+      | F32x4 ConvertUI32x4 -> V128.F32x4_convert.convert_i32x4_u
+      | F32x4 DemoteZeroF64x2 -> V128.F32x4_convert.demote_f64x2_zero
+      | F64x2 PromoteLowF32x4 -> V128.F64x2_convert.promote_low_f32x4
+      | F64x2 ConvertSI32x4 -> V128.F64x2_convert.convert_i32x4_s
+      | F64x2 ConvertUI32x4 -> V128.F64x2_convert.convert_i32x4_u
+      | _ -> assert false
+    in fun v -> to_vec (f (of_vec 1 v))
+
+  let shiftop (op : shiftop) =
+    let f = match op with
+      | I8x16 Shl -> V128.I8x16.shl
+      | I8x16 ShrS -> V128.I8x16.shr_s
+      | I8x16 ShrU -> V128.I8x16.shr_u
+      | I16x8 Shl -> V128.I16x8.shl
+      | I16x8 ShrS -> V128.I16x8.shr_s
+      | I16x8 ShrU -> V128.I16x8.shr_u
+      | I32x4 Shl -> V128.I32x4.shl
+      | I32x4 ShrS -> V128.I32x4.shr_s
+      | I32x4 ShrU -> V128.I32x4.shr_u
+      | I64x2 Shl -> V128.I64x2.shl
+      | I64x2 ShrS -> V128.I64x2.shr_s
+      | I64x2 ShrU -> V128.I64x2.shr_u
+      | _ -> .
+    in fun v n -> to_vec (f (of_vec 1 v) (I32Num.of_num 2 n))
+
+  let bitmaskop (op : bitmaskop) v =
+    let f = match op with
+      | I8x16 Bitmask -> V128.I8x16.bitmask
+      | I16x8 Bitmask -> V128.I16x8.bitmask
+      | I32x4 Bitmask -> V128.I32x4.bitmask
+      | I64x2 Bitmask -> V128.I64x2.bitmask
+      | _ -> .
+    in I32 (f (of_vec 1 v))
+
+  let vtestop (op : vtestop) =
+    let f = match op with
+      | AnyTrue -> V128.I8x16.any_true
+    in fun v -> f (of_vec 1 v)
+
+  let vunop (op : vunop) =
+    let f = match op with
+      | Not -> V128.V1x128.lognot
+    in fun v -> to_vec (f (of_vec 1 v))
+
+  let vbinop (op : vbinop) =
+    let f = match op with
+      | And -> V128.V1x128.and_
+      | Or -> V128.V1x128.or_
+      | Xor -> V128.V1x128.xor
+      | AndNot -> V128.V1x128.andnot
+    in fun v1 v2 -> to_vec (f (of_vec 1 v1) (of_vec 2 v2))
+
+  let vternop (op : vternop) =
+    let f = match op with
+      | Bitselect -> V128.V1x128.bitselect
+    in fun v1 v2 v3 -> to_vec (f (of_vec 1 v1) (of_vec 2 v2) (of_vec 3 v3))
+end
+
+module V128CvtOp =
+struct
+  open Ast.V128Op
+  open V128Vec
+  open V128
+
+  let splatop (op : splatop) v =
+    let i =
+      match op with
+      | I8x16 Splat -> V128.I8x16.splat (I32Num.of_num 1 v)
+      | I16x8 Splat -> V128.I16x8.splat (I32Num.of_num 1 v)
+      | I32x4 Splat -> V128.I32x4.splat (I32Num.of_num 1 v)
+      | I64x2 Splat -> V128.I64x2.splat (I64Num.of_num 1 v)
+      | F32x4 Splat -> V128.F32x4.splat (F32Num.of_num 1 v)
+      | F64x2 Splat -> V128.F64x2.splat (F64Num.of_num 1 v)
+    in to_vec i
+
+  let extractop (op : extractop) v =
+    let v128 = of_vec 1 v in
+    match op with
+    | I8x16 (Extract (i, SX)) -> I32 (V128.I8x16.extract_lane_s i v128)
+    | I8x16 (Extract (i, ZX)) -> I32 (V128.I8x16.extract_lane_u i v128)
+    | I16x8 (Extract (i, SX)) -> I32 (V128.I16x8.extract_lane_s i v128)
+    | I16x8 (Extract (i, ZX)) -> I32 (V128.I16x8.extract_lane_u i v128)
+    | I32x4 (Extract (i, ())) -> I32 (V128.I32x4.extract_lane_u i v128)
+    | I64x2 (Extract (i, ())) -> I64 (V128.I64x2.extract_lane_u i v128)
+    | F32x4 (Extract (i, ())) -> F32 (V128.F32x4.extract_lane i v128)
+    | F64x2 (Extract (i, ())) -> F64 (V128.F64x2.extract_lane i v128)
+
+  let replaceop (op : replaceop) v (n : num) =
+    let v128 = of_vec 1 v in
+    let v128' = match op with
+      | I8x16 (Replace i) -> V128.I8x16.replace_lane i v128 (I32Num.of_num 1 n)
+      | I16x8 (Replace i) -> V128.I16x8.replace_lane i v128 (I32Num.of_num 1 n)
+      | I32x4 (Replace i) -> V128.I32x4.replace_lane i v128 (I32Num.of_num 1 n)
+      | I64x2 (Replace i) -> V128.I64x2.replace_lane i v128 (I64Num.of_num 1 n)
+      | F32x4 (Replace i) -> V128.F32x4.replace_lane i v128 (F32Num.of_num 1 n)
+      | F64x2 (Replace i) -> V128.F64x2.replace_lane i v128 (F64Num.of_num 1 n)
+    in to_vec v128'
+end
+
+(* Dispatch *)
+
+let op v128 = function
+  | V128 x -> v128 x
+
+let eval_testop = op V128Op.testop
+let eval_unop = op V128Op.unop
+let eval_binop = op V128Op.binop
+let eval_relop = op V128Op.relop
+let eval_cvtop = op V128Op.cvtop
+let eval_shiftop = op V128Op.shiftop
+let eval_bitmaskop = op V128Op.bitmaskop
+let eval_vtestop = op V128Op.vtestop
+let eval_vunop = op V128Op.vunop
+let eval_vbinop = op V128Op.vbinop
+let eval_vternop = op V128Op.vternop
+let eval_splatop = op V128CvtOp.splatop
+let eval_extractop = op V128CvtOp.extractop
+let eval_replaceop = op V128CvtOp.replaceop
diff --git a/interpreter/exec/eval_vec.mli b/interpreter/exec/eval_vec.mli
new file mode 100644
index 000000000..45b59033e
--- /dev/null
+++ b/interpreter/exec/eval_vec.mli
@@ -0,0 +1,16 @@
+open Value
+
+val eval_testop : Ast.vec_testop -> vec -> bool
+val eval_unop : Ast.vec_unop -> vec -> vec
+val eval_binop : Ast.vec_binop -> vec -> vec -> vec
+val eval_relop : Ast.vec_relop -> vec -> vec -> vec
+val eval_cvtop : Ast.vec_cvtop -> vec -> vec
+val eval_shiftop : Ast.vec_shiftop -> vec -> num -> vec
+val eval_bitmaskop : Ast.vec_bitmaskop -> vec -> num
+val eval_vtestop : Ast.vec_vtestop -> vec -> bool
+val eval_vunop : Ast.vec_vunop -> vec -> vec
+val eval_vbinop : Ast.vec_vbinop -> vec -> vec -> vec
+val eval_vternop : Ast.vec_vternop -> vec -> vec -> vec -> vec
+val eval_splatop : Ast.vec_splatop -> num -> vec
+val eval_extractop : Ast.vec_extractop -> vec -> num
+val eval_replaceop : Ast.vec_replaceop -> vec -> num -> vec
diff --git a/interpreter/exec/i16.ml b/interpreter/exec/i16.ml
new file mode 100644
index 000000000..54eb9ed84
--- /dev/null
+++ b/interpreter/exec/i16.ml
@@ -0,0 +1,12 @@
+(* Uses Int32 as the underlying storage. All int16 values will be
+ * stored signed-extended. E.g. -1 will be stored with all high bits set.
+ *)
+include Ixx.Make (struct
+  include Int32
+
+  let bitwidth = 16
+  let to_hex_string i = Printf.sprintf "%lx" (Int32.logand i 0xffffl)
+
+  let of_int64 = Int64.to_int32
+  let to_int64 = Int64.of_int32
+end)
diff --git a/interpreter/exec/i32.ml b/interpreter/exec/i32.ml
index 4d8a64e7f..49c85e2fa 100644
--- a/interpreter/exec/i32.ml
+++ b/interpreter/exec/i32.ml
@@ -5,4 +5,7 @@ include Ixx.Make
     include Int32
     let bitwidth = 32
     let to_hex_string = Printf.sprintf "%lx"
+
+    let of_int64 = Int64.to_int32
+    let to_int64 = Int64.of_int32
   end)
diff --git a/interpreter/exec/i32_convert.ml b/interpreter/exec/i32_convert.ml
index 05814fa49..166d5ff0f 100644
--- a/interpreter/exec/i32_convert.ml
+++ b/interpreter/exec/i32_convert.ml
@@ -4,41 +4,41 @@ let wrap_i64 x = Int64.to_int32 x
 
 let trunc_f32_s x =
   if F32.ne x x then
-    raise Numeric_error.InvalidConversionToInteger
+    raise Ixx.InvalidConversion
   else
     let xf = F32.to_float x in
     if xf >= -.Int32.(to_float min_int) || xf < Int32.(to_float min_int) then
-      raise Numeric_error.IntegerOverflow
+      raise Ixx.Overflow
     else
       Int32.of_float xf
 
 let trunc_f32_u x =
   if F32.ne x x then
-    raise Numeric_error.InvalidConversionToInteger
+    raise Ixx.InvalidConversion
   else
     let xf = F32.to_float x in
     if xf >= -.Int32.(to_float min_int) *. 2.0 || xf <= -1.0 then
-      raise Numeric_error.IntegerOverflow
+      raise Ixx.Overflow
     else
       Int64.(to_int32 (of_float xf))
 
 let trunc_f64_s x =
   if F64.ne x x then
-    raise Numeric_error.InvalidConversionToInteger
+    raise Ixx.InvalidConversion
   else
     let xf = F64.to_float x in
     if xf >= -.Int32.(to_float min_int) || xf <= Int32.(to_float min_int) -. 1.0 then
-      raise Numeric_error.IntegerOverflow
+      raise Ixx.Overflow
     else
       Int32.of_float xf
 
 let trunc_f64_u x =
   if F64.ne x x then
-    raise Numeric_error.InvalidConversionToInteger
+    raise Ixx.InvalidConversion
   else
     let xf = F64.to_float x in
     if xf >= -.Int32.(to_float min_int) *. 2.0 || xf <= -1.0 then
-      raise Numeric_error.IntegerOverflow
+      raise Ixx.Overflow
     else
       Int64.(to_int32 (of_float xf))
 
diff --git a/interpreter/exec/i64.ml b/interpreter/exec/i64.ml
index ac348e8d7..f43235dd3 100644
--- a/interpreter/exec/i64.ml
+++ b/interpreter/exec/i64.ml
@@ -5,4 +5,7 @@ include Ixx.Make
     include Int64
     let bitwidth = 64
     let to_hex_string = Printf.sprintf "%Lx"
+
+    let of_int64 i = i
+    let to_int64 i = i
   end)
diff --git a/interpreter/exec/i64_convert.ml b/interpreter/exec/i64_convert.ml
index 0c14e6c4c..835cdf6c7 100644
--- a/interpreter/exec/i64_convert.ml
+++ b/interpreter/exec/i64_convert.ml
@@ -6,21 +6,21 @@ let extend_i32_u x = Int64.logand (Int64.of_int32 x) 0x0000_0000_ffff_ffffL
 
 let trunc_f32_s x =
   if F32.ne x x then
-    raise Numeric_error.InvalidConversionToInteger
+    raise Ixx.InvalidConversion
   else
     let xf = F32.to_float x in
     if xf >= -.Int64.(to_float min_int) || xf < Int64.(to_float min_int) then
-      raise Numeric_error.IntegerOverflow
+      raise Ixx.Overflow
     else
       Int64.of_float xf
 
 let trunc_f32_u x =
   if F32.ne x x then
-    raise Numeric_error.InvalidConversionToInteger
+    raise Ixx.InvalidConversion
   else
     let xf = F32.to_float x in
     if xf >= -.Int64.(to_float min_int) *. 2.0 || xf <= -1.0 then
-      raise Numeric_error.IntegerOverflow
+      raise Ixx.Overflow
     else if xf >= -.Int64.(to_float min_int) then
       Int64.(logxor (of_float (xf -. 0x1p63)) min_int)
     else
@@ -28,21 +28,21 @@ let trunc_f32_u x =
 
 let trunc_f64_s x =
   if F64.ne x x then
-    raise Numeric_error.InvalidConversionToInteger
+    raise Ixx.InvalidConversion
   else
     let xf = F64.to_float x in
     if xf >= -.Int64.(to_float min_int) || xf < Int64.(to_float min_int) then
-      raise Numeric_error.IntegerOverflow
+      raise Ixx.Overflow
     else
       Int64.of_float xf
 
 let trunc_f64_u x =
   if F64.ne x x then
-    raise Numeric_error.InvalidConversionToInteger
+    raise Ixx.InvalidConversion
   else
     let xf = F64.to_float x in
     if xf >= -.Int64.(to_float min_int) *. 2.0 || xf <= -1.0 then
-      raise Numeric_error.IntegerOverflow
+      raise Ixx.Overflow
     else if xf >= -.Int64.(to_float min_int) then
       Int64.(logxor (of_float (xf -. 0x1p63)) min_int)
     else
diff --git a/interpreter/exec/i8.ml b/interpreter/exec/i8.ml
new file mode 100644
index 000000000..bd15d39da
--- /dev/null
+++ b/interpreter/exec/i8.ml
@@ -0,0 +1,12 @@
+(* Uses Int32 as the underlying storage. All int8 values will be
+ * stored signed-extended. E.g. -1 will be stored with all high bits set.
+ *)
+include Ixx.Make (struct
+  include Int32
+
+  let bitwidth = 8
+  let to_hex_string i = Printf.sprintf "%lx" (Int32.logand i 0xffl)
+
+  let of_int64 = Int64.to_int32
+  let to_int64 = Int64.of_int32
+end)
diff --git a/interpreter/exec/ixx.ml b/interpreter/exec/ixx.ml
index ec23208d8..18f8b7d06 100644
--- a/interpreter/exec/ixx.ml
+++ b/interpreter/exec/ixx.ml
@@ -1,3 +1,7 @@
+exception Overflow
+exception DivideByZero
+exception InvalidConversion
+
 module type RepType =
 sig
   type t
@@ -8,12 +12,13 @@ sig
   val max_int : t
   val min_int : t
 
+  val abs : t -> t
   val neg : t -> t
   val add : t -> t -> t
   val sub : t -> t -> t
   val mul : t -> t -> t
-  val div : t -> t -> t (* raises Division_by_zero *)
-  val rem : t -> t -> t (* raises Division_by_zero *)
+  val div : t -> t -> t (* raises DivideByZero *)
+  val rem : t -> t -> t (* raises DivideByZero *)
 
   val logand : t -> t -> t
   val lognot : t -> t
@@ -25,6 +30,8 @@ sig
 
   val of_int : int -> t
   val to_int : t -> int
+  val of_int64: int64 -> t
+  val to_int64: t -> int64
   val to_string : t -> string
   val to_hex_string : t -> string
 
@@ -41,6 +48,9 @@ sig
 
   val zero : t
 
+  val lognot : t -> t
+  val abs : t -> t
+  val neg : t -> t
   val add : t -> t -> t
   val sub : t -> t -> t
   val mul : t -> t -> t
@@ -48,6 +58,7 @@ sig
   val div_u : t -> t -> t (* raises IntegerDivideByZero *)
   val rem_s : t -> t -> t (* raises IntegerDivideByZero *)
   val rem_u : t -> t -> t (* raises IntegerDivideByZero *)
+  val avgr_u : t -> t -> t
   val and_ : t -> t -> t
   val or_ : t -> t -> t
   val xor : t -> t -> t
@@ -72,6 +83,17 @@ sig
   val ge_s : t -> t -> bool
   val ge_u : t -> t -> bool
 
+  val as_unsigned : t -> t
+
+  (* Saturating arithmetic, used for small ints. *)
+  val saturate_s : t -> t
+  val saturate_u : t -> t
+  val add_sat_s : t -> t -> t
+  val add_sat_u : t -> t -> t
+  val sub_sat_s : t -> t -> t
+  val sub_sat_u : t -> t -> t
+  val q15mulr_sat_s : t -> t -> t
+
   val of_int_s : int -> t
   val of_int_u : int -> t
   val of_string_s : string -> t
@@ -98,7 +120,7 @@ struct
    * "Unsigned Short Division from Signed Division".
    *)
   let divrem_u n d =
-    if d = Rep.zero then raise Numeric_error.IntegerDivideByZero else
+    if d = Rep.zero then raise DivideByZero else
     let t = Rep.shift_right d (Rep.bitwidth - 1) in
     let n' = Rep.logand n (Rep.lognot t) in
     let q = Rep.shift_left (Rep.div (Rep.shift_right_logical n' 1) d) 1 in
@@ -118,17 +140,36 @@ struct
   let one = Rep.one
   let ten = Rep.of_int 10
 
+  let lognot = Rep.lognot
+  let abs = Rep.abs
+  let neg = Rep.neg
+
+  (* If bit (bitwidth - 1) is set, sx will sign-extend t to maintain the
+   * invariant that small ints are stored sign-extended inside a wider int. *)
+  let sx x =
+    let i = 64 - Rep.bitwidth in
+    Rep.of_int64 Int64.(shift_right (shift_left (Rep.to_int64 x) i) i)
+
   (* add, sub, and mul are sign-agnostic and do not trap on overflow. *)
-  let add = Rep.add
-  let sub = Rep.sub
-  let mul = Rep.mul
+  let add x y = sx (Rep.add x y)
+  let sub x y = sx (Rep.sub x y)
+
+  let mul x y = sx (Rep.mul x y)
+
+  (* We don't override min_int and max_int since those are used
+   * by other functions (like parsing), and rely on it being
+   * min/max for int32 *)
+  (* The smallest signed |bitwidth|-bits int. *)
+  let low_int = Rep.shift_left Rep.minus_one (Rep.bitwidth - 1)
+  (* The largest signed |bitwidth|-bits int. *)
+  let high_int = Rep.logxor low_int Rep.minus_one
 
   (* result is truncated toward zero *)
   let div_s x y =
     if y = Rep.zero then
-      raise Numeric_error.IntegerDivideByZero
-    else if x = Rep.min_int && y = Rep.minus_one then
-      raise Numeric_error.IntegerOverflow
+      raise DivideByZero
+    else if x = low_int && y = Rep.minus_one then
+      raise Overflow
     else
       Rep.div x y
 
@@ -139,29 +180,51 @@ struct
   (* result has the sign of the dividend *)
   let rem_s x y =
     if y = Rep.zero then
-      raise Numeric_error.IntegerDivideByZero
+      raise DivideByZero
     else
       Rep.rem x y
 
   let rem_u x y =
     let q, r = divrem_u x y in r
 
+  let avgr_u x y =
+    let open Int64 in
+    (* Mask with bottom #bitwidth bits set *)
+    let mask = shift_right_logical minus_one (64 - Rep.bitwidth) in
+    let x64 = logand mask (Rep.to_int64 x) in
+    let y64 = logand mask (Rep.to_int64 y) in
+    Rep.of_int64 (div (add (add x64 y64) one) (of_int 2))
+
   let and_ = Rep.logand
   let or_ = Rep.logor
   let xor = Rep.logxor
 
   (* WebAssembly's shifts mask the shift count according to the bitwidth. *)
   let shift f x y =
-    f x (Rep.to_int (Rep.logand y (Rep.of_int (Rep.bitwidth - 1))))
+    f x Rep.(to_int (logand y (of_int (bitwidth - 1))))
 
   let shl x y =
-    shift Rep.shift_left x y
+    sx (shift Rep.shift_left x y)
 
   let shr_s x y =
     shift Rep.shift_right x y
 
+  (* Check if we are storing smaller ints. *)
+  let needs_extend = shl one (Rep.of_int (Rep.bitwidth - 1)) <> Rep.min_int
+
+  (*
+   * When Int is used to store a smaller int, it is stored in signed extended
+   * form. Some instructions require the unsigned form, which requires masking
+   * away the top 32-bitwidth bits.
+   *)
+  let as_unsigned x =
+    if not needs_extend then x else
+    (* Mask with bottom #bitwidth bits set *)
+    let mask = Rep.(shift_right_logical minus_one (32 - bitwidth)) in
+    Rep.logand x mask
+
   let shr_u x y =
-    shift Rep.shift_right_logical x y
+    sx (shift Rep.shift_right_logical (as_unsigned x) y)
 
   (* We must mask the count to implement rotates via shifts. *)
   let clamp_rotate_count n =
@@ -169,11 +232,11 @@ struct
 
   let rotl x y =
     let n = clamp_rotate_count y in
-    or_ (Rep.shift_left x n) (Rep.shift_right_logical x (Rep.bitwidth - n))
+    or_ (shl x (Rep.of_int n)) (shr_u x (Rep.of_int (Rep.bitwidth - n)))
 
   let rotr x y =
     let n = clamp_rotate_count y in
-    or_ (Rep.shift_right_logical x n) (Rep.shift_left x (Rep.bitwidth - n))
+    or_ (shr_u x (Rep.of_int n)) (shl x (Rep.of_int (Rep.bitwidth - n)))
 
   (* clz is defined for all values, including all-zeros. *)
   let clz x =
@@ -223,8 +286,33 @@ struct
   let ge_s x y = x >= y
   let ge_u x y = cmp_u x (>=) y
 
+  let saturate_s x = sx (min (max x low_int) high_int)
+  let saturate_u x = sx (min (max x Rep.zero) (as_unsigned Rep.minus_one))
+
+  (* add/sub for int, used for higher-precision arithmetic for I8 and I16 *)
+  let add_int x y =
+    assert (Rep.bitwidth < 32);
+    Rep.(of_int ((to_int x) + (to_int y)))
+
+  let sub_int x y =
+    assert (Rep.bitwidth < 32);
+    Rep.(of_int ((to_int x) - (to_int y)))
+
+  let add_sat_s x y = saturate_s (add_int x y)
+  let add_sat_u x y = saturate_u (add_int (as_unsigned x) (as_unsigned y))
+  let sub_sat_s x y = saturate_s (sub_int x y)
+  let sub_sat_u x y = saturate_u (sub_int (as_unsigned x) (as_unsigned y))
+
+  let q15mulr_sat_s x y =
+    (* mul x64 y64 can overflow int64 when both are int32 min, but this is only
+     * used by i16x8, so we are fine for now. *)
+    assert (Rep.bitwidth < 32);
+    let x64 = Rep.to_int64 x in
+    let y64 = Rep.to_int64 y in
+    saturate_s (Rep.of_int64 Int64.((shift_right (add (mul x64 y64) 0x4000L) 15)))
+
   let to_int_s = Rep.to_int
-  let to_int_u i = Rep.to_int i land (Rep.to_int Rep.max_int lsl 1) lor 1
+  let to_int_u i = Rep.to_int i land ((Rep.to_int Rep.max_int lsl 1) lor 1)
 
   let of_int_s = Rep.of_int
   let of_int_u i = and_ (Rep.of_int i) (or_ (shl (Rep.of_int max_int) one) one)
@@ -245,6 +333,23 @@ struct
 
   let max_upper, max_lower = divrem_u Rep.minus_one ten
 
+  let sign_extend i =
+    (* This module is used with I32 and I64, but the bitwidth can be less
+     * than that, e.g. for I16. When used for smaller integers, the stored value
+     * needs to be signed extended, e.g. parsing -1 into a I16 (backed by Int32)
+     * should have all high bits set. We can do that by logor with a mask,
+     * where the mask is minus_one left shifted by bitwidth. But if bitwidth
+     * matches the number of bits of Rep, the shift will be incorrect.
+     *   -1 (Int32) << 32 = -1
+     * Then the logor will be also wrong. So we check and bail out early.
+     * *)
+    if not needs_extend then i else
+    let sign_bit = Rep.logand (Rep.of_int (1 lsl (Rep.bitwidth - 1))) i in
+    if sign_bit = Rep.zero then i else
+    (* Build a sign-extension mask *)
+    let sign_mask = (Rep.shift_left Rep.minus_one Rep.bitwidth) in
+    Rep.logor sign_mask i
+
   let of_string s =
     let open Rep in
     let len = String.length s in
@@ -269,13 +374,18 @@ struct
       else parse_dec i zero
     in
     require (len > 0);
-    match s.[0] with
-    | '+' -> parse_int 1
-    | '-' ->
-      let n = parse_int 1 in
-      require (ge_s (sub n one) minus_one);
-      Rep.neg n
-    | _ -> parse_int 0
+    let parsed =
+      match s.[0] with
+      | '+' -> parse_int 1
+      | '-' ->
+        let n = parse_int 1 in
+        require (ge_s (sub n one) minus_one);
+        Rep.neg n
+      | _ -> parse_int 0
+    in
+    let n = sign_extend parsed in
+    require (low_int <= n && n <= high_int);
+    n
 
   let of_string_s s =
     let n = of_string s in
@@ -284,7 +394,7 @@ struct
 
   let of_string_u s =
     let n = of_string s in
-    require (s.[0] != '+' && s.[0] != '-');
+    require (s.[0] <> '+' && s.[0] <> '-');
     n
 
   (* String conversion that groups digits for readability *)
diff --git a/interpreter/exec/numeric_error.ml b/interpreter/exec/numeric_error.ml
deleted file mode 100644
index 0dcf7bc19..000000000
--- a/interpreter/exec/numeric_error.ml
+++ /dev/null
@@ -1,3 +0,0 @@
-exception IntegerOverflow
-exception IntegerDivideByZero
-exception InvalidConversionToInteger
diff --git a/interpreter/exec/v128.ml b/interpreter/exec/v128.ml
new file mode 100644
index 000000000..550fd9bfa
--- /dev/null
+++ b/interpreter/exec/v128.ml
@@ -0,0 +1,506 @@
+(* Types *)
+
+type t = string
+type bits = string
+
+type ('i8x16, 'i16x8, 'i32x4, 'i64x2, 'f32x4, 'f64x2) laneop =
+  | I8x16 of 'i8x16 | I16x8 of 'i16x8 | I32x4 of 'i32x4 | I64x2 of 'i64x2
+  | F32x4 of 'f32x4 | F64x2 of 'f64x2
+
+type shape = (unit, unit, unit, unit, unit, unit) laneop
+
+
+(* Basics *)
+
+let bitwidth = 128
+let bytewidth = bitwidth / 8
+
+let zero = String.make bytewidth '\x00'
+let of_bits x = x
+let to_bits x = x
+
+let num_lanes shape =
+  match shape with
+  | I8x16 _ -> 16
+  | I16x8 _ -> 8
+  | I32x4 _ -> 4
+  | I64x2 _ -> 2
+  | F32x4 _ -> 4
+  | F64x2 _ -> 2
+
+let type_of_lane = function
+  | I8x16 _ | I16x8 _ | I32x4 _ -> Types.I32Type
+  | I64x2 _ -> Types.I64Type
+  | F32x4 _ -> Types.F32Type
+  | F64x2 _ -> Types.F64Type
+
+
+(* Shape-based operations *)
+
+module Convert (Lane : sig type t end) =
+struct
+  module type S =
+  sig
+    val shape : shape
+    val to_lanes : t -> Lane.t list
+    val of_lanes : Lane.t list -> t
+  end
+end
+
+module type IntShape =
+sig
+  type lane
+
+  val num_lanes : int
+  val to_lanes : t -> lane list
+  val of_lanes : lane list -> t
+
+  val splat : lane -> t
+  val extract_lane_s : int -> t -> lane
+  val extract_lane_u : int -> t -> lane
+  val replace_lane : int -> t -> lane -> t
+
+  val eq : t -> t -> t
+  val ne : t -> t -> t
+  val lt_s : t -> t -> t
+  val lt_u : t -> t -> t
+  val le_s : t -> t -> t
+  val le_u : t -> t -> t
+  val gt_s : t -> t -> t
+  val gt_u : t -> t -> t
+  val ge_s : t -> t -> t
+  val ge_u : t -> t -> t
+  val abs : t -> t
+  val neg : t -> t
+  val popcnt : t -> t
+  val add : t -> t -> t
+  val sub : t -> t -> t
+  val min_s : t -> t -> t
+  val min_u : t -> t -> t
+  val max_s : t -> t -> t
+  val max_u : t -> t -> t
+  val mul : t -> t -> t
+  val avgr_u : t -> t -> t
+  val any_true : t -> bool
+  val all_true : t -> bool
+  val bitmask : t -> Int32.t
+  val shl : t -> I32.t -> t
+  val shr_s : t -> I32.t -> t
+  val shr_u : t -> I32.t -> t
+  val add_sat_s : t -> t -> t
+  val add_sat_u : t -> t -> t
+  val sub_sat_s : t -> t -> t
+  val sub_sat_u : t -> t -> t
+  val q15mulr_sat_s : t -> t -> t
+end
+
+module MakeIntShape (IXX : Ixx.S) (Cvt : Convert(IXX).S) :
+  IntShape with type lane = IXX.t =
+struct
+  type lane = IXX.t
+
+  let num_lanes = num_lanes Cvt.shape
+  let of_lanes = Cvt.of_lanes
+  let to_lanes = Cvt.to_lanes
+
+  let unop f x = of_lanes (List.map f (to_lanes x))
+  let unopi f x = of_lanes (List.mapi f (to_lanes x))
+  let binop f x y = of_lanes (List.map2 f (to_lanes x) (to_lanes y))
+  let reduceop f a s = List.fold_left (fun a b -> f a (b <> IXX.zero)) a (to_lanes s)
+  let cmp f x y = if f x y then IXX.of_int_s (-1) else IXX.zero
+
+  let splat x = of_lanes (List.init num_lanes (fun i -> x))
+  let extract_lane_s i s = List.nth (to_lanes s) i
+  let extract_lane_u i s = IXX.as_unsigned (extract_lane_s i s)
+  let replace_lane i v x = unopi (fun j y -> if j = i then x else y) v
+
+  let eq = binop (cmp IXX.eq)
+  let ne = binop (cmp IXX.ne)
+  let lt_s = binop (cmp IXX.lt_s)
+  let lt_u = binop (cmp IXX.lt_u)
+  let le_s = binop (cmp IXX.le_s)
+  let le_u = binop (cmp IXX.le_u)
+  let gt_s = binop (cmp IXX.gt_s)
+  let gt_u = binop (cmp IXX.gt_u)
+  let ge_s = binop (cmp IXX.ge_s)
+  let ge_u = binop (cmp IXX.ge_u)
+  let abs = unop IXX.abs
+  let neg = unop IXX.neg
+  let popcnt = unop IXX.popcnt
+  let add = binop IXX.add
+  let sub = binop IXX.sub
+  let mul = binop IXX.mul
+  let choose f x y = if f x y then x else y
+  let min_s = binop (choose IXX.le_s)
+  let min_u = binop (choose IXX.le_u)
+  let max_s = binop (choose IXX.ge_s)
+  let max_u = binop (choose IXX.ge_u)
+  (* The result of avgr_u will not overflow this type, but the intermediate might,
+   * so have the Int type implement it so they can extend it accordingly *)
+  let avgr_u = binop IXX.avgr_u
+  let any_true = reduceop (||) false
+  let all_true = reduceop (&&) true
+  (* Extract top bits using signed-comparision with zero *)
+  let bitmask x =
+    let xs = to_lanes x in
+    let negs = List.map (fun x -> if IXX.(lt_s x zero) then Int32.one else Int32.zero) xs in
+    List.fold_right (fun a b -> Int32.(logor a (shift_left b 1))) negs Int32.zero
+  let shl v s =
+    let shift = IXX.of_int_u (Int32.to_int s) in
+    unop (fun a -> IXX.shl a shift) v
+  let shr_s v s =
+    let shift = IXX.of_int_u (Int32.to_int s) in
+    unop (fun a -> IXX.shr_s a shift) v
+  let shr_u v s =
+    let shift = IXX.of_int_u (Int32.to_int s) in
+    unop (fun a -> IXX.shr_u a shift) v
+  let add_sat_s = binop IXX.add_sat_s
+  let add_sat_u = binop IXX.add_sat_u
+  let sub_sat_s = binop IXX.sub_sat_s
+  let sub_sat_u = binop IXX.sub_sat_u
+  (* The intermediate will overflow lane.t, so have Int implement this. *)
+  let q15mulr_sat_s = binop IXX.q15mulr_sat_s
+end
+
+module type FloatShape =
+sig
+  type lane
+
+  val num_lanes : int
+  val to_lanes : t -> lane list
+  val of_lanes : lane list -> t
+
+  val splat : lane -> t
+  val extract_lane : int -> t -> lane
+  val replace_lane : int -> t -> lane -> t
+
+  val eq : t -> t -> t
+  val ne : t -> t -> t
+  val lt : t -> t -> t
+  val le : t -> t -> t
+  val gt : t -> t -> t
+  val ge : t -> t -> t
+  val abs : t -> t
+  val neg : t -> t
+  val sqrt : t -> t
+  val ceil : t -> t
+  val floor : t -> t
+  val trunc : t -> t
+  val nearest : t -> t
+  val add : t -> t -> t
+  val sub : t -> t -> t
+  val mul : t -> t -> t
+  val div : t -> t -> t
+  val min : t -> t -> t
+  val max : t -> t -> t
+  val pmin : t -> t -> t
+  val pmax : t -> t -> t
+end
+
+module MakeFloatShape (FXX : Fxx.S) (Cvt : Convert(FXX).S) :
+  FloatShape with type lane = FXX.t =
+struct
+  type lane = FXX.t
+
+  let num_lanes = num_lanes Cvt.shape
+  let of_lanes = Cvt.of_lanes
+  let to_lanes = Cvt.to_lanes
+
+  let unop f x = of_lanes (List.map f (to_lanes x))
+  let unopi f x = of_lanes (List.mapi f (to_lanes x))
+  let binop f x y = of_lanes (List.map2 f (to_lanes x) (to_lanes y))
+  let all_ones = FXX.of_float (Int64.float_of_bits (Int64.minus_one))
+  let cmp f x y = if f x y then all_ones else FXX.zero
+
+  let splat x = of_lanes (List.init num_lanes (fun i -> x))
+  let extract_lane i s = List.nth (to_lanes s) i
+  let replace_lane i v x = unopi (fun j y -> if j = i then x else y) v
+
+  let eq = binop (cmp FXX.eq)
+  let ne = binop (cmp FXX.ne)
+  let lt = binop (cmp FXX.lt)
+  let le = binop (cmp FXX.le)
+  let gt = binop (cmp FXX.gt)
+  let ge = binop (cmp FXX.ge)
+  let abs = unop FXX.abs
+  let neg = unop FXX.neg
+  let sqrt = unop FXX.sqrt
+  let ceil = unop FXX.ceil
+  let floor = unop FXX.floor
+  let trunc = unop FXX.trunc
+  let nearest = unop FXX.nearest
+  let add = binop FXX.add
+  let sub = binop FXX.sub
+  let mul = binop FXX.mul
+  let div = binop FXX.div
+  let min = binop FXX.min
+  let max = binop FXX.max
+  let pmin = binop (fun x y -> if FXX.lt y x then y else x)
+  let pmax = binop (fun x y -> if FXX.lt x y then y else x)
+end
+
+module I8x16 = MakeIntShape (I8)
+  (struct
+    let shape = I8x16 ()
+    let to_lanes s =
+      List.init 16 (fun i -> Int32.of_int (Bytes.get_int8 (Bytes.of_string s) i))
+    let of_lanes fs =
+      let b = Bytes.create bytewidth in
+      List.iteri (fun i f -> Bytes.set_int8 b i (Int32.to_int f)) fs;
+      Bytes.to_string b
+  end)
+
+module I16x8 = MakeIntShape (I16)
+  (struct
+    let shape = I16x8 ()
+    let to_lanes s =
+      List.init 8 (fun i -> Int32.of_int (Bytes.get_int16_le (Bytes.of_string s) (i*2)))
+    let of_lanes fs =
+      let b = Bytes.create bytewidth in
+      List.iteri (fun i f -> Bytes.set_int16_le b (i*2) (Int32.to_int f)) fs;
+      Bytes.to_string b
+  end)
+
+module I32x4 = MakeIntShape (I32)
+  (struct
+    let shape = I32x4 ()
+    let to_lanes s =
+      List.init 4 (fun i -> I32.of_bits (Bytes.get_int32_le (Bytes.of_string s) (i*4)))
+    let of_lanes fs =
+      let b = Bytes.create bytewidth in
+      List.iteri (fun i f -> Bytes.set_int32_le b (i*4) (I32.to_bits f)) fs;
+      Bytes.to_string b
+  end)
+
+module I64x2 = MakeIntShape (I64)
+  (struct
+    let shape = I64x2 ()
+    let to_lanes s =
+      List.init 2 (fun i -> I64.of_bits (Bytes.get_int64_le (Bytes.of_string s) (i*8)))
+    let of_lanes fs =
+      let b = Bytes.create bytewidth in
+      List.iteri (fun i f -> Bytes.set_int64_le b (i*8) (I64.to_bits f)) fs;
+      Bytes.to_string b
+  end)
+
+module F32x4 = MakeFloatShape (F32)
+  (struct
+    let shape = F32x4 ()
+    let to_lanes s =
+      List.init 4 (fun i -> F32.of_bits (Bytes.get_int32_le (Bytes.of_string s) (i*4)))
+    let of_lanes fs =
+      let b = Bytes.create bytewidth in
+      List.iteri (fun i f -> Bytes.set_int32_le b (i*4) (F32.to_bits f)) fs;
+      Bytes.to_string b
+  end)
+
+module F64x2 = MakeFloatShape (F64)
+  (struct
+    let shape = F64x2 ()
+    let to_lanes s =
+      List.init 2 (fun i -> F64.of_bits (Bytes.get_int64_le (Bytes.of_string s) (i*8)))
+    let of_lanes fs =
+      let b = Bytes.create bytewidth in
+      List.iteri (fun i f -> Bytes.set_int64_le b (i*8) (F64.to_bits f)) fs;
+      Bytes.to_string b
+  end)
+
+
+(* Special shapes *)
+
+module V1x128 =
+struct
+  let unop f x = I64x2.of_lanes (List.map f (I64x2.to_lanes x))
+  let binop f x y =
+    I64x2.of_lanes (List.map2 f (I64x2.to_lanes x) (I64x2.to_lanes y))
+
+  let lognot = unop I64.lognot
+  let and_ = binop I64.and_
+  let or_ = binop I64.or_
+  let xor = binop I64.xor
+  let andnot = binop (fun x y -> I64.and_ x (I64.lognot y))
+
+  let bitselect v1 v2 c =
+    let v2_andnot_c = andnot v2 c in
+    let v1_and_c = binop I64.and_ v1 c in
+    binop I64.or_ v1_and_c v2_andnot_c
+end
+
+module V8x16 =
+struct
+  let swizzle v1 v2 =
+    let ns = I8x16.to_lanes v1 in
+    let is = I8x16.to_lanes v2 in
+    let select i =
+      Option.value (List.nth_opt ns (I32.to_int_u i)) ~default: I32.zero
+    in I8x16.of_lanes (List.map select is)
+
+  let shuffle v1 v2 is =
+    let ns = I8x16.to_lanes v1 @ I8x16.to_lanes v2 in
+    I8x16.of_lanes (List.map (List.nth ns) is)
+end
+
+
+(* Conversions *)
+
+let narrow to_lanes of_lanes sat_op x y =
+  let xy = to_lanes x @ to_lanes y in
+  of_lanes (List.map sat_op xy)
+
+module I8x16_convert =
+struct
+  let narrow_s = narrow I16x8.to_lanes I8x16.of_lanes I8.saturate_s
+  let narrow_u = narrow I16x8.to_lanes I8x16.of_lanes I8.saturate_u
+end
+
+module I16x8_convert =
+struct
+  let narrow_s = narrow I32x4.to_lanes I16x8.of_lanes I16.saturate_s
+  let narrow_u = narrow I32x4.to_lanes I16x8.of_lanes I16.saturate_u
+
+  let ext_s = Int32.logand 0xffffffffl
+  let ext_u = Int32.logand 0xffl
+
+  let extend take_or_drop ext x =
+    I16x8.of_lanes (List.map ext (take_or_drop 8 (I8x16.to_lanes x)))
+  let extend_low_s = extend Lib.List.take ext_s
+  let extend_high_s = extend Lib.List.drop ext_s
+  let extend_low_u = extend Lib.List.take ext_u
+  let extend_high_u = extend Lib.List.drop ext_u
+
+  let extmul_low_s x y = I16x8.mul (extend_low_s x) (extend_low_s y)
+  let extmul_high_s x y = I16x8.mul (extend_high_s x) (extend_high_s y)
+  let extmul_low_u x y = I16x8.mul (extend_low_u x) (extend_low_u y)
+  let extmul_high_u x y = I16x8.mul (extend_high_u x) (extend_high_u y)
+
+  let extadd ext x y = Int32.add (ext x) (ext y)
+  let extadd_pairwise_s x =
+    I16x8.of_lanes (Lib.List.pairwise (extadd ext_s) (I8x16.to_lanes x))
+  let extadd_pairwise_u x =
+    I16x8.of_lanes (Lib.List.pairwise (extadd ext_u) (I8x16.to_lanes x))
+end
+
+module I32x4_convert =
+struct
+  let convert f v = I32x4.of_lanes (List.map f (F32x4.to_lanes v))
+  let trunc_sat_f32x4_s = convert I32_convert.trunc_sat_f32_s
+  let trunc_sat_f32x4_u = convert I32_convert.trunc_sat_f32_u
+
+  let convert_zero f v =
+    I32x4.of_lanes (List.map f (F64x2.to_lanes v) @ I32.[zero; zero])
+  let trunc_sat_f64x2_s_zero = convert_zero I32_convert.trunc_sat_f64_s
+  let trunc_sat_f64x2_u_zero = convert_zero I32_convert.trunc_sat_f64_u
+
+  let ext_s = Int32.logand 0xffffffffl
+  let ext_u = Int32.logand 0xffffl
+
+  let extend take_or_drop ext x =
+    I32x4.of_lanes (List.map ext (take_or_drop 4 (I16x8.to_lanes x)))
+  let extend_low_s = extend Lib.List.take ext_s
+  let extend_high_s = extend Lib.List.drop ext_s
+  let extend_low_u = extend Lib.List.take ext_u
+  let extend_high_u = extend Lib.List.drop ext_u
+
+  let dot_s x y =
+    let xs = I16x8.to_lanes x in
+    let ys = I16x8.to_lanes y in
+    let rec dot xs ys =
+      match xs, ys with
+      | x1::x2::xss, y1::y2::yss ->
+        Int32.(add (mul x1 y1) (mul x2 y2)) :: dot xss yss
+      | [], [] -> []
+      | _, _ -> assert false
+    in I32x4.of_lanes (dot xs ys)
+
+  let extmul_low_s x y = I32x4.mul (extend_low_s x) (extend_low_s y)
+  let extmul_high_s x y = I32x4.mul (extend_high_s x) (extend_high_s y)
+  let extmul_low_u x y = I32x4.mul (extend_low_u x) (extend_low_u y)
+  let extmul_high_u x y = I32x4.mul (extend_high_u x) (extend_high_u y)
+
+  let extadd ext x y = Int32.add (ext x) (ext y)
+  let extadd_pairwise_s x =
+    I32x4.of_lanes (Lib.List.pairwise (extadd ext_s) (I16x8.to_lanes x))
+  let extadd_pairwise_u x =
+    I32x4.of_lanes (Lib.List.pairwise (extadd ext_u) (I16x8.to_lanes x))
+end
+
+module I64x2_convert =
+struct
+  let ext_s = Int64.logand 0xffffffffffffffffL
+  let ext_u = Int64.logand 0xffffffffL
+
+  let extend take_or_drop ext x =
+    I64x2.of_lanes
+      (List.map
+        (fun i32 -> ext (Int64.of_int32 i32))
+        (take_or_drop 2 (I32x4.to_lanes x)))
+  let extend_low_s = extend Lib.List.take ext_s
+  let extend_high_s = extend Lib.List.drop ext_s
+  let extend_low_u = extend Lib.List.take ext_u
+  let extend_high_u = extend Lib.List.drop ext_u
+
+  let extmul_low_s x y = I64x2.mul (extend_low_s x) (extend_low_s y)
+  let extmul_high_s x y = I64x2.mul (extend_high_s x) (extend_high_s y)
+  let extmul_low_u x y = I64x2.mul (extend_low_u x) (extend_low_u y)
+  let extmul_high_u x y = I64x2.mul (extend_high_u x) (extend_high_u y)
+end
+
+module F32x4_convert =
+struct
+  let convert f v = F32x4.of_lanes (List.map f (I32x4.to_lanes v))
+  let convert_i32x4_s = convert F32_convert.convert_i32_s
+  let convert_i32x4_u = convert F32_convert.convert_i32_u
+  let demote_f64x2_zero v =
+    F32x4.of_lanes
+      (List.map F32_convert.demote_f64 (F64x2.to_lanes v) @ F32.[zero; zero])
+end
+
+module F64x2_convert =
+struct
+  let convert f v =
+    F64x2.of_lanes (List.map f (Lib.List.take 2 (I32x4.to_lanes v)))
+  let convert_i32x4_s = convert F64_convert.convert_i32_s
+  let convert_i32x4_u = convert F64_convert.convert_i32_u
+  let promote_low_f32x4 v =
+    F64x2.of_lanes
+      (List.map F64_convert.promote_f32 (Lib.List.take 2 (F32x4.to_lanes v)))
+end
+
+
+(* String conversion *)
+
+let to_string s =
+  String.concat " " (List.map I32.to_string_s (I32x4.to_lanes s))
+
+let to_hex_string s =
+  String.concat " " (List.map I32.to_hex_string (I32x4.to_lanes s))
+
+let of_strings shape ss =
+  if List.length ss <> num_lanes shape then
+    raise (Invalid_argument "wrong length");
+  let open Bytes in
+  let b = create bytewidth in
+  (match shape with
+  | I8x16 () ->
+    List.iteri (fun i s -> set_uint8 b i (I8.to_int_u (I8.of_string s))) ss
+  | I16x8 () ->
+    List.iteri (fun i s -> set_int16_le b (i * 2) (I16.to_int_u (I16.of_string s))) ss
+  | I32x4 () ->
+    List.iteri (fun i s -> set_int32_le b (i * 4) (I32.of_string s)) ss
+  | I64x2 () ->
+    List.iteri (fun i s -> set_int64_le b (i * 8) (I64.of_string s)) ss
+  | F32x4 () ->
+    List.iteri (fun i s -> set_int32_le b (i * 4) (F32.to_bits (F32.of_string s))) ss
+  | F64x2 () ->
+    List.iteri (fun i s -> set_int64_le b (i * 8) (F64.to_bits (F64.of_string s))) ss
+  );
+  to_string b
+
+
+let string_of_shape = function
+  | I8x16 _ -> "i8x16"
+  | I16x8 _ -> "i16x8"
+  | I32x4 _ -> "i32x4"
+  | I64x2 _ -> "i64x2"
+  | F32x4 _ -> "f32x4"
+  | F64x2 _ -> "f64x2"
diff --git a/interpreter/exec/v128.mli b/interpreter/exec/v128.mli
new file mode 100644
index 000000000..f9535c158
--- /dev/null
+++ b/interpreter/exec/v128.mli
@@ -0,0 +1,211 @@
+(* Types *)
+
+type t
+type bits = string
+
+type ('i8x16, 'i16x8, 'i32x4, 'i64x2, 'f32x4, 'f64x2) laneop =
+  | I8x16 of 'i8x16 | I16x8 of 'i16x8 | I32x4 of 'i32x4 | I64x2 of 'i64x2
+  | F32x4 of 'f32x4 | F64x2 of 'f64x2
+
+type shape = (unit, unit, unit, unit, unit, unit) laneop
+
+
+(* Basics *)
+
+val bitwidth : int
+
+val num_lanes : ('a, 'b, 'c, 'd, 'e, 'f) laneop -> int
+val type_of_lane : ('a, 'b, 'c, 'd, 'e, 'f) laneop -> Types.num_type
+val string_of_shape : ('a, 'b, 'c, 'd, 'e, 'f) laneop -> string
+
+val zero : t
+val of_bits : bits -> t
+val to_bits : t -> bits
+
+
+(* String conversion *)
+
+val to_string : t -> string
+val to_hex_string : t -> string
+val of_strings : shape -> string list -> t
+
+
+(* Shape-based operations *)
+
+module type IntShape =
+sig
+  type lane
+
+  val num_lanes : int
+  val to_lanes : t -> lane list
+  val of_lanes : lane list -> t
+
+  val splat : lane -> t
+  val extract_lane_s : int -> t -> lane
+  val extract_lane_u : int -> t -> lane
+  val replace_lane : int -> t -> lane -> t
+
+  val eq : t -> t -> t
+  val ne : t -> t -> t
+  val lt_s : t -> t -> t
+  val lt_u : t -> t -> t
+  val le_s : t -> t -> t
+  val le_u : t -> t -> t
+  val gt_s : t -> t -> t
+  val gt_u : t -> t -> t
+  val ge_s : t -> t -> t
+  val ge_u : t -> t -> t
+  val abs : t -> t
+  val neg : t -> t
+  val popcnt : t -> t
+  val add : t -> t -> t
+  val sub : t -> t -> t
+  val min_s : t -> t -> t
+  val min_u : t -> t -> t
+  val max_s : t -> t -> t
+  val max_u : t -> t -> t
+  val mul : t -> t -> t
+  val avgr_u : t -> t -> t
+  val any_true : t -> bool
+  val all_true : t -> bool
+  val bitmask : t -> Int32.t
+  val shl : t -> I32.t -> t
+  val shr_s : t -> I32.t -> t
+  val shr_u : t -> I32.t -> t
+  val add_sat_s : t -> t -> t
+  val add_sat_u : t -> t -> t
+  val sub_sat_s : t -> t -> t
+  val sub_sat_u : t -> t -> t
+  val q15mulr_sat_s : t -> t -> t
+end
+
+module type FloatShape =
+sig
+  type lane
+
+  val num_lanes : int
+  val to_lanes : t -> lane list
+  val of_lanes : lane list -> t
+
+  val splat : lane -> t
+  val extract_lane : int -> t -> lane
+  val replace_lane : int -> t -> lane -> t
+
+  val eq : t -> t -> t
+  val ne : t -> t -> t
+  val lt : t -> t -> t
+  val le : t -> t -> t
+  val gt : t -> t -> t
+  val ge : t -> t -> t
+  val abs : t -> t
+  val neg : t -> t
+  val sqrt : t -> t
+  val ceil : t -> t
+  val floor : t -> t
+  val trunc : t -> t
+  val nearest : t -> t
+  val add : t -> t -> t
+  val sub : t -> t -> t
+  val mul : t -> t -> t
+  val div : t -> t -> t
+  val min : t -> t -> t
+  val max : t -> t -> t
+  val pmin : t -> t -> t
+  val pmax : t -> t -> t
+end
+
+module I8x16 : IntShape with type lane = I8.t
+module I16x8 : IntShape with type lane = I16.t
+module I32x4 : IntShape with type lane = I32.t
+module I64x2 : IntShape with type lane = I64.t
+module F32x4 : FloatShape with type lane = F32.t
+module F64x2 : FloatShape with type lane = F64.t
+
+
+(* Special shapes *)
+
+module V1x128 :
+sig
+  val lognot : t -> t
+  val and_ : t -> t -> t
+  val or_ : t -> t -> t
+  val xor : t -> t -> t
+  val andnot : t -> t -> t
+  val bitselect : t -> t -> t -> t
+end
+
+module V8x16 :
+sig
+  val swizzle : t -> t -> t
+  val shuffle : t -> t -> int list -> t
+end
+
+
+(* Conversions *)
+
+module I8x16_convert :
+sig
+  val narrow_s : t -> t -> t
+  val narrow_u : t -> t -> t
+end
+
+module I16x8_convert :
+sig
+  val narrow_s : t -> t -> t
+  val narrow_u : t -> t -> t
+  val extend_low_s : t -> t
+  val extend_high_s : t -> t
+  val extend_low_u : t -> t
+  val extend_high_u : t -> t
+  val extmul_low_s : t -> t -> t
+  val extmul_high_s : t -> t -> t
+  val extmul_low_u : t -> t -> t
+  val extmul_high_u : t -> t -> t
+  val extadd_pairwise_s : t -> t
+  val extadd_pairwise_u : t -> t
+end
+
+module I32x4_convert :
+sig
+  val trunc_sat_f32x4_s : t -> t
+  val trunc_sat_f32x4_u : t -> t
+  val trunc_sat_f64x2_s_zero : t -> t
+  val trunc_sat_f64x2_u_zero : t -> t
+  val extend_low_s : t -> t
+  val extend_high_s : t -> t
+  val extend_low_u : t -> t
+  val extend_high_u : t -> t
+  val dot_s : t -> t -> t
+  val extmul_low_s : t -> t -> t
+  val extmul_high_s : t -> t -> t
+  val extmul_low_u : t -> t -> t
+  val extmul_high_u : t -> t -> t
+  val extadd_pairwise_s : t -> t
+  val extadd_pairwise_u : t -> t
+end
+
+module I64x2_convert :
+sig
+  val extend_low_s : t -> t
+  val extend_high_s : t -> t
+  val extend_low_u : t -> t
+  val extend_high_u : t -> t
+  val extmul_low_s : t -> t -> t
+  val extmul_high_s : t -> t -> t
+  val extmul_low_u : t -> t -> t
+  val extmul_high_u : t -> t -> t
+end
+
+module F32x4_convert :
+sig
+  val convert_i32x4_s : t -> t
+  val convert_i32x4_u : t -> t
+  val demote_f64x2_zero : t -> t
+end
+
+module F64x2_convert :
+sig
+  val promote_low_f32x4 : t -> t
+  val convert_i32x4_s : t -> t
+  val convert_i32x4_u : t -> t
+end
diff --git a/interpreter/host/spectest.ml b/interpreter/host/spectest.ml
index 168fb9ff3..309fa3d16 100644
--- a/interpreter/host/spectest.ml
+++ b/interpreter/host/spectest.ml
@@ -14,6 +14,7 @@ let global (GlobalType (t, _) as gt) =
     | NumType I64Type -> Num (I64 666L)
     | NumType F32Type -> Num (F32 (F32.of_float 666.6))
     | NumType F64Type -> Num (F64 (F64.of_float 666.6))
+    | VecType V128Type -> Vec (V128 (V128.I32x4.of_lanes [666l; 666l; 666l; 666l]))
     | RefType (_, t) -> Ref (NullRef t)
     | BotType -> assert false
   in Global.alloc gt v
diff --git a/interpreter/runtime/instance.ml b/interpreter/runtime/instance.ml
index 30727c260..79317afd7 100644
--- a/interpreter/runtime/instance.ml
+++ b/interpreter/runtime/instance.ml
@@ -44,6 +44,13 @@ let () =
     | FuncRef _ -> "func"
     | r -> string_of_ref' r
 
+let () =
+  let eq_ref' = !Value.eq_ref' in
+  Value.eq_ref' := fun r1 r2 ->
+    match r1, r2 with
+    | FuncRef f1, FuncRef f2 -> f1 == f2
+    | _, _ -> eq_ref' r1 r2
+
 
 (* Auxiliary functions *)
 
diff --git a/interpreter/runtime/memory.ml b/interpreter/runtime/memory.ml
index 323ee6303..55b703dc8 100644
--- a/interpreter/runtime/memory.ml
+++ b/interpreter/runtime/memory.ml
@@ -103,7 +103,7 @@ let storen mem a o n x =
   in loop (effective_address a o) n x
 
 let load_num mem a o t =
-  let n = loadn mem a o (Types.size t) in
+  let n = loadn mem a o (Types.num_size t) in
   match t with
   | I32Type -> I32 (Int64.to_int32 n)
   | I64Type -> I64 n
@@ -111,20 +111,19 @@ let load_num mem a o t =
   | F64Type -> F64 (F64.of_bits n)
 
 let store_num mem a o n =
-  let x =
-    match n with
-    | I32 x -> Int64.of_int32 x
-    | I64 x -> x
-    | F32 x -> Int64.of_int32 (F32.to_bits x)
-    | F64 x -> F64.to_bits x
-  in storen mem a o (Types.size (Value.type_of_num n)) x
+  let store = storen mem a o (Types.num_size (Value.type_of_num n)) in
+  match n with
+  | I32 x -> store (Int64.of_int32 x)
+  | I64 x -> store x
+  | F32 x -> store (Int64.of_int32 (F32.to_bits x))
+  | F64 x -> store (F64.to_bits x)
 
 let extend x n = function
   | ZX -> x
   | SX -> let sh = 64 - 8 * n in Int64.(shift_right (shift_left x sh) sh)
 
-let load_packed sz ext mem a o t =
-  assert (packed_size sz <= Types.size t);
+let load_num_packed sz ext mem a o t =
+  assert (packed_size sz <= num_size t);
   let w = packed_size sz in
   let x = extend (loadn mem a o w) w ext in
   match t with
@@ -132,8 +131,8 @@ let load_packed sz ext mem a o t =
   | I64Type -> I64 x
   | _ -> raise Type
 
-let store_packed sz mem a o n =
-  assert (packed_size sz <= Types.size (Value.type_of_num n));
+let store_num_packed sz mem a o n =
+  assert (packed_size sz <= Types.num_size (Value.type_of_num n));
   let w = packed_size sz in
   let x =
     match n with
@@ -141,3 +140,36 @@ let store_packed sz mem a o n =
     | I64 x -> x
     | _ -> raise Type
   in storen mem a o w x
+
+let load_vec mem a o t =
+  match t with
+  | V128Type ->
+    V128 (V128.of_bits (load_bytes mem (effective_address a o) (Types.vec_size t)))
+
+let store_vec mem a o n =
+  match n with
+  | V128 x -> store_bytes mem (effective_address a o) (V128.to_bits x)
+
+let load_vec_packed sz ext mem a o t =
+  assert (packed_size sz < vec_size t);
+  let x = loadn mem a o (packed_size sz) in
+  let b = Bytes.make 16 '\x00' in
+  Bytes.set_int64_le b 0 x;
+  let v = V128.of_bits (Bytes.to_string b) in
+  let r =
+    match sz, ext with
+    | Pack64, ExtLane (Pack8x8, SX) -> V128.I16x8_convert.extend_low_s v
+    | Pack64, ExtLane (Pack8x8, ZX) -> V128.I16x8_convert.extend_low_u v
+    | Pack64, ExtLane (Pack16x4, SX) -> V128.I32x4_convert.extend_low_s v
+    | Pack64, ExtLane (Pack16x4, ZX) -> V128.I32x4_convert.extend_low_u v
+    | Pack64, ExtLane (Pack32x2, SX) -> V128.I64x2_convert.extend_low_s v
+    | Pack64, ExtLane (Pack32x2, ZX) -> V128.I64x2_convert.extend_low_u v
+    | _, ExtLane _ -> assert false
+    | Pack8, ExtSplat -> V128.I8x16.splat (I8.of_int_s (Int64.to_int x))
+    | Pack16, ExtSplat -> V128.I16x8.splat (I16.of_int_s (Int64.to_int x))
+    | Pack32, ExtSplat -> V128.I32x4.splat (I32.of_int_s (Int64.to_int x))
+    | Pack64, ExtSplat -> V128.I64x2.splat x
+    | Pack32, ExtZero -> v
+    | Pack64, ExtZero -> v
+    | _, ExtZero -> assert false
+  in V128 r
diff --git a/interpreter/runtime/memory.mli b/interpreter/runtime/memory.mli
index e4b732f6f..79fafbceb 100644
--- a/interpreter/runtime/memory.mli
+++ b/interpreter/runtime/memory.mli
@@ -33,9 +33,18 @@ val load_num :
   memory -> address -> offset -> num_type -> num (* raises Bounds *)
 val store_num :
   memory -> address -> offset -> num -> unit (* raises Bounds *)
-val load_packed :
+val load_num_packed :
   pack_size -> extension -> memory -> address -> offset -> num_type -> num
     (* raises Type, Bounds *)
-val store_packed :
+val store_num_packed :
   pack_size -> memory -> address -> offset -> num -> unit
     (* raises Type, Bounds *)
+
+val load_vec :
+  memory -> address -> offset -> vec_type -> vec (* raises Bounds *)
+val store_vec :
+  memory -> address -> offset -> vec -> unit
+    (* raises Type, Bounds *)
+val load_vec_packed :
+  pack_size -> vec_extension -> memory -> address -> offset -> vec_type -> vec
+    (* raises Type, Bounds *)
diff --git a/interpreter/runtime/value.ml b/interpreter/runtime/value.ml
index c5a5059ec..48fe64639 100644
--- a/interpreter/runtime/value.ml
+++ b/interpreter/runtime/value.ml
@@ -6,24 +6,84 @@ open Types
 type ('i32, 'i64, 'f32, 'f64) op =
   I32 of 'i32 | I64 of 'i64 | F32 of 'f32 | F64 of 'f64
 
+type ('v128) vecop =
+  V128 of 'v128
+
 type num = (I32.t, I64.t, F32.t, F64.t) op
+type vec = (V128.t) vecop
 
 type ref_ = ..
 type ref_ += NullRef of heap_type
 
-type value = Num of num | Ref of ref_
+type value = Num of num | Vec of vec | Ref of ref_
 type t = value
 
 
-(* Projections *)
+(* Injection & projection *)
 
 let as_num = function
   | Num n -> n
-  | Ref _ -> failwith "as_num"
+  | _ -> failwith "as_num"
+
+let as_vec = function
+  | Vec i -> i
+  | _ -> failwith "as_vec"
 
 let as_ref = function
-  | Num _ -> failwith "as_ref"
   | Ref r -> r
+  | _ -> failwith "as_ref"
+
+
+exception TypeError of int * num * num_type
+
+module type NumType =
+sig
+  type t
+  val to_num : t -> num
+  val of_num : int -> num -> t
+end
+
+module I32Num =
+struct
+  type t = I32.t
+  let to_num i = I32 i
+  let of_num n = function I32 i -> i | v -> raise (TypeError (n, v, I32Type))
+end
+
+module I64Num =
+struct
+  type t = I64.t
+  let to_num i = I64 i
+  let of_num n = function I64 i -> i | v -> raise (TypeError (n, v, I64Type))
+end
+
+module F32Num =
+struct
+  type t = F32.t
+  let to_num i = F32 i
+  let of_num n = function F32 z -> z | v -> raise (TypeError (n, v, F32Type))
+end
+
+module F64Num =
+struct
+  type t = F64.t
+  let to_num i = F64 i
+  let of_num n = function F64 z -> z | v -> raise (TypeError (n, v, F64Type))
+end
+
+module type VecType =
+sig
+  type t
+  val to_vec : t -> vec
+  val of_vec : int -> vec -> t
+end
+
+module V128Vec =
+struct
+  type t = V128.t
+  let to_vec i = V128 i
+  let of_vec n = function V128 z -> z
+end
 
 
 (* Typing *)
@@ -34,6 +94,9 @@ let type_of_num = function
   | F32 _ -> F32Type
   | F64 _ -> F64Type
 
+let type_of_vec = function
+  | V128 _ -> V128Type
+
 let type_of_ref' = ref (function _ -> assert false)
 let type_of_ref = function
   | NullRef t -> (Nullable, t)
@@ -41,9 +104,32 @@ let type_of_ref = function
 
 let type_of_value = function
   | Num n -> NumType (type_of_num n)
+  | Vec i -> VecType (type_of_vec i)
   | Ref r -> RefType (type_of_ref r)
 
 
+(* Comparison *)
+
+let eq_num n1 n2 = n1 = n2
+
+let eq_vec v1 v2 = v1 = v2
+
+let eq_ref' = ref (fun r1 r2 ->
+  match r1, r2 with
+  | NullRef _, NullRef _ -> true
+  | _, _ -> false
+)
+
+let eq_ref r1 r2 = !eq_ref' r1 r2
+
+let eq v1 v2 =
+  match v1, v2 with
+  | Num n1, Num n2 -> eq_num n1 n2
+  | Vec v1, Vec v2 -> eq_vec v1 v2
+  | Ref r1, Ref r2 -> eq_ref r1 r2
+  | _, _ -> false
+
+
 (* Defaults *)
 
 let default_num = function
@@ -52,12 +138,16 @@ let default_num = function
   | F32Type -> F32 F32.zero
   | F64Type -> F64 F64.zero
 
+let default_vec = function
+  | V128Type -> V128 V128.zero
+
 let default_ref = function
   | (Nullable, t) -> NullRef t
   | (NonNullable, _) -> assert false
 
 let default_value = function
   | NumType t' -> Num (default_num t')
+  | VecType t' -> Vec (default_vec t')
   | RefType t' -> Ref (default_ref t')
   | BotType -> assert false
 
@@ -72,11 +162,24 @@ let string_of_num = function
   | F32 z -> F32.to_string z
   | F64 z -> F64.to_string z
 
+let hex_string_of_num = function
+  | I32 i -> I32.to_hex_string i
+  | I64 i -> I64.to_hex_string i
+  | F32 z -> F32.to_hex_string z
+  | F64 z -> F64.to_hex_string z
+
+let string_of_vec = function
+  | V128 v -> V128.to_string v
+
+let hex_string_of_vec = function
+  | V128 v -> V128.to_hex_string v
+
 let string_of_ref' = ref (function NullRef t -> "null" | _ -> "ref")
 let string_of_ref r = !string_of_ref' r
 
 let string_of_value = function
   | Num n -> string_of_num n
+  | Vec i -> string_of_vec i
   | Ref r -> string_of_ref r
 
 let string_of_values = function
diff --git a/interpreter/script/js.ml b/interpreter/script/js.ml
index b3fc69f1d..23f3bb65c 100644
--- a/interpreter/script/js.ml
+++ b/interpreter/script/js.ml
@@ -266,7 +266,8 @@ let abs_mask_of = function
 
 let value v =
   match v.it with
-  | Num num -> [Const (num @@ v.at) @@ v.at]
+  | Num n -> [Const (n @@ v.at) @@ v.at]
+  | Vec s -> [VecConst (s @@ v.at) @@ v.at]
   | Ref (NullRef t) -> [RefNull t @@ v.at]
   | Ref (ExternRef n) ->
     [Const (I32 n @@ v.at) @@ v.at; Call (externref_idx @@ v.at) @@ v.at]
@@ -282,50 +283,92 @@ let get t at =
 let run ts at =
   [], []
 
+let nan_bitmask_of = function
+  | CanonicalNan -> abs_mask_of  (* differ from canonical NaN in sign bit *)
+  | ArithmeticNan -> canonical_nan_of  (* 1 everywhere canonical NaN is *)
+
 let assert_return ress ts at =
   let test (res, t) =
     match res.it with
-    | LitResult {it = Num num; at = at'} ->
-      let t', reinterpret = reinterpret_of (type_of_num num) in
+    | NumResult (NumPat {it = num; at = at'}) ->
+      let t', reinterpret = reinterpret_of (Value.type_of_num num) in
       [ reinterpret @@ at;
         Const (num @@ at')  @@ at;
         reinterpret @@ at;
         Compare (eq_of t') @@ at;
         Test (I32 I32Op.Eqz) @@ at;
         BrIf (0l @@ at) @@ at ]
-    | LitResult {it = Ref (NullRef t); _} ->
-      [ RefIsNull @@ at;
-        Test (I32 I32Op.Eqz) @@ at;
-        BrIf (0l @@ at) @@ at ]
-    | LitResult {it = Ref (ExternRef n); _} ->
-      [ Const (I32 n @@ at) @@ at;
-        Call (externref_idx @@ at) @@ at;
-        Call (eq_externref_idx @@ at)  @@ at;
-        Test (I32 I32Op.Eqz) @@ at;
-        BrIf (0l @@ at) @@ at ]
-    | LitResult {it = Ref _; _} ->
-      assert false
-    | NanResult nanop ->
+    | NumResult (NanPat nanop) ->
       let nan =
         match nanop.it with
-        | I32 _ | I64 _ -> assert false
-        | F32 n | F64 n -> n
+        | Value.I32 _ | Value.I64 _ -> .
+        | Value.F32 n | Value.F64 n -> n
       in
-      let nan_bitmask_of =
-        match nan with
-        | CanonicalNan -> abs_mask_of (* must only differ from the canonical NaN in its sign bit *)
-        | ArithmeticNan -> canonical_nan_of (* can be any NaN that's one everywhere the canonical NaN is one *)
-      in
-      let t = type_of_num nanop.it in
+      let t = Value.type_of_num nanop.it in
       let t', reinterpret = reinterpret_of t in
       [ reinterpret @@ at;
-        Const (nan_bitmask_of t' @@ at) @@ at;
+        Const (nan_bitmask_of nan t' @@ at) @@ at;
         Binary (and_of t') @@ at;
         Const (canonical_nan_of t' @@ at) @@ at;
         Compare (eq_of t') @@ at;
         Test (I32 I32Op.Eqz) @@ at;
         BrIf (0l @@ at) @@ at ]
-    | RefResult t ->
+    | VecResult (VecPat (Value.V128 (shape, pats))) ->
+      let open Value in
+      let mask_and_canonical = function
+        | NumPat {it = I32 _ as i; _} -> I32 (Int32.minus_one), i
+        | NumPat {it = I64 _ as i; _} -> I64 (Int64.minus_one), i
+        | NumPat {it = F32 f; _} ->
+          I32 (Int32.minus_one), I32 (I32_convert.reinterpret_f32 f)
+        | NumPat {it = F64 f; _} ->
+          I64 (Int64.minus_one), I64 (I64_convert.reinterpret_f64 f)
+        | NanPat {it = F32 nan; _} ->
+          nan_bitmask_of nan I32Type, canonical_nan_of I32Type
+        | NanPat {it = F64 nan; _} ->
+          nan_bitmask_of nan I64Type, canonical_nan_of I64Type
+        | _ -> .
+      in
+      let masks, canons =
+        List.split (List.map (fun p -> mask_and_canonical p) pats) in
+      let all_ones =
+        V128.I32x4.of_lanes (List.init 4 (fun _ -> Int32.minus_one)) in
+      let mask, expected = match shape with
+        | V128.I8x16 () ->
+          all_ones, V128.I8x16.of_lanes (List.map (I32Num.of_num 0) canons)
+        | V128.I16x8 () ->
+          all_ones, V128.I16x8.of_lanes (List.map (I32Num.of_num 0) canons)
+        | V128.I32x4 () ->
+          all_ones, V128.I32x4.of_lanes (List.map (I32Num.of_num 0) canons)
+        | V128.I64x2 () ->
+          all_ones, V128.I64x2.of_lanes (List.map (I64Num.of_num 0) canons)
+        | V128.F32x4 () ->
+          V128.I32x4.of_lanes (List.map (I32Num.of_num 0) masks),
+          V128.I32x4.of_lanes (List.map (I32Num.of_num 0) canons)
+        | V128.F64x2 () ->
+          V128.I64x2.of_lanes (List.map (I64Num.of_num 0) masks),
+          V128.I64x2.of_lanes (List.map (I64Num.of_num 0) canons)
+      in
+      [ VecConst (V128 mask @@ at) @@ at;
+        VecBinaryBits (V128 V128Op.And) @@ at;
+        VecConst (V128 expected @@ at) @@ at;
+        VecCompare (V128 (V128.I8x16 V128Op.Eq)) @@ at;
+        (* If all lanes are non-zero, then they are equal *)
+        VecTest (V128 (V128.I8x16 V128Op.AllTrue)) @@ at;
+        Test (I32 I32Op.Eqz) @@ at;
+        BrIf (0l @@ at) @@ at ]
+    | RefResult (RefPat {it = Value.NullRef t; _}) ->
+      [ RefIsNull @@ at;
+        Test (Value.I32 I32Op.Eqz) @@ at;
+        BrIf (0l @@ at) @@ at ]
+    | RefResult (RefPat {it = Script.ExternRef n; _}) ->
+      [ Const (Value.I32 n @@ at) @@ at;
+        Call (externref_idx @@ at) @@ at;
+        Call (eq_externref_idx @@ at)  @@ at;
+        Test (Value.I32 I32Op.Eqz) @@ at;
+        BrIf (0l @@ at) @@ at ]
+    | RefResult (RefPat _) ->
+      assert false
+    | RefResult (RefTypePat t) ->
       let is_ref_idx =
         match t with
         | FuncHeapType -> is_funcref_idx
@@ -336,7 +379,7 @@ let assert_return ress ts at =
       [ Call (is_ref_idx @@ at) @@ at;
         Test (I32 I32Op.Eqz) @@ at;
         BrIf (0l @@ at) @@ at ]
-    | NullResult ->
+    | RefResult NullPat ->
       (match t with
       | RefType _ ->
         [ BrOnNull (0l @@ at) @@ at ]
@@ -398,6 +441,7 @@ let is_js_num_type = function
 
 let is_js_value_type = function
   | NumType t -> is_js_num_type t
+  | VecType t -> false
   | RefType t -> true
   | BotType -> assert false
 
@@ -442,30 +486,57 @@ let of_float z =
   | "-inf" -> "-Infinity"
   | s -> s
 
+let of_num n =
+  let open Value in
+  match n with
+  | I32 i -> I32.to_string_s i
+  | I64 i -> "int64(\"" ^ I64.to_string_s i ^ "\")"
+  | F32 z -> of_float (F32.to_float z)
+  | F64 z -> of_float (F64.to_float z)
+
+let of_vec v =
+  let open Value in
+  match v with
+  | V128 v -> "v128(\"" ^ V128.to_string v ^ "\")"
+
+let of_ref r =
+  let open Value in
+  match r with
+  | NullRef _ -> "null"
+  | ExternRef n -> "externref(" ^ Int32.to_string n ^ ")"
+  | _ -> assert false
+
 let of_value v =
   match v.it with
-  | Num (I32 i) -> I32.to_string_s i
-  | Num (I64 i) -> "int64(\"" ^ I64.to_string_s i ^ "\")"
-  | Num (F32 z) -> of_float (F32.to_float z)
-  | Num (F64 z) -> of_float (F64.to_float z)
-  | Ref (NullRef _) -> "null"
-  | Ref (ExternRef n) -> "externref(" ^ Int32.to_string n ^ ")"
-  | _ -> assert false
+  | Num n -> of_num n
+  | Vec v -> of_vec v
+  | Ref r -> of_ref r
 
 let of_nan = function
   | CanonicalNan -> "\"nan:canonical\""
   | ArithmeticNan -> "\"nan:arithmetic\""
 
+let of_num_pat = function
+  | NumPat num -> of_num num.it
+  | NanPat nanop ->
+    match nanop.it with
+    | Value.I32 _ | Value.I64 _ -> .
+    | Value.F32 n | Value.F64 n -> of_nan n
+
+let of_vec_pat = function
+  | VecPat (Value.V128 (shape, pats)) ->
+    Printf.sprintf "v128(\"%s\")" (String.concat " " (List.map of_num_pat pats))
+
+let of_ref_pat = function
+  | RefPat r -> of_ref r.it
+  | RefTypePat t -> "\"ref." ^ string_of_heap_type t ^ "\""
+  | NullPat -> "\"ref.null\""
+
 let of_result res =
   match res.it with
-  | LitResult value -> of_value value
-  | NanResult nanop ->
-    (match nanop.it with
-    | I32 _ | I64 _ -> assert false
-    | F32 n | F64 n -> of_nan n
-    )
-  | RefResult t -> "\"ref." ^ string_of_heap_type t ^ "\""
-  | NullResult -> "\"ref.null\""
+  | NumResult np -> of_num_pat np
+  | VecResult vp -> of_vec_pat vp
+  | RefResult rp -> of_ref_pat rp
 
 let rec of_definition def =
   match def.it with
diff --git a/interpreter/script/run.ml b/interpreter/script/run.ml
index edb33f1e2..98faf4c41 100644
--- a/interpreter/script/run.ml
+++ b/interpreter/script/run.ml
@@ -228,21 +228,37 @@ let string_of_nan = function
 
 let type_of_result r =
   match r with
-  | LitResult v -> Value.type_of_value v.it
-  | NanResult n -> Types.NumType (Value.type_of_num n.it)
-  | RefResult t -> Types.(RefType (NonNullable, t))
-  | NullResult -> Types.(RefType (Nullable, ExternHeapType))
+  | NumResult (NumPat n) -> Types.NumType (Value.type_of_num n.it)
+  | NumResult (NanPat n) -> Types.NumType (Value.type_of_num n.it)
+  | VecResult (VecPat _) -> Types.VecType Types.V128Type
+  | RefResult (RefPat r) -> Types.RefType (Value.type_of_ref r.it)
+  | RefResult (RefTypePat t) -> Types.(RefType (NonNullable, t))
+  | RefResult (NullPat) -> Types.(RefType (Nullable, ExternHeapType))
+
+let string_of_num_pat (p : num_pat) =
+  match p with
+  | NumPat n -> Value.string_of_num n.it
+  | NanPat nanop ->
+    match nanop.it with
+    | Value.I32 _ | Value.I64 _ -> assert false
+    | Value.F32 n | Value.F64 n -> string_of_nan n
+
+let string_of_vec_pat (p : vec_pat) =
+  match p with
+  | VecPat (Value.V128 (shape, ns)) ->
+    String.concat " " (List.map string_of_num_pat ns)
+
+let string_of_ref_pat (p : ref_pat) =
+  match p with
+  | RefPat r -> Value.string_of_ref r.it
+  | RefTypePat t -> Types.string_of_heap_type t
+  | NullPat -> "null"
 
 let string_of_result r =
   match r with
-  | LitResult v -> Value.string_of_value v.it
-  | NanResult nanop ->
-    (match nanop.it with
-    | Value.I32 _ | Value.I64 _ -> assert false
-    | Value.F32 n | Value.F64 n -> string_of_nan n
-    )
-  | RefResult t -> Types.string_of_heap_type t
-  | NullResult -> "null"
+  | NumResult np -> string_of_num_pat np
+  | VecResult vp -> string_of_vec_pat vp
+  | RefResult rp -> string_of_ref_pat rp
 
 let string_of_results = function
   | [r] -> string_of_result r
@@ -329,39 +345,59 @@ let run_action act : Value.t list =
     | None -> Assert.error act.at "undefined export"
     )
 
-let assert_result at got expect =
+let assert_nan_pat n nan =
+  let open Value in
+  match n, nan.it with
+  | F32 z, F32 CanonicalNan -> z = F32.pos_nan || z = F32.neg_nan
+  | F64 z, F64 CanonicalNan -> z = F64.pos_nan || z = F64.neg_nan
+  | F32 z, F32 ArithmeticNan ->
+    let pos_nan = F32.to_bits F32.pos_nan in
+    Int32.logand (F32.to_bits z) pos_nan = pos_nan
+  | F64 z, F64 ArithmeticNan ->
+    let pos_nan = F64.to_bits F64.pos_nan in
+    Int64.logand (F64.to_bits z) pos_nan = pos_nan
+  | _, _ -> false
+
+let assert_num_pat n np =
+  match np with
+    | NumPat n' -> n = n'.it
+    | NanPat nanop -> assert_nan_pat n nanop
+
+let assert_vec_pat v p =
   let open Value in
+  match v, p with
+  | V128 v, VecPat (V128 (shape, ps)) ->
+    let extract = match shape with
+      | V128.I8x16 () -> fun v i -> I32 (V128.I8x16.extract_lane_s i v)
+      | V128.I16x8 () -> fun v i -> I32 (V128.I16x8.extract_lane_s i v)
+      | V128.I32x4 () -> fun v i -> I32 (V128.I32x4.extract_lane_s i v)
+      | V128.I64x2 () -> fun v i -> I64 (V128.I64x2.extract_lane_s i v)
+      | V128.F32x4 () -> fun v i -> F32 (V128.F32x4.extract_lane i v)
+      | V128.F64x2 () -> fun v i -> F64 (V128.F64x2.extract_lane i v)
+    in
+    List.for_all2 assert_num_pat
+      (List.init (V128.num_lanes shape) (extract v)) ps
+
+let assert_ref_pat r p =
+  match r, p with
+  | r, RefPat r' -> Value.eq_ref r r'.it
+  | Instance.FuncRef _, RefTypePat Types.FuncHeapType
+  | ExternRef _, RefTypePat Types.ExternHeapType -> true
+  | Value.NullRef _, NullPat -> true
+  | _ -> false
+
+let assert_pat v r =
+  let open Value in
+  match v, r with
+  | Num n, NumResult np -> assert_num_pat n np
+  | Vec v, VecResult vp -> assert_vec_pat v vp
+  | Ref r, RefResult rp -> assert_ref_pat r rp
+  | _, _ -> false
+
+let assert_result at got expect =
   if
     List.length got <> List.length expect ||
-    List.exists2 (fun v r ->
-      match r with
-      | LitResult v' -> v <> v'.it
-      | NanResult nanop ->
-        (match nanop.it, v with
-        | F32 CanonicalNan, Num (F32 z) ->
-          z <> F32.pos_nan && z <> F32.neg_nan
-        | F64 CanonicalNan, Num (F64 z) ->
-          z <> F64.pos_nan && z <> F64.neg_nan
-        | F32 ArithmeticNan, Num (F32 z) ->
-          let pos_nan = F32.to_bits F32.pos_nan in
-          Int32.logand (F32.to_bits z) pos_nan <> pos_nan
-        | F64 ArithmeticNan, Num (F64 z) ->
-          let pos_nan = F64.to_bits F64.pos_nan in
-          Int64.logand (F64.to_bits z) pos_nan <> pos_nan
-        | _, _ -> false
-        )
-      | RefResult t ->
-        (match t, v with
-        | Types.FuncHeapType, Ref (Instance.FuncRef _)
-        | Types.ExternHeapType, Ref (ExternRef _) -> false
-        | _ -> true
-        )
-      | NullResult ->
-        (match v with
-        | Ref (NullRef _) -> false
-        | _ -> true
-        )
-    ) got expect
+    List.exists2 (fun v r -> not (assert_pat v r)) got expect
   then begin
     print_string "Result: "; print_values got;
     print_string "Expect: "; print_results expect;
diff --git a/interpreter/script/script.ml b/interpreter/script/script.ml
index 82c73be91..2d6c430f8 100644
--- a/interpreter/script/script.ml
+++ b/interpreter/script/script.ml
@@ -1,6 +1,8 @@
 type var = string Source.phrase
 
 type Value.ref_ += ExternRef of int32
+type num = Value.num Source.phrase
+type ref_ = Value.ref_ Source.phrase
 type literal = Value.t Source.phrase
 
 type definition = definition' Source.phrase
@@ -18,12 +20,23 @@ type nanop = nanop' Source.phrase
 and nanop' = (Lib.void, Lib.void, nan, nan) Value.op
 and nan = CanonicalNan | ArithmeticNan
 
+type num_pat =
+  | NumPat of num
+  | NanPat of nanop
+
+type vec_pat =
+  | VecPat of (V128.shape * num_pat list) Value.vecop
+
+type ref_pat =
+  | RefPat of ref_
+  | RefTypePat of Types.heap_type
+  | NullPat
+
 type result = result' Source.phrase
 and result' =
-  | LitResult of literal
-  | NanResult of nanop
-  | RefResult of Types.heap_type
-  | NullResult
+  | NumResult of num_pat
+  | VecResult of vec_pat
+  | RefResult of ref_pat
 
 type assertion = assertion' Source.phrase
 and assertion' =
@@ -65,3 +78,10 @@ let () =
   Value.string_of_ref' := function
     | ExternRef n -> "ref " ^ Int32.to_string n
     | r -> string_of_ref' r
+
+let () =
+  let eq_ref' = !Value.eq_ref' in
+  Value.eq_ref' := fun r1 r2 ->
+    match r1, r2 with
+    | ExternRef n1, ExternRef n2 -> n1 = n2
+    | _, _ -> eq_ref' r1 r2
diff --git a/interpreter/syntax/ast.ml b/interpreter/syntax/ast.ml
index d9ad52edc..7cb898dc6 100644
--- a/interpreter/syntax/ast.ml
+++ b/interpreter/syntax/ast.ml
@@ -20,6 +20,8 @@
 
 open Types
 
+type void = Lib.void
+
 
 (* Operators *)
 
@@ -40,7 +42,7 @@ module FloatOp =
 struct
   type unop = Neg | Abs | Ceil | Floor | Trunc | Nearest | Sqrt
   type binop = Add | Sub | Mul | Div | Min | Max | CopySign
-  type testop
+  type testop = |
   type relop = Eq | Ne | Lt | Gt | Le | Ge
   type cvtop = ConvertSI32 | ConvertUI32 | ConvertSI64 | ConvertUI64
              | PromoteF32 | DemoteF64
@@ -52,22 +54,85 @@ module I64Op = IntOp
 module F32Op = FloatOp
 module F64Op = FloatOp
 
+module V128Op =
+struct
+  type itestop = AllTrue
+  type iunop = Abs | Neg | Popcnt
+  type funop = Abs | Neg | Sqrt | Ceil | Floor | Trunc | Nearest
+  type ibinop = Add | Sub | Mul | MinS | MinU | MaxS | MaxU | AvgrU
+              | AddSatS | AddSatU | SubSatS | SubSatU | DotS | Q15MulRSatS
+              | ExtMulLowS | ExtMulHighS | ExtMulLowU | ExtMulHighU
+              | Swizzle | Shuffle of int list | NarrowS | NarrowU
+  type fbinop = Add | Sub | Mul | Div | Min | Max | Pmin | Pmax
+  type irelop = Eq | Ne | LtS | LtU | LeS | LeU | GtS | GtU | GeS | GeU
+  type frelop = Eq | Ne | Lt | Le | Gt | Ge
+  type icvtop = ExtendLowS | ExtendLowU | ExtendHighS | ExtendHighU
+              | ExtAddPairwiseS | ExtAddPairwiseU
+              | TruncSatSF32x4 | TruncSatUF32x4
+              | TruncSatSZeroF64x2 | TruncSatUZeroF64x2
+  type fcvtop = DemoteZeroF64x2 | PromoteLowF32x4
+              | ConvertSI32x4 | ConvertUI32x4
+  type ishiftop = Shl | ShrS | ShrU
+  type ibitmaskop = Bitmask
+
+  type vtestop = AnyTrue
+  type vunop = Not
+  type vbinop = And | Or | Xor | AndNot
+  type vternop = Bitselect
+
+  type testop = (itestop, itestop, itestop, itestop, void, void) V128.laneop
+  type unop = (iunop, iunop, iunop, iunop, funop, funop) V128.laneop
+  type binop = (ibinop, ibinop, ibinop, ibinop, fbinop, fbinop) V128.laneop
+  type relop = (irelop, irelop, irelop, irelop, frelop, frelop) V128.laneop
+  type cvtop = (icvtop, icvtop, icvtop, icvtop, fcvtop, fcvtop) V128.laneop
+  type shiftop = (ishiftop, ishiftop, ishiftop, ishiftop, void, void) V128.laneop
+  type bitmaskop = (ibitmaskop, ibitmaskop, ibitmaskop, ibitmaskop, void, void) V128.laneop
+
+  type nsplatop = Splat
+  type 'a nextractop = Extract of int * 'a
+  type nreplaceop = Replace of int
+
+  type splatop = (nsplatop, nsplatop, nsplatop, nsplatop, nsplatop, nsplatop) V128.laneop
+  type extractop = (extension nextractop, extension nextractop, unit nextractop, unit nextractop, unit nextractop, unit nextractop) V128.laneop
+  type replaceop = (nreplaceop, nreplaceop, nreplaceop, nreplaceop, nreplaceop, nreplaceop) V128.laneop
+end
+
+type testop = (I32Op.testop, I64Op.testop, F32Op.testop, F64Op.testop) Value.op
 type unop = (I32Op.unop, I64Op.unop, F32Op.unop, F64Op.unop) Value.op
 type binop = (I32Op.binop, I64Op.binop, F32Op.binop, F64Op.binop) Value.op
-type testop = (I32Op.testop, I64Op.testop, F32Op.testop, F64Op.testop) Value.op
 type relop = (I32Op.relop, I64Op.relop, F32Op.relop, F64Op.relop) Value.op
 type cvtop = (I32Op.cvtop, I64Op.cvtop, F32Op.cvtop, F64Op.cvtop) Value.op
 
-type 'a memop = {ty : num_type; align : int; offset : int32; sz : 'a option}
-type loadop = (pack_size * extension) memop
-type storeop = pack_size memop
+type vec_testop = (V128Op.testop) Value.vecop
+type vec_relop = (V128Op.relop) Value.vecop
+type vec_unop = (V128Op.unop) Value.vecop
+type vec_binop = (V128Op.binop) Value.vecop
+type vec_cvtop = (V128Op.cvtop) Value.vecop
+type vec_shiftop = (V128Op.shiftop) Value.vecop
+type vec_bitmaskop = (V128Op.bitmaskop) Value.vecop
+type vec_vtestop = (V128Op.vtestop) Value.vecop
+type vec_vunop = (V128Op.vunop) Value.vecop
+type vec_vbinop = (V128Op.vbinop) Value.vecop
+type vec_vternop = (V128Op.vternop) Value.vecop
+type vec_splatop = (V128Op.splatop) Value.vecop
+type vec_extractop = (V128Op.extractop) Value.vecop
+type vec_replaceop = (V128Op.replaceop) Value.vecop
+
+type ('t, 'p) memop = {ty : 't; align : int; offset : int32; pack : 'p}
+type loadop = (num_type, (pack_size * extension) option) memop
+type storeop = (num_type, pack_size option) memop
+
+type vec_loadop = (vec_type, (pack_size * vec_extension) option) memop
+type vec_storeop = (vec_type, unit) memop
+type vec_laneop = (vec_type, pack_size) memop * int
 
 
 (* Expressions *)
 
 type idx = int32 Source.phrase
 type num = Value.num Source.phrase
-type name = Types.name
+type vec = Value.vec Source.phrase
+type name = int list
 
 type local = local' Source.phrase
 and local' = value_type
@@ -110,6 +175,10 @@ and instr' =
   | ElemDrop of idx                   (* drop passive element segment *)
   | Load of loadop                    (* read memory at address *)
   | Store of storeop                  (* write memory at address *)
+  | VecLoad of vec_loadop             (* read memory at address *)
+  | VecStore of vec_storeop           (* write memory at address *)
+  | VecLoadLane of vec_laneop         (* read single lane at address *)
+  | VecStoreLane of vec_laneop        (* write single lane to address *)
   | MemorySize                        (* size of memory *)
   | MemoryGrow                        (* grow memory *)
   | MemoryFill                        (* fill memory range with value *)
@@ -126,6 +195,21 @@ and instr' =
   | Unary of unop                     (* unary numeric operator *)
   | Binary of binop                   (* binary numeric operator *)
   | Convert of cvtop                  (* conversion *)
+  | VecConst of vec                   (* constant *)
+  | VecTest of vec_testop             (* vector test *)
+  | VecCompare of vec_relop           (* vector comparison *)
+  | VecUnary of vec_unop              (* unary vector operator *)
+  | VecBinary of vec_binop            (* binary vector operator *)
+  | VecConvert of vec_cvtop           (* vector conversion *)
+  | VecShift of vec_shiftop           (* vector shifts *)
+  | VecBitmask of vec_bitmaskop       (* vector masking *)
+  | VecTestBits of vec_vtestop        (* vector bit test *)
+  | VecUnaryBits of vec_vunop         (* unary bit vector operator *)
+  | VecBinaryBits of vec_vbinop       (* binary bit vector operator *)
+  | VecTernaryBits of vec_vternop     (* ternary bit vector operator *)
+  | VecSplat of vec_splatop           (* number to vector conversion *)
+  | VecExtract of vec_extractop       (* extract lane from vector *)
+  | VecReplace of vec_replaceop       (* replace lane in vector *)
 
 
 (* Globals & Functions *)
diff --git a/interpreter/syntax/free.ml b/interpreter/syntax/free.ml
index 43a56792a..e468c3e10 100644
--- a/interpreter/syntax/free.ml
+++ b/interpreter/syntax/free.ml
@@ -69,6 +69,9 @@ let var_type = function
 let num_type = function
   | I32Type | I64Type | F32Type | F64Type -> empty
 
+let vec_type = function
+  | V128Type -> empty
+
 let heap_type = function
   | FuncHeapType | ExternHeapType | BotHeapType -> empty
   | DefHeapType x -> var_type x
@@ -78,6 +81,7 @@ let ref_type = function
 
 let value_type = function
   | NumType t -> num_type t
+  | VecType t -> vec_type t
   | RefType t -> ref_type t
   | BotType -> empty
 
@@ -120,7 +124,14 @@ let rec instr (e : instr) =
   | TableCopy (x, y) -> tables (idx x) ++ tables (idx y)
   | TableInit (x, y) -> tables (idx x) ++ elems (idx y)
   | ElemDrop x -> elems (idx x)
-  | Load _ | Store _ | MemorySize | MemoryGrow | MemoryCopy | MemoryFill ->
+  | Load _ | Store _
+  | VecLoad _ | VecStore _ | VecLoadLane _ | VecStoreLane _
+  | MemorySize | MemoryGrow | MemoryCopy | MemoryFill ->
+    memories zero
+  | VecConst _ | VecTest _ | VecUnary _ | VecBinary _ | VecCompare _
+  | VecConvert _ | VecShift _ | VecBitmask _
+  | VecTestBits _ | VecUnaryBits _ | VecBinaryBits _ | VecTernaryBits _
+  | VecSplat _ | VecExtract _ | VecReplace _ ->
     memories zero
   | MemoryInit x -> memories zero ++ datas (idx x)
   | DataDrop x -> datas (idx x)
diff --git a/interpreter/syntax/operators.ml b/interpreter/syntax/operators.ml
index ea71e3fc5..bae67b076 100644
--- a/interpreter/syntax/operators.ml
+++ b/interpreter/syntax/operators.ml
@@ -1,6 +1,7 @@
 open Source
 open Types
 open Value
+open V128
 open Ast
 
 
@@ -8,6 +9,7 @@ let i32_const n = Const (I32 n.it @@ n.at)
 let i64_const n = Const (I64 n.it @@ n.at)
 let f32_const n = Const (F32 n.it @@ n.at)
 let f64_const n = Const (F64 n.it @@ n.at)
+let v128_const n = VecConst (V128 n.it @@ n.at)
 let ref_null t = RefNull t
 let ref_func x = RefFunc x
 
@@ -49,45 +51,45 @@ let table_copy x y = TableCopy (x, y)
 let table_init x y = TableInit (x, y)
 let elem_drop x = ElemDrop x
 
-let i32_load align offset = Load {ty = I32Type; align; offset; sz = None}
-let i64_load align offset = Load {ty = I64Type; align; offset; sz = None}
-let f32_load align offset = Load {ty = F32Type; align; offset; sz = None}
-let f64_load align offset = Load {ty = F64Type; align; offset; sz = None}
+let i32_load align offset = Load {ty = I32Type; align; offset; pack = None}
+let i64_load align offset = Load {ty = I64Type; align; offset; pack = None}
+let f32_load align offset = Load {ty = F32Type; align; offset; pack = None}
+let f64_load align offset = Load {ty = F64Type; align; offset; pack = None}
 let i32_load8_s align offset =
-  Load {ty = I32Type; align; offset; sz = Some (Pack8, SX)}
+  Load {ty = I32Type; align; offset; pack = Some (Pack8, SX)}
 let i32_load8_u align offset =
-  Load {ty = I32Type; align; offset; sz = Some (Pack8, ZX)}
+  Load {ty = I32Type; align; offset; pack = Some (Pack8, ZX)}
 let i32_load16_s align offset =
-  Load {ty = I32Type; align; offset; sz = Some (Pack16, SX)}
+  Load {ty = I32Type; align; offset; pack = Some (Pack16, SX)}
 let i32_load16_u align offset =
-  Load {ty = I32Type; align; offset; sz = Some (Pack16, ZX)}
+  Load {ty = I32Type; align; offset; pack = Some (Pack16, ZX)}
 let i64_load8_s align offset =
-  Load {ty = I64Type; align; offset; sz = Some (Pack8, SX)}
+  Load {ty = I64Type; align; offset; pack = Some (Pack8, SX)}
 let i64_load8_u align offset =
-  Load {ty = I64Type; align; offset; sz = Some (Pack8, ZX)}
+  Load {ty = I64Type; align; offset; pack = Some (Pack8, ZX)}
 let i64_load16_s align offset =
-  Load {ty = I64Type; align; offset; sz = Some (Pack16, SX)}
+  Load {ty = I64Type; align; offset; pack = Some (Pack16, SX)}
 let i64_load16_u align offset =
-  Load {ty = I64Type; align; offset; sz = Some (Pack16, ZX)}
+  Load {ty = I64Type; align; offset; pack = Some (Pack16, ZX)}
 let i64_load32_s align offset =
-  Load {ty = I64Type; align; offset; sz = Some (Pack32, SX)}
+  Load {ty = I64Type; align; offset; pack = Some (Pack32, SX)}
 let i64_load32_u align offset =
-  Load {ty = I64Type; align; offset; sz = Some (Pack32, ZX)}
+  Load {ty = I64Type; align; offset; pack = Some (Pack32, ZX)}
 
-let i32_store align offset = Store {ty = I32Type; align; offset; sz = None}
-let i64_store align offset = Store {ty = I64Type; align; offset; sz = None}
-let f32_store align offset = Store {ty = F32Type; align; offset; sz = None}
-let f64_store align offset = Store {ty = F64Type; align; offset; sz = None}
+let i32_store align offset = Store {ty = I32Type; align; offset; pack = None}
+let i64_store align offset = Store {ty = I64Type; align; offset; pack = None}
+let f32_store align offset = Store {ty = F32Type; align; offset; pack = None}
+let f64_store align offset = Store {ty = F64Type; align; offset; pack = None}
 let i32_store8 align offset =
-  Store {ty = I32Type; align; offset; sz = Some Pack8}
+  Store {ty = I32Type; align; offset; pack = Some Pack8}
 let i32_store16 align offset =
-  Store {ty = I32Type; align; offset; sz = Some Pack16}
+  Store {ty = I32Type; align; offset; pack = Some Pack16}
 let i64_store8 align offset =
-  Store {ty = I64Type; align; offset; sz = Some Pack8}
+  Store {ty = I64Type; align; offset; pack = Some Pack8}
 let i64_store16 align offset =
-  Store {ty = I64Type; align; offset; sz = Some Pack16}
+  Store {ty = I64Type; align; offset; pack = Some Pack16}
 let i64_store32 align offset =
-  Store {ty = I64Type; align; offset; sz = Some Pack32}
+  Store {ty = I64Type; align; offset; pack = Some Pack32}
 
 let memory_size = MemorySize
 let memory_grow = MemoryGrow
@@ -240,3 +242,270 @@ let i32_reinterpret_f32 = Convert (I32 I32Op.ReinterpretFloat)
 let i64_reinterpret_f64 = Convert (I64 I64Op.ReinterpretFloat)
 let f32_reinterpret_i32 = Convert (F32 F32Op.ReinterpretInt)
 let f64_reinterpret_i64 = Convert (F64 F64Op.ReinterpretInt)
+
+let v128_load align offset = VecLoad {ty = V128Type; align; offset; pack = None}
+let v128_load8x8_s align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtLane (Pack8x8, SX))}
+let v128_load8x8_u align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtLane (Pack8x8, ZX))}
+let v128_load16x4_s align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtLane (Pack16x4, SX))}
+let v128_load16x4_u align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtLane (Pack16x4, ZX))}
+let v128_load32x2_s align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtLane (Pack32x2, SX))}
+let v128_load32x2_u align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtLane (Pack32x2, ZX))}
+let v128_load8_splat align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack8, ExtSplat)}
+let v128_load16_splat align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack16, ExtSplat)}
+let v128_load32_splat align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack32, ExtSplat)}
+let v128_load64_splat align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtSplat)}
+let v128_load32_zero align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack32, ExtZero)}
+let v128_load64_zero align offset =
+  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtZero)}
+
+let v128_store align offset = VecStore {ty = V128Type; align; offset; pack = ()}
+
+let v128_load8_lane align offset i =
+  VecLoadLane ({ty = V128Type; align; offset; pack = Pack8}, i)
+let v128_load16_lane align offset i =
+  VecLoadLane ({ty = V128Type; align; offset; pack = Pack16}, i)
+let v128_load32_lane align offset i =
+  VecLoadLane ({ty = V128Type; align; offset; pack = Pack32}, i)
+let v128_load64_lane align offset i =
+  VecLoadLane ({ty = V128Type; align; offset; pack = Pack64}, i)
+
+let v128_store8_lane align offset i =
+  VecStoreLane ({ty = V128Type; align; offset; pack = Pack8}, i)
+let v128_store16_lane align offset i =
+  VecStoreLane ({ty = V128Type; align; offset; pack = Pack16}, i)
+let v128_store32_lane align offset i =
+  VecStoreLane ({ty = V128Type; align; offset; pack = Pack32}, i)
+let v128_store64_lane align offset i =
+  VecStoreLane ({ty = V128Type; align; offset; pack = Pack64}, i)
+
+let v128_not = VecUnaryBits (V128 V128Op.Not)
+let v128_and = VecBinaryBits (V128 V128Op.And)
+let v128_andnot = VecBinaryBits (V128 V128Op.AndNot)
+let v128_or = VecBinaryBits (V128 V128Op.Or)
+let v128_xor = VecBinaryBits (V128 V128Op.Xor)
+let v128_bitselect = VecTernaryBits (V128 V128Op.Bitselect)
+let v128_any_true = VecTestBits (V128 V128Op.AnyTrue)
+
+let i8x16_swizzle = VecBinary (V128 (I8x16 V128Op.Swizzle))
+let i8x16_shuffle is = VecBinary (V128 (I8x16 (V128Op.Shuffle is)))
+
+let i8x16_splat = VecSplat (V128 (I8x16 V128Op.Splat))
+let i8x16_extract_lane_s i = VecExtract (V128 (I8x16 (V128Op.Extract (i, SX))))
+let i8x16_extract_lane_u i = VecExtract (V128 (I8x16 (V128Op.Extract (i, ZX))))
+let i8x16_replace_lane i = VecReplace (V128 (I8x16 (V128Op.Replace i)))
+let i8x16_eq = VecCompare (V128 (I8x16 V128Op.Eq))
+let i8x16_ne = VecCompare (V128 (I8x16 V128Op.Ne))
+let i8x16_lt_s = VecCompare (V128 (I8x16 V128Op.LtS))
+let i8x16_lt_u = VecCompare (V128 (I8x16 V128Op.LtU))
+let i8x16_le_s = VecCompare (V128 (I8x16 V128Op.LeS))
+let i8x16_le_u = VecCompare (V128 (I8x16 V128Op.LeU))
+let i8x16_gt_s = VecCompare (V128 (I8x16 V128Op.GtS))
+let i8x16_gt_u = VecCompare (V128 (I8x16 V128Op.GtU))
+let i8x16_ge_s = VecCompare (V128 (I8x16 V128Op.GeS))
+let i8x16_ge_u = VecCompare (V128 (I8x16 V128Op.GeU))
+let i8x16_neg = VecUnary (V128 (I8x16 V128Op.Neg))
+let i8x16_bitmask = VecBitmask (V128 (I8x16 V128Op.Bitmask))
+let i8x16_all_true = VecTest (V128 (I8x16 V128Op.AllTrue))
+let i8x16_narrow_i16x8_s = VecBinary (V128 (I8x16 V128Op.NarrowS))
+let i8x16_narrow_i16x8_u = VecBinary (V128 (I8x16 V128Op.NarrowU))
+let i16x8_extend_low_i8x16_s = VecConvert (V128 (I16x8 V128Op.ExtendLowS))
+let i16x8_extend_high_i8x16_s = VecConvert (V128 (I16x8 V128Op.ExtendHighS))
+let i16x8_extend_low_i8x16_u = VecConvert (V128 (I16x8 V128Op.ExtendLowU))
+let i16x8_extend_high_i8x16_u = VecConvert (V128 (I16x8 V128Op.ExtendHighU))
+let i8x16_shl = VecShift (V128 (I8x16 V128Op.Shl))
+let i8x16_shr_s = VecShift (V128 (I8x16 V128Op.ShrS))
+let i8x16_shr_u = VecShift (V128 (I8x16 V128Op.ShrU))
+let i8x16_add = VecBinary (V128 (I8x16 V128Op.Add))
+let i8x16_add_sat_s = VecBinary (V128 (I8x16 V128Op.AddSatS))
+let i8x16_add_sat_u = VecBinary (V128 (I8x16 V128Op.AddSatU))
+let i8x16_sub = VecBinary (V128 (I8x16 V128Op.Sub))
+let i8x16_sub_sat_s = VecBinary (V128 (I8x16 V128Op.SubSatS))
+let i8x16_sub_sat_u = VecBinary (V128 (I8x16 V128Op.SubSatU))
+let i8x16_abs = VecUnary (V128 (I8x16 V128Op.Abs))
+let i8x16_popcnt = VecUnary (V128 (I8x16 V128Op.Popcnt))
+let i8x16_min_s = VecBinary (V128 (I8x16 V128Op.MinS))
+let i8x16_min_u = VecBinary (V128 (I8x16 V128Op.MinU))
+let i8x16_max_s = VecBinary (V128 (I8x16 V128Op.MaxS))
+let i8x16_max_u = VecBinary (V128 (I8x16 V128Op.MaxU))
+let i8x16_avgr_u = VecBinary (V128 (I8x16 V128Op.AvgrU))
+
+let i16x8_splat = VecSplat (V128 (I16x8 V128Op.Splat))
+let i16x8_extract_lane_s i = VecExtract (V128 (I16x8 (V128Op.Extract (i, SX))))
+let i16x8_extract_lane_u i = VecExtract (V128 (I16x8 (V128Op.Extract (i, ZX))))
+let i16x8_replace_lane i = VecReplace (V128 (I16x8 (V128Op.Replace i)))
+let i16x8_eq = VecCompare (V128 (I16x8 V128Op.Eq))
+let i16x8_ne = VecCompare (V128 (I16x8 V128Op.Ne))
+let i16x8_lt_s = VecCompare (V128 (I16x8 V128Op.LtS))
+let i16x8_lt_u = VecCompare (V128 (I16x8 V128Op.LtU))
+let i16x8_le_s = VecCompare (V128 (I16x8 V128Op.LeS))
+let i16x8_le_u = VecCompare (V128 (I16x8 V128Op.LeU))
+let i16x8_gt_s = VecCompare (V128 (I16x8 V128Op.GtS))
+let i16x8_gt_u = VecCompare (V128 (I16x8 V128Op.GtU))
+let i16x8_ge_s = VecCompare (V128 (I16x8 V128Op.GeS))
+let i16x8_ge_u = VecCompare (V128 (I16x8 V128Op.GeU))
+let i16x8_neg = VecUnary (V128 (I16x8 V128Op.Neg))
+let i16x8_bitmask = VecBitmask (V128 (I16x8 V128Op.Bitmask))
+let i16x8_all_true = VecTest (V128 (I16x8 V128Op.AllTrue))
+let i16x8_narrow_i32x4_s = VecBinary (V128 (I16x8 V128Op.NarrowS))
+let i16x8_narrow_i32x4_u = VecBinary (V128 (I16x8 V128Op.NarrowU))
+let i16x8_shl = VecShift (V128 (I16x8 V128Op.Shl))
+let i16x8_shr_s = VecShift (V128 (I16x8 V128Op.ShrS))
+let i16x8_shr_u = VecShift (V128 (I16x8 V128Op.ShrU))
+let i16x8_add = VecBinary (V128 (I16x8 V128Op.Add))
+let i16x8_add_sat_s = VecBinary (V128 (I16x8 V128Op.AddSatS))
+let i16x8_add_sat_u = VecBinary (V128 (I16x8 V128Op.AddSatU))
+let i16x8_sub = VecBinary (V128 (I16x8 V128Op.Sub))
+let i16x8_sub_sat_s = VecBinary (V128 (I16x8 V128Op.SubSatS))
+let i16x8_sub_sat_u = VecBinary (V128 (I16x8 V128Op.SubSatU))
+let i16x8_mul = VecBinary (V128 (I16x8 V128Op.Mul))
+let i16x8_abs = VecUnary (V128 (I16x8 V128Op.Abs))
+let i16x8_min_s = VecBinary (V128 (I16x8 V128Op.MinS))
+let i16x8_min_u = VecBinary (V128 (I16x8 V128Op.MinU))
+let i16x8_max_s = VecBinary (V128 (I16x8 V128Op.MaxS))
+let i16x8_max_u = VecBinary (V128 (I16x8 V128Op.MaxU))
+let i16x8_avgr_u = VecBinary (V128 (I16x8 V128Op.AvgrU))
+let i16x8_extmul_low_i8x16_s = VecBinary (V128 (I16x8 V128Op.ExtMulLowS))
+let i16x8_extmul_high_i8x16_s = VecBinary (V128 (I16x8 V128Op.ExtMulHighS))
+let i16x8_extmul_low_i8x16_u = VecBinary (V128 (I16x8 V128Op.ExtMulLowU))
+let i16x8_extmul_high_i8x16_u = VecBinary (V128 (I16x8 V128Op.ExtMulHighU))
+let i16x8_q15mulr_sat_s = VecBinary (V128 (I16x8 V128Op.Q15MulRSatS))
+let i16x8_extadd_pairwise_i8x16_s = VecConvert (V128 (I16x8 V128Op.ExtAddPairwiseS))
+let i16x8_extadd_pairwise_i8x16_u = VecConvert (V128 (I16x8 V128Op.ExtAddPairwiseU))
+
+let i32x4_splat = VecSplat (V128 (I32x4 V128Op.Splat))
+let i32x4_extract_lane i = VecExtract (V128 (I32x4 (V128Op.Extract (i, ()))))
+let i32x4_replace_lane i = VecReplace (V128 (I32x4 (V128Op.Replace i)))
+let i32x4_eq = VecCompare (V128 (I32x4 V128Op.Eq))
+let i32x4_ne = VecCompare (V128 (I32x4 V128Op.Ne))
+let i32x4_lt_s = VecCompare (V128 (I32x4 V128Op.LtS))
+let i32x4_lt_u = VecCompare (V128 (I32x4 V128Op.LtU))
+let i32x4_le_s = VecCompare (V128 (I32x4 V128Op.LeS))
+let i32x4_le_u = VecCompare (V128 (I32x4 V128Op.LeU))
+let i32x4_gt_s = VecCompare (V128 (I32x4 V128Op.GtS))
+let i32x4_gt_u = VecCompare (V128 (I32x4 V128Op.GtU))
+let i32x4_ge_s = VecCompare (V128 (I32x4 V128Op.GeS))
+let i32x4_ge_u = VecCompare (V128 (I32x4 V128Op.GeU))
+let i32x4_abs = VecUnary (V128 (I32x4 V128Op.Abs))
+let i32x4_neg = VecUnary (V128 (I32x4 V128Op.Neg))
+let i32x4_bitmask = VecBitmask (V128 (I32x4 V128Op.Bitmask))
+let i32x4_all_true = VecTest (V128 (I32x4 V128Op.AllTrue))
+let i32x4_extend_low_i16x8_s = VecConvert (V128 (I32x4 V128Op.ExtendLowS))
+let i32x4_extend_high_i16x8_s = VecConvert (V128 (I32x4 V128Op.ExtendHighS))
+let i32x4_extend_low_i16x8_u = VecConvert (V128 (I32x4 V128Op.ExtendLowU))
+let i32x4_extend_high_i16x8_u = VecConvert (V128 (I32x4 V128Op.ExtendHighU))
+let i32x4_shl = VecShift (V128 (I32x4 V128Op.Shl))
+let i32x4_shr_s = VecShift (V128 (I32x4 V128Op.ShrS))
+let i32x4_shr_u = VecShift (V128 (I32x4 V128Op.ShrU))
+let i32x4_add = VecBinary (V128 (I32x4 V128Op.Add))
+let i32x4_sub = VecBinary (V128 (I32x4 V128Op.Sub))
+let i32x4_min_s = VecBinary (V128 (I32x4 V128Op.MinS))
+let i32x4_min_u = VecBinary (V128 (I32x4 V128Op.MinU))
+let i32x4_max_s = VecBinary (V128 (I32x4 V128Op.MaxS))
+let i32x4_max_u = VecBinary (V128 (I32x4 V128Op.MaxU))
+let i32x4_mul = VecBinary (V128 (I32x4 V128Op.Mul))
+let i32x4_dot_i16x8_s = VecBinary (V128 (I32x4 V128Op.DotS))
+let i32x4_trunc_sat_f32x4_s = VecConvert (V128 (I32x4 V128Op.TruncSatSF32x4))
+let i32x4_trunc_sat_f32x4_u = VecConvert (V128 (I32x4 V128Op.TruncSatUF32x4))
+let i32x4_trunc_sat_f64x2_s_zero = VecConvert (V128 (I32x4 V128Op.TruncSatSZeroF64x2))
+let i32x4_trunc_sat_f64x2_u_zero = VecConvert (V128 (I32x4 V128Op.TruncSatUZeroF64x2))
+let i32x4_extmul_low_i16x8_s = VecBinary (V128 (I32x4 V128Op.ExtMulLowS))
+let i32x4_extmul_high_i16x8_s = VecBinary (V128 (I32x4 V128Op.ExtMulHighS))
+let i32x4_extmul_low_i16x8_u = VecBinary (V128 (I32x4 V128Op.ExtMulLowU))
+let i32x4_extmul_high_i16x8_u = VecBinary (V128 (I32x4 V128Op.ExtMulHighU))
+let i32x4_extadd_pairwise_i16x8_s = VecConvert (V128 (I32x4 V128Op.ExtAddPairwiseS))
+let i32x4_extadd_pairwise_i16x8_u = VecConvert (V128 (I32x4 V128Op.ExtAddPairwiseU))
+
+let i64x2_splat = VecSplat (V128 (I64x2 V128Op.Splat))
+let i64x2_extract_lane i = VecExtract (V128 (I64x2 (V128Op.Extract (i, ()))))
+let i64x2_replace_lane i = VecReplace (V128 (I64x2 (V128Op.Replace i)))
+let i64x2_extend_low_i32x4_s = VecConvert (V128 (I64x2 V128Op.ExtendLowS))
+let i64x2_extend_high_i32x4_s = VecConvert (V128 (I64x2 V128Op.ExtendHighS))
+let i64x2_extend_low_i32x4_u = VecConvert (V128 (I64x2 V128Op.ExtendLowU))
+let i64x2_extend_high_i32x4_u = VecConvert (V128 (I64x2 V128Op.ExtendHighU))
+let i64x2_eq = VecCompare (V128 (I64x2 V128Op.Eq))
+let i64x2_ne = VecCompare (V128 (I64x2 V128Op.Ne))
+let i64x2_lt_s = VecCompare (V128 (I64x2 V128Op.LtS))
+let i64x2_le_s = VecCompare (V128 (I64x2 V128Op.LeS))
+let i64x2_gt_s = VecCompare (V128 (I64x2 V128Op.GtS))
+let i64x2_ge_s = VecCompare (V128 (I64x2 V128Op.GeS))
+let i64x2_abs = VecUnary (V128 (I64x2 V128Op.Abs))
+let i64x2_neg = VecUnary (V128 (I64x2 V128Op.Neg))
+let i64x2_bitmask = VecBitmask (V128 (I64x2 V128Op.Bitmask))
+let i64x2_all_true = VecTest (V128 (I64x2 V128Op.AllTrue))
+let i64x2_add = VecBinary (V128 (I64x2 V128Op.Add))
+let i64x2_sub = VecBinary (V128 (I64x2 V128Op.Sub))
+let i64x2_mul = VecBinary (V128 (I64x2 V128Op.Mul))
+let i64x2_shl = VecShift (V128 (I64x2 V128Op.Shl))
+let i64x2_shr_s = VecShift (V128 (I64x2 V128Op.ShrS))
+let i64x2_shr_u = VecShift (V128 (I64x2 V128Op.ShrU))
+let i64x2_extmul_low_i32x4_s = VecBinary (V128 (I64x2 V128Op.ExtMulLowS))
+let i64x2_extmul_high_i32x4_s = VecBinary (V128 (I64x2 V128Op.ExtMulHighS))
+let i64x2_extmul_low_i32x4_u = VecBinary (V128 (I64x2 V128Op.ExtMulLowU))
+let i64x2_extmul_high_i32x4_u = VecBinary (V128 (I64x2 V128Op.ExtMulHighU))
+
+let f32x4_splat = VecSplat (V128 (F32x4 V128Op.Splat))
+let f32x4_extract_lane i = VecExtract (V128 (F32x4 (V128Op.Extract (i, ()))))
+let f32x4_replace_lane i = VecReplace (V128 (F32x4 (V128Op.Replace i)))
+let f32x4_eq = VecCompare (V128 (F32x4 V128Op.Eq))
+let f32x4_ne = VecCompare (V128 (F32x4 V128Op.Ne))
+let f32x4_lt = VecCompare (V128 (F32x4 V128Op.Lt))
+let f32x4_le = VecCompare (V128 (F32x4 V128Op.Le))
+let f32x4_gt = VecCompare (V128 (F32x4 V128Op.Gt))
+let f32x4_ge = VecCompare (V128 (F32x4 V128Op.Ge))
+let f32x4_abs = VecUnary (V128 (F32x4 V128Op.Abs))
+let f32x4_neg = VecUnary (V128 (F32x4 V128Op.Neg))
+let f32x4_sqrt = VecUnary (V128 (F32x4 V128Op.Sqrt))
+let f32x4_ceil = VecUnary (V128 (F32x4 V128Op.Ceil))
+let f32x4_floor = VecUnary (V128 (F32x4 V128Op.Floor))
+let f32x4_trunc = VecUnary (V128 (F32x4 V128Op.Trunc))
+let f32x4_nearest = VecUnary (V128 (F32x4 V128Op.Nearest))
+let f32x4_add = VecBinary (V128 (F32x4 V128Op.Add))
+let f32x4_sub = VecBinary (V128 (F32x4 V128Op.Sub))
+let f32x4_mul = VecBinary (V128 (F32x4 V128Op.Mul))
+let f32x4_div = VecBinary (V128 (F32x4 V128Op.Div))
+let f32x4_min = VecBinary (V128 (F32x4 V128Op.Min))
+let f32x4_max = VecBinary (V128 (F32x4 V128Op.Max))
+let f32x4_pmin = VecBinary (V128 (F32x4 V128Op.Pmin))
+let f32x4_pmax = VecBinary (V128 (F32x4 V128Op.Pmax))
+let f32x4_demote_f64x2_zero = VecConvert (V128 (F32x4 V128Op.DemoteZeroF64x2))
+let f32x4_convert_i32x4_s = VecConvert (V128 (F32x4 V128Op.ConvertSI32x4))
+let f32x4_convert_i32x4_u = VecConvert (V128 (F32x4 V128Op.ConvertUI32x4))
+
+let f64x2_splat = VecSplat (V128 (F64x2 V128Op.Splat))
+let f64x2_extract_lane i = VecExtract (V128 (F64x2 (V128Op.Extract (i, ()))))
+let f64x2_replace_lane i = VecReplace (V128 (F64x2 (V128Op.Replace i)))
+let f64x2_eq = VecCompare (V128 (F64x2 V128Op.Eq))
+let f64x2_ne = VecCompare (V128 (F64x2 V128Op.Ne))
+let f64x2_lt = VecCompare (V128 (F64x2 V128Op.Lt))
+let f64x2_le = VecCompare (V128 (F64x2 V128Op.Le))
+let f64x2_gt = VecCompare (V128 (F64x2 V128Op.Gt))
+let f64x2_ge = VecCompare (V128 (F64x2 V128Op.Ge))
+let f64x2_neg = VecUnary (V128 (F64x2 V128Op.Neg))
+let f64x2_sqrt = VecUnary (V128 (F64x2 V128Op.Sqrt))
+let f64x2_ceil = VecUnary (V128 (F64x2 V128Op.Ceil))
+let f64x2_floor = VecUnary (V128 (F64x2 V128Op.Floor))
+let f64x2_trunc = VecUnary (V128 (F64x2 V128Op.Trunc))
+let f64x2_nearest = VecUnary (V128 (F64x2 V128Op.Nearest))
+let f64x2_add = VecBinary (V128 (F64x2 V128Op.Add))
+let f64x2_sub = VecBinary (V128 (F64x2 V128Op.Sub))
+let f64x2_mul = VecBinary (V128 (F64x2 V128Op.Mul))
+let f64x2_div = VecBinary (V128 (F64x2 V128Op.Div))
+let f64x2_min = VecBinary (V128 (F64x2 V128Op.Min))
+let f64x2_max = VecBinary (V128 (F64x2 V128Op.Max))
+let f64x2_abs = VecUnary (V128 (F64x2 V128Op.Abs))
+let f64x2_pmin = VecBinary (V128 (F64x2 V128Op.Pmin))
+let f64x2_pmax = VecBinary (V128 (F64x2 V128Op.Pmax))
+let f64x2_promote_low_f32x4 = VecConvert (V128 (F64x2 V128Op.PromoteLowF32x4))
+let f64x2_convert_low_i32x4_s = VecConvert (V128 (F64x2 V128Op.ConvertSI32x4))
+let f64x2_convert_low_i32x4_u = VecConvert (V128 (F64x2 V128Op.ConvertUI32x4))
diff --git a/interpreter/syntax/types.ml b/interpreter/syntax/types.ml
index afb2bc1ca..3e6c93b45 100644
--- a/interpreter/syntax/types.ml
+++ b/interpreter/syntax/types.ml
@@ -8,11 +8,13 @@ and var = SynVar of syn_var | SemVar of sem_var
 
 and nullability = NonNullable | Nullable
 and num_type = I32Type | I64Type | F32Type | F64Type
+and vec_type = V128Type
 and ref_type = nullability * heap_type
 and heap_type =
   FuncHeapType | ExternHeapType | DefHeapType of var | BotHeapType
+and value_type =
+  NumType of num_type | VecType of vec_type | RefType of ref_type | BotType
 
-and value_type = NumType of num_type | RefType of ref_type | BotType
 and result_type = value_type list
 and func_type = FuncType of result_type * result_type
 and def_type = FuncDefType of func_type
@@ -33,40 +35,61 @@ type import_type = ImportType of extern_type * name * name
 type module_type =
   ModuleType of def_type list * import_type list * export_type list
 
-type pack_size = Pack8 | Pack16 | Pack32
+(* TODO: these types should move somewhere else *)
+type pack_size = Pack8 | Pack16 | Pack32 | Pack64
 type extension = SX | ZX
+type pack_shape = Pack8x8 | Pack16x4 | Pack32x2
+type vec_extension =
+  | ExtLane of pack_shape * extension
+  | ExtSplat
+  | ExtZero
 
 
 (* Attributes *)
 
-let size = function
+let num_size = function
   | I32Type | F32Type -> 4
   | I64Type | F64Type -> 8
 
+let vec_size = function
+  | V128Type -> 16
+
 let packed_size = function
   | Pack8 -> 1
   | Pack16 -> 2
   | Pack32 -> 4
+  | Pack64 -> 8
+
+let packed_shape_size = function
+  | Pack8x8 | Pack16x4 | Pack32x2 -> 8
 
 let is_syn_var = function SynVar _ -> true | SemVar _ -> false
 let is_sem_var = function SemVar _ -> true | SynVar _ -> false
 
 let is_num_type = function
   | NumType _ | BotType -> true
-  | RefType _ -> false
+  | _ -> false
+
+let is_vec_type = function
+  | VecType _ | BotType -> true
+  | _ -> false
 
 let is_ref_type = function
-  | NumType _ -> false
   | RefType _ | BotType -> true
+  | _ -> false
 
 let defaultable_num_type = function
   | _ -> true
 
+let defaultable_vec_type = function
+  | _ -> true
+
 let defaultable_ref_type = function
   | (nul, _) -> nul = Nullable
 
 let defaultable_value_type = function
   | NumType t -> defaultable_num_type t
+  | VecType t -> defaultable_vec_type t
   | RefType t -> defaultable_ref_type t
   | BotType -> assert false
 
@@ -110,6 +133,8 @@ let sem_var_type c = function
 
 let sem_num_type c t = t
 
+let sem_vec_type c t = t
+
 let sem_heap_type c = function
   | FuncHeapType -> FuncHeapType
   | ExternHeapType -> ExternHeapType
@@ -121,6 +146,7 @@ let sem_ref_type c = function
 
 let sem_value_type c = function
   | NumType t -> NumType (sem_num_type c t)
+  | VecType t -> VecType (sem_vec_type c t)
   | RefType t -> RefType (sem_ref_type c t)
   | BotType -> BotType
 
@@ -204,6 +230,9 @@ and string_of_num_type = function
   | F32Type -> "f32"
   | F64Type -> "f64"
 
+and string_of_vec_type = function
+  | V128Type -> "v128"
+
 and string_of_heap_type = function
   | FuncHeapType -> "func"
   | ExternHeapType -> "extern"
@@ -216,6 +245,7 @@ and string_of_ref_type = function
 
 and string_of_value_type = function
   | NumType t -> string_of_num_type t
+  | VecType t -> string_of_vec_type t
   | RefType t -> string_of_ref_type t
   | BotType -> "(something)"
 
diff --git a/interpreter/tests/smallint.ml b/interpreter/tests/smallint.ml
new file mode 100644
index 000000000..3fe21c7c6
--- /dev/null
+++ b/interpreter/tests/smallint.ml
@@ -0,0 +1,108 @@
+(* Simple, non-exhaustive tests for small ints (i8, i16). *)
+
+let s32max = 0x7fffffffl
+let s32min = 0x80000000l
+let u32max = 0xffffffffl
+let u32min = 0l
+
+(* Smaller ints are stored sign extended in an Int32. *)
+let s16max = 32767l
+let s16min = -32768l
+let u16max = u32max
+let u16min = 0l
+
+let s8max = 127l
+let s8min = -128l
+let u8max = u32max
+let u8min = 0l
+
+let assert_equal x y =
+  if x <> y then raise (Failure
+  (Printf.sprintf "Expected: %ld, but got %ld." x y))
+
+let () =
+  (* test addition wrap around *)
+  assert_equal u32min (I32.add u32max 1l);
+  assert_equal u16min (I16.add u16max 1l);
+  assert_equal u8min (I8.add u8max 1l);
+  assert_equal s32min (I32.add s32max 1l);
+  assert_equal s16min (I16.add s16max 1l);
+  assert_equal s8min (I8.add s8max 1l);
+
+  (* test subtraction wrap around *)
+  assert_equal u32max (I32.sub u32min 1l);
+  assert_equal u16max (I16.sub u16min 1l);
+  assert_equal u8max (I8.sub u8min 1l);
+  assert_equal s32max (I32.sub s32min 1l);
+  assert_equal s16max (I16.sub s16min 1l);
+  assert_equal s8max (I8.sub s8min 1l);
+
+  (* test mul wrap around *)
+  assert_equal 1l (I32.mul u32max u32max);
+  assert_equal 1l (I16.mul u16max u16max);
+  assert_equal 1l (I8.mul u8max u8max);
+  assert_equal 1l (I32.mul s32max s32max);
+  assert_equal 1l (I16.mul s16max s16max);
+  assert_equal 1l (I8.mul s8max s8max);
+
+  (* test add_sat_s *)
+  assert_equal s16max (I16.add_sat_s s16max 1l);
+  assert_equal s8max (I8.add_sat_s s8max 1l);
+  assert_equal u16max (I16.add_sat_u u16max 1l);
+  assert_equal u8max (I8.add_sat_u u8max 1l);
+
+  (* test sub_sat_s *)
+  assert_equal s16min (I16.sub_sat_s s16min 1l);
+  assert_equal s8min (I8.sub_sat_s s8min 1l);
+  assert_equal 0l (I16.sub_sat_u 0l 1l);
+  assert_equal 0l (I8.sub_sat_u 0l 1l);
+
+  (* test div wrap around *)
+  try
+    ignore (I32.div_s s32min (-1l));
+    ignore (I16.div_s s16min (-1l));
+    ignore (I8.div_s s8min (-1l));
+    assert false
+  with Ixx.Overflow ->
+    ();
+
+  (* test shifts overflow *)
+  assert_equal s16min (I16.shl 16384l 1l);
+  assert_equal s8min (I8.shl 64l 1l);
+  assert_equal 0x7fffl (I16.shr_u u16max 1l);
+  assert_equal 0x7fl (I8.shr_u u8max 1l);
+  (* check that the top bits are not messed with *)
+  assert_equal u16max (I16.shr_u u16max 0l);
+  assert_equal u8max (I8.shr_u u8max 0l);
+
+  (* check rotation *)
+  assert_equal 1l (I16.rotl s16min 1l);
+  assert_equal 1l (I8.rotl s8min 1l);
+  assert_equal s16min (I16.rotl 0x4000l 1l);
+  assert_equal s8min (I8.rotl 0x40l 1l);
+
+  assert_equal s32min (I32.rotr 1l 1l);
+  assert_equal s16min (I16.rotr 1l 1l);
+  assert_equal s8min (I8.rotr 1l 1l);
+
+  assert_equal 1l (I32.rotr s32min 31l);
+  assert_equal 1l (I16.rotr s16min 15l);
+  assert_equal 1l (I8.rotr s8min 7l);
+  assert_equal 0x40000000l (I32.rotr s32min 1l);
+  assert_equal 0x4000l (I16.rotr s16min 1l);
+  assert_equal 0x40l (I8.rotr s8min 1l);
+
+  (* check clz *)
+  assert_equal 0l (I16.clz s16min);
+  assert_equal 0l (I8.clz s8min);
+  assert_equal 1l (I16.clz s16max);
+  assert_equal 1l (I8.clz s8max);
+
+  (* check popcnt *)
+  assert_equal 1l (I32.popcnt s32min);
+  assert_equal 1l (I16.popcnt s16min);
+  assert_equal 1l (I8.popcnt s8min);
+  assert_equal 16l (I16.popcnt (-1l));
+  assert_equal 8l (I8.popcnt (-1l));
+  assert_equal 15l (I16.popcnt s16max);
+  assert_equal 7l (I8.popcnt s8max);
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index a858fcd03..37e47b9b2 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -56,6 +56,7 @@ let break_string s =
 (* Types *)
 
 let num_type t = string_of_num_type t
+let vec_type t = string_of_vec_type t
 let ref_type t = string_of_ref_type t
 let heap_type t = string_of_heap_type t
 let value_type t = string_of_value_type t
@@ -80,11 +81,22 @@ let pack_size = function
   | Pack8 -> "8"
   | Pack16 -> "16"
   | Pack32 -> "32"
+  | Pack64 -> "64"
 
 let extension = function
   | SX -> "_s"
   | ZX -> "_u"
 
+let pack_shape = function
+  | Pack8x8 -> "8x8"
+  | Pack16x4 -> "16x4"
+  | Pack32x2 -> "32x2"
+
+let vec_extension sz = function
+  | ExtLane (sh, ext) -> pack_shape sh ^ extension ext
+  | ExtSplat -> pack_size sz ^ "_splat"
+  | ExtZero -> pack_size sz ^ "_zero"
+
 
 (* Operators *)
 
@@ -149,7 +161,7 @@ module FloatOp =
 struct
   open Ast.FloatOp
 
-  let testop xx = fun _ -> assert false
+  let testop xx = function (_ : testop) -> .
 
   let relop xx = function
     | Eq -> "eq"
@@ -187,12 +199,176 @@ struct
     | ReinterpretInt -> "reinterpret_i" ^ xx
 end
 
-let oper (intop, floatop) op =
+module V128Op =
+struct
+  open Ast.V128Op
+
+  let half = function
+    | "16x8" -> "8x16"
+    | "32x4" -> "16x8"
+    | "64x2" -> "32x4"
+    | _ -> assert false
+
+  let double = function
+    | "8x16" -> "16x8"
+    | "16x8" -> "32x4"
+    | "32x4" -> "64x2"
+    | _ -> assert false
+
+  let voidop xxxx = function (_ : void) -> .
+
+  let itestop xxxx (op : itestop) = match op with
+    | AllTrue -> "all_true"
+
+  let iunop xxxx (op : iunop) = match op with
+    | Neg -> "neg"
+    | Abs -> "abs"
+    | Popcnt -> "popcnt"
+
+  let funop xxxx (op : funop) = match op with
+    | Neg -> "neg"
+    | Abs -> "abs"
+    | Sqrt -> "sqrt"
+    | Ceil -> "ceil"
+    | Floor -> "floor"
+    | Trunc -> "trunc"
+    | Nearest -> "nearest"
+
+  let ibinop xxxx (op : ibinop) = match op with
+    | Add -> "add"
+    | AddSatS -> "add_sat_s"
+    | AddSatU -> "add_sat_u"
+    | Sub -> "sub"
+    | SubSatS -> "sub_sat_s"
+    | SubSatU -> "sub_sat_u"
+    | Mul -> "mul"
+    | DotS -> "dot_i" ^ half xxxx ^ "_s"
+    | ExtMulLowS -> "extmul_low_i" ^ half xxxx ^ "_s"
+    | ExtMulHighS -> "extmul_high_i" ^ half xxxx ^ "_s"
+    | ExtMulLowU -> "extmul_low_i" ^ half xxxx ^ "_u"
+    | ExtMulHighU -> "extmul_high_i" ^ half xxxx ^ "_u"
+    | Q15MulRSatS -> "q15mulr_sat_s"
+    | MinS -> "min_s"
+    | MinU -> "min_u"
+    | MaxS -> "max_s"
+    | MaxU -> "max_u"
+    | AvgrU -> "avgr_u"
+    | NarrowS -> "narrow_i" ^ double xxxx ^ "_s"
+    | NarrowU -> "narrow_i" ^ double xxxx ^ "_u"
+    | Shuffle is -> "shuffle " ^ String.concat " " (List.map nat is)
+    | Swizzle -> "swizzle"
+
+  let fbinop xxxx (op : fbinop) = match op with
+    | Add -> "add"
+    | Sub -> "sub"
+    | Mul -> "mul"
+    | Div -> "div"
+    | Min -> "min"
+    | Max -> "max"
+    | Pmin -> "pmin"
+    | Pmax -> "pmax"
+
+  let irelop xxxx (op : irelop) = match op with
+    | Eq -> "eq"
+    | Ne -> "ne"
+    | LtS -> "lt_s"
+    | LtU -> "lt_u"
+    | GtS -> "gt_s"
+    | GtU -> "gt_u"
+    | LeS -> "le_s"
+    | LeU -> "le_u"
+    | GeS -> "ge_s"
+    | GeU -> "ge_u"
+
+  let frelop xxxx (op : frelop) = match op with
+    | Eq -> "eq"
+    | Ne -> "ne"
+    | Lt -> "lt"
+    | Le -> "le"
+    | Gt -> "gt"
+    | Ge -> "ge"
+
+  let icvtop xxxx (op : icvtop) = match op with
+    | ExtendLowS -> "extend_low_i" ^ half xxxx ^ "_s"
+    | ExtendLowU -> "extend_low_i" ^ half xxxx ^ "_u"
+    | ExtendHighS -> "extend_high_i" ^ half xxxx ^ "_s"
+    | ExtendHighU -> "extend_high_i" ^ half xxxx ^ "_u"
+    | ExtAddPairwiseS -> "extadd_pairwise_i" ^ half xxxx ^ "_s"
+    | ExtAddPairwiseU -> "extadd_pairwise_i" ^ half xxxx ^ "_u"
+    | TruncSatSF32x4 -> "trunc_sat_f32x4_s"
+    | TruncSatUF32x4 -> "trunc_sat_f32x4_u"
+    | TruncSatSZeroF64x2 -> "trunc_sat_f64x2_s_zero"
+    | TruncSatUZeroF64x2 -> "trunc_sat_f64x2_u_zero"
+
+  let fcvtop xxxx (op : fcvtop) = match op with
+    | DemoteZeroF64x2  -> "demote_f64x2_zero"
+    | PromoteLowF32x4  -> "promote_low_f32x4"
+    | ConvertSI32x4 ->
+      "convert_" ^ (if xxxx = "32x4" then "" else "low_") ^ "i32x4_s"
+    | ConvertUI32x4 ->
+      "convert_" ^ (if xxxx = "32x4" then "" else "low_") ^ "i32x4_u"
+
+  let ishiftop xxxx (op : ishiftop) = match op with
+    | Shl -> "shl"
+    | ShrS -> "shr_s"
+    | ShrU -> "shr_u"
+
+  let ibitmaskop xxxx (op : ibitmaskop) = match op with
+    | Bitmask -> "bitmask"
+
+  let vtestop (op : vtestop) = match op with
+    | AnyTrue -> "any_true"
+
+  let vunop (op : vunop) = match op with
+    | Not -> "not"
+
+  let vbinop (op : vbinop) = match op with
+    | And -> "and"
+    | AndNot -> "andnot"
+    | Or -> "or"
+    | Xor -> "xor"
+
+  let vternop (op : vternop) = match op with
+    | Bitselect -> "bitselect"
+
+  let splatop xxxx (op : nsplatop) = match op with
+    | Splat -> "splat"
+
+  let pextractop xxxx (op : extension nextractop) = match op with
+    | Extract (i, ext) -> "extract_lane" ^ extension ext ^ " " ^ nat i
+
+  let extractop xxxx (op : unit nextractop) = match op with
+    | Extract (i, ()) -> "extract_lane " ^ nat i
+
+  let replaceop xxxx (op : nreplaceop) = match op with
+    | Replace i -> "replace_lane " ^ nat i
+
+  let lane_oper (pop, iop, fop) op =
+    match op with
+    | V128.I8x16 o -> pop "8x16" o
+    | V128.I16x8 o -> pop "16x8" o
+    | V128.I32x4 o -> iop "32x4" o
+    | V128.I64x2 o -> iop "64x2" o
+    | V128.F32x4 o -> fop "32x4" o
+    | V128.F64x2 o -> fop "64x2" o
+end
+
+let oper (iop, fop) op =
+  num_type (type_of_num op) ^ "." ^
+  (match op with
+  | I32 o -> iop "32" o
+  | I64 o -> iop "64" o
+  | F32 o -> fop "32" o
+  | F64 o -> fop "64" o
+  )
+
+let vec_oper (vop) op =
+  match op with
+  | V128 o -> "v128." ^ vop o
+
+let vec_shape_oper (pop, iop, fop) op =
   match op with
-  | I32 o -> "i32." ^ intop "32" o
-  | I64 o -> "i64." ^ intop "64" o
-  | F32 o -> "f32." ^ floatop "32" o
-  | F64 o -> "f64." ^ floatop "64" o
+  | V128 o -> V128.string_of_shape o ^ "." ^ V128Op.lane_oper (pop, iop, fop) o
 
 let unop = oper (IntOp.unop, FloatOp.unop)
 let binop = oper (IntOp.binop, FloatOp.binop)
@@ -200,28 +376,58 @@ let testop = oper (IntOp.testop, FloatOp.testop)
 let relop = oper (IntOp.relop, FloatOp.relop)
 let cvtop = oper (IntOp.cvtop, FloatOp.cvtop)
 
-let memop name {ty; align; offset; _} sz =
-  num_type ty ^ "." ^ name ^
+let vec_unop = vec_shape_oper (V128Op.iunop, V128Op.iunop, V128Op.funop)
+let vec_binop = vec_shape_oper (V128Op.ibinop, V128Op.ibinop, V128Op.fbinop)
+let vec_testop = vec_shape_oper (V128Op.itestop, V128Op.itestop, V128Op.voidop)
+let vec_relop = vec_shape_oper (V128Op.irelop, V128Op.irelop, V128Op.frelop)
+let vec_cvtop = vec_shape_oper (V128Op.icvtop, V128Op.icvtop, V128Op.fcvtop)
+let vec_shiftop = vec_shape_oper (V128Op.ishiftop, V128Op.ishiftop, V128Op.voidop)
+let vec_bitmaskop = vec_shape_oper (V128Op.ibitmaskop, V128Op.ibitmaskop, V128Op.voidop)
+let vec_vunop = vec_oper (V128Op.vunop)
+let vec_vbinop = vec_oper (V128Op.vbinop)
+let vec_vternop = vec_oper (V128Op.vternop)
+let vec_vtestop = vec_oper (V128Op.vtestop)
+let vec_splatop = vec_shape_oper (V128Op.splatop, V128Op.splatop, V128Op.splatop)
+let vec_extractop = vec_shape_oper (V128Op.pextractop, V128Op.extractop, V128Op.extractop)
+let vec_replaceop = vec_shape_oper (V128Op.replaceop, V128Op.replaceop, V128Op.replaceop)
+
+let memop name typ {ty; align; offset; _} sz =
+  typ ty ^ "." ^ name ^
   (if offset = 0l then "" else " offset=" ^ nat32 offset) ^
   (if 1 lsl align = sz then "" else " align=" ^ nat (1 lsl align))
 
 let loadop op =
-  match op.sz with
-  | None -> memop "load" op (size op.ty)
+  match op.pack with
+  | None -> memop "load" num_type op (num_size op.ty)
   | Some (sz, ext) ->
-    memop ("load" ^ pack_size sz ^ extension ext) op (packed_size sz)
+    memop ("load" ^ pack_size sz ^ extension ext) num_type op (packed_size sz)
 
 let storeop op =
-  match op.sz with
-  | None -> memop "store" op (size op.ty)
-  | Some sz -> memop ("store" ^ pack_size sz) op (packed_size sz)
+  match op.pack with
+  | None -> memop "store" num_type op (num_size op.ty)
+  | Some sz -> memop ("store" ^ pack_size sz) num_type op (packed_size sz)
+
+let vec_loadop (op : vec_loadop) =
+  match op.pack with
+  | None -> memop "load" vec_type op (vec_size op.ty)
+  | Some (sz, ext) ->
+    memop ("load" ^ vec_extension sz ext) vec_type op (packed_size sz)
+
+let vec_storeop op =
+  memop "store" vec_type op (vec_size op.ty)
+
+let vec_laneop instr (op, i) =
+  memop (instr ^ pack_size op.pack ^ "_lane") vec_type op
+    (packed_size op.pack) ^ " " ^ nat i
 
 
 (* Expressions *)
 
 let var x = nat32 x.it
 let num v = string_of_num v.it
-let constop v = num_type (type_of_num v.it) ^ ".const"
+let vec v = string_of_vec v.it
+let constop v = num_type (type_of_num v) ^ ".const"
+let vec_constop v = vec_type (type_of_vec v) ^ ".const i32x4"
 
 let block_type = function
   | VarBlockType (SynVar x) -> [Node ("type " ^ nat32 x, [])]
@@ -273,6 +479,10 @@ let rec instr e =
     | ElemDrop x -> "elem.drop " ^ var x, []
     | Load op -> loadop op, []
     | Store op -> storeop op, []
+    | VecLoad op -> vec_loadop op, []
+    | VecStore op -> vec_storeop op, []
+    | VecLoadLane op -> vec_laneop "load" op, []
+    | VecStoreLane op -> vec_laneop "store" op, []
     | MemorySize -> "memory.size", []
     | MemoryGrow -> "memory.grow", []
     | MemoryFill -> "memory.fill", []
@@ -283,12 +493,27 @@ let rec instr e =
     | RefIsNull -> "ref.is_null", []
     | RefAsNonNull -> "ref.as_non_null", []
     | RefFunc x -> "ref.func " ^ var x, []
-    | Const n -> constop n ^ " " ^ num n, []
+    | Const n -> constop n.it ^ " " ^ num n, []
     | Test op -> testop op, []
     | Compare op -> relop op, []
     | Unary op -> unop op, []
     | Binary op -> binop op, []
     | Convert op -> cvtop op, []
+    | VecConst v -> vec_constop v.it ^ " " ^ vec v, []
+    | VecTest op -> vec_testop op, []
+    | VecUnary op -> vec_unop op, []
+    | VecBinary op -> vec_binop op, []
+    | VecCompare op -> vec_relop op, []
+    | VecConvert op -> vec_cvtop op, []
+    | VecShift op -> vec_shiftop op, []
+    | VecBitmask op -> vec_bitmaskop op, []
+    | VecTestBits op -> vec_vtestop op, []
+    | VecUnaryBits op -> vec_vunop op, []
+    | VecBinaryBits op -> vec_vbinop op, []
+    | VecTernaryBits op -> vec_vternop op, []
+    | VecSplat op -> vec_splatop op, []
+    | VecExtract op -> vec_extractop op, []
+    | VecReplace op -> vec_replaceop op, []
   in Node (head, inner)
 
 let const head c =
@@ -443,26 +668,19 @@ let module_ = module_with_var_opt None
 
 (* Scripts *)
 
+let num mode = if mode = `Binary then hex_string_of_num else string_of_num
+let vec mode = if mode = `Binary then hex_string_of_vec else string_of_vec
+
+let ref_ = function
+  | NullRef t -> Node ("ref.null " ^ heap_type t, [])
+  | Script.ExternRef n -> Node ("ref.extern " ^ nat32 n, [])
+  | _ -> assert false
+
 let literal mode lit =
   match lit.it with
-  | Num (Value.I32 i) ->
-    let f = if mode = `Binary then I32.to_hex_string else I32.to_string_s in
-    Node ("i32.const " ^ f i, [])
-  | Num (Value.I64 i) ->
-    let f = if mode = `Binary then I64.to_hex_string else I64.to_string_s in
-    Node ("i64.const " ^ f i, [])
-  | Num (Value.F32 z) ->
-    let f = if mode = `Binary then F32.to_hex_string else F32.to_string in
-    Node ("f32.const " ^ f z, [])
-  | Num (Value.F64 z) ->
-    let f = if mode = `Binary then F64.to_hex_string else F64.to_string in
-    Node ("f64.const " ^ f z, [])
-  | Ref (Value.NullRef t) ->
-    Node ("ref.null " ^ heap_type t, [])
-  | Ref (Script.ExternRef n) ->
-    Node ("ref.extern " ^ nat32 n, [])
-  | Ref _ ->
-    assert false
+  | Num n -> Node (constop n ^ " " ^ num mode n, [])
+  | Vec v -> Node (vec_constop v ^ " " ^ vec mode v, [])
+  | Ref r -> ref_ r
 
 let definition mode x_opt def =
   try
@@ -503,17 +721,40 @@ let nan = function
   | CanonicalNan -> "nan:canonical"
   | ArithmeticNan -> "nan:arithmetic"
 
+let nanop (n : nanop) =
+  match n.it with
+  | F32 n' | F64 n' -> nan n'
+  | _ -> .
+
+let num_pat mode = function
+  | NumPat n -> literal mode (Value.Num n.it @@ n.at)
+  | NanPat nan -> Node (constop nan.it ^ " " ^ nanop nan, [])
+
+let lane_pat mode pat shape =
+  let choose fb ft = if mode = `Binary then fb else ft in
+  match pat, shape with
+  | NumPat {it = Value.I32 i; _}, V128.I8x16 () ->
+    choose I8.to_hex_string I8.to_string_s i
+  | NumPat {it = Value.I32 i; _}, V128.I16x8 () ->
+    choose I16.to_hex_string I16.to_string_s i
+  | NumPat n, _ -> num mode n.it
+  | NanPat nan, _ -> nanop nan
+
+let vec_pat mode = function
+  | VecPat (V128 (shape, pats)) ->
+    let lanes = List.map (fun p -> Atom (lane_pat mode p shape)) pats in
+    Node ("v128.const " ^ V128.string_of_shape shape, lanes)
+
+let ref_pat = function
+  | RefPat r -> ref_ r.it
+  | RefTypePat t -> Node ("ref." ^ heap_type t, [])
+  | NullPat -> Node ("ref.null", [])
+
 let result mode res =
   match res.it with
-  | LitResult lit -> literal mode lit
-  | NanResult nanop ->
-    (match nanop.it with
-    | I32 _ | I64 _ -> assert false
-    | F32 n -> Node ("f32.const " ^ nan n, [])
-    | F64 n -> Node ("f64.const " ^ nan n, [])
-    )
-  | RefResult t -> Node ("ref." ^ heap_type t, [])
-  | NullResult -> Node ("ref.null", [])
+  | NumResult np -> num_pat mode np
+  | VecResult vp -> vec_pat mode vp
+  | RefResult rp -> ref_pat rp
 
 let assertion mode ass =
   match ass.it with
diff --git a/interpreter/text/lexer.mll b/interpreter/text/lexer.mll
index 0b511723d..340faf11a 100644
--- a/interpreter/text/lexer.mll
+++ b/interpreter/text/lexer.mll
@@ -18,6 +18,8 @@ let error_nest start lexbuf msg =
   lexbuf.Lexing.lex_start_p <- start;
   error lexbuf msg
 
+let unknown lexbuf = error lexbuf ("unknown operator " ^ Lexing.lexeme lexbuf)
+
 let string s =
   let b = Buffer.create (String.length s) in
   let i = ref 1 in
@@ -52,6 +54,10 @@ let num_type = function
   | "f64" -> Types.F64Type
   | _ -> assert false
 
+let vec_type = function
+  | "v128" -> Types.V128Type
+  | _ -> assert false
+
 let intop t i32 i64 =
   match t with
   | "i32" -> i32
@@ -72,6 +78,30 @@ let numop t i32 i64 f32 f64 =
   | "f64" -> f64
   | _ -> assert false
 
+let v128op s i8x16 i16x8 i32x4 i64x2 f32x4 f64x2 =
+  match s with
+  | "i8x16" -> i8x16
+  | "i16x8" -> i16x8
+  | "i32x4" -> i32x4
+  | "i64x2" -> i64x2
+  | "f32x4" -> f32x4
+  | "f64x2" -> f64x2
+  | _ -> assert false
+
+let v128intop s i8x16 i16x8 i32x4 i64x2 =
+  match s with
+  | "i8x16" -> i8x16
+  | "i16x8" -> i16x8
+  | "i32x4" -> i32x4
+  | "i64x2" -> i64x2
+  | _ -> assert false
+
+let v128floatop s f32x4 f64x2 =
+  match s with
+  | "f32x4" -> f32x4
+  | "f64x2" -> f64x2
+  | _ -> assert false
+
 let memsz sz m8 m16 m32 =
   match sz with
   | "8" -> m8
@@ -86,6 +116,23 @@ let ext e s u =
   | _ -> assert false
 
 let opt = Lib.Option.get
+
+let v128_shape = function
+  | "i8x16" -> V128.I8x16 ()
+  | "i16x8" -> V128.I16x8 ()
+  | "i32x4" -> V128.I32x4 ()
+  | "i64x2" -> V128.I64x2 ()
+  | "f32x4" -> V128.F32x4 ()
+  | "f64x2" -> V128.F64x2 ()
+  | _ -> assert false
+
+let only shapes s lexbuf =
+  if not (List.mem s shapes) then
+    unknown lexbuf
+
+let except shapes s lexbuf =
+  if (List.mem s shapes) then
+    unknown lexbuf
 }
 
 let sign = '+' | '-'
@@ -140,10 +187,14 @@ let name = '$' reserved
 let ixx = "i" ("32" | "64")
 let fxx = "f" ("32" | "64")
 let nxx = ixx | fxx
+let vxxx = "v128"
 let mixx = "i" ("8" | "16" | "32" | "64")
 let mfxx = "f" ("32" | "64")
 let sign = "s" | "u"
 let mem_size = "8" | "16" | "32"
+let v128_int_shape = "i8x16" | "i16x8" | "i32x4" | "i64x2"
+let v128_float_shape = "f32x4" | "f64x2"
+let v128_shape = v128_int_shape | v128_float_shape
 
 rule token = parse
   | "(" { LPAR }
@@ -165,9 +216,12 @@ rule token = parse
   | "extern" { EXTERN }
   | "externref" { EXTERNREF }
   | "funcref" { FUNCREF }
-  | (nxx as t) { NUM_TYPE (num_type t) }
+  | nxx as t { NUM_TYPE (num_type t) }
+  | vxxx as t { VEC_TYPE (vec_type t) }
   | "mut" { MUT }
 
+  | v128_shape as s { VEC_SHAPE (v128_shape s) }
+
   | (nxx as t)".const"
     { let open Source in
       CONST (numop t
@@ -180,6 +234,13 @@ rule token = parse
         (fun s -> let n = F64.of_string s.it in
           f64_const (n @@ s.at), Value.F64 n))
     }
+  | vxxx".const"
+    { let open Source in
+      VEC_CONST
+        (fun shape ss at ->
+          let v = V128.of_strings shape (List.map (fun s -> s.it) ss) in
+          (v128_const (v @@ at), Value.V128 v))
+    }
   | "ref.null" { REF_NULL }
   | "ref.func" { REF_FUNC }
   | "ref.extern" { REF_EXTERN }
@@ -240,7 +301,7 @@ rule token = parse
         numop t (i32_store (opt a 2)) (i64_store (opt a 3))
                 (f32_store (opt a 2)) (f64_store (opt a 3)) o) }
   | (ixx as t)".load"(mem_size as sz)"_"(sign as s)
-    { if t = "i32" && sz = "32" then error lexbuf "unknown operator";
+    { if t = "i32" && sz = "32" then unknown lexbuf;
       LOAD (fun a o ->
         intop t
           (memsz sz
@@ -252,7 +313,7 @@ rule token = parse
             (ext s i64_load16_s i64_load16_u (opt a 1))
             (ext s i64_load32_s i64_load32_u (opt a 2)) o)) }
   | (ixx as t)".store"(mem_size as sz)
-    { if t = "i32" && sz = "32" then error lexbuf "unknown operator";
+    { if t = "i32" && sz = "32" then unknown lexbuf;
       STORE (fun a o ->
         intop t
           (memsz sz
@@ -263,6 +324,44 @@ rule token = parse
             (i64_store8 (opt a 0))
             (i64_store16 (opt a 1))
             (i64_store32 (opt a 2)) o)) }
+  | "v128.load"
+    { VEC_LOAD (fun a o -> (v128_load (opt a 4)) o) }
+  | "v128.store"
+    { VEC_STORE (fun a o -> (v128_store (opt a 4)) o) }
+  | "v128.load8x8_"(sign as s)
+    { VEC_LOAD (fun a o -> (ext s v128_load8x8_s v128_load8x8_u (opt a 3)) o) }
+  | "v128.load16x4_"(sign as s)
+    { VEC_LOAD (fun a o -> (ext s v128_load16x4_s v128_load16x4_u (opt a 3)) o) }
+  | "v128.load32x2_"(sign as s)
+    { VEC_LOAD (fun a o -> (ext s v128_load32x2_s v128_load32x2_u (opt a 3)) o) }
+  | "v128.load8_splat"
+    { VEC_LOAD (fun a o -> (v128_load8_splat (opt a 0)) o) }
+  | "v128.load16_splat"
+    { VEC_LOAD (fun a o -> (v128_load16_splat (opt a 1)) o) }
+  | "v128.load32_splat"
+    { VEC_LOAD (fun a o -> (v128_load32_splat (opt a 2)) o) }
+  | "v128.load64_splat"
+    { VEC_LOAD (fun a o -> (v128_load64_splat (opt a 3)) o) }
+  | "v128.load32_zero"
+    { VEC_LOAD (fun a o -> (v128_load32_zero (opt a 2)) o) }
+  | "v128.load64_zero"
+    { VEC_LOAD (fun a o -> (v128_load64_zero (opt a 3)) o) }
+  | "v128.load8_lane"
+    { VEC_LOAD_LANE (fun a o i -> (v128_load8_lane (opt a 0)) o i) }
+  | "v128.load16_lane"
+    { VEC_LOAD_LANE (fun a o i -> (v128_load16_lane (opt a 1)) o i) }
+  | "v128.load32_lane"
+    { VEC_LOAD_LANE (fun a o i -> (v128_load32_lane (opt a 2)) o i) }
+  | "v128.load64_lane"
+    { VEC_LOAD_LANE (fun a o i -> (v128_load64_lane (opt a 3)) o i) }
+  | "v128.store8_lane"
+    { VEC_STORE_LANE (fun a o i -> (v128_store8_lane (opt a 0)) o i) }
+  | "v128.store16_lane"
+    { VEC_STORE_LANE (fun a o i -> (v128_store16_lane (opt a 1)) o i) }
+  | "v128.store32_lane"
+    { VEC_STORE_LANE (fun a o i -> (v128_store32_lane (opt a 2)) o i) }
+  | "v128.store64_lane"
+    { VEC_STORE_LANE (fun a o i -> (v128_store64_lane (opt a 3)) o i) }
 
   | "offset="(nat as s) { OFFSET_EQ_NAT s }
   | "align="(nat as s) { ALIGN_EQ_NAT s }
@@ -393,6 +492,196 @@ rule token = parse
   | "input" { INPUT }
   | "output" { OUTPUT }
 
+  | vxxx".not" { VEC_UNARY v128_not }
+  | vxxx".and" { VEC_UNARY v128_and }
+  | vxxx".andnot" { VEC_UNARY v128_andnot }
+  | vxxx".or" { VEC_UNARY v128_or }
+  | vxxx".xor" { VEC_UNARY v128_xor }
+  | vxxx".bitselect" { VEC_TERNARY v128_bitselect }
+  | vxxx".any_true" { VEC_TEST (v128_any_true) }
+
+  | (v128_shape as s)".neg"
+    { VEC_UNARY
+        (v128op s i8x16_neg i16x8_neg i32x4_neg i64x2_neg f32x4_neg f64x2_neg) }
+  | (v128_float_shape as s)".sqrt"
+    { VEC_UNARY (v128floatop s f32x4_sqrt f64x2_sqrt) }
+  | (v128_float_shape as s)".ceil"
+    { VEC_UNARY (v128floatop s f32x4_ceil f64x2_ceil) }
+  | (v128_float_shape as s)".floor"
+    { VEC_UNARY (v128floatop s f32x4_floor f64x2_floor) }
+  | (v128_float_shape as s)".trunc"
+    { VEC_UNARY (v128floatop s f32x4_trunc f64x2_trunc) }
+  | (v128_float_shape as s)".nearest"
+    { VEC_UNARY (v128floatop s f32x4_nearest f64x2_nearest) }
+  | (v128_shape as s)".abs"
+    { VEC_UNARY
+        (v128op s i8x16_abs i16x8_abs i32x4_abs i64x2_abs f32x4_abs f64x2_abs) }
+  | "i8x16.popcnt" { VEC_UNARY i8x16_popcnt }
+  | (v128_int_shape as s)".avgr_u"
+    { only ["i8x16"; "i16x8"] s lexbuf;
+      VEC_UNARY (v128intop s i8x16_avgr_u i16x8_avgr_u unreachable unreachable) }
+  | "i32x4.trunc_sat_f32x4_"(sign as s)
+    { VEC_UNARY (ext s i32x4_trunc_sat_f32x4_s i32x4_trunc_sat_f32x4_u) }
+  | "i32x4.trunc_sat_f64x2_"(sign as s)"_zero"
+    { VEC_UNARY (ext s i32x4_trunc_sat_f64x2_s_zero i32x4_trunc_sat_f64x2_u_zero) }
+  | "f64x2.promote_low_f32x4"
+    { VEC_UNARY f64x2_promote_low_f32x4 }
+  | "f32x4.demote_f64x2_zero"
+    { VEC_UNARY f32x4_demote_f64x2_zero }
+  | "f32x4.convert_i32x4_"(sign as s)
+    { VEC_UNARY (ext s f32x4_convert_i32x4_s f32x4_convert_i32x4_u) }
+  | "f64x2.convert_low_i32x4_"(sign as s)
+    { VEC_UNARY (ext s f64x2_convert_low_i32x4_s f64x2_convert_low_i32x4_u) }
+  | "i16x8.extadd_pairwise_i8x16_"(sign as s)
+    { VEC_UNARY (ext s i16x8_extadd_pairwise_i8x16_s i16x8_extadd_pairwise_i8x16_u) }
+  | "i32x4.extadd_pairwise_i16x8_"(sign as s)
+    { VEC_UNARY (ext s i32x4_extadd_pairwise_i16x8_s i32x4_extadd_pairwise_i16x8_u) }
+
+  | (v128_shape as s)".eq"
+    { VEC_BINARY (v128op s i8x16_eq i16x8_eq i32x4_eq i64x2_eq f32x4_eq f64x2_eq) }
+  | (v128_shape as s)".ne"
+    { VEC_BINARY (v128op s i8x16_ne i16x8_ne i32x4_ne i64x2_ne f32x4_ne f64x2_ne) }
+  | (v128_int_shape as s)".lt_s"
+    { VEC_BINARY (v128intop s i8x16_lt_s i16x8_lt_s i32x4_lt_s i64x2_lt_s) }
+  | (v128_int_shape as s)".lt_u"
+    { except ["i64x2"] s lexbuf;
+      VEC_BINARY (v128intop s i8x16_lt_u i16x8_lt_u i32x4_lt_u unreachable) }
+  | (v128_int_shape as s)".le_s"
+    { VEC_BINARY (v128intop s i8x16_le_s i16x8_le_s i32x4_le_s i64x2_le_s) }
+  | (v128_int_shape as s)".le_u"
+    { except ["i64x2"] s lexbuf;
+      VEC_BINARY (v128intop s i8x16_le_u i16x8_le_u i32x4_le_u unreachable) }
+  | (v128_int_shape as s)".gt_s"
+    { VEC_BINARY (v128intop s i8x16_gt_s i16x8_gt_s i32x4_gt_s i64x2_gt_s) }
+  | (v128_int_shape as s)".gt_u"
+    { except ["i64x2"] s lexbuf;
+      VEC_BINARY (v128intop s i8x16_gt_u i16x8_gt_u i32x4_gt_u unreachable) }
+  | (v128_int_shape as s)".ge_s"
+    { VEC_BINARY (v128intop s i8x16_ge_s i16x8_ge_s i32x4_ge_s i64x2_ge_s) }
+  | (v128_int_shape as s)".ge_u"
+    { except ["i64x2"] s lexbuf;
+      VEC_BINARY (v128intop s i8x16_ge_u i16x8_ge_u i32x4_ge_u unreachable) }
+  | (v128_float_shape as s)".lt" { VEC_BINARY (v128floatop s f32x4_lt f64x2_lt) }
+  | (v128_float_shape as s)".le" { VEC_BINARY (v128floatop s f32x4_le f64x2_le) }
+  | (v128_float_shape as s)".gt" { VEC_BINARY (v128floatop s f32x4_gt f64x2_gt) }
+  | (v128_float_shape as s)".ge" { VEC_BINARY (v128floatop s f32x4_ge f64x2_ge) }
+  | "i8x16.swizzle" { VEC_BINARY i8x16_swizzle }
+
+  | (v128_shape as s)".add"
+    { VEC_BINARY
+        (v128op s i8x16_add i16x8_add i32x4_add i64x2_add f32x4_add f64x2_add) }
+  | (v128_shape as s)".sub"
+    { VEC_BINARY
+        (v128op s i8x16_sub i16x8_sub i32x4_sub i64x2_sub f32x4_sub f64x2_sub) }
+  | (v128_shape as s)".min_s"
+    { only ["i8x16"; "i16x8"; "i32x4"] s lexbuf;
+      VEC_BINARY
+        (v128op s i8x16_min_s i16x8_min_s i32x4_min_s unreachable
+                  unreachable unreachable) }
+  | (v128_shape as s)".min_u"
+    { only ["i8x16"; "i16x8"; "i32x4"] s lexbuf;
+      VEC_BINARY
+        (v128op s i8x16_min_u i16x8_min_u i32x4_min_u unreachable
+                  unreachable unreachable) }
+  | (v128_shape as s)".max_s"
+    { only ["i8x16"; "i16x8"; "i32x4"] s lexbuf;
+      VEC_BINARY
+        (v128op s i8x16_max_s i16x8_max_s i32x4_max_s unreachable
+                  unreachable unreachable) }
+  | (v128_shape as s)".max_u"
+    { only ["i8x16"; "i16x8"; "i32x4"] s lexbuf;
+      VEC_BINARY
+        (v128op s i8x16_max_u i16x8_max_u i32x4_max_u unreachable
+                  unreachable unreachable) }
+  | (v128_shape as s)".mul"
+    { only ["i16x8"; "i32x4"; "i64x2"; "f32x4"; "f64x2"] s lexbuf;
+      VEC_BINARY
+        (v128op s unreachable i16x8_mul i32x4_mul i64x2_mul f32x4_mul f64x2_mul) }
+  | (v128_float_shape as s)".div"
+    { VEC_BINARY (v128floatop s f32x4_div f64x2_div) }
+  | (v128_float_shape as s)".min"
+    { VEC_BINARY (v128floatop s f32x4_min f64x2_min) }
+  | (v128_float_shape as s)".max"
+    { VEC_BINARY (v128floatop s f32x4_max f64x2_max) }
+  | (v128_float_shape as s)".pmin"
+    { VEC_BINARY (v128floatop s f32x4_pmin f64x2_pmin) }
+  | (v128_float_shape as s)".pmax"
+    { VEC_BINARY (v128floatop s f32x4_pmax f64x2_pmax) }
+  | "i8x16.add_sat_"(sign as s)
+    { VEC_BINARY (ext s i8x16_add_sat_s i8x16_add_sat_u) }
+  | "i8x16.sub_sat_"(sign as s)
+    { VEC_BINARY (ext s i8x16_sub_sat_s i8x16_sub_sat_u) }
+  | "i16x8.add_sat_"(sign as s)
+    { VEC_BINARY (ext s i16x8_add_sat_s i16x8_add_sat_u) }
+  | "i16x8.sub_sat_"(sign as s)
+    { VEC_BINARY (ext s i16x8_sub_sat_s i16x8_sub_sat_u) }
+  | "i32x4.dot_i16x8_s"
+    { VEC_BINARY i32x4_dot_i16x8_s }
+  | "i8x16.narrow_i16x8_"(sign as s)
+    { VEC_BINARY (ext s i8x16_narrow_i16x8_s i8x16_narrow_i16x8_u) }
+  | "i16x8.narrow_i32x4_"(sign as s)
+    { VEC_BINARY (ext s i16x8_narrow_i32x4_s i16x8_narrow_i32x4_u) }
+  | "i16x8.extend_low_i8x16_"(sign as s)
+    { VEC_UNARY (ext s i16x8_extend_low_i8x16_s i16x8_extend_low_i8x16_u) }
+  | "i16x8.extend_high_i8x16_"(sign as s)
+    { VEC_UNARY (ext s i16x8_extend_high_i8x16_s i16x8_extend_high_i8x16_u) }
+  | "i32x4.extend_low_i16x8_"(sign as s)
+    { VEC_UNARY (ext s i32x4_extend_low_i16x8_s i32x4_extend_low_i16x8_u) }
+  | "i32x4.extend_high_i16x8_"(sign as s)
+    { VEC_UNARY (ext s i32x4_extend_high_i16x8_s i32x4_extend_high_i16x8_u) }
+  | "i64x2.extend_low_i32x4_"(sign as s)
+    { VEC_UNARY (ext s i64x2_extend_low_i32x4_s i64x2_extend_low_i32x4_u) }
+  | "i64x2.extend_high_i32x4_"(sign as s)
+    { VEC_UNARY (ext s i64x2_extend_high_i32x4_s i64x2_extend_high_i32x4_u) }
+  | "i16x8.extmul_low_i8x16_"(sign as s)
+    { VEC_BINARY (ext s i16x8_extmul_low_i8x16_s i16x8_extmul_low_i8x16_u) }
+  | "i16x8.extmul_high_i8x16_"(sign as s)
+    { VEC_BINARY (ext s i16x8_extmul_high_i8x16_s i16x8_extmul_high_i8x16_u) }
+  | "i32x4.extmul_low_i16x8_"(sign as s)
+    { VEC_BINARY (ext s i32x4_extmul_low_i16x8_s i32x4_extmul_low_i16x8_u) }
+  | "i32x4.extmul_high_i16x8_"(sign as s)
+    { VEC_BINARY (ext s i32x4_extmul_high_i16x8_s i32x4_extmul_high_i16x8_u) }
+  | "i64x2.extmul_low_i32x4_"(sign as s)
+    { VEC_BINARY (ext s i64x2_extmul_low_i32x4_s i64x2_extmul_low_i32x4_u) }
+  | "i64x2.extmul_high_i32x4_"(sign as s)
+    { VEC_BINARY (ext s i64x2_extmul_high_i32x4_s i64x2_extmul_high_i32x4_u) }
+  | "i16x8.q15mulr_sat_s"
+    { VEC_BINARY i16x8_q15mulr_sat_s }
+
+  | (v128_int_shape as s)".all_true"
+    { VEC_TEST
+        (v128intop s i8x16_all_true i16x8_all_true i32x4_all_true i64x2_all_true) }
+  | (v128_int_shape as s)".bitmask"
+    { VEC_BITMASK
+        (v128intop s i8x16_bitmask i16x8_bitmask i32x4_bitmask i64x2_bitmask) }
+  | (v128_int_shape as s)".shl"
+    { VEC_SHIFT (v128intop s i8x16_shl i16x8_shl i32x4_shl i64x2_shl) }
+  | (v128_int_shape as s)".shr_s"
+    { VEC_SHIFT (v128intop s i8x16_shr_s i16x8_shr_s i32x4_shr_s i64x2_shr_s) }
+  | (v128_int_shape as s)".shr_u"
+    { VEC_SHIFT (v128intop s i8x16_shr_u i16x8_shr_u i32x4_shr_u i64x2_shr_u) }
+  | "i8x16.shuffle" { VEC_SHUFFLE }
+
+  | (v128_shape as s)".splat"
+    { VEC_SPLAT (v128op s i8x16_splat i16x8_splat i32x4_splat
+                           i64x2_splat f32x4_splat f64x2_splat) }
+  | (v128_shape as s)".extract_lane"
+    { except ["i8x16"; "i16x8"] s lexbuf;
+      VEC_EXTRACT (fun i ->
+        v128op s
+          (fun _ -> unreachable) (fun _ -> unreachable)
+          i32x4_extract_lane i64x2_extract_lane
+          f32x4_extract_lane f64x2_extract_lane i) }
+  | (("i8x16"|"i16x8") as t)".extract_lane_"(sign as s)
+    { VEC_EXTRACT (fun i ->
+        if t = "i8x16"
+        then ext s i8x16_extract_lane_s i8x16_extract_lane_u i
+        else ext s i16x8_extract_lane_s i16x8_extract_lane_u i )}
+  | (v128_shape as s)".replace_lane"
+    { VEC_REPLACE
+        (v128op s i8x16_replace_lane i16x8_replace_lane i32x4_replace_lane
+                  i64x2_replace_lane f32x4_replace_lane f64x2_replace_lane) }
+
   | name as s { VAR s }
 
   | ";;"utf8_no_nl*eof { EOF }
@@ -403,7 +692,7 @@ rule token = parse
   | '\n' { Lexing.new_line lexbuf; token lexbuf }
   | eof { EOF }
 
-  | reserved { error lexbuf "unknown operator" }
+  | reserved { unknown lexbuf }
   | utf8 { error lexbuf "malformed operator" }
   | _ { error lexbuf "malformed UTF-8 encoding" }
 
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index d86750a13..5e4c6ca7f 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -39,6 +39,38 @@ let ati i =
 let num f s =
   try f s with Failure _ -> error s.at "constant out of range"
 
+let vec f shape ss at =
+  try f shape ss at with
+  | Failure _ -> error at "constant out of range"
+  | Invalid_argument _ -> error at "wrong number of lane literals"
+
+let vec_lane_nan shape l at =
+  let open Value in
+  match shape with
+  | V128.F32x4 () -> NanPat (F32 l @@ at)
+  | V128.F64x2 () -> NanPat (F64 l @@ at)
+  | _ -> error at "invalid vector constant"
+
+let vec_lane_lit shape l at =
+  let open Value in
+  match shape with
+  | V128.I8x16 () -> NumPat (I32 (I8.of_string l) @@ at)
+  | V128.I16x8 () -> NumPat (I32 (I16.of_string l) @@ at)
+  | V128.I32x4 () -> NumPat (I32 (I32.of_string l) @@ at)
+  | V128.I64x2 () -> NumPat (I64 (I64.of_string l) @@ at)
+  | V128.F32x4 () -> NumPat (F32 (F32.of_string l) @@ at)
+  | V128.F64x2 () -> NumPat (F64 (F64.of_string l) @@ at)
+
+let vec_lane_index s at =
+  match int_of_string s with
+  | n when 0 <= n && n < 256 -> n
+  | _ | exception Failure _ -> error at "malformed lane index"
+
+let shuffle_lit ss at =
+  if not (List.length ss = 16) then
+    error at "invalid lane length";
+  List.map (fun s -> vec_lane_index s.it s.at) ss
+
 let nanop f nan =
   let open Source in
   let open Value in
@@ -207,7 +239,7 @@ let inline_func_type_explicit (c : context) x ft at =
 
 %token LPAR RPAR
 %token NAT INT FLOAT STRING VAR
-%token NUM_TYPE FUNCREF EXTERNREF REF EXTERN NULL MUT
+%token NUM_TYPE VEC_TYPE VEC_SHAPE FUNCREF EXTERNREF REF EXTERN NULL MUT
 %token UNREACHABLE NOP DROP SELECT
 %token BLOCK END IF THEN ELSE LOOP LET
 %token BR BR_IF BR_TABLE BR_ON_NULL BR_ON_NON_NULL
@@ -219,6 +251,10 @@ let inline_func_type_explicit (c : context) x ft at =
 %token LOAD STORE OFFSET_EQ_NAT ALIGN_EQ_NAT
 %token CONST UNARY BINARY TEST COMPARE CONVERT
 %token REF_NULL REF_FUNC REF_EXTERN REF_IS_NULL REF_AS_NON_NULL
+%token VEC_LOAD VEC_STORE VEC_LOAD_LANE VEC_STORE_LANE
+%token VEC_CONST VEC_UNARY VEC_BINARY VEC_TERNARY VEC_TEST
+%token VEC_SHIFT VEC_BITMASK VEC_SHUFFLE
+%token VEC_EXTRACT VEC_REPLACE
 %token FUNC START TYPE PARAM RESULT LOCAL GLOBAL
 %token TABLE ELEM MEMORY DATA DECLARE OFFSET ITEM IMPORT EXPORT
 %token MODULE BIN QUOTE
@@ -235,7 +271,9 @@ let inline_func_type_explicit (c : context) x ft at =
 %token<string> STRING
 %token<string> VAR
 %token<Types.num_type> NUM_TYPE
+%token<Types.vec_type> VEC_TYPE
 %token<string Source.phrase -> Ast.instr' * Value.num> CONST
+%token<V128.shape -> string Source.phrase list -> Source.region -> Ast.instr' * Value.vec> VEC_CONST
 %token<Ast.instr'> UNARY
 %token<Ast.instr'> BINARY
 %token<Ast.instr'> TEST
@@ -243,8 +281,22 @@ let inline_func_type_explicit (c : context) x ft at =
 %token<Ast.instr'> CONVERT
 %token<int option -> Memory.offset -> Ast.instr'> LOAD
 %token<int option -> Memory.offset -> Ast.instr'> STORE
+%token<int option -> Memory.offset -> Ast.instr'> VEC_LOAD
+%token<int option -> Memory.offset -> Ast.instr'> VEC_STORE
+%token<int option -> Memory.offset -> int -> Ast.instr'> VEC_LOAD_LANE
+%token<int option -> Memory.offset -> int -> Ast.instr'> VEC_STORE_LANE
+%token<Ast.instr'> VEC_UNARY
+%token<Ast.instr'> VEC_BINARY
+%token<Ast.instr'> VEC_TERNARY
+%token<Ast.instr'> VEC_TEST
+%token<Ast.instr'> VEC_SHIFT
+%token<Ast.instr'> VEC_BITMASK
+%token<Ast.instr'> VEC_SPLAT
+%token<int -> Ast.instr'> VEC_EXTRACT
+%token<int -> Ast.instr'> VEC_REPLACE
 %token<string> OFFSET_EQ_NAT
 %token<string> ALIGN_EQ_NAT
+%token<V128.shape> VEC_SHAPE
 
 %token<Script.nan> NAN
 
@@ -286,6 +338,7 @@ ref_type :
 
 value_type :
   | NUM_TYPE { fun c -> NumType $1 }
+  | VEC_TYPE { fun c -> VecType $1 }
   | ref_type { fun c -> RefType ($1 c) }
 
 value_type_list :
@@ -300,12 +353,8 @@ def_type :
   | LPAR FUNC func_type RPAR { fun c -> FuncDefType ($3 c) }
 
 func_type :
-  | /* empty */
-    { fun c -> FuncType ([], []) }
-  | LPAR RESULT value_type_list RPAR func_type
-    { fun c -> let FuncType (ins, out) = $5 c in
-      if ins <> [] then error (at ()) "result before parameter";
-      FuncType (ins, snd $3 c @ out) }
+  | func_type_result
+    { fun c -> FuncType ([], $1 c) }
   | LPAR PARAM value_type_list RPAR func_type
     { fun c -> let FuncType (ins, out) = $5 c in
       FuncType (snd $3 c @ ins, out) }
@@ -313,6 +362,12 @@ func_type :
     { fun c -> let FuncType (ins, out) = $6 c in
       FuncType ($4 c :: ins, out) }
 
+func_type_result :
+  | /* empty */
+    { fun c -> [] }
+  | LPAR RESULT value_type_list RPAR func_type_result
+    { fun c -> snd $3 c @ $5 c }
+
 table_type :
   | limits ref_type { fun c -> TableType ($1, $2 c) }
 
@@ -334,6 +389,10 @@ num :
   | INT { $1 @@ at () }
   | FLOAT { $1 @@ at () }
 
+num_list:
+  | /* empty */ { [] }
+  | num num_list { $1 :: $2 }
+
 var :
   | NAT { let at = at () in fun c lookup -> nat32 $1 at @@ at }
   | VAR { let at = at () in fun c lookup -> lookup c ($1 @@ at) @@ at }
@@ -427,6 +486,12 @@ plain_instr :
   | ELEM_DROP var { fun c -> elem_drop ($2 c elem) }
   | LOAD offset_opt align_opt { fun c -> $1 $3 $2 }
   | STORE offset_opt align_opt { fun c -> $1 $3 $2 }
+  | VEC_LOAD offset_opt align_opt { fun c -> $1 $3 $2 }
+  | VEC_STORE offset_opt align_opt { fun c -> $1 $3 $2 }
+  | VEC_LOAD_LANE offset_opt align_opt NAT
+    { let at = at () in fun c -> $1 $3 $2 (vec_lane_index $4 at) }
+  | VEC_STORE_LANE offset_opt align_opt NAT
+    { let at = at () in fun c -> $1 $3 $2 (vec_lane_index $4 at) }
   | MEMORY_SIZE { fun c -> memory_size }
   | MEMORY_GROW { fun c -> memory_grow }
   | MEMORY_FILL { fun c -> memory_fill }
@@ -443,6 +508,17 @@ plain_instr :
   | UNARY { fun c -> $1 }
   | BINARY { fun c -> $1 }
   | CONVERT { fun c -> $1 }
+  | VEC_CONST VEC_SHAPE num_list { let at = at () in fun c -> fst (vec $1 $2 $3 at) }
+  | VEC_UNARY { fun c -> $1 }
+  | VEC_BINARY { fun c -> $1 }
+  | VEC_TERNARY { fun c -> $1 }
+  | VEC_TEST { fun c -> $1 }
+  | VEC_SHIFT { fun c -> $1 }
+  | VEC_BITMASK { fun c -> $1 }
+  | VEC_SHUFFLE num_list { let at = at () in fun c -> i8x16_shuffle (shuffle_lit $2 at) }
+  | VEC_SPLAT { fun c -> $1 }
+  | VEC_EXTRACT NAT { let at = at () in fun c -> $1 (vec_lane_index $2 at) }
+  | VEC_REPLACE NAT { let at = at () in fun c -> $1 (vec_lane_index $2 at) }
 
 
 select_instr :
@@ -1148,7 +1224,7 @@ script_module :
     { $3, Quoted ("quote:" ^ string_of_pos (at()).left, $5) @@ at() }
 
 action :
-  | LPAR INVOKE module_var_opt name const_list RPAR
+  | LPAR INVOKE module_var_opt name literal_list RPAR
     { Invoke ($3, $4, $5) @@ at () }
   | LPAR GET module_var_opt name RPAR
     { Get ($3, $4) @@ at() }
@@ -1183,22 +1259,45 @@ meta :
   | LPAR OUTPUT script_var_opt STRING RPAR { Output ($3, Some $4) @@ at () }
   | LPAR OUTPUT script_var_opt RPAR { Output ($3, None) @@ at () }
 
-const :
-  | LPAR CONST num RPAR { Value.Num (snd (num $2 $3)) @@ at () }
-  | LPAR REF_NULL heap_type RPAR
-    { Value.Ref (Value.NullRef ($3 (empty_context ()))) @@ at () }
-  | LPAR REF_EXTERN NAT RPAR { Value.Ref (ExternRef (nat32 $3 (ati 3))) @@ at () }
+literal_num :
+  | LPAR CONST num RPAR { snd (num $2 $3) }
+
+literal_vec :
+  | LPAR VEC_CONST VEC_SHAPE num_list RPAR { snd (vec $2 $3 $4 (at ())) }
+
+literal_ref :
+  | LPAR REF_NULL heap_type RPAR { Value.NullRef ($3 (empty_context ())) }
+  | LPAR REF_EXTERN NAT RPAR { Script.ExternRef (nat32 $3 (ati 3)) }
 
-const_list :
+literal :
+  | literal_num { Value.Num $1 @@ at () }
+  | literal_vec { Value.Vec $1 @@ at () }
+  | literal_ref { Value.Ref $1 @@ at () }
+
+literal_list :
   | /* empty */ { [] }
-  | const const_list { $1 :: $2 }
+  | literal literal_list { $1 :: $2 }
+
+numpat :
+  | num { fun sh -> vec_lane_lit sh $1.it $1.at }
+  | NAN { fun sh -> vec_lane_nan sh $1 (ati 3) }
+
+numpat_list:
+  | /* empty */ { [] }
+  | numpat numpat_list { $1 :: $2 }
 
 result :
-  | const { LitResult $1 @@ at () }
-  | LPAR CONST NAN RPAR { NanResult (nanop $2 ($3 @@ ati 3)) @@ at () }
-  | LPAR REF_FUNC RPAR { RefResult FuncHeapType @@ at () }
-  | LPAR REF_EXTERN RPAR { RefResult ExternHeapType @@ at () }
-  | LPAR REF_NULL RPAR { NullResult @@ at () }
+  | literal_num { NumResult (NumPat ($1 @@ at())) @@ at () }
+  | LPAR CONST NAN RPAR { NumResult (NanPat (nanop $2 ($3 @@ ati 3))) @@ at () }
+  | literal_ref { RefResult (RefPat ($1 @@ at ())) @@ at () }
+  | LPAR REF_FUNC RPAR { RefResult (RefTypePat FuncHeapType) @@ at () }
+  | LPAR REF_EXTERN RPAR { RefResult (RefTypePat ExternHeapType) @@ at () }
+  | LPAR REF_NULL RPAR { RefResult NullPat @@ at () }
+  | LPAR VEC_CONST VEC_SHAPE numpat_list RPAR {
+    if V128.num_lanes $3 <> List.length $4 then
+      error (at ()) "wrong number of lane literals";
+    VecResult (VecPat (Value.V128 ($3, List.map (fun lit -> lit $3) $4))) @@ at ()
+  }
 
 result_list :
   | /* empty */ { [] }
diff --git a/interpreter/util/lib.ml b/interpreter/util/lib.ml
index 7becaf1f6..b0548100a 100644
--- a/interpreter/util/lib.ml
+++ b/interpreter/util/lib.ml
@@ -1,4 +1,4 @@
-type void
+type void = |
 
 module Fun =
 struct
@@ -116,6 +116,11 @@ struct
   let rec concat_map f = function
     | [] -> []
     | x::xs -> f x @ concat_map f xs
+
+  let rec pairwise f = function
+    | [] -> []
+    | x1::x2::xs -> f x1 x2 :: pairwise f xs
+    | _ -> failwith "pairwise"
 end
 
 module List32 =
diff --git a/interpreter/util/lib.mli b/interpreter/util/lib.mli
index 1b2604437..08978cb24 100644
--- a/interpreter/util/lib.mli
+++ b/interpreter/util/lib.mli
@@ -1,6 +1,6 @@
 (* Things that should be in the OCaml library... *)
 
-type void
+type void = |
 
 module Fun :
 sig
@@ -27,6 +27,7 @@ sig
   val index_where : ('a -> bool) -> 'a list -> int option
   val map_filter : ('a -> 'b option) -> 'a list -> 'b list
   val concat_map : ('a -> 'b list) -> 'a list -> 'b list
+  val pairwise : ('a -> 'a -> 'b) -> 'a list -> 'b list
 end
 
 module List32 :
diff --git a/interpreter/valid/match.ml b/interpreter/valid/match.ml
index 143b2dc04..cb07f7e85 100644
--- a/interpreter/valid/match.ml
+++ b/interpreter/valid/match.ml
@@ -32,6 +32,9 @@ let eq_limits c a lim1 lim2 =
 let rec eq_num_type c a t1 t2 =
   t1 = t2
 
+and eq_vec_type c a t1 t2 =
+  t1 = t2
+
 and eq_heap_type c a t1 t2 =
   match t1, t2 with
   | DefHeapType x1, DefHeapType x2 -> eq_var_type c a x1 x2
@@ -45,6 +48,7 @@ and eq_ref_type c a t1 t2 =
 and eq_value_type c a t1 t2 =
   match t1, t2 with
   | NumType t1', NumType t2' -> eq_num_type c a t1' t2'
+  | VecType t1', VecType t2' -> eq_vec_type c a t1' t2'
   | RefType t1', RefType t2' -> eq_ref_type c a t1' t2'
   | _, _ -> false
 
@@ -99,6 +103,9 @@ let match_limits c a lim1 lim2 =
 let rec match_num_type c a t1 t2 =
   t1 = t2
 
+and match_vec_type c a t1 t2 =
+  t1 = t2
+
 and match_heap_type c a t1 t2 =
   match t1, t2 with
   | DefHeapType x1, FuncHeapType ->
@@ -117,6 +124,7 @@ and match_ref_type c a t1 t2 =
 and match_value_type c a t1 t2 =
   match t1, t2 with
   | NumType t1', NumType t2' -> match_num_type c a t1' t2'
+  | VecType t1', VecType t2' -> match_vec_type c a t1' t2'
   | RefType t1', RefType t2' -> match_ref_type c a t1' t2'
   | BotType, _ -> true
   | _, _ -> false
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index 5a47b11fa..9a7c40acb 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -77,6 +77,9 @@ let check_limits {min; max} range at msg =
 let check_num_type (c : context) (t : num_type) at =
   ()
 
+let check_vec_type (c : context) (t : vec_type) at =
+  ()
+
 let check_heap_type (c : context) (t : heap_type) at =
   match t with
   | FuncHeapType | ExternHeapType -> ()
@@ -90,6 +93,7 @@ let check_ref_type (c : context) (t : ref_type) at =
 let check_value_type (c : context) (t : value_type) at =
   match t with
   | NumType t' -> check_num_type c t' at
+  | VecType t' -> check_vec_type c t' at
   | RefType t' -> check_ref_type c t' at
   | BotType -> ()
 
@@ -125,6 +129,8 @@ let check_type (c : context) (t : type_) =
   check_def_type c t.it t.at
 
 
+
+
 (* Stack typing *)
 
 (*
@@ -168,13 +174,6 @@ let push c (ell1, ts1) (ell2, ts2) =
 let peek i (ell, ts) =
   try List.nth (List.rev ts) i with Failure _ -> BotType
 
-let peek_num i (ell, ts) at =
-  let t = peek i (ell, ts) in
-  require (is_num_type t) at
-    ("type mismatch: instruction requires numeric type" ^
-     " but stack has " ^ string_of_value_type t);
-  t
-
 let peek_ref i (ell, ts) at =
   match peek i (ell, ts) with
   | RefType rt -> rt
@@ -188,10 +187,9 @@ let peek_ref i (ell, ts) at =
 (* Type Synthesis *)
 
 let type_num = Value.type_of_num
-let type_unop = Value.type_of_num
-let type_binop = Value.type_of_num
-let type_testop = Value.type_of_num
-let type_relop = Value.type_of_num
+let type_vec = Value.type_of_vec
+let type_vec_lane = function
+  | Value.V128 laneop -> V128.type_of_lane laneop
 
 let type_cvtop at = function
   | Value.I32 cvtop ->
@@ -229,25 +227,51 @@ let type_cvtop at = function
     | DemoteF64 -> error at "invalid conversion"
     ), F64Type
 
+let num_lanes = function
+  | Value.V128 laneop -> V128.num_lanes laneop
+
+let lane_extractop = function
+  | Value.V128 extractop ->
+    let open V128 in let open V128Op in
+    match extractop with
+    | I8x16 (Extract (i, _)) | I16x8 (Extract (i, _))
+    | I32x4 (Extract (i, _)) | I64x2 (Extract (i, _))
+    | F32x4 (Extract (i, _)) | F64x2 (Extract (i, _)) -> i
+
+let lane_replaceop = function
+  | Value.V128 replaceop ->
+    let open V128 in let open V128Op in
+    match replaceop with
+    | I8x16 (Replace i) | I16x8 (Replace i)
+    | I32x4 (Replace i) | I64x2 (Replace i)
+    | F32x4 (Replace i) | F64x2 (Replace i) -> i
+
 
 (* Expressions *)
 
-let check_pack sz t at =
-  require (packed_size sz < size t) at "invalid sign extension"
+let check_pack sz t_sz at =
+  require (packed_size sz < t_sz) at "invalid sign extension"
 
 let check_unop unop at =
   match unop with
   | Value.I32 (IntOp.ExtendS sz) | Value.I64 (IntOp.ExtendS sz) ->
-    check_pack sz (Value.type_of_num unop) at
+    check_pack sz (num_size (Value.type_of_num unop)) at
+  | _ -> ()
+
+let check_vec_binop binop at =
+  match binop with
+  | Value.(V128 (V128.I8x16 (V128Op.Shuffle is))) ->
+    if List.exists ((<=) 32) is then
+      error at "invalid lane index"
   | _ -> ()
 
-let check_memop (c : context) (memop : 'a memop) get_sz at =
+let check_memop (c : context) (memop : ('t, 's) memop) ty_size get_sz at =
   let _mt = memory c (0l @@ at) in
   let size =
-    match get_sz memop.sz with
-    | None -> size memop.ty
+    match get_sz memop.pack with
+    | None -> ty_size memop.ty
     | Some sz ->
-      check_pack sz memop.ty at;
+      check_pack sz (ty_size memop.ty) at;
       packed_size sz
   in
   require (1 lsl memop.align <= size) at
@@ -298,11 +322,15 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : op_type
     [peek 0 s] --> []
 
   | Select None ->
-    let t = peek_num 1 s e.at in
+    let t = peek 1 s in
+    require (is_num_type t || is_vec_type t) e.at
+      ("type mismatch: instruction requires numeric or vector type" ^
+       " but stack has " ^ string_of_value_type t);
     [t; t; NumType I32Type] --> [t]
 
   | Select (Some ts) ->
-    require (List.length ts = 1) e.at "invalid result arity other than 1 is not (yet) allowed";
+    require (List.length ts = 1) e.at
+      "invalid result arity other than 1 is not (yet) allowed";
     check_result_type c ts e.at;
     (ts @ ts @ [NumType I32Type]) --> ts
 
@@ -487,13 +515,33 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : op_type
     [] --> []
 
   | Load memop ->
-    check_memop c memop (Lib.Option.map fst) e.at;
+    check_memop c memop num_size (Lib.Option.map fst) e.at;
     [NumType I32Type] --> [NumType memop.ty]
 
   | Store memop ->
-    check_memop c memop (fun sz -> sz) e.at;
+    check_memop c memop num_size (fun sz -> sz) e.at;
     [NumType I32Type; NumType memop.ty] --> []
 
+  | VecLoad memop ->
+    check_memop c memop vec_size (Lib.Option.map fst) e.at;
+    [NumType I32Type] --> [VecType memop.ty]
+
+  | VecStore memop ->
+    check_memop c memop vec_size (fun _ -> None) e.at;
+    [NumType I32Type; VecType memop.ty] --> []
+
+  | VecLoadLane (memop, i) ->
+    check_memop c memop vec_size (fun sz -> Some sz) e.at;
+    require (i < vec_size memop.ty / packed_size memop.pack) e.at
+      "invalid lane index";
+    [NumType I32Type; VecType memop.ty] -->  [VecType memop.ty]
+
+  | VecStoreLane (memop, i) ->
+    check_memop c memop vec_size (fun sz -> Some sz) e.at;
+    require (i < vec_size memop.ty / packed_size memop.pack) e.at
+      "invalid lane index";
+    [NumType I32Type; VecType memop.ty] -->  []
+
   | MemorySize ->
     let _mt = memory c (0l @@ e.at) in
     [] --> [NumType I32Type]
@@ -542,26 +590,94 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : op_type
     [] --> [t]
 
   | Test testop ->
-    let t = NumType (type_testop testop) in
+    let t = NumType (type_num testop) in
     [t] --> [NumType I32Type]
 
   | Compare relop ->
-    let t = NumType (type_relop relop) in
+    let t = NumType (type_num relop) in
     [t; t] --> [NumType I32Type]
 
   | Unary unop ->
     check_unop unop e.at;
-    let t = NumType (type_unop unop) in
+    let t = NumType (type_num unop) in
     [t] --> [t]
 
   | Binary binop ->
-    let t = NumType (type_binop binop) in
+    let t = NumType (type_num binop) in
     [t; t] --> [t]
 
   | Convert cvtop ->
     let t1, t2 = type_cvtop e.at cvtop in
     [NumType t1] --> [NumType t2]
 
+  | VecConst v ->
+    let t = VecType (type_vec v.it) in
+    [] --> [t]
+
+  | VecTest testop ->
+    let t = VecType (type_vec testop) in
+    [t] --> [NumType I32Type]
+
+  | VecUnary unop ->
+    let t = VecType (type_vec unop) in
+    [t] --> [t]
+
+  | VecBinary binop ->
+    check_vec_binop binop e.at;
+    let t = VecType (type_vec binop) in
+    [t; t] --> [t]
+
+  | VecCompare relop ->
+    let t = VecType (type_vec relop) in
+    [t; t] --> [t]
+
+  | VecConvert cvtop ->
+    let t = VecType (type_vec cvtop) in
+    [t] --> [t]
+
+  | VecShift shiftop ->
+    let t = VecType (type_vec shiftop) in
+    [t; NumType I32Type] --> [VecType V128Type]
+
+  | VecBitmask bitmaskop ->
+    let t = VecType (type_vec bitmaskop) in
+    [t] --> [NumType I32Type]
+
+  | VecTestBits vtestop ->
+    let t = VecType (type_vec vtestop) in
+    [t] --> [NumType I32Type]
+
+  | VecUnaryBits vunop ->
+    let t = VecType (type_vec vunop) in
+    [t] --> [t]
+
+  | VecBinaryBits vbinop ->
+    let t = VecType (type_vec vbinop) in
+    [t; t] --> [t]
+
+  | VecTernaryBits vternop ->
+    let t = VecType (type_vec vternop) in
+    [t; t; t] --> [t]
+
+  | VecSplat splatop ->
+    let t1 = type_vec_lane splatop in
+    let t2 = VecType (type_vec splatop) in
+    [NumType t1] --> [t2]
+
+  | VecExtract extractop ->
+    let t = VecType (type_vec extractop) in
+    let t2 = type_vec_lane extractop in
+    require (lane_extractop extractop < num_lanes extractop) e.at
+      "invalid lane index";
+    [t] --> [NumType t2]
+
+  | VecReplace replaceop ->
+    let t = VecType (type_vec replaceop) in
+    let t2 = type_vec_lane replaceop in
+    require (lane_replaceop replaceop < num_lanes replaceop) e.at
+      "invalid lane index";
+    [t; NumType t2] --> [t]
+
 and check_seq (c : context) (s : infer_result_type) (es : instr list)
   : infer_result_type =
   match es with
@@ -614,7 +730,8 @@ let is_const (c : context) (e : instr) =
   match e.it with
   | RefNull _
   | RefFunc _
-  | Const _ -> true
+  | Const _
+  | VecConst _ -> true
   | GlobalGet x -> let GlobalType (_, mut) = global c x in mut = Immutable
   | _ -> false
 
diff --git a/proposals/README.md b/proposals/README.md
index 364b7ab4d..170c15123 100644
--- a/proposals/README.md
+++ b/proposals/README.md
@@ -1,3 +1,4 @@
 # Proposals
 
-This directory contains overviews for post-MVP proposals that are included in this repository.
+This directory contains overviews for post-MVP proposals that have been finished and merged into the spec.
+Proposals that are not yet finished can be found at https://github.com/WebAssembly/proposals.
diff --git a/proposals/multi-value/Overview.md b/proposals/multi-value/Overview.md
index a6aeb61b6..b3c0277fe 100644
--- a/proposals/multi-value/Overview.md
+++ b/proposals/multi-value/Overview.md
@@ -14,7 +14,7 @@
   - can easily be lifted by generalising to value* -> value*
 
 * Generalised semantics is well-understood
-  - https://github.com/WebAssembly/spec/tree/master/papers/pldi2017.pdf
+  - https://github.com/WebAssembly/spec/tree/main/papers/pldi2017.pdf
 
 * Semi-complete implementation of multiple results in V8
 
diff --git a/proposals/nontrapping-float-to-int-conversion/Overview.md b/proposals/nontrapping-float-to-int-conversion/Overview.md
index 574fcde70..6a80ca817 100644
--- a/proposals/nontrapping-float-to-int-conversion/Overview.md
+++ b/proposals/nontrapping-float-to-int-conversion/Overview.md
@@ -32,7 +32,7 @@ https://github.com/WebAssembly/meetings/pull/3
 
 and
 
-https://github.com/WebAssembly/meetings/blob/master/2017/CG-05.md#non-trapping-float-to-int
+https://github.com/WebAssembly/meetings/blob/main/2017/CG-05.md#non-trapping-float-to-int
 
 which made decisions about which semantics to choose, and which encoding strategy.
 
@@ -43,7 +43,7 @@ https://github.com/WebAssembly/design/pull/1089
 At the CG-07-06 meeting it was decided that a full spec repo fork should be
 created to follow the new process for new features:
 
-https://github.com/WebAssembly/meetings/blob/master/2017/CG-07-06.md#float-to-int-conversion
+https://github.com/WebAssembly/meetings/blob/main/2017/CG-07-06.md#float-to-int-conversion
 
 This led to the creation of the present repo:
 
diff --git a/proposals/reference-types/Overview.md b/proposals/reference-types/Overview.md
index 43a36d351..670658f2b 100644
--- a/proposals/reference-types/Overview.md
+++ b/proposals/reference-types/Overview.md
@@ -6,7 +6,7 @@ TODO: more text, motivation, explanation
 
 Motivation:
 
-* Easier and more efficient interop with host environment (see e.g. the [Interface Types proposal](https://github.com/WebAssembly/interface-types/blob/master/proposals/interface-types/Explainer.md))
+* Easier and more efficient interop with host environment (see e.g. the [Interface Types proposal](https://github.com/WebAssembly/interface-types/blob/main/proposals/interface-types/Explainer.md))
   - allow host references to be represented directly by type `externref` (see [here](https://github.com/WebAssembly/interface-types/issues/9))
   - without having to go through tables, allocating slots, and maintaining index bijections at the boundaries
 
@@ -19,7 +19,7 @@ by repurposing tables as a general memory for opaque data types
 * Set the stage for later additions:
 
   - Typed function references (see [below](#typed-function-references))
-  - Exception references (see the [exception handling proposal](https://github.com/WebAssembly/exception-handling/blob/master/proposals/Exceptions.md) and [here](https://github.com/WebAssembly/interface-types/issues/10))
+  - Exception references (see the [exception handling proposal](https://github.com/WebAssembly/exception-handling/blob/main/proposals/Exceptions.md) and [here](https://github.com/WebAssembly/interface-types/issues/10))
   - A smoother transition path to GC (see the [GC proposal](https://github.com/WebAssembly/gc/blob/master/proposals/gc/Overview.md))
 
 Get the most important parts soon!
diff --git a/proposals/sign-extension-ops/Overview.md b/proposals/sign-extension-ops/Overview.md
index 55df64b4c..4b1650e7d 100644
--- a/proposals/sign-extension-ops/Overview.md
+++ b/proposals/sign-extension-ops/Overview.md
@@ -45,7 +45,7 @@ instr ::= ...
         | 0xC4                  =>  i64.extend32_s
 ```
 
-[future sext]: https://github.com/WebAssembly/design/blob/master/FutureFeatures.md#additional-integer-operators
+[future sext]: https://github.com/WebAssembly/design/blob/main/FutureFeatures.md#additional-integer-operators
 [instruction syntax]: https://webassembly.github.io/spec/syntax/instructions.html
 [instruction binary format]: https://webassembly.github.io/spec/binary/instructions.html
 [spec]: https://webassembly.github.io/sign-extension-ops/
diff --git a/proposals/simd/BinarySIMD.md b/proposals/simd/BinarySIMD.md
new file mode 100644
index 000000000..d8c87cee9
--- /dev/null
+++ b/proposals/simd/BinarySIMD.md
@@ -0,0 +1,270 @@
+# Binary encoding of SIMD
+
+This document describes the binary encoding of the SIMD value type and
+instructions.
+
+## SIMD value type
+
+The `v128` value type is encoded as 0x7b:
+
+```
+valtype ::= ...
+          | 0x7B => v128
+```
+
+## SIMD instruction encodings
+
+All SIMD instructions are encoded as a 0xfd prefix byte followed by a
+SIMD-specific opcode in LEB128 format:
+
+```
+instr ::= ...
+        | 0xFD simdop:varuint32 ...
+```
+
+Some SIMD instructions have additional immediate operands following `simdop`.
+These immediate operands are encoded as individual bytes.
+For example, the `i8x16.shuffle` instruction has 16 bytes after `simdop`.
+
+In the description below, `ImmLaneIdx{I}` indicates the maximum value of the byte.
+For example, `ImmLaneIdx16` is a byte with values in the range 0-15 (inclusive).
+
+
+| Instruction                     | `simdop` | Immediate operands       |
+| --------------------------------|---------:|--------------------------|
+| `v128.load`                     |    `0x00`| m:memarg                 |
+| `v128.load8x8_s`                |    `0x01`| m:memarg                 |
+| `v128.load8x8_u`                |    `0x02`| m:memarg                 |
+| `v128.load16x4_s`               |    `0x03`| m:memarg                 |
+| `v128.load16x4_u`               |    `0x04`| m:memarg                 |
+| `v128.load32x2_s`               |    `0x05`| m:memarg                 |
+| `v128.load32x2_u`               |    `0x06`| m:memarg                 |
+| `v128.load8_splat`              |    `0x07`| m:memarg                 |
+| `v128.load16_splat`             |    `0x08`| m:memarg                 |
+| `v128.load32_splat`             |    `0x09`| m:memarg                 |
+| `v128.load64_splat`             |    `0x0a`| m:memarg                 |
+| `v128.store`                    |    `0x0b`| m:memarg                 |
+| `v128.const`                    |    `0x0c`| i:ImmByte[16]            |
+| `i8x16.shuffle`                 |    `0x0d`| s:ImmLaneIdx32[16]       |
+| `i8x16.swizzle`                 |    `0x0e`| -                        |
+| `i8x16.splat`                   |    `0x0f`| -                        |
+| `i16x8.splat`                   |    `0x10`| -                        |
+| `i32x4.splat`                   |    `0x11`| -                        |
+| `i64x2.splat`                   |    `0x12`| -                        |
+| `f32x4.splat`                   |    `0x13`| -                        |
+| `f64x2.splat`                   |    `0x14`| -                        |
+| `i8x16.extract_lane_s`          |    `0x15`| i:ImmLaneIdx16           |
+| `i8x16.extract_lane_u`          |    `0x16`| i:ImmLaneIdx16           |
+| `i8x16.replace_lane`            |    `0x17`| i:ImmLaneIdx16           |
+| `i16x8.extract_lane_s`          |    `0x18`| i:ImmLaneIdx8            |
+| `i16x8.extract_lane_u`          |    `0x19`| i:ImmLaneIdx8            |
+| `i16x8.replace_lane`            |    `0x1a`| i:ImmLaneIdx8            |
+| `i32x4.extract_lane`            |    `0x1b`| i:ImmLaneIdx4            |
+| `i32x4.replace_lane`            |    `0x1c`| i:ImmLaneIdx4            |
+| `i64x2.extract_lane`            |    `0x1d`| i:ImmLaneIdx2            |
+| `i64x2.replace_lane`            |    `0x1e`| i:ImmLaneIdx2            |
+| `f32x4.extract_lane`            |    `0x1f`| i:ImmLaneIdx4            |
+| `f32x4.replace_lane`            |    `0x20`| i:ImmLaneIdx4            |
+| `f64x2.extract_lane`            |    `0x21`| i:ImmLaneIdx2            |
+| `f64x2.replace_lane`            |    `0x22`| i:ImmLaneIdx2            |
+| `i8x16.eq`                      |    `0x23`| -                        |
+| `i8x16.ne`                      |    `0x24`| -                        |
+| `i8x16.lt_s`                    |    `0x25`| -                        |
+| `i8x16.lt_u`                    |    `0x26`| -                        |
+| `i8x16.gt_s`                    |    `0x27`| -                        |
+| `i8x16.gt_u`                    |    `0x28`| -                        |
+| `i8x16.le_s`                    |    `0x29`| -                        |
+| `i8x16.le_u`                    |    `0x2a`| -                        |
+| `i8x16.ge_s`                    |    `0x2b`| -                        |
+| `i8x16.ge_u`                    |    `0x2c`| -                        |
+| `i16x8.eq`                      |    `0x2d`| -                        |
+| `i16x8.ne`                      |    `0x2e`| -                        |
+| `i16x8.lt_s`                    |    `0x2f`| -                        |
+| `i16x8.lt_u`                    |    `0x30`| -                        |
+| `i16x8.gt_s`                    |    `0x31`| -                        |
+| `i16x8.gt_u`                    |    `0x32`| -                        |
+| `i16x8.le_s`                    |    `0x33`| -                        |
+| `i16x8.le_u`                    |    `0x34`| -                        |
+| `i16x8.ge_s`                    |    `0x35`| -                        |
+| `i16x8.ge_u`                    |    `0x36`| -                        |
+| `i32x4.eq`                      |    `0x37`| -                        |
+| `i32x4.ne`                      |    `0x38`| -                        |
+| `i32x4.lt_s`                    |    `0x39`| -                        |
+| `i32x4.lt_u`                    |    `0x3a`| -                        |
+| `i32x4.gt_s`                    |    `0x3b`| -                        |
+| `i32x4.gt_u`                    |    `0x3c`| -                        |
+| `i32x4.le_s`                    |    `0x3d`| -                        |
+| `i32x4.le_u`                    |    `0x3e`| -                        |
+| `i32x4.ge_s`                    |    `0x3f`| -                        |
+| `i32x4.ge_u`                    |    `0x40`| -                        |
+| `f32x4.eq`                      |    `0x41`| -                        |
+| `f32x4.ne`                      |    `0x42`| -                        |
+| `f32x4.lt`                      |    `0x43`| -                        |
+| `f32x4.gt`                      |    `0x44`| -                        |
+| `f32x4.le`                      |    `0x45`| -                        |
+| `f32x4.ge`                      |    `0x46`| -                        |
+| `f64x2.eq`                      |    `0x47`| -                        |
+| `f64x2.ne`                      |    `0x48`| -                        |
+| `f64x2.lt`                      |    `0x49`| -                        |
+| `f64x2.gt`                      |    `0x4a`| -                        |
+| `f64x2.le`                      |    `0x4b`| -                        |
+| `f64x2.ge`                      |    `0x4c`| -                        |
+| `v128.not`                      |    `0x4d`| -                        |
+| `v128.and`                      |    `0x4e`| -                        |
+| `v128.andnot`                   |    `0x4f`| -                        |
+| `v128.or`                       |    `0x50`| -                        |
+| `v128.xor`                      |    `0x51`| -                        |
+| `v128.bitselect`                |    `0x52`| -                        |
+| `i8x16.abs`                     |    `0x60`| -                        |
+| `i8x16.neg`                     |    `0x61`| -                        |
+| `i8x16.all_true`                |    `0x63`| -                        |
+| `i8x16.bitmask`                 |    `0x64`| -                        |
+| `i8x16.narrow_i16x8_s`          |    `0x65`| -                        |
+| `i8x16.narrow_i16x8_u`          |    `0x66`| -                        |
+| `i8x16.shl`                     |    `0x6b`| -                        |
+| `i8x16.shr_s`                   |    `0x6c`| -                        |
+| `i8x16.shr_u`                   |    `0x6d`| -                        |
+| `i8x16.add`                     |    `0x6e`| -                        |
+| `i8x16.add_sat_s`               |    `0x6f`| -                        |
+| `i8x16.add_sat_u`               |    `0x70`| -                        |
+| `i8x16.sub`                     |    `0x71`| -                        |
+| `i8x16.sub_sat_s`               |    `0x72`| -                        |
+| `i8x16.sub_sat_u`               |    `0x73`| -                        |
+| `i8x16.min_s`                   |    `0x76`| -                        |
+| `i8x16.min_u`                   |    `0x77`| -                        |
+| `i8x16.max_s`                   |    `0x78`| -                        |
+| `i8x16.max_u`                   |    `0x79`| -                        |
+| `i8x16.avgr_u`                  |    `0x7b`| -                        |
+| `i16x8.abs`                     |    `0x80`| -                        |
+| `i16x8.neg`                     |    `0x81`| -                        |
+| `i16x8.all_true`                |    `0x83`| -                        |
+| `i16x8.bitmask`                 |    `0x84`| -                        |
+| `i16x8.narrow_i32x4_s`          |    `0x85`| -                        |
+| `i16x8.narrow_i32x4_u`          |    `0x86`| -                        |
+| `i16x8.extend_low_i8x16_s`      |    `0x87`| -                        |
+| `i16x8.extend_high_i8x16_s`     |    `0x88`| -                        |
+| `i16x8.extend_low_i8x16_u`      |    `0x89`| -                        |
+| `i16x8.extend_high_i8x16_u`     |    `0x8a`| -                        |
+| `i16x8.shl`                     |    `0x8b`| -                        |
+| `i16x8.shr_s`                   |    `0x8c`| -                        |
+| `i16x8.shr_u`                   |    `0x8d`| -                        |
+| `i16x8.add`                     |    `0x8e`| -                        |
+| `i16x8.add_sat_s`               |    `0x8f`| -                        |
+| `i16x8.add_sat_u`               |    `0x90`| -                        |
+| `i16x8.sub`                     |    `0x91`| -                        |
+| `i16x8.sub_sat_s`               |    `0x92`| -                        |
+| `i16x8.sub_sat_u`               |    `0x93`| -                        |
+| `i16x8.mul`                     |    `0x95`| -                        |
+| `i16x8.min_s`                   |    `0x96`| -                        |
+| `i16x8.min_u`                   |    `0x97`| -                        |
+| `i16x8.max_s`                   |    `0x98`| -                        |
+| `i16x8.max_u`                   |    `0x99`| -                        |
+| `i16x8.avgr_u`                  |    `0x9b`| -                        |
+| `i32x4.abs`                     |    `0xa0`| -                        |
+| `i32x4.neg`                     |    `0xa1`| -                        |
+| `i32x4.all_true`                |    `0xa3`| -                        |
+| `i32x4.bitmask`                 |    `0xa4`| -                        |
+| `i32x4.extend_low_i16x8_s`      |    `0xa7`| -                        |
+| `i32x4.extend_high_i16x8_s`     |    `0xa8`| -                        |
+| `i32x4.extend_low_i16x8_u`      |    `0xa9`| -                        |
+| `i32x4.extend_high_i16x8_u`     |    `0xaa`| -                        |
+| `i32x4.shl`                     |    `0xab`| -                        |
+| `i32x4.shr_s`                   |    `0xac`| -                        |
+| `i32x4.shr_u`                   |    `0xad`| -                        |
+| `i32x4.add`                     |    `0xae`| -                        |
+| `i32x4.sub`                     |    `0xb1`| -                        |
+| `i32x4.mul`                     |    `0xb5`| -                        |
+| `i32x4.min_s`                   |    `0xb6`| -                        |
+| `i32x4.min_u`                   |    `0xb7`| -                        |
+| `i32x4.max_s`                   |    `0xb8`| -                        |
+| `i32x4.max_u`                   |    `0xb9`| -                        |
+| `i32x4.dot_i16x8_s`             |    `0xba`| -                        |
+| `i64x2.abs`                     |    `0xc0`| -                        |
+| `i64x2.neg`                     |    `0xc1`| -                        |
+| `i64x2.bitmask`                 |    `0xc4`| -                        |
+| `i64x2.extend_low_i32x4_s`      |    `0xc7`| -                        |
+| `i64x2.extend_high_i32x4_s`     |    `0xc8`| -                        |
+| `i64x2.extend_low_i32x4_u`      |    `0xc9`| -                        |
+| `i64x2.extend_high_i32x4_u`     |    `0xca`| -                        |
+| `i64x2.shl`                     |    `0xcb`| -                        |
+| `i64x2.shr_s`                   |    `0xcc`| -                        |
+| `i64x2.shr_u`                   |    `0xcd`| -                        |
+| `i64x2.add`                     |    `0xce`| -                        |
+| `i64x2.sub`                     |    `0xd1`| -                        |
+| `i64x2.mul`                     |    `0xd5`| -                        |
+| `f32x4.ceil`                    |    `0x67`| -                        |
+| `f32x4.floor`                   |    `0x68`| -                        |
+| `f32x4.trunc`                   |    `0x69`| -                        |
+| `f32x4.nearest`                 |    `0x6a`| -                        |
+| `f64x2.ceil`                    |    `0x74`| -                        |
+| `f64x2.floor`                   |    `0x75`| -                        |
+| `f64x2.trunc`                   |    `0x7a`| -                        |
+| `f64x2.nearest`                 |    `0x94`| -                        |
+| `f32x4.abs`                     |    `0xe0`| -                        |
+| `f32x4.neg`                     |    `0xe1`| -                        |
+| `f32x4.sqrt`                    |    `0xe3`| -                        |
+| `f32x4.add`                     |    `0xe4`| -                        |
+| `f32x4.sub`                     |    `0xe5`| -                        |
+| `f32x4.mul`                     |    `0xe6`| -                        |
+| `f32x4.div`                     |    `0xe7`| -                        |
+| `f32x4.min`                     |    `0xe8`| -                        |
+| `f32x4.max`                     |    `0xe9`| -                        |
+| `f32x4.pmin`                    |    `0xea`| -                        |
+| `f32x4.pmax`                    |    `0xeb`| -                        |
+| `f64x2.abs`                     |    `0xec`| -                        |
+| `f64x2.neg`                     |    `0xed`| -                        |
+| `f64x2.sqrt`                    |    `0xef`| -                        |
+| `f64x2.add`                     |    `0xf0`| -                        |
+| `f64x2.sub`                     |    `0xf1`| -                        |
+| `f64x2.mul`                     |    `0xf2`| -                        |
+| `f64x2.div`                     |    `0xf3`| -                        |
+| `f64x2.min`                     |    `0xf4`| -                        |
+| `f64x2.max`                     |    `0xf5`| -                        |
+| `f64x2.pmin`                    |    `0xf6`| -                        |
+| `f64x2.pmax`                    |    `0xf7`| -                        |
+| `i32x4.trunc_sat_f32x4_s`       |    `0xf8`| -                        |
+| `i32x4.trunc_sat_f32x4_u`       |    `0xf9`| -                        |
+| `f32x4.convert_i32x4_s`         |    `0xfa`| -                        |
+| `f32x4.convert_i32x4_u`         |    `0xfb`| -                        |
+| `v128.load32_zero`              |    `0x5c`| m:memarg                 |
+| `v128.load64_zero`              |    `0x5d`| m:memarg                 |
+| `i16x8.extmul_low_i8x16_s`      |    `0x9c`| -                        |
+| `i16x8.extmul_high_i8x16_s`     |    `0x9d`| -                        |
+| `i16x8.extmul_low_i8x16_u`      |    `0x9e`| -                        |
+| `i16x8.extmul_high_i8x16_u`     |    `0x9f`| -                        |
+| `i32x4.extmul_low_i16x8_s`      |    `0xbc`| -                        |
+| `i32x4.extmul_high_i16x8_s`     |    `0xbd`| -                        |
+| `i32x4.extmul_low_i16x8_u`      |    `0xbe`| -                        |
+| `i32x4.extmul_high_i16x8_u`     |    `0xbf`| -                        |
+| `i64x2.extmul_low_i32x4_s`      |    `0xdc`| -                        |
+| `i64x2.extmul_high_i32x4_s`     |    `0xdd`| -                        |
+| `i64x2.extmul_low_i32x4_u`      |    `0xde`| -                        |
+| `i64x2.extmul_high_i32x4_u`     |    `0xdf`| -                        |
+| `i16x8.q15mulr_sat_s`           |    `0x82`| -                        |
+| `v128.any_true`                 |    `0x53`| -                        |
+| `v128.load8_lane`               |    `0x54`| m:memarg, i:ImmLaneIdx16 |
+| `v128.load16_lane`              |    `0x55`| m:memarg, i:ImmLaneIdx8  |
+| `v128.load32_lane`              |    `0x56`| m:memarg, i:ImmLaneIdx4  |
+| `v128.load64_lane`              |    `0x57`| m:memarg, i:ImmLaneIdx2  |
+| `v128.store8_lane`              |    `0x58`| m:memarg, i:ImmLaneIdx16 |
+| `v128.store16_lane`             |    `0x59`| m:memarg, i:ImmLaneIdx8  |
+| `v128.store32_lane`             |    `0x5a`| m:memarg, i:ImmLaneIdx4  |
+| `v128.store64_lane`             |    `0x5b`| m:memarg, i:ImmLaneIdx2  |
+| `i64x2.eq`                      |    `0xd6`| -                        |
+| `i64x2.ne`                      |    `0xd7`| -                        |
+| `i64x2.lt_s`                    |    `0xd8`| -                        |
+| `i64x2.gt_s`                    |    `0xd9`| -                        |
+| `i64x2.le_s`                    |    `0xda`| -                        |
+| `i64x2.ge_s`                    |    `0xdb`| -                        |
+| `i64x2.all_true`                |    `0xc3`| -                        |
+| `f64x2.convert_low_i32x4_s`     |    `0xfe`| -                        |
+| `f64x2.convert_low_i32x4_u`     |    `0xff`| -                        |
+| `i32x4.trunc_sat_f64x2_s_zero`  |    `0xfc`| -                        |
+| `i32x4.trunc_sat_f64x2_u_zero`  |    `0xfd`| -                        |
+| `f32x4.demote_f64x2_zero`       |    `0x5e`| -                        |
+| `f64x2.promote_low_f32x4`       |    `0x5f`| -                        |
+| `i8x16.popcnt`                  |    `0x62`| -                        |
+| `i16x8.extadd_pairwise_i8x16_s` |    `0x7c`| -                        |
+| `i16x8.extadd_pairwise_i8x16_u` |    `0x7d`| -                        |
+| `i32x4.extadd_pairwise_i16x8_s` |    `0x7e`| -                        |
+| `i32x4.extadd_pairwise_i16x8_u` |    `0x7f`| -                        |
diff --git a/proposals/simd/ImplementationStatus.md b/proposals/simd/ImplementationStatus.md
new file mode 100644
index 000000000..24c67d7e6
--- /dev/null
+++ b/proposals/simd/ImplementationStatus.md
@@ -0,0 +1,248 @@
+| Instruction                     | LLVM[1]                   | V8[2]              | WAVM[3]            | ChakraCore[4]      | SpiderMonkey[5]    |
+| --------------------------------|---------------------------|--------------------|--------------------|--------------------|--------------------|
+| `v128.load`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `v128.load8x8_s`                |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load8x8_u`                |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load16x4_s`               |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load16x4_u`               |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load32x2_s`               |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load32x2_u`               |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load8_splat`              |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load16_splat`             |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load32_splat`             |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load64_splat`             |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.store`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `v128.const`                    | `-munimplemented-simd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.shuffle`                 |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.swizzle`                 |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i8x16.splat`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.splat`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.splat`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i64x2.splat`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.splat`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.splat`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.extract_lane_s`          |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.extract_lane_u`          |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.replace_lane`            |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.extract_lane_s`          |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.extract_lane_u`          |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.replace_lane`            |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.extract_lane`            |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.replace_lane`            |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i64x2.extract_lane`            |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i64x2.replace_lane`            |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.extract_lane`            |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.replace_lane`            |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.extract_lane`            |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.replace_lane`            |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.eq`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.ne`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.lt_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.lt_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.gt_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.gt_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.le_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.le_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.ge_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.ge_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.eq`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.ne`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.lt_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.lt_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.gt_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.gt_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.le_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.le_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.ge_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.ge_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.eq`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.ne`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.lt_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.lt_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.gt_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.gt_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.le_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.le_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.ge_s`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.ge_u`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.eq`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.ne`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.lt`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.gt`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.le`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.ge`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.eq`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.ne`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.lt`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.gt`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.le`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.ge`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `v128.not`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `v128.and`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `v128.andnot`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.or`                       |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `v128.xor`                      |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `v128.bitselect`                |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.abs`                     |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i8x16.neg`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.all_true`                |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.bitmask`                 | `-munimplemented-simd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i8x16.narrow_i16x8_s`          |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i8x16.narrow_i16x8_u`          |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i8x16.shl`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.shr_s`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.shr_u`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.add`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.add_sat_s`               |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.add_sat_u`               |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.sub`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.sub_sat_s`               |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.sub_sat_u`               |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i8x16.min_s`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i8x16.min_u`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i8x16.max_s`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i8x16.max_u`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i8x16.avgr_u`                  |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.abs`                     |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.neg`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.all_true`                |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.bitmask`                 | `-munimplemented-simd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.narrow_i32x4_s`          |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.narrow_i32x4_u`          |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.extend_low_i8x16_s`      |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.extend_high_i8x16_s`     |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.extend_low_i8x16_u`      |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.extend_high_i8x16_u`     |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.shl`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.shr_s`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.shr_u`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.add`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.add_sat_s`               |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.add_sat_u`               |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.sub`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.sub_sat_s`               |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.sub_sat_u`               |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.mul`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i16x8.min_s`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.min_u`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.max_s`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.max_u`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.avgr_u`                  |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.q15mulr_sat_s`           |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.abs`                     |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.neg`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.all_true`                |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.bitmask`                 | `-munimplemented-simd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.extend_low_i16x8_s`      |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.extend_high_i16x8_s`     |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.extend_low_i16x8_u`      |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.extend_high_i16x8_u`     |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.shl`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.shr_s`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.shr_u`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.add`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.sub`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.mul`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.min_s`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.min_u`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.max_s`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.max_u`                   |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.dot_i16x8_s`             |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.eq`                      |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.abs`                     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.neg`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i64x2.all_true`                |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.bitmask`                 |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.shl`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i64x2.shr_s`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i64x2.shr_u`                   |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i64x2.add`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i64x2.sub`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i64x2.mul`                     |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.extend_low_i32x4_s`      |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.extend_high_i32x4_s`     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.extend_low_i32x4_u`      |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.extend_high_i32x4_u`     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f32x4.abs`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.neg`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.sqrt`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.add`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.sub`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.mul`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.div`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.min`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.max`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.pmin`                    |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f32x4.pmax`                    |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f32x4.ceil`                    |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f32x4.floor`                   |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f32x4.trunc`                   |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f32x4.nearest`                 |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f64x2.abs`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.neg`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.sqrt`                    |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.add`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.sub`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.mul`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.div`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.min`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.max`                     |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f64x2.pmin`                    |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f64x2.pmax`                    |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f64x2.ceil`                    |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f64x2.floor`                   |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f64x2.trunc`                   |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f64x2.nearest`                 |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.trunc_sat_f32x4_s`       |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `i32x4.trunc_sat_f32x4_u`       |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.convert_i32x4_s`         |               `-msimd128` | :heavy_check_mark: |                    | :heavy_check_mark: | :heavy_check_mark: |
+| `f32x4.convert_i32x4_u`         |               `-msimd128` | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load32_zero`              |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load64_zero`              |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.extmul_low_i8x16_s`      |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.extmul_high_i8x16_s`     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.extmul_low_i8x16_u`      |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.extmul_high_i8x16_u`     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.extmul_low_i16x8_s`      |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.extmul_high_i16x8_s`     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.extmul_low_i16x8_u`      |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.extmul_high_i16x8_u`     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.extmul_low_i32x4_s`      |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.extmul_high_i32x4_s`     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.extmul_low_i32x4_u`      |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.extmul_high_i32x4_u`     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.any_true`                 |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load8_lane`               |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load16_lane`              |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load32_lane`              |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.load64_lane`              |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.store8_lane`              |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.store16_lane`             |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.store32_lane`             |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `v128.store64_lane`             |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.ne`                      |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f64x2.convert_low_i32x4_s`     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f64x2.convert_low_i32x4_u`     |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.trunc_sat_f64x2_s_zero`  |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.trunc_sat_f64x2_u_zero`  |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f32x4.demote_f64x2_zero`       |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `f64x2.promote_low_f32x4`       |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i8x16.popcnt`                  |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.extadd_pairwise_i8x16_s` |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i16x8.extadd_pairwise_i8x16_u` |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.extadd_pairwise_i16x8_s` |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i32x4.extadd_pairwise_i16x8_u` |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.lt_s`                    |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.gt_s`                    |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.le_s`                    |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+| `i64x2.ge_s`                    |                           | :heavy_check_mark: |                    |                    | :heavy_check_mark: |
+
+[1] Tip of tree LLVM as of May 20, 2020
+
+[2] V8 9.1.0.
+
+[3] Not known to be updated after latest renumbering. Requires flag `--enable simd`
+
+[4] Only in 1.12.* (development branch). Requires (case-insensitive) flag `-wasmsimd`
+
+[5] Firefox x64/x86 (SSE4.1+ only) from FF89, ARM64 from FF90. Earlier versions control in about:config under `javascript.options.wasm_simd`
diff --git a/proposals/simd/NewOpcodes.md b/proposals/simd/NewOpcodes.md
new file mode 100644
index 000000000..49b1232a4
--- /dev/null
+++ b/proposals/simd/NewOpcodes.md
@@ -0,0 +1,157 @@
+| Memory instruction | opcode |
+| ------------------ | ------ |
+| v128.load          | 0x00   |
+| v128.load8x8_s     | 0x01   |
+| v128.load8x8_u     | 0x02   |
+| v128.load16x4_s    | 0x03   |
+| v128.load16x4_u    | 0x04   |
+| v128.load32x2_s    | 0x05   |
+| v128.load32x2_u    | 0x06   |
+| v128.load8_splat   | 0x07   |
+| v128.load16_splat  | 0x08   |
+| v128.load32_splat  | 0x09   |
+| v128.load64_splat  | 0x0a   |
+| v128.store         | 0x0b   |
+
+| Basic operation | opcode |
+| ----------------| ------ |
+| v128.const      | 0x0c   |
+| i8x16.shuffle   | 0x0d   |
+| i8x16.swizzle   | 0x0e   |
+
+| Splat operation | opcode |
+| --------------- | ------ |
+| i8x16.splat     | 0x0f   |
+| i16x8.splat     | 0x10   |
+| i32x4.splat     | 0x11   |
+| i64x2.splat     | 0x12   |
+| f32x4.splat     | 0x13   |
+| f64x2.splat     | 0x14   |
+
+| Lane operation       | opcode |
+| -------------------- | ------ |
+| i8x16.extract_lane_s | 0x15   |
+| i8x16.extract_lane_u | 0x16   |
+| i8x16.replace_lane   | 0x17   |
+| i16x8.extract_lane_s | 0x18   |
+| i16x8.extract_lane_u | 0x19   |
+| i16x8.replace_lane   | 0x1a   |
+| i32x4.extract_lane   | 0x1b   |
+| i32x4.replace_lane   | 0x1c   |
+| i64x2.extract_lane   | 0x1d   |
+| i64x2.replace_lane   | 0x1e   |
+| f32x4.extract_lane   | 0x1f   |
+| f32x4.replace_lane   | 0x20   |
+| f64x2.extract_lane   | 0x21   |
+| f64x2.replace_lane   | 0x22   |
+
+| i8x16 Cmp  | opcode | i16x8 Cmp  | opcode | i32x4 Cmp  | opcode |
+| ---------- | ------ | ---------- | ------ | ---------- | ------ |
+| i8x16.eq   | 0x23   | i16x8.eq   | 0x2d   | i32x4.eq   | 0x37   |
+| i8x16.ne   | 0x24   | i16x8.ne   | 0x2e   | i32x4.ne   | 0x38   |
+| i8x16.lt_s | 0x25   | i16x8.lt_s | 0x2f   | i32x4.lt_s | 0x39   |
+| i8x16.lt_u | 0x26   | i16x8.lt_u | 0x30   | i32x4.lt_u | 0x3a   |
+| i8x16.gt_s | 0x27   | i16x8.gt_s | 0x31   | i32x4.gt_s | 0x3b   |
+| i8x16.gt_u | 0x28   | i16x8.gt_u | 0x32   | i32x4.gt_u | 0x3c   |
+| i8x16.le_s | 0x29   | i16x8.le_s | 0x33   | i32x4.le_s | 0x3d   |
+| i8x16.le_u | 0x2a   | i16x8.le_u | 0x34   | i32x4.le_u | 0x3e   |
+| i8x16.ge_s | 0x2b   | i16x8.ge_s | 0x35   | i32x4.ge_s | 0x3f   |
+| i8x16.ge_u | 0x2c   | i16x8.ge_u | 0x36   | i32x4.ge_u | 0x40   |
+
+| f32x4 Cmp | opcode | f64x2 Cmp | opcode |
+| --------- | ------ | --------- | ------ |
+| f32x4.eq  | 0x41   | f64x2.eq  | 0x47   |
+| f32x4.ne  | 0x42   | f64x2.ne  | 0x48   |
+| f32x4.lt  | 0x43   | f64x2.lt  | 0x49   |
+| f32x4.gt  | 0x44   | f64x2.gt  | 0x4a   |
+| f32x4.le  | 0x45   | f64x2.le  | 0x4b   |
+| f32x4.ge  | 0x46   | f64x2.ge  | 0x4c   |
+
+| v128 Op        | opcode |
+| -------------- | ------ |
+| v128.not       | 0x4d   |
+| v128.and       | 0x4e   |
+| v128.andnot    | 0x4f   |
+| v128.or        | 0x50   |
+| v128.xor       | 0x51   |
+| v128.bitselect | 0x52   |
+| v128.any_true  | 0x53   |
+
+| Load Lane Op      | opcode |
+| ----------------- | ------ |
+| v128.load8_lane   | 0x54   |
+| v128.load16_lane  | 0x55   |
+| v128.load32_lane  | 0x56   |
+| v128.load64_lane  | 0x57   |
+| v128.store8_lane  | 0x58   |
+| v128.store16_lane | 0x59   |
+| v128.store32_lane | 0x5a   |
+| v128.store64_lane | 0x5b   |
+| v128.load32_zero  | 0x5c   |
+| v128.load64_zero  | 0x5d   |
+
+| Float conversion        | opcode |
+| ----------------------- | ------ |
+| f32x4.demote_f64x2_zero | 0x5e   |
+| f64x2.promote_low_f32x4 | 0x5f   |
+
+| i8x16 Op                      | opcode | i16x8 Op                  | opcode | i32x4 Op                  | opcode | i64x2 Op                  | opcode |
+| ----------------------------- | ------ | ------------------------- | ------ | ------------------------- | ------ | ------------------------- | ------ |
+| i8x16.abs                     | 0x60   | i16x8.abs                 | 0x80   | i32x4.abs                 | 0xa0   | i64x2.abs                 | 0xc0   |
+| i8x16.neg                     | 0x61   | i16x8.neg                 | 0x81   | i32x4.neg                 | 0xa1   | i64x2.neg                 | 0xc1   |
+| i8x16.popcnt                  | 0x62   | i16x8.q15mulr_sat_s       | 0x82   |                           | 0xa2   | -------------             | 0xc2   |
+| i8x16.all_true                | 0x63   | i16x8.all_true            | 0x83   | i32x4.all_true            | 0xa3   | i64x2.all_true            | 0xc3   |
+| i8x16.bitmask                 | 0x64   | i16x8.bitmask             | 0x84   | i32x4.bitmask             | 0xa4   | i64x2.bitmask             | 0xc4   |
+| i8x16.narrow_i16x8_s          | 0x65   | i16x8.narrow_i32x4_s      | 0x85   | ---- narrow ----          | 0xa5   | -------------             | 0xc5   |
+| i8x16.narrow_i16x8_u          | 0x66   | i16x8.narrow_i32x4_u      | 0x86   | ---- narrow ----          | 0xa6   | -------------             | 0xc6   |
+| f32x4.ceil                    | 0x67   | i16x8.extend_low_i8x16_s  | 0x87   | i32x4.extend_low_i16x8_s  | 0xa7   | i64x2.extend_low_i32x4_s  | 0xc7   |
+| f32x4.floor                   | 0x68   | i16x8.extend_high_i8x16_s | 0x88   | i32x4.extend_high_i16x8_s | 0xa8   | i64x2.extend_high_i32x4_s | 0xc8   |
+| f32x4.trunc                   | 0x69   | i16x8.extend_low_i8x16_u  | 0x89   | i32x4.extend_low_i16x8_u  | 0xa9   | i64x2.extend_low_i32x4_u  | 0xc9   |
+| f32x4.nearest                 | 0x6a   | i16x8.extend_high_i8x16_u | 0x8a   | i32x4.extend_high_i16x8_u | 0xaa   | i64x2.extend_high_i32x4_u | 0xca   |
+| i8x16.shl                     | 0x6b   | i16x8.shl                 | 0x8b   | i32x4.shl                 | 0xab   | i64x2.shl                 | 0xcb   |
+| i8x16.shr_s                   | 0x6c   | i16x8.shr_s               | 0x8c   | i32x4.shr_s               | 0xac   | i64x2.shr_s               | 0xcc   |
+| i8x16.shr_u                   | 0x6d   | i16x8.shr_u               | 0x8d   | i32x4.shr_u               | 0xad   | i64x2.shr_u               | 0xcd   |
+| i8x16.add                     | 0x6e   | i16x8.add                 | 0x8e   | i32x4.add                 | 0xae   | i64x2.add                 | 0xce   |
+| i8x16.add_sat_s               | 0x6f   | i16x8.add_sat_s           | 0x8f   | ---- add_sat ----         | 0xaf   | -------------             | 0xcf   |
+| i8x16.add_sat_u               | 0x70   | i16x8.add_sat_u           | 0x90   | ---- add_sat ----         | 0xb0   | -------------             | 0xd0   |
+| i8x16.sub                     | 0x71   | i16x8.sub                 | 0x91   | i32x4.sub                 | 0xb1   | i64x2.sub                 | 0xd1   |
+| i8x16.sub_sat_s               | 0x72   | i16x8.sub_sat_s           | 0x92   | ---- sub_sat ----         | 0xb2   | -------------             | 0xd2   |
+| i8x16.sub_sat_u               | 0x73   | i16x8.sub_sat_u           | 0x93   | ---- sub_sat ----         | 0xb3   | -------------             | 0xd3   |
+| f64x2.ceil                    | 0x74   | f64x2.nearest             | 0x94   | -------------             | 0xb4   | -------------             | 0xd4   |
+| f64x2.floor                   | 0x75   | i16x8.mul                 | 0x95   | i32x4.mul                 | 0xb5   | i64x2.mul                 | 0xd5   |
+| i8x16.min_s                   | 0x76   | i16x8.min_s               | 0x96   | i32x4.min_s               | 0xb6   | i64x2.eq                  | 0xd6   |
+| i8x16.min_u                   | 0x77   | i16x8.min_u               | 0x97   | i32x4.min_u               | 0xb7   | i64x2.ne                  | 0xd7   |
+| i8x16.max_s                   | 0x78   | i16x8.max_s               | 0x98   | i32x4.max_s               | 0xb8   | i64x2.lt_s                | 0xd8   |
+| i8x16.max_u                   | 0x79   | i16x8.max_u               | 0x99   | i32x4.max_u               | 0xb9   | i64x2.gt_s                | 0xd9   |
+| f64x2.trunc                   | 0x7a   |                           | 0x9a   | i32x4.dot_i16x8_s         | 0xba   | i64x2.le_s                | 0xda   |
+| i8x16.avgr_u                  | 0x7b   | i16x8.avgr_u              | 0x9b   | ---- avgr_u ----          | 0xbb   | i64x2.ge_s                | 0xdb   |
+| i16x8.extadd_pairwise_i8x16_s | 0x7c   | i16x8.extmul_low_i8x16_s  | 0x9c   | i32x4.extmul_low_i16x8_s  | 0xbc   | i64x2.extmul_low_i32x4_s  | 0xdc   |
+| i16x8.extadd_pairwise_i8x16_u | 0x7d   | i16x8.extmul_high_i8x16_s | 0x9d   | i32x4.extmul_high_i16x8_s | 0xbd   | i64x2.extmul_high_i32x4_s | 0xdd   |
+| i32x4.extadd_pairwise_i16x8_s | 0x7e   | i16x8.extmul_low_i8x16_u  | 0x9e   | i32x4.extmul_low_i16x8_u  | 0xbe   | i64x2.extmul_low_i32x4_u  | 0xde   |
+| i32x4.extadd_pairwise_i16x8_u | 0x7f   | i16x8.extmul_high_i8x16_u | 0x9f   | i32x4.extmul_high_i16x8_u | 0xbf   | i64x2.extmul_high_i32x4_u | 0xdf   |
+
+| f32x4 Op        | opcode | f64x2 Op        | opcode |
+| --------------- | ------ | --------------- | ------ |
+| f32x4.abs       | 0xe0   | f64x2.abs       | 0xec   |
+| f32x4.neg       | 0xe1   | f64x2.neg       | 0xed   |
+| ---- round ---- | 0xe2   | ---- round ---- | 0xee   |
+| f32x4.sqrt      | 0xe3   | f64x2.sqrt      | 0xef   |
+| f32x4.add       | 0xe4   | f64x2.add       | 0xf0   |
+| f32x4.sub       | 0xe5   | f64x2.sub       | 0xf1   |
+| f32x4.mul       | 0xe6   | f64x2.mul       | 0xf2   |
+| f32x4.div       | 0xe7   | f64x2.div       | 0xf3   |
+| f32x4.min       | 0xe8   | f64x2.min       | 0xf4   |
+| f32x4.max       | 0xe9   | f64x2.max       | 0xf5   |
+| f32x4.pmin      | 0xea   | f64x2.pmin      | 0xf6   |
+| f32x4.pmax      | 0xeb   | f64x2.pmax      | 0xf7   |
+
+| Conversion Op                | opcode |
+| ---------------------------- | ------ |
+| i32x4.trunc_sat_f32x4_s      | 0xf8   |
+| i32x4.trunc_sat_f32x4_u      | 0xf9   |
+| f32x4.convert_i32x4_s        | 0xfa   |
+| f32x4.convert_i32x4_u        | 0xfb   |
+| i32x4.trunc_sat_f64x2_s_zero | 0xfc   |
+| i32x4.trunc_sat_f64x2_u_zero | 0xfd   |
+| f64x2.convert_low_i32x4_s    | 0xfe   |
+| f64x2.convert_low_i32x4_u    | 0xff   |
diff --git a/proposals/simd/SIMD.md b/proposals/simd/SIMD.md
new file mode 100644
index 000000000..9f2c802a4
--- /dev/null
+++ b/proposals/simd/SIMD.md
@@ -0,0 +1,1178 @@
+# WebAssembly 128-bit packed SIMD Extension
+
+This specification describes a 128-bit packed *Single Instruction Multiple
+Data* (SIMD) extension to WebAssembly that can be implemented efficiently on
+current popular instruction set architectures.
+
+See also [The binary encoding of SIMD instructions](BinarySIMD.md).
+
+## Motivation
+
+WebAssembly aims to take advantage of [common hardware capabilities](https://github.com/WebAssembly/design/blob/master/Portability.md#assumptions-for-efficient-execution)
+for near native speed. The motivation for this proposal is to introduce
+WebAssembly operations that map to commonly available [SIMD](https://en.wikipedia.org/wiki/SIMD)
+instructions in hardware. 
+
+SIMD instructions in hardware work by performing simultaneous computations over
+packed data in one instruction. These are commonly used to improve performance
+for multimedia applications. The set of SIMD instructions in hardware is large, 
+and varies across different versions of hardware. This proposal is comprised
+of a portable subset of operations that in most cases map to commonly used
+instructions in mordern hardware. 
+
+
+# Types
+
+WebAssembly is extended with a new `v128` value type and a number of new kinds
+of immediate operands used by the SIMD instructions.
+
+## SIMD value type
+
+The `v128` value type is the _only_ type introduced in this extension. It has a
+concrete mapping to a 128-bit representation with bits numbered 0–127. The
+`v128` type corresponds to a vector register in a typical SIMD ISA. The
+interpretation of the 128 bits in the vector register is provided by the
+individual instructions. When a `v128` value is represented as 16 bytes, bits
+0-7 go in the first byte with bit 0 as the LSB, bits 8-15 go in the second byte,
+etc.
+
+## Immediate operands
+
+Some of the new SIMD instructions defined here have immediate operands that are
+encoded as individual bytes in the binary encoding. Many have a limited valid
+range, and it is a validation error if the immediate operands are out of range.
+
+* `ImmByte`: A single unconstrained byte (0-255).
+* `ImmLaneIdx2`: A byte with values in the range 0–1 identifying a lane.
+* `ImmLaneIdx4`: A byte with values in the range 0–3 identifying a lane.
+* `ImmLaneIdx8`: A byte with values in the range 0–7 identifying a lane.
+* `ImmLaneIdx16`: A byte with values in the range 0–15 identifying a lane.
+* `ImmLaneIdx32`: A byte with values in the range 0–31 identifying a lane.
+
+## Operations on the SIMD value type
+
+The _single_ `v128` SIMD type can be used to represent different types of packed
+data, e.g., it can represent four 32-bit floating point values, 8 16-bit signed
+or unsigned integer values, etc.
+
+The instructions introduced in this specification are named according to the
+following schema: `{interpretation}.{operation}`. Where the `{interpretation}`
+prefix denotes how the bytes of the `v128` type are interpreted by the `{operation}`. 
+
+For example, the instructions `f32x4.extract_lane` and `i64x2.extract_lane`
+perform the same semantic operation: extracting the scalar value of a vector
+lane. However, the `f32x4.extract_lane` instruction returns a 32-bit wide
+floating point value, while the `i64x2.extract_lane` instruction returns a
+64-bit wide integer value.
+
+The `v128` vector type interpretation interprets the vector as a bag of bits. 
+The `v{lane_width}x{n}` interpretations (e.g. `v32x4`) interpret the vector as
+`n` lanes of `lane_width` bits. The `{t}{lane_width}x{n}` interpretations (e.g.
+`i32x4` or `f32x4`) interpret the vector as `n` lanes of type `{t}{lane_width}`.
+
+### Lane division interpretation
+
+The first level of interpretations of the `v128` type imposes a lane structure on
+the bits:
+
+* `v8x16 : v128`: 8-bit lanes numbered 0–15. Lane n corresponds to bits 8n – 8n+7.
+* `v16x8 : v128`: 16-bit lanes numbered 0–7. Lane n corresponds to bits 16n – 16n+15.
+* `v32x4 : v128`: 32-bit lanes numbered 0–3. Lane n corresponds to bits 32n – 32n+31.
+* `v64x2 : v128`: 64-bit lanes numbered 0–1. Lane n corresponds to bits 64n – 64n+63.
+
+The lane dividing interpretations don't say anything about the semantics of the
+bits in each lane. The interpretations have *properties* used by the semantic
+specification pseudo-code below:
+
+|    S    | S.LaneBits | S.Lanes | S.MaskType |
+|---------|-----------:|--------:|:----------:|
+| `v8x16` |          8 |      16 | `i8x16`    |
+| `v16x8` |         16 |       8 | `i16x8`    |
+| `v32x4` |         32 |       4 | `i32x4`    |
+| `v64x2` |         64 |       2 | `i64x2`    |
+
+Since WebAssembly is little-endian, the least significant bit in each lane is
+the bit with the lowest number.
+
+### Modulo integer interpretations
+
+The bits in a lane can be interpreted as integers with modulo arithmetic
+semantics. Many arithmetic operations can be defined on these types which don't
+impose a signed or unsigned integer interpretation.
+
+* `i8x16 : v8x16`: Each lane is an `i8`.
+* `i16x8 : v16x8`: Each lane is an `i16`.
+* `i32x4 : v32x4`: Each lane is an `i32`.
+* `i64x2 : v64x2`: Each lane is an `i64`.
+
+Additional properties:
+
+|    S    |  S.Smin | S.Smax | S.Umax |
+|---------|--------:|-------:|-------:|
+| `i8x16` |    -2^7 |  2^7-1 |  2^8-1 |
+| `i16x8` |   -2^15 | 2^15-1 | 2^16-1 |
+| `i32x4` |   -2^31 | 2^31-1 | 2^32-1 |
+| `i64x2` |   -2^63 | 2^63-1 | 2^64-1 |
+
+Some operations interpret each lane specifically as a signed or unsigned
+integer. These operations have `_s` and `_u` suffixes as is the convention is
+WebAssembly.
+
+### Floating-point interpretations
+
+Each lane is interpreted as an IEEE floating-point number.
+
+* `f32x4 : v32x4`: Each lane is an `f32`.
+* `f64x2 : v64x2`: Each lane is an `f64`.
+
+The floating-point operations in this specification aim to be compatible with
+WebAssembly's scalar floating-point operations. In particular, the rules about
+NaN propagation and default NaN values are the same, and all operations use the
+default *roundTiesToEven* rounding mode.
+
+# JavaScript API and SIMD Values
+
+Accessing WebAssembly module imports or exports containing SIMD Type from JavaScript will throw.
+
+### Module Function Imports
+
+Calling an imported function from JavaScript when the function arguments or result is of type v128 will cause the host function to immidiately throw a [`TypeError`](https://tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror).
+
+### Exported Function Exotic Objects
+
+Invoking the [[Call]] method of an Exported Function Exotic Object when the function type of its [[Closure]] has an argument or result of type v128 will cause the host function to immidiately throw a [`TypeError`](https://tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror).
+
+
+## WebAssembly Module Instatiation
+
+Instantiating a WebAssembly Module from a Module moduleObject will throw a LinkError exception, when the global's valtype is v128 and the imported objects type is not WebAssembly.Global. 
+
+## Exported Functions
+
+### Exported Function Call
+
+Calling an Exported Function will throw a [`TypeError`](https://tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror), when parameters or results contains a v128. This error is thrown each time the [[Call]] method is invoked.
+
+### Creating a host function
+
+Creating a host function from JavaScript object will throw a [`TypeError`](https://tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror), when the host function signature contains a v128.
+
+### Global constructor
+
+If Global(descriptor, v) constructor will throw a [`TypeError`](https://tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror), when invoked with v of valuetype v128.
+
+## JavaScript coercion
+
+### ToJSValue
+
+The algorithm toJSValue(w) should have an assertion ensuring w is not of the form v128.const v128.
+
+### ToWebAssemblyValue
+
+The algorithm ToWebAssemblyValue(v, type)  should have an assertion ensuring type is not v128.
+
+## JavaScript API Global Object algorithms
+
+### ToValueType
+
+The algorithm ToValueType(s) will return 'v128' if s equals "v128".
+
+### DefaultValue 
+
+The algorithm DefaultValueType(valueType) will return v128.const 0.
+
+### GetGlobalValue
+
+The algorithm GetGlobalValue(Global global) will throw a [`TypeError`](https://tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror), when type_global(store, global.[[Global]]) is of the form mut v128.
+
+### Global value attribute Setter
+
+The setter of the value attribute of Global will throw a [`TypeError`](https://tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror), when invoked with a value v of valuetype v128.
+
+# Operations
+
+The SIMD operations described in this sections are generally named
+`S.Op`, where `S` is either a SIMD type or one of the interpretations
+of a SIMD type. Immediate mode operands are prefixed with `imm`.
+
+Many operations are simply the lane-wise application of a scalar operation:
+
+```python
+def S.lanewise_unary(func, a):
+    result = S.New()
+    for i in range(S.Lanes):
+        result[i] = func(a[i])
+    return result
+
+def S.lanewise_binary(func, a, b):
+    result = S.New()
+    for i in range(S.Lanes):
+        result[i] = func(a[i], b[i])
+    return result
+```
+
+Comparison operators produce a mask vector where the bits in each lane are 0
+for false and all ones for true:
+
+```python
+def S.lanewise_comparison(func, a, b):
+    all_ones = S.MaskType.Umax
+    result = S.MaskType.New()
+    for i in range(S.Lanes):
+        result[i] = all_ones if func(a[i], b[i]) else 0
+    return result
+```
+
+## Constructing SIMD values
+
+### Constant
+* `v128.const(imm: ImmByte[16]) -> v128`
+
+Materialize a constant `v128` SIMD value from the 16 immediate bytes in the
+immediate mode operand `imm` . The `v128.const` instruction is encoded with 16
+immediate bytes which provide the bits of the vector directly.
+
+### Create vector with identical lanes
+* `i8x16.splat(x: i32) -> v128`
+* `i16x8.splat(x: i32) -> v128`
+* `i32x4.splat(x: i32) -> v128`
+* `i64x2.splat(x: i64) -> v128`
+* `f32x4.splat(x: f32) -> v128`
+* `f64x2.splat(x: f64) -> v128`
+
+Construct a vector with `x` replicated to all lanes:
+
+```python
+def S.splat(x):
+    result = S.New()
+    for i in range(S.Lanes):
+        result[i] = S.Reduce(x)
+    return result
+```
+
+## Accessing lanes
+
+### Extract lane as a scalar
+* `i8x16.extract_lane_s(a: v128, imm: ImmLaneIdx16) -> i32`
+* `i8x16.extract_lane_u(a: v128, imm: ImmLaneIdx16) -> i32`
+* `i16x8.extract_lane_s(a: v128, imm: ImmLaneIdx8) -> i32`
+* `i16x8.extract_lane_u(a: v128, imm: ImmLaneIdx8) -> i32`
+* `i32x4.extract_lane(a: v128, imm: ImmLaneIdx4) -> i32`
+* `i64x2.extract_lane(a: v128, imm: ImmLaneIdx2) -> i64`
+* `f32x4.extract_lane(a: v128, imm: ImmLaneIdx4) -> f32`
+* `f64x2.extract_lane(a: v128, imm: ImmLaneIdx2) -> f64`
+
+Extract the scalar value of lane specified in the immediate mode operand `imm`
+in `a`. The `{interpretation}.extract_lane{_s}{_u}` instructions are encoded
+with one immediate byte providing the index of the lane to extract.
+
+```python
+def S.extract_lane(a, i):
+    return a[i]
+```
+
+The `_s` and `_u` variants will sign-extend or zero-extend the lane value to
+`i32` respectively.
+
+### Replace lane value
+* `i8x16.replace_lane(a: v128, imm: ImmLaneIdx16, x: i32) -> v128`
+* `i16x8.replace_lane(a: v128, imm: ImmLaneIdx8, x: i32) -> v128`
+* `i32x4.replace_lane(a: v128, imm: ImmLaneIdx4, x: i32) -> v128`
+* `i64x2.replace_lane(a: v128, imm: ImmLaneIdx2, x: i64) -> v128`
+* `f32x4.replace_lane(a: v128, imm: ImmLaneIdx4, x: f32) -> v128`
+* `f64x2.replace_lane(a: v128, imm: ImmLaneIdx2, x: f64) -> v128`
+
+Return a new vector with lanes identical to `a`, except for the lane specified
+in the immediate mode operand `imm` which has the value `x`. The
+`{interpretation}.replace_lane` instructions are encoded with an immediate byte 
+providing the index of the lane the value of which is to be replaced.
+
+```python
+def S.replace_lane(a, i, x):
+    result = S.New()
+    for j in range(S.Lanes):
+        result[j] = a[j]
+    result[i] = x
+    return result
+```
+
+The input lane value, `x`, is interpreted the same way as for the splat
+instructions. For the `i8` and `i16` lanes, the high bits of `x` are ignored.
+
+### Shuffling using immediate indices
+* `i8x16.shuffle(a: v128, b: v128, imm: ImmLaneIdx32[16]) -> v128`
+
+Returns a new vector with lanes selected from the lanes of the two input vectors
+`a` and `b` specified in the 16 byte wide immediate mode operand `imm`. This
+instruction is encoded with 16 bytes providing the indices of the elements to
+return. The indices `i` in range `[0, 15]` select the `i`-th element of `a`. The
+indices in range `[16, 31]` select the `i - 16`-th element of `b`.
+
+```python
+def S.shuffle(a, b, s):
+    result = S.New()
+    for i in range(S.Lanes):
+        if s[i] < S.lanes:
+            result[i] = a[s[i]]
+        else:
+            result[i] = b[s[i] - S.lanes]
+    return result
+```
+
+### Swizzling using variable indices
+* `i8x16.swizzle(a: v128, s: v128) -> v128`
+
+Returns a new vector with lanes selected from the lanes of the first input
+vector `a` specified in the second input vector `s`. The indices `i` in range
+`[0, 15]` select the `i`-th element of `a`. For indices outside of the range
+the resulting lane is initialized to 0.
+
+```python
+def S.swizzle(a, s):
+    result = S.New()
+    for i in range(S.Lanes):
+        if s[i] < S.lanes:
+            result[i] = a[s[i]]
+        else:
+            result[i] = 0
+    return result
+```
+
+## Integer arithmetic
+
+Wrapping integer arithmetic discards the high bits of the result.
+
+```python
+def S.Reduce(x):
+    bitmask = (1 << S.LaneBits) - 1
+    return x & bitmask
+```
+
+There is no integer division operation provided here. This operation is not
+commonly part of 128-bit SIMD ISAs.
+
+### Integer addition
+* `i8x16.add(a: v128, b: v128) -> v128`
+* `i16x8.add(a: v128, b: v128) -> v128`
+* `i32x4.add(a: v128, b: v128) -> v128`
+* `i64x2.add(a: v128, b: v128) -> v128`
+
+Lane-wise wrapping integer addition:
+
+```python
+def S.add(a, b):
+    def add(x, y):
+        return S.Reduce(x + y)
+    return S.lanewise_binary(add, a, b)
+```
+
+### Integer subtraction
+* `i8x16.sub(a: v128, b: v128) -> v128`
+* `i16x8.sub(a: v128, b: v128) -> v128`
+* `i32x4.sub(a: v128, b: v128) -> v128`
+* `i64x2.sub(a: v128, b: v128) -> v128`
+
+Lane-wise wrapping integer subtraction:
+
+```python
+def S.sub(a, b):
+    def sub(x, y):
+        return S.Reduce(x - y)
+    return S.lanewise_binary(sub, a, b)
+```
+
+### Integer multiplication
+* `i16x8.mul(a: v128, b: v128) -> v128`
+* `i32x4.mul(a: v128, b: v128) -> v128`
+* `i64x2.mul(a: v128, b: v128) -> v128`
+
+Lane-wise wrapping integer multiplication:
+
+```python
+def S.mul(a, b):
+    def mul(x, y):
+        return S.Reduce(x * y)
+    return S.lanewise_binary(mul, a, b)
+```
+
+### Integer dot product
+* `i32x4.dot_i16x8_s(a: v128, b: v128) -> v128`
+
+Lane-wise multiply signed 16-bit integers in the two input vectors and add adjacent pairs of the full 32-bit results.
+
+### Integer negation
+* `i8x16.neg(a: v128) -> v128`
+* `i16x8.neg(a: v128) -> v128`
+* `i32x4.neg(a: v128) -> v128`
+* `i64x2.neg(a: v128) -> v128`
+
+Lane-wise wrapping integer negation. In wrapping arithmetic, `y = -x` is the
+unique value such that `x + y == 0`.
+
+```python
+def S.neg(a):
+    def neg(x):
+        return S.Reduce(-x)
+    return S.lanewise_unary(neg, a)
+```
+
+## Extended integer arithmetic
+
+### Extended integer multiplication
+* `i16x8.extmul_low_i8x16_s(a: v128, b: v128) -> v128`
+* `i16x8.extmul_high_i8x16_s(a: v128, b: v128) -> v128`
+* `i16x8.extmul_low_i8x16_u(a: v128, b: v128) -> v128`
+* `i16x8.extmul_high_i8x16_u(a: v128, b: v128) -> v128`
+* `i32x4.extmul_low_i16x8_s(a: v128, b: v128) -> v128`
+* `i32x4.extmul_high_i16x8_s(a: v128, b: v128) -> v128`
+* `i32x4.extmul_low_i16x8_u(a: v128, b: v128) -> v128`
+* `i32x4.extmul_high_i16x8_u(a: v128, b: v128) -> v128`
+* `i64x2.extmul_low_i32x4_s(a: v128, b: v128) -> v128`
+* `i64x2.extmul_high_i32x4_s(a: v128, b: v128) -> v128`
+* `i64x2.extmul_low_i32x4_u(a: v128, b: v128) -> v128`
+* `i64x2.extmul_high_i32x4_u(a: v128, b: v128) -> v128`
+
+Lane-wise integer extended multiplication producing twice wider result than the inputs.
+
+These instructions provide a more performant equivalent to the following composite operations:
+- `i16x8.extmul_low_i8x16_s(a, b)` is equivalent to `i16x8.mul(i16x8.extend_low_i8x16_s(a), i16x8.extend_low_i8x16_s(b))`.
+- `i16x8.extmul_high_i8x16_s(a, b)` is equivalent to `i16x8.mul(i16x8.extend_high_i8x16_s(a), i16x8.extend_high_i8x16_s(b))`.
+- `i16x8.extmul_low_i8x16_u(a, b)` is equivalent to `i16x8.mul(i16x8.extend_low_i8x16_u(a), i16x8.extend_low_i8x16_u(b))`.
+- `i16x8.extmul_high_i8x16_u(a, b)` is equivalent to `i16x8.mul(i16x8.extend_high_i8x16_u(a), i16x8.extend_high_i8x16_u(b))`.
+- `i32x4.extmul_low_i16x8_s(a, b)` is equivalent to `i32x4.mul(i32x4.extend_low_i16x8_s(a), i32x4.extend_low_i16x8_s(b))`.
+- `i32x4.extmul_high_i16x8_s(a, b)` is equivalent to `i32x4.mul(i32x4.extend_high_i16x8_s(a), i32x4.extend_high_i16x8_s(b))`.
+- `i32x4.extmul_low_i16x8_u(a, b)` is equivalent to `i32x4.mul(i32x4.extend_low_i16x8_u(a), i32x4.extend_low_i16x8_u(b))`.
+- `i32x4.extmul_high_i16x8_u(a, b)` is equivalent to `i32x4.mul(i32x4.extend_high_i16x8_u(a), i32x4.extend_high_i16x8_u(b))`.
+- `i64x2.extmul_low_i32x4_s(a, b)` is equivalent to `i64x2.mul(i64x2.extend_low_i32x4_s(a), i64x2.extend_low_i32x4_s(b))`.
+- `i64x2.extmul_high_i32x4_s(a, b)` is equivalent to `i64x2.mul(i64x2.extend_high_i32x4_s(a), i64x2.extend_high_i32x4_s(b))`.
+- `i64x2.extmul_low_i32x4_u(a, b)` is equivalent to `i64x2.mul(i64x2.extend_low_i32x4_u(a), i64x2.extend_low_i32x4_u(b))`.
+- `i64x2.extmul_high_i32x4_u(a, b)` is equivalent to `i64x2.mul(i64x2.extend_high_i32x4_u(a), i64x2.extend_high_i32x4_u(b))`.
+
+### Extended pairwise integer addition
+* `i16x8.extadd_pairwise_i8x16_s(a: v128) -> v128`
+* `i16x8.extadd_pairwise_i8x16_u(a: v128) -> v128`
+* `i32x4.extadd_pairwise_i16x8_s(a: v128) -> v128`
+* `i32x4.extadd_pairwise_i16x8_u(a: v128) -> v128`
+
+Lane-wise integer extended pairwise addition producing extended results (twice wider results than the inputs).
+
+```python
+def S.extadd_pairwise_T(ext, a):
+    result = S.New()
+    for i in range(S.Lanes):
+        result[i] = ext(a[i*2]) + ext(a[i*2+1])
+
+def S.extadd_pairwise_T_s(a):
+    return S.extadd_pairwise_T(Sext, a)
+
+def S.extadd_pairwise_T_u(a):
+    return S.extadd_pairwise_T(Zext, a)
+```
+
+## Saturating integer arithmetic
+
+Saturating integer arithmetic behaves differently on signed and unsigned lanes.
+It is only defined here for 8-bit and 16-bit integer lanes.
+
+```python
+def S.SignedSaturate(x):
+    if x < S.Smin:
+        return S.Smin
+    if x > S.Smax:
+        return S.Smax
+    return x
+
+def S.UnsignedSaturate(x):
+    if x < 0:
+        return 0
+    if x > S.Umax:
+        return S.Umax
+    return x
+```
+
+### Saturating integer addition
+* `i8x16.add_sat_s(a: v128, b: v128) -> v128`
+* `i8x16.add_sat_u(a: v128, b: v128) -> v128`
+* `i16x8.add_sat_s(a: v128, b: v128) -> v128`
+* `i16x8.add_sat_u(a: v128, b: v128) -> v128`
+
+Lane-wise saturating addition:
+
+```python
+def S.add_sat_s(a, b):
+    def addsat(x, y):
+        return S.SignedSaturate(x + y)
+    return S.lanewise_binary(addsat, S.AsSigned(a), S.AsSigned(b))
+
+def S.add_sat_u(a, b):
+    def addsat(x, y):
+        return S.UnsignedSaturate(x + y)
+    return S.lanewise_binary(addsat, S.AsUnsigned(a), S.AsUnsigned(b))
+```
+
+### Saturating integer subtraction
+* `i8x16.sub_sat_s(a: v128, b: v128) -> v128`
+* `i8x16.sub_sat_u(a: v128, b: v128) -> v128`
+* `i16x8.sub_sat_s(a: v128, b: v128) -> v128`
+* `i16x8.sub_sat_u(a: v128, b: v128) -> v128`
+
+Lane-wise saturating subtraction:
+
+```python
+def S.sub_sat_s(a, b):
+    def subsat(x, y):
+        return S.SignedSaturate(x - y)
+    return S.lanewise_binary(subsat, S.AsSigned(a), S.AsSigned(b))
+
+def S.sub_sat_u(a, b):
+    def subsat(x, y):
+        return S.UnsignedSaturate(x - y)
+    return S.lanewise_binary(subsat, S.AsUnsigned(a), S.AsUnsigned(b))
+```
+
+### Saturating integer Q-format rounding multiplication
+
+* `i16x8.q15mulr_sat_s(a: v128, b: v128) -> v128`
+
+Lane-wise saturating rounding multiplication in Q15 format:
+
+```python
+def S.q15mulr_sat_s(a, b):
+    def subq15mulr(x, y):
+        return S.SignedSaturate((x * y + 0x4000) >> 15)
+    return S.lanewise_binary(subq15mulr, S.AsSigned(a), S.AsSigned(b))
+```
+
+### Lane-wise integer minimum
+* `i8x16.min_s(a: v128, b: v128) -> v128`
+* `i8x16.min_u(a: v128, b: v128) -> v128`
+* `i16x8.min_s(a: v128, b: v128) -> v128`
+* `i16x8.min_u(a: v128, b: v128) -> v128`
+* `i32x4.min_s(a: v128, b: v128) -> v128`
+* `i32x4.min_u(a: v128, b: v128) -> v128`
+
+Compares lane-wise signed/unsigned integers, and returns the minimum of
+each pair.
+
+```python
+def S.min(a, b):
+    return S.lanewise_binary(min, a, b)
+```
+
+### Lane-wise integer maximum
+* `i8x16.max_s(a: v128, b: v128) -> v128`
+* `i8x16.max_u(a: v128, b: v128) -> v128`
+* `i16x8.max_s(a: v128, b: v128) -> v128`
+* `i16x8.max_u(a: v128, b: v128) -> v128`
+* `i32x4.max_s(a: v128, b: v128) -> v128`
+* `i32x4.max_u(a: v128, b: v128) -> v128`
+
+Compares lane-wise signed/unsigned integers, and returns the maximum of
+each pair.
+
+```python
+def S.max(a, b):
+    return S.lanewise_binary(max, a, b)
+```
+
+### Lane-wise integer rounding average
+* `i8x16.avgr_u(a: v128, b: v128) -> v128`
+* `i16x8.avgr_u(a: v128, b: v128) -> v128`
+
+Lane-wise rounding average:
+
+```python
+def S.RoundingAverage(x, y):
+    return (x + y + 1) // 2
+
+def S.avgr_u(a, b):
+    return S.lanewise_binary(S.RoundingAverage, S.AsUnsigned(a), S.AsUnsigned(b))
+```
+
+### Lane-wise integer absolute value
+* `i8x16.abs(a: v128) -> v128`
+* `i16x8.abs(a: v128) -> v128`
+* `i32x4.abs(a: v128) -> v128`
+* `i64x2.abs(a: v128) -> v128`
+
+Lane-wise wrapping absolute value.
+
+```python
+def S.abs(a):
+    return S.lanewise_unary(abs, S.AsSigned(a))
+```
+
+## Bit shifts
+
+### Left shift by scalar
+* `i8x16.shl(a: v128, y: i32) -> v128`
+* `i16x8.shl(a: v128, y: i32) -> v128`
+* `i32x4.shl(a: v128, y: i32) -> v128`
+* `i64x2.shl(a: v128, y: i32) -> v128`
+
+Shift the bits in each lane to the left by the same amount. The shift count is
+taken modulo lane width:
+
+```python
+def S.shl(a, y):
+    # Number of bits to shift: 0 .. S.LaneBits - 1.
+    amount = y mod S.LaneBits
+    def shift(x):
+        return S.Reduce(x << amount)
+    return S.lanewise_unary(shift, a)
+```
+
+### Right shift by scalar
+* `i8x16.shr_s(a: v128, y: i32) -> v128`
+* `i8x16.shr_u(a: v128, y: i32) -> v128`
+* `i16x8.shr_s(a: v128, y: i32) -> v128`
+* `i16x8.shr_u(a: v128, y: i32) -> v128`
+* `i32x4.shr_s(a: v128, y: i32) -> v128`
+* `i32x4.shr_u(a: v128, y: i32) -> v128`
+* `i64x2.shr_s(a: v128, y: i32) -> v128`
+* `i64x2.shr_u(a: v128, y: i32) -> v128`
+
+Shift the bits in each lane to the right by the same amount. The shift count is
+taken modulo lane width.  This is an arithmetic right shift for the `_s`
+variants and a logical right shift for the `_u` variants.
+
+```python
+def S.shr_s(a, y):
+    # Number of bits to shift: 0 .. S.LaneBits - 1.
+    amount = y mod S.LaneBits
+    def shift(x):
+        return x >> amount
+    return S.lanewise_unary(shift, S.AsSigned(a))
+
+def S.shr_u(a, y):
+    # Number of bits to shift: 0 .. S.LaneBits - 1.
+    amount = y mod S.LaneBits
+    def shift(x):
+        return x >> amount
+    return S.lanewise_unary(shift, S.AsUnsigned(a))
+```
+
+
+## Bitwise operations
+
+Bitwise operations treat a `v128` value type as a vector of 128 independent bits.
+
+### Bitwise logic
+* `v128.and(a: v128, b: v128) -> v128`
+* `v128.or(a: v128, b: v128) -> v128`
+* `v128.xor(a: v128, b: v128) -> v128`
+* `v128.not(a: v128) -> v128`
+
+The logical operations defined on the scalar integer types are also available
+on the `v128` type where they operate bitwise the same way C's `&`, `|`, `^`,
+and `~` operators work on an `unsigned` type.
+
+### Bitwise AND-NOT
+
+* `v128.andnot(a: v128, b: v128) -> v128`
+
+Bitwise AND of bits of `a` and the logical inverse of bits of `b`. This operation is equivalent to `v128.and(a, v128.not(b))`.
+
+### Bitwise select
+* `v128.bitselect(v1: v128, v2: v128, c: v128) -> v128`
+
+Use the bits in the control mask `c` to select the corresponding bit from `v1`
+when 1 and `v2` when 0.
+This is the same as `v128.or(v128.and(v1, c), v128.and(v2, v128.not(c)))`.
+
+Note that the normal WebAssembly `select` instruction also works with vector
+types. It selects between two whole vectors controlled by a single scalar value,
+rather than selecting bits controlled by a control mask vector.
+
+### Lane-wise Population Count
+* `i8x16.popcnt(v: v128) -> v128`
+
+Count the number of bits set to one within each lane.
+
+```python
+def S.popcnt(v):
+    return S.lanewise_unary(popcnt, v)
+```
+
+## Boolean horizontal reductions
+
+These operations reduce all the lanes of an integer vector to a single scalar
+0 or 1 value. A lane is considered "true" if it is non-zero.
+
+### Any bit true
+* `v128.any_true(a: v128) -> i32`
+
+These functions return 1 if any bit in `a` is non-zero, 0 otherwise.
+
+### All lanes true
+* `i8x16.all_true(a: v128) -> i32`
+* `i16x8.all_true(a: v128) -> i32`
+* `i32x4.all_true(a: v128) -> i32`
+* `i64x2.all_true(a: v128) -> i32`
+
+These functions return 1 if all lanes in `a` are non-zero, 0 otherwise.
+
+```python
+def S.all_true(a):
+    for i in range(S.Lanes):
+        if a[i] == 0:
+            return 0
+    return 1
+```
+
+## Bitmask extraction
+
+* `i8x16.bitmask(a: v128) -> i32`
+* `i16x8.bitmask(a: v128) -> i32`
+* `i32x4.bitmask(a: v128) -> i32`
+* `i64x2.bitmask(a: v128) -> i32`
+
+These operations extract the high bit for each lane in `a` and produce a scalar
+mask with all bits concatenated.
+
+```python
+def S.bitmask(a):
+    result = 0
+    for i in range(S.Lanes):
+        if a[i] < 0:
+            result = result | (1 << i)
+    return result
+```
+
+## Comparisons
+
+The comparison operations all compare two vectors lane-wise, and produce a mask
+vector with the same number of lanes as the input interpretation where the bits
+in each lane are `0` for `false` and all ones for `true`.
+
+### Equality
+* `i8x16.eq(a: v128, b: v128) -> v128`
+* `i16x8.eq(a: v128, b: v128) -> v128`
+* `i32x4.eq(a: v128, b: v128) -> v128`
+* `i64x2.eq(a: v128, b: v128) -> v128`
+* `f32x4.eq(a: v128, b: v128) -> v128`
+* `f64x2.eq(a: v128, b: v128) -> v128`
+
+Integer equality is independent of the signed/unsigned interpretation. Floating
+point equality follows IEEE semantics, so a NaN lane compares not equal with
+anything, including itself, and +0.0 is equal to -0.0:
+
+```python
+def S.eq(a, b):
+    def eq(x, y):
+        return x == y
+    return S.lanewise_comparison(eq, a, b)
+```
+
+### Non-equality
+* `i8x16.ne(a: v128, b: v128) -> v128`
+* `i16x8.ne(a: v128, b: v128) -> v128`
+* `i32x4.ne(a: v128, b: v128) -> v128`
+* `i64x2.ne(a: v128, b: v128) -> v128`
+* `f32x4.ne(a: v128, b: v128) -> v128`
+* `f64x2.ne(a: v128, b: v128) -> v128`
+
+The `ne` operations produce the inverse of their `eq` counterparts:
+
+```python
+def S.ne(a, b):
+    def ne(x, y):
+        return x != y
+    return S.lanewise_comparison(ne, a, b)
+```
+
+### Less than
+* `i8x16.lt_s(a: v128, b: v128) -> v128`
+* `i8x16.lt_u(a: v128, b: v128) -> v128`
+* `i16x8.lt_s(a: v128, b: v128) -> v128`
+* `i16x8.lt_u(a: v128, b: v128) -> v128`
+* `i32x4.lt_s(a: v128, b: v128) -> v128`
+* `i32x4.lt_u(a: v128, b: v128) -> v128`
+* `i64x2.lt_s(a: v128, b: v128) -> v128`
+* `f32x4.lt(a: v128, b: v128) -> v128`
+* `f64x2.lt(a: v128, b: v128) -> v128`
+
+### Less than or equal
+* `i8x16.le_s(a: v128, b: v128) -> v128`
+* `i8x16.le_u(a: v128, b: v128) -> v128`
+* `i16x8.le_s(a: v128, b: v128) -> v128`
+* `i16x8.le_u(a: v128, b: v128) -> v128`
+* `i32x4.le_s(a: v128, b: v128) -> v128`
+* `i32x4.le_u(a: v128, b: v128) -> v128`
+* `i64x2.le_s(a: v128, b: v128) -> v128`
+* `f32x4.le(a: v128, b: v128) -> v128`
+* `f64x2.le(a: v128, b: v128) -> v128`
+
+### Greater than
+* `i8x16.gt_s(a: v128, b: v128) -> v128`
+* `i8x16.gt_u(a: v128, b: v128) -> v128`
+* `i16x8.gt_s(a: v128, b: v128) -> v128`
+* `i16x8.gt_u(a: v128, b: v128) -> v128`
+* `i32x4.gt_s(a: v128, b: v128) -> v128`
+* `i32x4.gt_u(a: v128, b: v128) -> v128`
+* `i64x2.gt_s(a: v128, b: v128) -> v128`
+* `f32x4.gt(a: v128, b: v128) -> v128`
+* `f64x2.gt(a: v128, b: v128) -> v128`
+
+### Greater than or equal
+* `i8x16.ge_s(a: v128, b: v128) -> v128`
+* `i8x16.ge_u(a: v128, b: v128) -> v128`
+* `i16x8.ge_s(a: v128, b: v128) -> v128`
+* `i16x8.ge_u(a: v128, b: v128) -> v128`
+* `i32x4.ge_s(a: v128, b: v128) -> v128`
+* `i32x4.ge_u(a: v128, b: v128) -> v128`
+* `i64x2.ge_s(a: v128, b: v128) -> v128`
+* `f32x4.ge(a: v128, b: v128) -> v128`
+* `f64x2.ge(a: v128, b: v128) -> v128`
+
+## Load and store
+
+Load and store operations are provided for the `v128` vectors. The memory
+operations take the same arguments and have the same semantics as the existing
+scalar WebAssembly load and store instructions (see
+[memarg](https://webassembly.github.io/spec/core/bikeshed/index.html#syntax-memarg).
+The difference is that the memory access size is 16 bytes which is also the
+natural alignment.
+
+### Load
+
+* `v128.load(m: memarg) -> v128`
+
+Load a `v128` vector from the given heap address.
+
+```python
+def S.load(m: memarg):
+    return S.from_bytes(memory[memarg.offset:memarg.offset + 16])
+```
+
+### Load and Zero-Pad
+
+* `v128.load32_zero(m: memarg) -> v128`
+* `v128.load64_zero(m: memarg) -> v128`
+
+Load a single 32-bit or 64-bit element into the lowest bits of a `v128` vector,
+and initialize all other bits of the `v128` vector to zero.
+
+```python
+def S.load32_zero(m: memarg):
+    return S.from_bytes(memory[memarg.offset:memarg.offset + 4])
+```
+
+```python
+def S.load64_zero(m: memarg):
+    return S.from_bytes(memory[memarg.offset:memarg.offset + 8])
+```
+
+### Load and Splat
+
+* `v128.load8_splat(m: memarg) -> v128`
+* `v128.load16_splat(m: memarg) -> v128`
+* `v128.load32_splat(m: memarg) -> v128`
+* `v128.load64_splat(m: memarg) -> v128`
+
+Load a single element and splat to all lanes of a `v128` vector. The natural
+alignment is the size of the element loaded.
+
+```python
+def S.load_splat(m: memarg):
+    val_bytes = memory[memarg.offset:memarg.offset + S.LaneBytes])
+    return S.splat(S.LaneType.from_bytes(val_bytes))
+```
+
+### Load Lane
+
+* `v128.load8_lane(m: memarg, x: v128, imm: ImmLaneIdx16) -> v128`
+* `v128.load16_lane(m: memarg, x: v128, imm: ImmLaneIdx8) -> v128`
+* `v128.load32_lane(m: memarg, x: v128, imm: ImmLaneIdx4) -> v128`
+* `v128.load64_lane(m: memarg, x: v128, imm: ImmLaneIdx2) -> v128`
+
+Load a single element from `m` into the lane of `x` specified in the immediate
+mode operand `imm`. The values of all other lanes of `x` are bypassed as is.
+
+### Load and Extend
+
+* `v128.load8x8_s(m: memarg) -> v128`: load eight 8-bit integers and sign extend each one to a 16-bit lane
+* `v128.load8x8_u(m: memarg) -> v128`: load eight 8-bit integers and zero extend each one to a 16-bit lane
+* `v128.load16x4_s(m: memarg) -> v128`: load four 16-bit integers and sign extend each one to a 32-bit lane
+* `v128.load16x4_u(m: memarg) -> v128`: load four 16-bit integers and zero extend each one to a 32-bit lane
+* `v128.load32x2_s(m: memarg) -> v128`: load two 32-bit integers and sign extend each one to a 64-bit lane
+* `v128.load32x2_u(m: memarg) -> v128`: load two 32-bit integers and zero extend each one to a 64-bit lane
+
+Fetch consecutive integers up to 32-bit wide and produce a vector with lanes up
+to 64 bits. The natural alignment is 8 bytes.
+
+```python
+def S.load_extend(ext, m: memarg):
+    result = S.New()
+    bytes = memory[memarg.offset:memarg.offset + 8])
+    for i in range(S.Lanes):
+        result[i] = ext(S.LaneType.from_bytes(bytes[(i * S.LaneBytes/2):((i+1) * S.LaneBytes/2)]))
+    return result
+
+def S.load_extend_s(m: memarg):
+    return S.load_extend(Sext, memarg)
+
+def S.load_extend_u(m: memarg):
+    return S.load_extend(Zext, memarg)
+```
+
+### Store
+
+* `v128.store(m: memarg, data: v128)`
+
+Store a `v128` vector to the given heap address.
+
+```python
+def S.store(m: memarg, a):
+    memory[memarg.offset:memarg.offset + 16] = bytes(a)
+```
+
+### Store Lane
+
+* `v128.store8_lane(m: memarg, data: v128, imm: ImmLaneIdx16)`
+* `v128.store16_lane(m: memarg, data: v128, imm: ImmLaneIdx8)`
+* `v128.store32_lane(m: memarg, data: v128, imm: ImmLaneIdx4)`
+* `v128.store64_lane(m: memarg, data: v128, imm: ImmLaneIdx2)`
+
+Store into `m` the lane of `data` specified in the immediate mode operand `imm`.
+
+## Floating-point sign bit operations
+
+These floating point operations are simple manipulations of the sign bit. No
+changes are made to the exponent or trailing significand bits, even for NaN
+inputs.
+
+### Negation
+* `f32x4.neg(a: v128) -> v128`
+* `f64x2.neg(a: v128) -> v128`
+
+Apply the IEEE `negate(x)` function to each lane. This simply inverts the sign
+bit, preserving all other bits.
+
+```python
+def S.neg(a):
+    return S.lanewise_unary(ieee.negate, a)
+```
+
+### Floating-point absolute value
+* `f32x4.abs(a: v128) -> v128`
+* `f64x2.abs(a: v128) -> v128`
+
+Apply the IEEE `abs(x)` function to each lane. This simply clears the sign bit,
+preserving all other bits.
+
+```python
+def S.abs(a):
+    return S.lanewise_unary(ieee.abs, a)
+```
+
+## Floating-point min and max
+
+These operations are not part of the IEEE 754-2008 standard. They are lane-wise
+versions of the existing scalar WebAssembly operations.
+
+### NaN-propagating minimum
+* `f32x4.min(a: v128, b: v128) -> v128`
+* `f64x2.min(a: v128, b: v128) -> v128`
+
+Lane-wise minimum value, propagating NaNs.
+
+### NaN-propagating maximum
+* `f32x4.max(a: v128, b: v128) -> v128`
+* `f64x2.max(a: v128, b: v128) -> v128`
+
+Lane-wise maximum value, propagating NaNs.
+
+### Pseudo-minimum
+* `f32x4.pmin(a: v128, b: v128) -> v128`
+* `f64x2.pmin(a: v128, b: v128) -> v128`
+
+Lane-wise minimum value, defined as `b < a ? b : a`.
+
+### Pseudo-maximum
+* `f32x4.pmax(a: v128, b: v128) -> v128`
+* `f64x2.pmax(a: v128, b: v128) -> v128`
+
+Lane-wise maximum value, defined as `a < b ? b : a`.
+
+## Floating-point arithmetic
+
+The floating-point arithmetic operations are all lane-wise versions of the
+existing scalar WebAssembly operations.
+
+### Addition
+* `f32x4.add(a: v128, b: v128) -> v128`
+* `f64x2.add(a: v128, b: v128) -> v128`
+
+Lane-wise IEEE `addition`.
+
+### Subtraction
+* `f32x4.sub(a: v128, b: v128) -> v128`
+* `f64x2.sub(a: v128, b: v128) -> v128`
+
+Lane-wise IEEE `subtraction`.
+
+### Division
+* `f32x4.div(a: v128, b: v128) -> v128`
+* `f64x2.div(a: v128, b: v128) -> v128`
+
+Lane-wise IEEE `division`.
+
+### Multiplication
+* `f32x4.mul(a: v128, b: v128) -> v128`
+* `f64x2.mul(a: v128, b: v128) -> v128`
+
+Lane-wise IEEE `multiplication`.
+
+### Square root
+* `f32x4.sqrt(a: v128) -> v128`
+* `f64x2.sqrt(a: v128) -> v128`
+
+Lane-wise IEEE `squareRoot`.
+
+### Round to integer above (ceiling)
+* `f32x4.ceil(a: v128) -> v128`
+* `f64x2.ceil(a: v128) -> v128`
+
+Lane-wise rounding to the nearest integral value not smaller than the input.
+
+### Round to integer below (floor)
+* `f32x4.floor(a: v128) -> v128`
+* `f64x2.floor(a: v128) -> v128`
+
+Lane-wise rounding to the nearest integral value not greater than the input.
+
+### Round to integer toward zero (truncate to integer)
+* `f32x4.trunc(a: v128) -> v128`
+* `f64x2.trunc(a: v128) -> v128`
+
+Lane-wise rounding to the nearest integral value with the magnitude not larger than the input.
+
+### Round to nearest integer, ties to even
+* `f32x4.nearest(a: v128) -> v128`
+* `f64x2.nearest(a: v128) -> v128`
+
+Lane-wise rounding to the nearest integral value; if two values are equally near, rounds to the even one.
+
+## Conversions
+### Integer to single-precision floating point
+* `f32x4.convert_i32x4_s(a: v128) -> v128`
+* `f32x4.convert_i32x4_u(a: v128) -> v128`
+
+Lane-wise conversion from integer to floating point. Integer values not
+representable as single-precision floating-point numbers will be rounded to the
+nearest-even representable number.
+
+### Integer to double-precision floating point
+* `f64x2.convert_low_i32x4_s(a: v128) -> v128`
+* `f64x2.convert_low_i32x4_u(a: v128) -> v128`
+
+Lane-wise conversion from integer to floating point.
+
+### Single-precision floating point to integer with saturation
+* `i32x4.trunc_sat_f32x4_s(a: v128) -> v128`
+* `i32x4.trunc_sat_f32x4_u(a: v128) -> v128`
+
+Lane-wise saturating conversion from single-precision floating point to integer
+using the IEEE `convertToIntegerTowardZero` function. If any input lane is a
+NaN, the resulting lane is 0. If the rounded integer value of a lane is outside
+the range of the destination type, the result is saturated to the nearest
+representable integer value.
+
+### Double-precision floating point to integer with saturation
+* `i32x4.trunc_sat_f64x2_s_zero(a: v128) -> v128`
+* `i32x4.trunc_sat_f64x2_u_zero(a: v128) -> v128`
+
+Saturating conversion of the two double-precision floating point lanes to two
+lower integer lanes using the IEEE `convertToIntegerTowardZero` function. The
+two higher lanes of the result are initialized to zero. If any input lane is a
+NaN, the resulting lane is 0. If the rounded integer value of a lane is outside
+the range of the destination type, the result is saturated to the nearest
+representable integer value.
+
+### Double-precision floating point to single-precision
+* `f32x4.demote_f64x2_zero(a: v128) -> v128`
+
+Conversion of the two double-precision floating point lanes to two lower
+single-precision lanes of the result. The two higher lanes of the result are
+initialized to zero. If the conversion result is not representable as a
+single-precision floating point number, it is rounded to the nearest-even
+representable number.
+
+### Single-precision floating point to double-precision
+* `f64x2.promote_low_f32x4(a: v128) -> v128`
+
+Conversion of the two lower single-precision floating point lanes to the two
+double-precision lanes of the result.
+
+### Integer to integer narrowing
+* `i8x16.narrow_i16x8_s(a: v128, b: v128) -> v128`
+* `i8x16.narrow_i16x8_u(a: v128, b: v128) -> v128`
+* `i16x8.narrow_i32x4_s(a: v128, b: v128) -> v128`
+* `i16x8.narrow_i32x4_u(a: v128, b: v128) -> v128`
+
+Converts two input vectors into a smaller lane vector by narrowing each lane,
+signed or unsigned. The signed narrowing operation will use signed saturation
+to handle overflow, 0x7f or 0x80 for i8x16, the unsigned narrowing operation
+will use unsigned saturation to handle overflow, 0x00 or 0xff for i8x16.
+Regardless of the whether the operation is signed or unsigned, the input lanes
+are interpreted as signed integers.
+
+```python
+def S.narrow_T_s(a, b):
+    result = S.New()
+    for i in range(T.Lanes):
+        result[i] = S.SignedSaturate(a[i])
+    for i in range(T.Lanes):
+        result[T.Lanes + i] = S.SignedSaturate(b[i])
+    return result
+
+def S.narrow_T_u(a, b):
+    result = S.New()
+    for i in range(T.Lanes):
+        result[i] = S.UnsignedSaturate(a[i])
+    for i in range(T.Lanes):
+        result[T.Lanes + i] = S.UnsignedSaturate(b[i])
+    return result
+```
+
+### Integer to integer extension
+* `i16x8.extend_low_i8x16_s(a: v128) -> v128`
+* `i16x8.extend_high_i8x16_s(a: v128) -> v128`
+* `i16x8.extend_low_i8x16_u(a: v128) -> v128`
+* `i16x8.extend_high_i8x16_u(a: v128) -> v128`
+* `i32x4.extend_low_i16x8_s(a: v128) -> v128`
+* `i32x4.extend_high_i16x8_s(a: v128) -> v128`
+* `i32x4.extend_low_i16x8_u(a: v128) -> v128`
+* `i32x4.extend_high_i16x8_u(a: v128) -> v128`
+* `i64x2.extend_low_i32x4_s(a: v128) -> v128`
+* `i64x2.extend_high_i32x4_s(a: v128) -> v128`
+* `i64x2.extend_low_i32x4_u(a: v128) -> v128`
+* `i64x2.extend_high_i32x4_u(a: v128) -> v128`
+
+Converts low or high half of the smaller lane vector to a larger lane vector,
+sign extended or zero (unsigned) extended.
+
+```python
+def S.extend_low_T(ext, a):
+    result = S.New()
+    for i in range(S.Lanes):
+        result[i] = ext(a[i])
+
+def S.extend_high_T(ext, a):
+    result = S.New()
+    for i in range(S.Lanes):
+        result[i] = ext(a[S.Lanes + i])
+
+def S.extend_low_T_s(a):
+    return S.extend_low_T(Sext, a)
+
+def S.extend_high_T_s(a):
+    return S.extend_high_T(Sext, a)
+
+def S.extend_low_T_u(a):
+    return S.extend_low_T(Zext, a)
+
+def S.extend_high_T_u(a):
+    return S.extend_high_T(Zext, a)
+```
diff --git a/proposals/simd/TextSIMD.md b/proposals/simd/TextSIMD.md
new file mode 100644
index 000000000..0f4fc6eb8
--- /dev/null
+++ b/proposals/simd/TextSIMD.md
@@ -0,0 +1,27 @@
+# Text format for SIMD
+
+### v128.const
+
+The `v128.const` instruction has multiple valid text formats corresponding to
+different lane interpretations. The valid text formats are
+
+```
+v128.const i8x16 i8 i8 i8 i8 i8 i8 i8 i8 i8 i8 i8 i8 i8 i8 i8 i8
+v128.const i16x8 i16 i16 i16 i16 i16 i16 i16 i16
+v128.const i32x4 i32 i32 i32 i32
+v128.const i64x2 i64 i64
+v128.const f32x4 f32 f32 f32 f32
+v128.const f64x2 f64 f64
+```
+
+The canonical text format used for printing `v128.const` instructions is
+
+```
+v128.const i32x4 0xNNNNNNNN 0xNNNNNNNN 0xNNNNNNNN 0xNNNNNNNN
+```
+
+### i8x16.shuffle
+
+```
+i8x16.shuffle i5 i5 i5 i5 i5 i5 i5 i5 i5 i5 i5 i5 i5 i5 i5 i5
+```
diff --git a/proposals/simd/W3CTAG-SIMDExplainer.md b/proposals/simd/W3CTAG-SIMDExplainer.md
new file mode 100644
index 000000000..b5d70633e
--- /dev/null
+++ b/proposals/simd/W3CTAG-SIMDExplainer.md
@@ -0,0 +1,72 @@
+# WASM SIMD Web Platform explainer
+
+## User benefits
+Modern processors support running multiple common computations in a single operation, so that instead of multiplying a number with a number, you can add (or multiply, subtract, etc.) the individual components of a fixed sized vector instead.
+
+##### Scalar operation #####
+
+```
+Ax + Bx = Cx
+Ay + By = Cy
+Az + Bz = Cz
+Aw + Bw = Cw
+```
+
+##### SIMD Operation of Vector Length 4 #####
+
+`Ax`|`Ay`|`Az`|`Aw`
+--|--|--|--
+
+<pre>
+            +
+</pre>
+
+`Bx`|`By`|`Bz`|`Bw`
+--|--|--|--
+
+<pre>
+            =
+</pre>
+
+`Cx`|`Cy`|`Cz`|`Cw`
+--|--|--|--
+
+
+
+
+
+
+This feature is called [Single Instruction Multiple Data (SIMD)](https://en.wikipedia.org/wiki/SIMD), and though hardware support exists for vector lengths up to 512 bits, 128-bit SIMD is the most common and is supported across common hardware architectures.
+
+SIMD has driven large speed ups in certain cases such as image manipulation, video encoding/decoding, machine learning, game engines and physics engines etc - with some of these use-cases not being usable without SIMD support, making SIMD support for the web platform essential for achieving near-native speed with certain native applications.
+
+This proposal outlines exposing a commonly available subset of 128-bit SIMD hardware instructions through WebAssembly.
+
+## Design principles
+This proposal consists of a portable set of widely used SIMD operations mapping closely to instructions available in modern hardware. The proposal draws heavily on inputs from application developers on the usefulness of the instructions and implementer feedback on performance. 
+
+JavaScript applications can access the SIMD values in WebAssembly module memory indirectly as scalar values through Arraybuffers, and manipulate them using function calls into WebAssembly. The 128-bit values are not currently exposed to JavaScript. There are no known accessibility, security or privacy implications specific to this feature. 
+
+## Prior work
+The current proposal builds on top of the [SIMD.js TC39 proposal](https://github.com/tc39/ecmascript_simd), which is no longer under active development. The SIMD.js proposal was abandoned for a few reasons:
+
+* Significant performance cliffs hidden within its high level abstractions making it challenging for real world applications to gain consistent benefits.
+* Gains only seen in carefully crafted asm.js code, which is not representative of the majority of JavaScript code in the wild.
+* High cost of implementation and optimization in engines that outweighed performance wins.
+
+Most of these were offset by the low level abstractions in WebAssembly, where we observed consistent performance across multiple architectures on real world applications.
+
+## References
+[1] GitHub repo: https://github.com/WebAssembly/simd
+
+[2] Proposal directory: https://github.com/WebAssembly/simd/tree/master/proposals/simd
+
+[3] Example usage and demos: https://v8.dev/features/simd
+
+[4] Tests: https://github.com/WebAssembly/simd/tree/master/test/core/simd
+
+[5] External status/issue trackers for this feature: https://www.chromestatus.com/feature/6533147810332672
+
+[6] SIMD.js: https://github.com/tc39/ecmascript_simd 
+
+[7] W3C Tag design reviews - WebAssembly SIMD : https://github.com/w3ctag/design-reviews/issues/487
diff --git a/proposals/simd/WebAssembly-SIMD-May-2017.pdf b/proposals/simd/WebAssembly-SIMD-May-2017.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..9b9fd29a55451545663df915779794afef1baadd
GIT binary patch
literal 128301
zcmbrlby!`?lP-*g;32pZ++BmayL)hF<GzvL?jGEOyKdawC3tXmw@c2PGxNLO%=gU9
zbN_(7o?ffFR#$b`daLSfG6fMaIwpD+II`ZI%bla5tL(|%emGVlMk0WrB^(bA5rd40
zt(lWK5!-u{5)p%#g|(B3!~3tbfs=`di4nlqgouw1&e6%i#J~p54IDVm3*XK7>B9!7
z<2QbKAGyW;z&>W~WDb_yCm8Kq%0exp;8)Lh4NP>$o~|9YQyaxx==wfNOo?~|*FZ!Z
z5#=5Q+)2e#y*S?`=9`7fE_w5B9a^oMbd0eA3h?GKq|6-oXXI?eR2k&Ri^MCRst|I1
z_V-ij>UxwV_eDT)52Ei*Q+Ty9ji3x1Z1k_R3O_j&sh79zUhh{o#dl^jxp1IK@yd;%
zKy`S1;dIM<yMoN(roH9mG@<h2=}=0NC)$)ThcmG?{(Cy_SAVqdXX<}`nYh^h-28LN
z{4WYpakn!eVo)$J`|H1hiLDb6%fBg0$;1)h>|kW#NW}hc4Z;9hr}z7gM1K_gu1#4J
zV+#WzfE$rE<9h=WBQq-z2Ro-O+`C5q7WAj%KbBB%02nEoI1y>TOA`?zVo))0b0X3u
zVh{#c100m?42(>O{uoTyk%@@oukrc#-VOCG@~>tU6(%CiKh5u>|1sI$0+{|t{zt;!
zwq|1bt2=|-`$QN7{}|l%-P%M9A|@^tMkY$)LjV0b$VhTkQC`9bo&a%xCO;DskzM0>
zz!FV!OQ1t3hD!P>Km-MlyNE!Gp`lQz8LM=Hiw6@MiK4;#e>Yr!z5Jxm-=!!by0aQ#
z1$$P`cD0uFGN8G>wAZ+>WOfEzXaQ4r{tngcqyg^Bnxlbsdeo)!8Fi%h4g%{FIFbf<
z=ccJCl=!^}#OyPOH#N0bqQCa`l-}34b(yw9f!uNa%_o+aLzwgf7@X)FJC8Rx<_<)H
za%~?r^BdIgbs`mW5EC;-4s322@m6o8^=;8EP3urfGWm86j^;Ra8*64ntHN3u*=Ak@
zRE|yx*@ju37mNu=MKTR+=Z<n_=KhBa7$aJ${^%Zgj&&%rC>r)@=p_W$$An(4HV35e
z2QKqWFt<Xp?J%fNNy9>vg%pdO{Xx^mi(2IeLnfMp9@)(hH<^j+I)o@jOy5dCk|;Qt
zrcJ7O>`6J^$%*FtuK7d9(mH{+@(b^v$CK&>`SC=iU__?oy7h4x0|*1`mQ*VpzqUP5
z6|BzYgTT&anfw_M*d;Vr-P(^Uf*@<XxZd9g6!784$JUPESyuEk`y5YM-vPrNL0osK
zBd1Sl+=ZC@ek79UEGD8mg++zZBBP@SNXZk%FL$5bwmP{i#)f)me`IxHUIgx|D()x1
z285co2J-l6#LyeV1^CQu`e3nBz+ii4SfQCa>w^IUxfGftVFm%bV8SGjq_+GX5Wpkt
zPfT!w?QQ1ev6YU|%pR|MkA(0#VYZtxg2c+Zw+PY34rIBs*m>&#)?E;vV_=-J;aL6X
z86jxDA>#S6*g>ulfd%+Ve1c4Zq?drO5P+%?<XZ%T6J%Nhck#Eh1Do~pn1qu1&TjWX
z2THvY(GDKLS6l!ts7sm=e9h0|<M;DV=(&PFV=(fOQ-$U~;c9(!7Zz0DM1$-T4vqN~
zC-5*yUW`TU|1(Eef%lrk38&?wuK!~;%p?)(hZk^Q07?qPi~-^zScC6U6*t~T@$Qig
z5jXT7Fqoaon^H{}d`OMmn47rgV6=hy-SHm<20ubhiD`Vqy$}(K(I5p!`C=7IoDWeV
znihkUkJ}t65o^B<`5`#RAO#DfAA2iUGh)+F&0yY8ig7N*C`C;MbC=!p6N}%&_X5MY
z>Ou{QGJY3Wc9ir;x?Z(!(ciSIlB*#X4UW0-kOn%jf8*JCH(}{8+p<+aH6kxWwE7<P
zAa0UhxV2HQp`Cq4?s7ag^!m~c=Y!`%upUj=-$4-rs|98C9r;TV5vet)$|szUdmmo{
zP`X(a{fgzCh=V@4_v#o@RYxrfwn^fV%f+Kf29aVaky54B`Kd@+66=!ll7qg)4}CQj
zcfisV(37tq%_7n#LyqHDNT4J~lb6C16<U(xl4=%k7jPFYP(m!Woz?i6(vqPi4-x@N
z0U5;OS(2}kw}#5&OJl7PkCHvf<P#Q>U6b|cvncex_(;7LJ~u%qb_sMT`{h-s<%n(8
zb@K*Fil*fz8ip9A8HO7A|7Pn`Bx{TFi);KWUm|c&HBDCV1xIM6z<s)@PPXprFOy%4
z_~IP-Pc!iceb<EhpletYG863`${oBNoSoWXr4QYV-|ktIunQvMBU&S(uUL1RC$=V*
z*()vd-rA@VAE<4qy%LENO%uTrqkqb%0_M=>GJe|pl%Hj^B)2rMT(W$cqc4q|D4KB1
zoXF5;ecOHxKCEg9^=Nvuyy-dQJ&eam!)eFC#!<ydX6<LgPP0uLO4~`>V;!h7*MhHy
z(%RA5tJh;pOg$Y{F(s=F=gKLsI4Po=;>%wx<t;ZVuGKKhldBy^)s3Uq<`8VuX;gL<
zl9y)CV9>8rJj>xz%qq{y?-1|M_8IP+B>MF&Trj<>I43Np!ywZjZ_|k6XKd*db)Hrp
zcR#05gMHWq-<CFcRcMA}oMhyXtn%XQn##A9iMj~{t6g())>5|Cf!wMUP0cc~`E0Hp
zo<XlX_w)xEc;0Z0@C=Mq41L-YT4lN;T0%`KO=u09y2Gl+o?pFbR=P&OfgsB*quTMp
z)!q8?61sJljuRkvnr_u9Myp)w#4XY-@e}zI6AW*#TQCUeZqdnwvNZrWhjO&P*))C;
zu?0inNl`r`S+t&^IZic>IGzWOfO(ENONZq!Wxv^k=MYP8Odp}|W|uRox}3PBb@VtY
zyAZkO(reSZy2!iq()2`wER7s19zKvz6u*Zv0k0R5T&W(bUfCFTXLx3LR>b#}FO)Bm
z54GK;y%flBZ}0-~;_|q9wQ#=oxbP$o#R*jgyAPKSB?hGi!w1g{`x)99s;3LQtMxk}
z!?ZrB&MXFm(6g{hAP+1Xf-d@_BNja^YZ>{mdy}f0x0@>zouR0RaBr(b^x*WMcz7g+
zG={6#ka(ZyoVcv0r)aXMbg~AmX6?3EgjNJmAuk3YF1jbFi$lrX^s035*70w+ty6jy
zouu01Uk>#<B_k6RG5TGa_S6Kpg!t>9-a=8kOLk-`uJxN;cc2#HTZ5nC_WEh|A}@6B
zO`c<+k^^c2rbLo^bwiCLD<sh+w;<#N>o=Th^e_FkOA=xd@~Bu!rb@;v0_yJTW`xKL
z!m4O=S$HWx3_YxQjKVF$7IUYnsJQ}Du`-m7nx?HOQLi#L5)q{7Wd54)wU#w&X5uDU
z!-}IQyVu)k+qNV4Lsvsj-fX69uFhudF0Vn)U2LaTNaca^6*|k!a;~~vEt@y(N6|J!
zHWEwcBVr?wCb;XiVQaIB*@{)|-^^>zcKd~zg%meIbmQ7c)_vCK)+ei`wdIz}$;5h7
zH-;m>!+y(?t;8LzYXa3DR!46GPCx~>1y8OUE+1W2Ru5XPG*S&U^_C_pHgwB(MlW+O
z8(Y<n+tm!T?Y|*gL>oufF&Ec>q$(}N=ZX&V5B+eW({@3Jo{c9NzXp~UI@WD`X22sM
z`(XG8(D2%P2JaNC$^~uu3|2PFdM1u?4_i9SeDr-pP9!d3C&UBA3kJHQo#(h`7dVPJ
z64<*V<NB+&><0iZ8#lt9sHF!AEP2iMP@G@5E`AT(6P{%v@GQB90e>D)yky-rOlpN`
z<;<_lhc@K1TX@QNt{?c$WZ;kE)A6Ujd0j``rl!>nn@LZ^j-&rb=gM;Rz7*;Yya*4)
z4F0O_#Me@{J)KceRk1eWmt3iL(d<yN40?K2O)fR7;L_y=W&lAaK`)W>1g)7#`p4cD
z2lZz*paZ+wm!z%osCH=J-lOgl!`f{Na3|_50~a#<!{aG^yXTwU3hx1M?PUt41X+)N
z)PwWI{Ke>aE0+RJo;vd<fBDPY{eo!;==wN&;oC%Qh*@+{lQ6?u;zOl;5A;OI1dUjo
z*r9m2_(a4*#HvU2b>I0&MDom5U<cJ}!(HN3X_mL^6UfYPsQ27z>L`_8YOT1P>v8_p
zX3uzkd&bq`tgt9-t+bv0*6$_f$>@3@_TX6lUOq7^lHb(}_W9C{+{Scw{Vw3@=|AJ{
zzhLNJXq%mh`5(Oc2ig8<dk4Xi!oorZjwZ(M!1*t{s{79~On>nA{}<E#4Y~ij0H$1B
z7O=wp33R1Cs^}RqDj&*o+Y^koNO}S%>6aTk8;OG10KOpT`})-Wr9f9Iq3#za4VJW{
zq~+RZTj~JCV`8SnZ$%|-OI-Ok?_A_-33Yy6nih9*O_*0!L@J&Mj=tZ^oFvfR9^GMX
z7#1eQikY?q`vXxt^23{@p4p`pTQe=%kN!V<j$S6Nd!nk^9v?4GU$^vK?_Bj?mqYnW
zo&qblQwGJTsfIM=k<q?UMW1d_p8NVl_)jc-4T=>;g=Q^DV7D$RleM!sN6MSW2560G
zJZK#8l=RPMemCA*iHmyMx$<IuR*>G)Ug}h@X`pAV*}O`y#UtRGI8@+Zp)fQ9glbgv
zLTfLlW|YI%XQn3C&;R1Ywaa#_QDpB#V*t&KBTgc8^9HGja2t$aB59;={0KvWSAqu6
zjt9e=*fGg|p7k<v(7XMBf=O<?(;ZOugP(ZoPBzva!(q}%oA`>LA3G{CxOwgBBTG&q
z9XIKhF%BdN-H&{A5fjV(L`qniq}lAdXtQ2hzIARS-(x{cUl=&Zw|AZq9Pl_pOD@SS
zVf|63hlIKwTB!=-BbhD+0H0trn;E~*?3u+>H!3$EF+q0}4QX*=wKBs{WG}Uc6Q`ZD
zQfBwH2ehQnhovoQ%|6zsw61;O`^HIc`@`a1V%<S@w;G@r6uVbMTuy7L$Ow#`-+;_~
zr9rpA53du5eXSzVhxvKx!YQkK<NEfpa~0LFU{S46q+G0^ydXeE1gip}@tv7y2Nn&k
zG$HM4;T>_?&uZ?&S9gn2E{r=AD7ogEtcw1=+^JE4Pa~g-m3{#Rs_=r0(y<Lvw&#-=
zS@)S)u+)08b!+i^97g1w(hH|Kdb^HBwl)&hq71l@M&omCu+uhO3H(`2sUt*Feq#|m
z#edWuA~=6?p4c1kTgY<xt!n)ELI$ND66Pkdp=&d45Qc_7M+s@);42srU|hfc*1md$
z%5Ag*4B^Q*OwwFWcG0R^H7@eq$hdN5a4YTE^eD|R6kU`vnQ6(0(Ncs}-cle?cl=E{
znlqH+@$>H7O6_-Fqtr$3$d^*!=;8Oo0<&c>U~8A*sgiiOz9@mIn!bzQ;N=(f_`(hd
z9gPX}!w^L=>&-8pNPoSsBi!l-D{>=Lxa@nIcMs?*Jaxd#_f84Ajpx#B8D$6iA*t@_
z>~=JJKka(vd*|+d+qGlBg)U&7X*iYn^x?ZLyRyJ^Ib#BgSxif9I}cSI8B-n}R4QNP
z<UI~Zo=ivO42fYd=rwF?T*j8*Q&l=g)!c8fCR=-l+TvT7?Z**S^-9VI(@r^h86K{O
zS#k<ytT4q*Ku{(yT#`8@<N4HPoiHbu1iG?oMs}7vo_1&{p1a#iiqMMd?gw;_#R~2^
z;pN&r|61TE?SJ8&{z;NBF|u;~yXX1eCI*=P&a3=;X5cU1^)IObxc@sf@UM~kKY58i
zLI3}2Zh)DH>8~6G9K*lo3EoBht2D0v>{FTl&F}uVNul}-{b<qw``-0E<?B4?ki6G*
zUhi6qt}1ZsIJbtZ9X43S_F4h_FT(3<v2)lc%`+qZrrGFUKH-)P4OLX=o0zD&OdziU
zS_oSR-Vk0mU6)&2eI6U0CQf}?^}Sx)_x1Q(Uv4nov=?kU`Lp!pB0H?4e7bxd!RgY<
zZBzPf@o!Iel<%SmTX=gj-yY9Pp8A534NiJoSJx4@Ugvy(Z$@`V>!9a}#<x}A6+_2k
zQI;;>bI#LF@NOEysWb<YHqMWEQ^vQOUmG1S7Xuw<uMZ1vuMc~x{Li=Qs~m3^BU!Hc
zZwIbE4~JLLJ`eXccY6SR@8_*7z9;Tn$bRR;ew%~c<tRW2kWrK{pz`F`fOCf&YK4v7
z(^11p!>MxP^^^1Q!VU3>Q6s{OGhWcpNs>X+>C9KxD~DF3tGb-Xgp;qdFDoF4*3lU!
z-DHD<Zj5DF$T}eHe9`N#36g~Cob-~mjWi^E0~&2$K!aWpiY}Fn&fd|y{CW6%cpP6q
zdET6f-t<CMpZsN*bp}Y7a0QuR^(@@X`mW@u0=M-|nBtA*^(`37OZo1G<AnTfl|z33
z3uL?HkZvDuNC`yuL3(1|Y9G6D#!7B>M*DE?)|D-MCwujEy`{XP;)r#{F0atJ#df((
z>*=Enh#pJKl09c3N^I+99(mcLx+cE_(~DLcaq6O{Ws^^{XRO2KiD(P!V>yaU0gQ^>
z$W94s%3<Y5`?WTOO)toLfhGSU9KFSNxmOKWx6dXn3DfwfZ9m*A8=}J-Fp=+l*bbi1
z#D!Iwf^Eot-yNCiay{nJ>U`Cvv*#W1^nD0yMyA#O{!YEeV-;Z4m}j)tJ`gZj7zArX
zR2XzN|6qn+^qrk_&`^dwd+TfE(MI)6$#N33*BWCxR}G)g@}#Syfs6L-kqt<2DAtoI
zOry>eBRq-rmxs~^?Q6dkRs9m^1=MH4?>tIg@{a{o3>f99eYqAcIXB0!i!EoBO+#jE
z8qeLjK-|U?0=kuO@BTJUj0QV~M|56(<XxL1z*1P7<|dK1;FYziTdmldamJ#~He@1L
zRJ#<U-Ll<DFl?<?u1De0m9H1&l>oThRVVp|c?Oa0`!kT79^^Mn8}n40xOc7)<MCWD
zW&T+(_K4ordz+z4=3-TJke)h~A6=TfIS!}nQ9npV0(p05o7bnPNsgRaza)%3iB?C$
zSr4gNklji;LP;Mb=jJ0v0rBww74wtH3;qmk@MVn70s40`h(NWh?#L<Go_Y}uizwST
zR`%c&gd`K{JdZ&MH8D0dvX4P8_tY(PsKmQfUt0{?!^Oy23O-j2DO<9&C@M$bOuL2J
zI^~Eo`c)+D_rp6lZHaQXC~|#^HxqefTEtrodT2SFxpZ+mVlwq1ZUerl2XQE=^x)Rx
ztQB)f#5Ux{uuB(~n@gtW;-=a=<xLNc4HB2XzewO&k4GxhzHkP#NIJj7FS(prD306i
zqYbees$ZORR?i6=<mFHt7Gxr1wxTGu^PKZN7?1?^j&>vfB-`!c4;+?kO^R2n0&8J$
zg9{d&ZOyuJM0=A58-?EHr9&JZ7qN5s{>xA2g%4Vg7><WXb=3|h`8gbS=)c;uXJi;x
z*|(LRPL$9_BYSH4Wd`TY1DwH?KUjrWl5}U6lX#WAu=ij9C7>IQY5q)uDn(X9KEOGc
z<3XVtH)$-mlC1qA3~zlAH432etITqOnTO=e!;q__IhEvAnPcUX>%8~D2TQ^n(OFRk
z3Y(@A>w0~ryHiY>>Q7PMZof}dqesY*#9dU8*??}Jm@$s-<)`2p_JyhK^>^OIZ5DHN
zckNW^5#s@iQKH)CKL(ePRTPUf9fyA2T;z!4bQinn`iRML9<}1~i=yn;0>$Shi)SGS
zj@7DazYMZ?mHBuaRW11_+hi2*rkJMO5Kb%d3Uf&vdP;+gUUxysIJ@L`DJihF=RQ*~
zG{0e2uphsoU~x8%z}MK*JDz|KS>9=QD*}TWtM{62C5Av@>TUR~WYU{-TY_~`Yh`u_
zTX9nsiz<RNQO?(y_1k0fL+L;w@oysSN{}QP9e_sMX%0(@v=JTw!b2Vb{UaWMHS3JF
zC74_FmGIg}EC5TlPjtbJ=S5OUJJaK=ff)h^Ip^0ns!@L$@;aMkxI}DsCghlg+z@uF
zzt&7Sg*axjKvkW#Vb!5S+?X7xBUfl?4vdyuKRR{GLwtbjk>oApLi}k;Qy0K#1GV}@
z0|vc<@hE2kz};YiK48~3<FRUboGGbIZmo@99>+$5*U@BH|C<w8``K75%P^yC35FTU
zc87+|Ze$Fh+J!h((qt1f4t`xf4sQHDwKQOHS;pLehPIu_(Wm&kr``tV7TqU{0AO6f
zu}wqaad{bIVnFC$uZwqNK-0+9ytXxOb}X`I$;?5q3CZOFesP_sH43p@Psl;bUYw!v
zq1mPt_6h>{QG0e&dn)S2zB&^G`R<5b&^t5c%yMy&U<VN&8Pt4-*Y!}6v6K8pNNI7%
z?9@0z>Nzw&v`#lpGB*uzx{n;wrQwxImyw-Nu~l&+YqSB#8Zyk=(a08Roe8o_oe78l
z4RUM8!aFBreErK|B^U#2jd#Dt++hZ+#@34a(ju2|*%&}ofx&FON;Mom>{e|#2TQ`)
zSCB@BZKP$Ea6g<)H-_gqZ`2yuXxB8Vd>d(3Dt+%_2Cx7b1FmyS0oV1W0C!O`&yiC4
zCETZ+@^9zj+-qnz6X!1DA(pqhu_wooX=*mr+gkJXmp|z+)ajIIN*hq($J%Y|8J;Br
zTAY8`JN2*F{dk%mUcyaG14;H^Z62hvngEQnTyMz<rEbafrEmLbYMdSPYdCI&SHc_L
zH}p%K<Pz?!Ta|n}UpxPUx+wrpkj*nMh-+`L%GJ9s(z|R(;)l91UZ3+${}e&PFGWs1
z$=}u)y<DColG*B-pWoL!vuECRsBfoc4!kpQcBuh1@>h33_RJT%YMA3xm*^eLIWsrM
zwXTc28Q;&k8{{pXsl=W}t(|Q<CU_Zo%@zpBiRt|wi@zy`(#zs;GGVf9Nnj(IqnFa_
z;y{wzQ#!lg%=&xa<A}}#gV@_YaP_wRA9Kcl*D{AjDC0|iT+w!q@J_<lx#P&Ownt(c
zQAMxX{v3jarX&)Z@imEb9U@V1dcGisoKPjZ^x&y!Inw0gNP=0e&Z>v_2-}9th2!JM
zj87czo6{?ZZ4ckL*c32pSkU*b>3MU*a>_89dCu`3HB&$YUxS=s6~rhTePW2s=vuy?
zwkhDxU|ha@?}L>+#2d@b4}F?|80MMX<@M-y(TL^$y!-<MLbe*`=206@RUTVg9OuHa
zpb0at?XT9W<(N(i1`NKxAdpD=UEgZ8@B2GR`c{n4^44_iS@P0l81da!-XX2eY7Bhs
z`oBm0N#Ccam9JA?*V`rAoaRdt=3Cp}rB}lNF20o?6i8NSn9gHDQzo6L|E{&;W7&&(
zV?bEXpG8|E7e#;R2e%6@1042U(vQB_Jw5@tahr)~bVY1A>#G?@;Ps?{`X5><i^CF<
zN>@VIkDMd6YK)d}A%>$}W+x3U<AUlb;jUa(u&gMvmT&R7iJ8|()J3bmSWgA27=rtw
zc;`#ZT3(8c4QXpJ4B-Nc-~Y;omhA<}Tt~bqn{hqKPpk3s9#y;`vC794w$Ph#D-8O(
zr;a$wYO6jI!py4w)Wy3sEj<XcMEKFBImCl##cqKcAx9bYQTutDPbV06Sknf-)p6?3
zkWeXfnOeVOvw_+*Z+C^RJb5LOZ*~Q-J}g!FF}{<cqFBRB&VsP5pRPIGV~=S~%sP{<
znky7M1kz7!%A?}Pvy#P7mG{90B8U~CSQJCdxi+8&CZlBRv*ox`NV*aslEDh51>T`S
z7*(8Iy!~cjysaVHT}p)#ypwAaau|grEQ<?qXgd01wgp)EzSZJyY_s2{Tkc~L69*8U
zIdlechb&E^WHVNE!)l=)<n!6wC+X;R?_BWsb~k9LJ_p;$#&XVDg^{ip>o#p3Z&b-e
zK<GY7(M^g*?%Lofn0Wbm1U1V*UgyX`Uf0V(_KwYmrUQ$c-W{b~dajV$a&`H+TpQKc
z-p9v)&$0+@Y8QehB&^qr!yJJHj>Em>AH&|i=CcNp;-S5=4U*~jM506@QA+R*j#&ZI
zusbydQpks-3g2c(1s2V<%Z9*jrHoGU`Fhf(y_v3IC%i;#2r{W+FtlA3H}R#7!>cnQ
znQPERW5;lU-BW&3gr-GMFkpHLd_N?IWlQN!tHiet9>d_|g=DPyv+F-l=C4lR_kES*
zzEjgSwu={exxuoy^1Zxn@bx5|W=zh-K;@ACI43I^MMYb{q_BL&WtqGThk_a%Xp9n&
z#)fpwm>9jsc#F1WJmwh}un!$Ft!n8<mq~4oic$}S-C7i3t+p?`XqgCUZn79QPhX5h
zVdLV*i+Xoo#wUua0mE84G+k&s#RwuQjexOZ&2~`#l8|3cnfw0o9x0ZdardMa@%Gb&
zFm@t}v@iQqLvVJOJTJ9TksD&#xz<}6V(d*hlYv#DV|D0s$*~RezqW-Vt!^U@{p(H?
z&2bCD&V;p3i{1SpmN^F(?H0oZ_C+v0brsH>1YHtZH2ZDUm47Te;mi{!iMnPCMC!Mc
z;6dBUm8Fj%wvp;qwG^Z`oo2^Y<gOmom6U<M7Ho}UQq8Y)#u%J5-O4{%(H30R1O_#%
z9KxGN_0X?`hTK0z2>~s*y6Vh!YcxAEBjf(<EBL-7vq)`hZsE4_#|UC*%iyERJ2oh{
zusV6!$>41$5}K(V!q^*`ZA7JiS!dL};{r8plR=iB(NhhhB$<+4{EH2U18$9+PhZEA
z?86=JKw!nFzJm@mx~Ch^apLAQ-@n!N`&B@KdBv0t@_>bi(A-HJLwtcCa!AzjZS8zn
z%HqlMVp_TWVvTYSkzP+yx77449{xD+!?GmsLj!gnYGv0nb|=l^FKhu#t=)0`I?4Gk
z;`y>vHY?-EhET23H_S3aRRR9UUu|V>8W?1Z-DkZ_nHOYB*Bct;+iXQe&L6&Yn;wab
z@qPMf6e>7T%op@4OdOs`-3WBW=SSySLBf+-FA<8#LqU(|+slWTDUj%7o$$5n0pLGR
zZJ-CuR{z<wPTG6^`4Yal=QcURn8xPW=tY{Y8HwzUt3*diA}@$WQG(`|pyugQavz&+
zCxPUx@`~=y(<C#>5#FP*P53MP>EPF(0V*j8ZSk^>>h7urLlO>cGBZ&Wvw6<pDc~b1
zSFLlLDWL>9ITe`iu*|&_A}T?YszRfxgmhTmT=m3Ih7aX6ctg}ody{RfS{;IAgWU8n
zWU3`gCQsfYk%dNPw9UaSU%rim)m=mVFiQT{A)zd}U&K8_u}Nm;U0Wz~VML2%Ou75n
zh=iml-otbyo65F!et4o8gt`S7s9@wZ>?n%TNk%#D=PuPkgq^2Mu)U)OYh`2r=FEi%
zWr~(gy%0|?wX97Wd|Yj&QwN)3$A;X4ALZvs;^tG-?lfU;@86sXe|E39wjIHA4m9^^
z3>$~8kkk0e+3&j6v2rF4l4&+CabChX$Offj7?bZHDvm>&0`Q)Rp4;VnhsI26RlaSv
zlpQ{mgS*PaNE+7P4Lna8=)rrdi+fT>Lwx<!NfQKeSwabz09{9Nw7q&vYoXt-IVR}r
zPF+skF)E`Io{32G9h3CTd6NO8lco??JAt-AN#`f|rTnhXg}Jw<pDn(c#M|R(4~)pf
zq!&RNQ0pr**Mn&8u?zF@F^#qkAzKuLZFx<M^m%*I<Rdw~QI-Xy+RO&F@Ql8?kO#q@
z<r{GG3=ODVxCAUi@#SxaYRRaU$db5#-MWy31;Ox~6JTnKXLwjS$0Dm7Ql+z!TJxC1
z7uGV*nzJAAnZzSk^LEdO9=mQI=ubtx10=nA8q$)^N{`|GHTQ^mEK<&Hk$|Wd6Q?U&
z^f))#59!MGxNC0wLw8T|cr}}Sl%0_B=eeiTDswD0Q3TgJFV!pwF68K46pA!q8u5kI
z1Pzz*P(uAf5fgPKtkyHC7F~4HV<^$>QmrJK&qq&VKB9CFd-aP|k|UWdBqx!to^2jb
zniMXVynN$(gZAgWwbl(Z6w{KLiXy43k>?H}qDa;mW%sn{aJGV1%048_#HTWzcw7|e
zU99g;CEN$!NgwCJJ|p*MeH5@ig~VEx_o7Ar7j^FK><&{L`SmwKz#ft0Lt4e-&#VPf
zUA>NjJ!w*d$X-YdCCIp#JX@B`l;4ys->wHB;o-^MEEU|Ul1WwjNUPDs9cmM^&?H&u
z3AVqZ9otT+S{lHy=x|pQipfNqNI>;%v#U{uX-|JtW|_N>l1+%vW<Iqlgjb4czN|pD
z4<^i`vMoW@l7wUZp?Uo>-_YYI72W8zA*xf`)kAVV^-(BF0=}PWIfh(^LEB<+q^4@H
zQXG?j34wM<+R`8tW^Ok78yB`J9lI@Ao+)p!Ttiy<bADyed|$Fx%xBlle7<39hhf}`
zjSNohExC3ijXN@IrjKXv9G3Pl!DJq#pvQ23%tq0@e!T55wFXpER$Gnz?`SDf@>GFj
zZNsI}cZ-TFhc&<ncTUmBD0byNO_IoPDi5L@L6-%;38wi7DC*SHCgN>$qdPX-@^dCD
z_K&IK?$}sf1QCJ0NkLyZ*x~AIbqrys^*V^48<5lusF&ak?S-om_e}weUZc<sU_q?B
zc(vfR-^uh4=t_+)k5-itt6NV!6Bv1ho1)$BW}ifu(V02p#!|Qywss=zb)I>w?J2`h
z$s4Y^xXfO2DdQw*LNrGZWco$JbYdVF_o?f_NJiKw(er0+LobGbqN7*-rV&rfs9&@B
z%tKa7<(YPWe-LIj#I?X8c9uD<`p~bo(!MzsH_gbL8@rVP-Nz(_x4zFQo$4`EGdWbr
z!J#2ryZAk_`}2rEG4>M#ASr0dKP2={8QdD34m;jipAq=3Wx-5EU`!3R+JzRLjDtNl
zNf&Pi&gH`mv0g}+5_X%HDoIh2Hko46>r)&hUP>Kv*kbF5q9&SfzZyETMF6dIb3oW|
zdH#k%;5#fSVx$9b6J+HC4G~$HVhzx`)l-%WsIlrHMV6Xve@|%Ypt#{0R`~rvgE9Ft
z6{ZfT8zJ4Nd?Rcu_eIgJZ^uw^RI}k{tjq}%Bz#4$^tB-iJ#>CS5nEiJ>2BS|O`>Ho
z+JHj_7U7H_r501od+4f*{x*e58aY45aoq))lgKlB564Z}jeM{xW4m+OBwJS!KX;Iy
zoZ^@1kB<J%XB;m7(d^IqqgqZecVaS-3A9P`p^aAaS43?1a6;Umf*)0UzZxl`wyX6*
zgB^)$oIRwYo5CIHL2=1<G7Rkpf7-my7E~L0)C`Wg==g}rHorqg<MXGQ7#?QTBkNRF
z*`jw%sx5Yez7V5%%G$rGY=q0OMwJi)ztu`GM~e+KL4l$5Vv|K)Fgn$J{#Zk+ad{-G
za{OwNlZfMo05%0zo=?`@g-^vTFp!=CZ&JdR_e;`xM(j8{j#+B~dIn~KKa$y_&;?m3
zC{nrYD;_ta<kGqmg}vB^y58k@)+9^CJSIm)l6s{Hr-%`yiQcJjRB<&%%Y<YP@?4^=
z{Jt~Yg6}3lI*Ay)zrO@=O2s507`5()Bw@k_)<V8Yh&u{>dd`Vu!7*F!oCgBf#@`|D
z4_P<e&vsM_bGc$d(0m%R5<{wzT&&W(s68V2^_rc<eguX2WJs)XhW9_5Lsb|><(J@;
z&5qGGBNtMfQY*;@qRhA7R7I3aKTm}vl?{Ex?yh(N0{SvIOOb0ZN)8Z1_gkxW9e9}0
z>Ur&%!|qNUBXStFp7A?U6vhWsUK52;qko(5VhsRhVeyopBbDg!Of>4wkF0p&(=E{l
ziS0uj#4J9f_s3u3Ow1PBsnu=E^v}UKbyf49(yQLhDgP)ziv}~$_1oiS>WA}8K|W7X
zX#><k)nTirlr!g|i++*S0xvg*O)HB}eow7_KA;08ewfynq&x|zrT}|TAorERp#T$Q
z)8w$Y_Jezdu%NhMnodFy7x1M0vPSZgPGiaNuACOm>Vom0r%LUDku4btj!nlx4ch9W
zSPh-ML0Kiwp4n0Hg&Ezc;9cjaod|aqHGCG|x&6~#U1ai96lZ7!r_C4hP2^W&Z^hnt
z8}bOl6R<lv&(nSmCTeDgKN<#xQ=nSf2ZlpoPlXvyR<+rf_~UFFNZ|-dZ{_b0BNz8h
zf6tWir;>4}6s1Ht5xFR!9G=QY9}i1Hk)4-Bw_bfm?AkwOVYqt6cdPoS-dgPn)6_5h
zwfu`ogq9M`EM{>w@K?AADjIgFr5)7J?8(dROz9w_BjS_7b+SMIm{PUy^O;AKW?6)i
zRl%GtR-G-2Wy7Jcq7*buWb-T)t&e|{QE{ZBZHBOF+POkgWt?UF3Ah);McdX$uihO}
zi?CEfz^#W%XX_R_+TJH7EQYcv!%xE4Fg>ZNLmjTbPeL{bzv<OEOp+8(l$~Eft#al^
zX8R@gj?E2FTlI~U?|99%6>m7cZGH>0OynCtGZ%*aG~6b2J>sCf$L=L8KIEIb-w2AQ
zp#JV4PHe46V#6wD`t2uZuU>>ECAZW%(Bvdcblx{OA8+nd@k5iQCmnJ(+EI1$JfiY+
z96L6qje{SY7{OuiLCUO|x%Q)Hjb&oHMQdrk*-N=Aiber$n1-@wdp}p<&pe05W1W1P
z%kIYOw&B@r3hh2}OqZht#7eT{LTukw;%xRkD0i^w;-Q%;XAalJ7KwOdm0v*4(&$)>
z#OcPGp*N0IH2YYt90>CxtUxVjY6Rhg$D9v^cm?I+l8%%Eoo#4+29f2gqdgc6pemao
zAUrOG5Mv^}f}s4css&>pgkGC|y>(deN@hASMo7zf^Z^+!qB7#!<VT!HRHF857|3YQ
zoIrRlMrzw!k$`gOA3>Bmy@q$H8rp`KP0`}KOSWD8J`KZFYG`@=YB>7>V_HFMniR|*
zcMc%YSK!cxq{9=vtd+AB^wWk<ptTk2LK4)z(P+^Vn`Eeusb43czBcr_<zW)Klg)?G
z?c)R7y^5+ZqE({q5!oUMCzB@fHF`97_?teT0V7ew=I`&}VHiI+OC_>OMVMQtLtTs<
z6@Fyo|DjSU;L^JG+g;HD*4{cE4}A#ju<#?>z0Ek%qtTSixVa8U2ve`fQe{<H-acp=
zYf_1TvWs^TlF1k@xeUgzIB`HLt~NJ>#Uijam&~k2PU}7EA!R3~UjSXpSS=1jX(WvQ
zO>|b}O%=w)tr2}Br{Cvez8x_?h7HVifO=o4-xT~gaK|gxgIV~8yWDY*4YCEWV5?z}
ze+uV~H)hDzq-Nm~nTska#H%UPCh-h%#x_qv!tG0NQPXWq1RLZZFk$x9`5%SAe^pS<
z8^&2q{j(8v46s~;M)MpZPR>(~x0Z>$oBR>_4v8BCa&>-a$uKl=2<sbajp8kZm1#0r
z%~D&<58{-^W6?59!%#P&U#e=2f-e?_ybn$`RGlyLC#uRvpa08EdO{%2_hPu0-7Iq0
z0PU3sjcjnMQo`14fypX1;XgihR2f$t=9%Fs`_f54ZQTj8<vy#VeiK#-8!*Y;?yXXs
z(LmN-is}-72c?9(d7tavH!>5<$_8I1N3x4NbJJLG=r*{FVtkQ77&1On%@Akh12JZC
z-O}}+h}*?LKVFrPcPr$3*7J=*Bs0HCzwY3BZrLKRA(zaiM$YtkA3HHSvRx`%lZc)A
z_rPbYC06(p_8FUB#j3x`V%fF!RQ2C0H7*R}fA%qS%LaPFdyLH^7kEPzC$IAwroZs@
zTMq;07K~j9G?7~yYGrX!0O3-9v_ejZd4Ky@zyYSO1b7NOj**IV4+HI%#kcKAQK3le
zOS<KLWa0=)Ws72bq<jeJ%lOZhXm--)2<XrG?7!OxJNWSV&wz{l+}H(pNC9M0o{xWG
z3w7lPGm5$e?)Jly6saAI)<f)Z1^C&mDbOO1(A;X&y7X7hRz#)&CHV1%Meh&}cjMOV
zg8FWe**pvb7+e)Q(3l!6oRV<xCWj!SNf4c7v0?hTkxK(ooK|VSX006bonX6EPc_cx
zdR*_o`gjcRLS2-k*RijeQn^Beb`-@1`p4(!u0mRRvE^4k8Qz!c*7198dFgv`5WfEN
zBdbeRH3fS|HN*Gw)vYl){)?5Rtl(-M_uKS0n9$KI%>P_z|EtXWht9*n!OZdRmG(be
z_J24&{}T#6^WUWQ|ERS8sc8R?D(!!D{YTdSy3+nm$Y&*D{`*LPup<i*^B<DHUo`xG
zW#_-Q|4mW)|Ea(;|La+RznS{X|3>tGXX-Qk7fgL|2Lt#2o~j?Hs%ws?ipJOKXa@Ni
zhOiEiuFjv|2KInCR1Gz}ep$9f61DNjR5_h`*vW;Rd(7DMN9rnhj(ovJItJ81X*OT~
z_m2(K><qUB1$}W+Y{+mZ?`%g(pwc-v%d)YHAahT~!)fzgrsufpX>)S%5n%P|xK4_7
zFTgwJM>-!DQ0k;b)<UT`{d`|+V@Ik0wm<49<r&~ZuvUO3eR^!BePX12yZsXzYqBM1
zR}IoAin0L3#4>0vSVT9Oh>!=@BLV=)&!tVZ=eOXSIIkn%@$=i)LIAd9*8=8j+}S)W
z_ra0cmbKA{*|=?0<@2%F5t1pzz{OeM1g4Cc<!3j-^SGR7##6}l<vKYuqaSjfo3RdM
zS>x=cMGkZiLuo!vKgl{201?dNp9_*PjuJV1v%vJ6<uIcguNTZ#?Hgu<NpG+OU(wEM
zJGEBvws=Z9(bwr}`9^wva`8YsGoO>u;FW^)v|kHP{xIgM%I@>XeCgF9_7vk+gIN3E
zHCPAVhH)GchMBauOLX35gy~M#OHZFJh{j-u$sc$#Y+lAtB;3*Mm_;6UH(Qox)VU!-
zQ2vxh8_e&pzcjVxf#Nm<NZ`8V?X+s)R{{$f8#Ph|rnq~9yZOrHJ24Lx%-rK_Pj-ZG
z5QV3qTn-LsAOh3jChaD@t`W@9eVw$xsLASNt~Dq!^OVqe6HRk91p^j`Uy1<=-U~&u
zzIAd(G4p<UdHTddJTFp?`+Hw(zF8Oc*b?Y*)_p`?L~VG;Hkm<R4kXVM=cXj@r7=`M
zh^5v;5AOTIgm4hUi8U4ql7Afc=3A_~rk|I6Y)3#6Dl_Y0fhn_N1?RbkIT{yBgKeNc
zH9x*;i(cbD>oCG@<h!qp1c5y=QFL_W!dsD(?dtL0$;x*NJBxbV%x9b)?d`iUODnGZ
z%+QQm*nYZ%Yror`%SU`Lb4Nb|HR$jT!@tEhk9`s2jvEsk=Sf$rv+u|4{L)k+>Ui6z
zDN}RMU|9EUNGKtrwCQaG_Ns@cv0BNI{`9=9k>7}Y>@EyB+^Jo@wXEDK%befR$DHQZ
zfIx>dp_IPVx|Di;=`^BJfz@=)b;dR5y7`*TLtmhUR`+00(*78?6~?>YbKd-f(KM(Q
z?bB8FuTeN@!VA|AM(GbMIdgiD8Ld7>bUPt6%I;#=YA!SrRH#yw4gy?d*6JT79}^W#
z7{pv`tBj3!$9)5R;>^MeNh*HxRI58z?e$3GpB3us^vnmbElTntWiI_HM5;tl??6{I
zYU9@Z@!_lN7sK#zVh6&nKL{y)zK$>H#B;JK0e&Y`_0mr<^lP!Dpu#8wZrR*$4yvYM
z4<VR2<ePf12&cY|GW9E#O+Cadg-?C)692r$GQ#wh&em&&b%wuN3~QYitWCqZXTOfJ
zqYLP2G(F7unr*>Q!lhGL_;nX+iBGlBh7AW!WgS7L!$PgL*Og;}<niccUrx@Z)qwTc
zlr~T0kbKIgF*=_0zi{RM&^MWwnEvB1)jxF2f8})k<?WP+{+-jw{ICB0AMf|K2mgOK
zrxd8F9fGTh^%~DL1lKw~^J|VSUl`;>)hgY9zFJV1rX62rg;TRMhap%SA8$N*Ogb(z
z4G*OL{yV(1T~e?OMECLgv`5!G%#%`yf|~0QF(qG}n;_-2XyXNUyfL|^WxC0P*VW7V
z17I%;JJ+vX2vqTeo=eul?l@F@xiV!m-1+t4;0sQ^A`We_8gJa#_-Ah+nu?bWZT=W}
zMs<o)>oavgGcK)zG}+}UOuJg$EZGLCh+nPcYF+4upe}jB#v_PuydYW9kI%WCJM2M`
zL72<;Y~t|~ec4>_w55qcC~nYhUe&=2cN;E93Z3$CxGS?NqSwS$^HOQ!_`;se!Oi0C
z98LKg3bj|ue$InG$MO4}5$ZdXXnUbEq4X5tL%BA@eJk1O17%>=E0(A5&W%J~Ga?VY
zpxij@ei{?}fC(b((6q>JxzA8ee6HPS^n2^q7{xm{)>SUY@{r{2TCX^-+XsY5D6w*9
zygz&3t2qM8>kuO)N+1sw4cVbrj*r3BS#+H`_XD+U(CkEojQkSqc_$ezxTZ6&v%`Ux
z>N<q%MZ2*!15aacl7*Pwu$r^+hsS1c;IR}RG=Y7pZTiEwUW3jwQX%)FJhiFRx#3xT
z%jqbk1N{A%nA~iXhTqWlR0)V4Goq15_bGY5^tuh2PenL%hN?r^vPzWVl3~BKC{U9=
zTjcw1Ryi=@x$2Gu)K275yG5o&jdiCvC!A#HmJ69web9BSqwW(TRD{f=zJ^&0J5tWU
zI>p%-e%mU_7>SI^!of8#Xuy1XTBKc`C|p9II;Og1<?j6b&1{ix!4<=^1wGWumPl%O
zVkBe`e-*;ABLv5W`r8Y17>;H|aC-%9G<!eK2=*1UEa<X-ofkA+ReMNH{`l2nTaOp{
z8Ka3nqpyWv(GE!Imj!`)uPqK})3VG2&6wCL;mFm^7cF~W=&C{`9*&QbISC4nwH57#
z>JcW(`8;G}+9YOpz8+2%%#azm&l-th-j}9oV}E5it==T;@d;AzISb@Rc%ui=0jYsx
z8OeOf^zp>HG4xXU((6)$()vx0tz$8sx1`LNj%1e@GjrutjSDFnT-1PM!lbQBqz6U!
zc~z>*5FWCkZQUws*NL%oKtZF!^$umO^ONJA#&69j9eGa3^_LW|vG7F>$g4q(ysdMK
z+;zh>gs-qRXYmUqA%Tl%(ty-c3#KdG^)3-cf{2*UEBHTP<)D#aSAa?Wt>4nS()Py?
zuQsV4sdw1<zqC`JmCnhhX*C<tcy@16B!1)r>PX@qZZ|1SI`=VYh7Hl#vb)>I^|~q_
zleDBdwg<P{sPl|_2bsU=yWIiL><4f}XfUP*w+J|bTz4SPK4*9e*`$m$@LxW(lhjCg
z-f`Zw=TNTc^EYa7ToB;8g_~cEsU2nAX_t>7Z}|A{e}5&+&hk?IFZ|j+>_{d?j(;bE
z{)O}Yz{dZ}ul;of^FRC=%O6<!54QZ<ud)0E5dVARRuDTO)yw#){|p#*wn*U8XkqoM
zoA}-g8Ls=C{v?t=e~eQNE2~A-9(`u<OBOl&h}hZzD`nK{YJ>w3j`iaSnLz?k0XFLZ
zBq@e^P&V_&y$3r==;{TPjxY`*^6O(|BN{O}5hidl?4LNv2um>tMV*$kSh%x`AEM9C
z0H+nz^WfH?%7&IQ*$rO5Rl`29Hc8g8*qA{Jv4i4+?##kBd|yzjE#Q!xRPeK$1QY(U
z?xIzrM5$hi+8|xTA)ZDb;#ZdKB%oNJb$!fLqa$TxPhC%2N+#FJ)>TqL1~cxfKEHH@
z*k;eqd4Ec2xeKD2<;C(H&KWIP8Jma8F2xe{Q@s0aRjaqLrzB~T1Xdr7Zw8W?S??i|
z57xfEQ+e7+b}!~afB8C%!ZTQhTKVOFw%T8M{-b*q#=pK*|91H=_V}N~6)gWC`+v^%
z{$<hsQC#s?*MDsPzm6;ZC#QQ^{)?D_<?oo`zdH#Lu`26$GUC3r$HfO7bW5b&2{8{b
z&+0;*81W-O6+53NMqV-LXD=o3j@PSBM=LmituIovGTfc}<m%h$-b=aX%hA@`?R{mm
z{A<Tv(a6!(^2y6ZbcfF~KjGWiK*tlZkB9g3j(oH{|LIG|^2x>0+g*`<JK}5b`#t%N
zw=IT_H=oy&j+YmH{^yG<g11v2_N$K9p%#Y5WWu|><wBh`0DopBL*qbl@*bglW%9tt
z%u)2y&Mt|M+jHyN4)R3w+l9XM?%C_z`rFm|+cN)4N5>oT+vUXD<$%v)&)M5a^xL&`
zDc?&|d;3b}8RnaZkEaKSZ|NpFx$)^}=1KbLa!EQ11ZsP6^J#A9X>VWiZfn!aB78f)
zzrDWQ+S$3hym#n$cJpY~A@C05S=vemzPPXL+`MkNczXCe?_79za-6-~Ts(N!&o94R
z+<4rGn>_~bv^iBRA1!a`k9xYdW8d7q-d{F9R>nl*^Sr)mnvc-?!P&X!$-cGyt;J8i
zGt2dXYlQyoVgckMMEH7sk1YJ8T>PM(fE!83klZ-1T$}f@dExWCy5-qfH1YO;|MmIQ
zRq?^~{S|$9Ut8a<8GN4aqThP1o_ac-8av(?-kzTZ-nKeklKEd=*I!?@e7v7m-yZMz
zUy!OZKTR{y+XbREE-c&?4PH5QtbN-5RkW_~^m_gLc<<5i=GFlMEiEm>8}fDN6LQb)
zoa{W_ySTsEdv>hAG_T|H48B;zj6^S|Lzg)>zqxrgv!2}yjNBZY<jiGdW~I5lT;QRv
z>*+;wp+q+0%(Nw2Wi|Wd-0Xx+=<E5k8ODMoFP}hfyl(xbL|!P`BLv9HHx`1lo-LNW
zUN5}d8^#tW-rQW1?g%-nozDkOATNW8ZtK;b?X0Ns^!YpH)w{bKkGw>O3xR^OcZ%Gn
z@`J2rgd9j}jPRs9AW-j_!Di4r41DsQpl#!V<Mz=@DioHHn$ciyEikA=x(2l{uKe!&
z;d!eea-G5TEfgxDYX`y22gD9rqIU|o!@qyoIkAapgeOHxpP;;TX?|_$(5{RI@qw&y
zAo`;Hlz1YWwLbbrfcW|O+jMRD*YwsOaV~oF)5X57>yb1+92DGMKfZdWY<T!I17`RQ
zwv%&CDHLFy-eB-n+O=_YNtzMc`Chw}Tts6LXp*0_2Z2xap3NC~I(iqv&(|2s!G1LL
zbK@5?t#2@5fgnCz!nJ9IWGkA@H{2j6El#@@qGS#q%S?GxYsNH0eu#I~Q}lr&1?x^d
zy}Ul3do*%zvK@sXuAiy<du=bNtyP?n64QG<TzI(GoZyl<RyV4DJvd2qVL1_738_xB
z>mxH%`aRK@14g6s<MKqz!|-;2`^e67jU2E*2msvEEbc_%02(>M*YpYX*3bAeEAEKS
zRPMro9a~tx+Ri{zm<)jH9&S9n(}suJ=dF4mq(J=y$UrIyB0x>lA#A$HTj%`rh&$80
zRr4t_qGK9LQ1AIoz?O*p`qh%K@nReoN>6h5=;?hOy}VvdX75o@xB)4)IGt$LKS4t!
zG1O`3lTc4AR=Ue$N>%Xk@^9@CRR*j`g?OwdSx3sjCu^`_Tgb~N?=cckWi6w*H!Z4Y
zcr-Hy<DZi8xx4ufKcz=Q2_+TQuilw`(h(HOo!((4ozkuZ^pINSn(GLjt(0_r^zP6D
zn1{+OX#YTsL-YX&GykrWju48Np2QTw*fnfAlCF~>UIuHZL#=}{NJi4m4FcKDE_0s>
zzNYX=c%`<ufu5V%XD9@JFsG+sWlOetJlXqHZ_XY*B~W%IlF638(mEFc{ek{5qi0vI
zvF?r)u0Nh}<}=qT(6+hz_>sIoikBP^cXA3@j^cX3^}((}kG<RJfjK4E+C=ep3+IN@
zH~7_Sc;I&_BBaF%P3d*^U%zXxcm&l_EV_v<E~vvjA{GjB+PbmZzL!<tgfcRs1!quY
zAHu@*GKa2lxw<z+;sau6vnYtqoVG~tLj?;}FJ$2FWlU#2Ib2*HV?mLoKZ)UGW>q=+
z-W~1GS#%$=s`*bk<wrb7f=OherUIn})-HY5jvpUVT3n0W;cCB~odH<Wd>HFf&c{rF
zKk~D^JfH+aX$eQ~yb3$WoaFCRlnocjC&c627kk_jU~0_|#yoO53>nge1%i)c7RKWy
zI|l49JemOo>Jt3l4PY9RlS}LM&NYo|r3thzMH+eg>>J=&N|1Skgl~Cq+pm^8Q{W=F
zctAW%CmB0rGe)m-vEvr*G-H>W@GqEhZed^?DH3PzM?M29Lao)QVYmAOs{3SF(h9<<
zE6Zh!^$lsA@(nlnvD<+PNuJ!$!eKUFp5tp<Bip7<)cG#l-U${r0ON_f?5wIgq!0Z;
z%f$07Iu1U}xC|EZhx@O+$GuBxfm$&~S4&3h2dRdzAJE>41}n#oVrXA+G54gl{J*s&
zTZD-WscVG~dAER2=|_Q*IaAhkZ#R`64;Xx)Z)Fq8uT`5^mIb4C$x6=DS6oG2iNXaO
z`2k`EgiOOCudoanbb**cR8ros7ps)k-zpchwa~yUtMEIm$47|nE>LwJFGtVb`jnhv
zIr}KZ+u|>gCE#@_??<2m%;niD&J7H+JjL#x<}d=j#5ntGz+xvhO^z_!#Xw&^A}sqe
zLZuIU)sN@N%e?xwp4F_CiuQF6hS#(9^A(%fb7E+-w^#IZdtXl_XW!*6)3+a=KKZmT
zdI~Paw2NP!V+A4JCY|^cObkIFJ|bjHU?&Tn3w#nA{XYOSK+C_0Y512XCarl>JNB8&
z{cNpw!P14-1VRR!*cejGdVvs`r|FDf*B3rFzX6Q0dVj`+P&LRi8L^Us-d}w$kDsT!
z?-dTFZTY)*9+7!;%QcrHFZqgEJ72EwtGIyrNFakT7Vu&%5yb#6vu*&!w1HP<-9Orr
zZ8r(VUK3jzCq76F^2&TXbT}e&AW(rUAiR-7bn?p~2SapHWgZ1Q#{@DjoDUF0XG<O;
z!s}(;TFgRgMPll{Q^ry>cx-@`{nyxzt8>`k2}9Z@-V~415_skHGM@I2>{ncOd%Hgy
zgDSVU0JmQFZ<}Y$D;9~TpN30LIH`VnF!>-g%gX79%MHF+sqY!i1cKduAQIG308iIJ
zIESw<$pR(e|2<@HpZF){rA#j3c4`6=atfQrp|FFzQu+|&tEl(A1GCnL_<usS(iFmX
z$P~wg6P2+l;7C&F4Ip0U{Xy6wf~Ck~vuoC}qYASIpgx^B{lTy4%m&fB_D)?;nvH_>
zTYep?i4ZUN733)w3T>YxGB)qSDF}9FUC&Bm4x&Tx#|qYtgOZ#gAL<5(=|Ok@kX~t*
z?}VKt<L6~1HtR|^KVs0l$n!OuW6{7!_A_#~&<hklyk5vcAzKiUfFY#0K%&E8_)d<s
z54#P*Q2<FhVz(d+1wcIZl-C}J8VJTaxDdg#0lk;NK>Rx{8)P0#ktcrN=jPKlDmi&g
z(n}s?W<c(n#<biDl8EqfS$)nw^XaD!$_4Bw?>TiOcCKI$!jpXR(eDc}gS}%)qcXl>
z04k^7`&$0&D0ddZVdj2N?ke=L6pp#a<>vW6yL4U}m{g$!O+2JLrQzCTMxb57W$yYo
zj&wE3xnC|6Hy-4SHpY&MN6iaHX@KGO3ndWb5)Gld4bUP%X6bzdGfi=WSu>`~oeg&&
zSE0f9X#rXgau4C?bHCZ#`5vx`pNRVN>o!%6>XoW`=U;7|JE0upDa1F6+emeRF%#F=
z$=baA*71*P<|W9>J7<sby3oHLUwdbgh)=rejLG)B(n|sjs5I**Q9WDyOVGCXmw>-E
ziMP;73+QRH_i~g+>S?;ZPtm-`aq?F$={1V#dL)Hhy+Gtksjb+<4vdnbyASqE&kmA5
z$pt7rjKOodE-w#E*I%;EJ-3hb`oU#uS}rPd1rZ7#mV3Sp!ds7-`W#Kf$+Q-NA>ANE
z;8}VRb+ea;!-;JW5_s$suFv!Y^W7sE(0!B6e9JbZu51_+zwoX3uxDCsIvXazmbN*A
zo=p$H+m6AFE^6lbrQ43!L+b^jy>OfP8b`>VxR`^mU+psag<i<ZCpub&eJxoe6SY7I
z5vX7+C&^R-u<vuONCpUP^Q$qP3FJaRihv<wDqylHVTIge$h5ob{o$oB>FGo2%hb>f
zFP!P8;_uAl`;`OLDF2&LEY-9z^iP;T12BorcWXKNafEQl6W_T_&6k^<me>FZyK))P
zjuyT~sZJ*<4R9@(3~(3oJ1+mes5zwEKUFWYAdfoKQTUOL{FONg<-C}XSz6P<rLJM{
z`S@#2T0SUx+FkQ_IG7cL(_iQtL~znddGSXO)6lsM<dPsf<&QemGxfM+dcJ-Tc>;Wa
zr2&pwV;PEiV|+=QXvNlaJVAr((E(r;R48bWll|ami3mC*58=+BG;NXGE9tcFh*vg(
zm}YJz$v!1PPAwfmKXj^TmG_)M5Y+R%Z*q<b-(a5*D}88#Pl%O1AWIFx$4%1uk+eZ5
zPgveHF^n7eyBMHon<<f(YmB62VRY=x8<2e<d2?->^;Tw1D1{S9e_@>Xv4!x4q#H=y
z`4yLO(B?<x9;Gbevnz+<&rw^h2`_=2DMbL;d{it{nkTojc@lwa?ZXQf?d>@WK&RcG
z6D-LO#E<uF_$m;5DgBYl7N;{b0K_AvWFpItugXIq7d?@#ydRDzm+5$@k*LoL5Sg@Q
z`DWoz5WI%K=p$qRz=maw3ZA$e+%z!ulILeouDt`jh-2@h1H{SjJ_r;1%x<<rtTmdH
z5Mgl_hRJZHL&$`DhcPHXRe;zoZM=EpD+`bezaPa$Wn9GQjk@tvu|1C*owrh9#}Q$M
zvrYM1j%pGsUa@hTD*do<F8`pDP^);{o*0Rgy=>17&u-hZprJrQw@o@+7L<K~u8+e}
z+6-UVRhS9`SY7qwA(G6H!tJfFN1+VS=;csi{}RneYXej4EE=5|WG-sRUH&KX!@Gn=
zz8V<C8gt$HN4w-z<n+ltu)O##{~TIciC>hjdYB87HxF5)Fyz0=ATS`YF8{NnM90jO
zVQ(^Uk`fLxT#8n2E3Qx+;yk-5eif5giTufhfjH=mlX--IDe*n=>n+@sUAw1WUIa?_
zcbd-JpGDRAzQKMIWP(qGX`jBBn!Q)iBEhKMR>xC)5(DzEwuzfKXv;Hfh(j0fG?(PF
z)ZI1}MHv<h_)xa!<%RKinTJ}=iMp0-0U$}s5Q8~t>7EzPF6l_E^tm)QuUSBs=E*T7
zl~%L#Nw$MAs3^f7Mar^s{JR1`8SgCXN9L_08Q-CJGZYgY<&p<_E7!U)9X#bw)F9CU
zQtlYP2YC{rG^=<u1}fa(V#``*#i+LzN>^|zX`XmLNlH0amU1{D6;E=BV3;ETFGr5-
zK`=t`4l~Q(bdW5MoO1*%;Z!oqNUE#PWz8Ikv7$1}FOQyK9mHw2O|rviBTGh8`p>3v
zP`4>uwj5?EPnz8rM$Mi&UIFNPQk;Fd?0B4$#JP>1^I}&P`k~WZi1Vf`{n5@LBNwQ%
zyiaIhML>?2&MPh9b1=t&IrSB8FkOuZWZlWDH(b=v4MH8h$U*p1Mg!$!`X-I&!uUFI
z!CSFow3B_0EClZITF%xs3%zhB!TC(k@>LxU^IQ~I#$Z&t!<7z6dzAYW%N<UYjfE84
zTR!vycE7<z>`UvQIS$VSi^0_)6O7^)>I5!XNgnKhNk2LZ2nM^%aB>ij;rvUf+q9nr
z(X77#z$WUYD91V-zIZCPN`O)LQd~v5kjQe&)TL5IghB+Ce-I8(^xavRN|R$I?j9r?
zfRd?rh6f@OF9!A=C4wlO4YwKM;-(iSt*YTe6&MN01F=vmwTn1D-{nJ|7<oxX8=~bI
z37kWpzWXnbqCyF<AlSF>p|VgWEKTdCq`~+GR;P6dNAu!+N2tDICqc5MO0Uh!Pn09%
z{TbCX->r}q;HgkfRgy}=RH9F~IO0p`-YUS0gfY0RV?`jI=YibB59XD{Ax7d!Auso!
z&*6Uc=fUL3;2X!hSIm?RDCEPbGG^rXKnOz9>h|zGgD~2S7aWA&+n^$PflmcnUTI51
zbjq=Mus<FcZpinn9)4vm_PIJuKnR9JEeLzX$=&zpgi`LoxZ(GegRklfgAjMD(+-l~
zP{8k)nkoHv-yY(PtuDGq8HGHSLNU^Taa4RT1Rv^&*2k=1Zz`n_#n+fYKr31GAPjn?
zf#}K9Tt_`RpmgJ?u2g9h!AsM}KC9B_TZ$e*_-4lw#VfZeaPj6d1i!^}3jPlRbZ(W5
zJS%L^i^1PJ90pd)FfCEYrAibezN}4pcmv6k73J0`L+MNG7cz;E6rBUpy*xieNcS$<
zpv2dhaWZ($u^40N%c<UHnmW~soGEtHEI*R&f4(QI--O)fzQH~rR^rRHlTV11J|I&W
zbF5HCvfk$D04jrHrKXGdMR{byE)u6_`d)Gt-8X`wq*n|i5q1!!3l-Epd@l_FixMG0
zYK%ZI9$mSj1L2guMon1MWpg)bfdO=8(;$pXi(-rw+fdv?rYKkr(S#$M6=MXG|KdTh
zI@sb0f_-Tp-4nt(PA&+3lz45MWt7xIz!)iX1er5n14TFrOL{Z%OA>waiT9?_f0Y*T
z-O&`J_xN`~UY&A{KC;mpqR0&?R>DYhAQ%bMghPN}r|^CvoHtZsN{;Cu{Kz9x3{bYI
zQO<H&T7;=VO7G<;5aDaplpu89rwH5T(LQ9=>B`pgrM42ch$7AVlI#U>aM}Ehm*wO0
zfw8#wZ>uLb0iFwq+UDKh9k*mpil)df(m@o%+bjfTLIOOM?Fs?Xi|H_&!d?uQ1&+=c
z2`EjR!d{d1%R_|1Kg}zoi@{Pwhru`l3fKe5VKj#IDzX_{#FV@Y0cEpbjq^D6@{On1
z8%#PF-jXcJ6NDkj<58~!amFCm%YyEBjt_E1iPx}Kp@mo>{<h)R5-V|p2T^LB>jWmh
z32!7LixzvcxvfoqT=FLikx+7?gsY3T<h(*Vd4sNdY?6}dXeChYtk>H&F>RJ(ilnUc
zA-bQCUxoQQ<WuPRh$vUmMm=Rh@9@>&6MBgSd#9JFuC~R)%3;u0LJSge5Slk$4YsPg
z%ocCWqVzSy!V7=wDo~}i4^strDuK}~+{=U-1dEP2$aA^BK~%dz$XW~X4jD%rM;H@B
z0J=M6E`Q5Dq#8h&o&&)HCgqYBxcC?@B9TUc+082mnUNa5@W}6_<TQuiy!Zs92E0wP
z-O2>q8@ivYiob<<$rlKrbynO!^}kq&s?0X~94az+&4WptGQb!NV7UuCO*c9S?XE>5
zv0!nbR4fuqE=kDYXe^Ij8Y_o=NXP30r!YCGYF0IYloc2kr+MVWDL|Mr35o~B_uPh1
zQgAayy}=jF-bvt}>^;I6A*M3=K4+@$;a!eh#}FJl+Loek+ITV(1$<61yw3$e_O^5>
zdlE!H>)9rLK?X1kCwXWk{$oklAY78Gd1w-GQD9!c!Aa%<WI`Mw`5~QlF1JbWFGayH
zwSC<WqZ?KA^uZ?535U8bsb(j_bde3R-;-0gVfE7S@zPyS69J&}()$t)7AJj;;=H0{
z`f(nSLvkMWxk7hp!>ADx26Cz-H782fd}CtjOk9+Ni|#w~ViP+~2+@MP$yH>MQUhvK
zG*fw~dJobb{xO4@)Jx3_CJfFPTeH+}+Jbp)9!~j5zK^!}38qo_>!|OLv;~Q+Rs&gl
zcTJ+TVe-y6i|I_c5ZHWBPyJA|x%@F16O2nYEr%43!ZBY_A4t<;G7NFc=MyY}lzY`~
zCWP`8SO9>#tiAroJS^N=7DpBj#6k!K;vZ_(AUu<4S`c1S7D{#t9vCJG@zMiyN<LoR
zTaa53J16U8vK26o%jSD|bS3Gej!9KAWVm!<+{x<Hm!OZDRAp^IIM=Cv^$LnAwo0nX
zimQc+Ix=?sLp#<3lVK}^#AcYPc_=}58kGf#(a4S}V7yQIYi<$Eh}5Tz3ToAqnpaeq
z!L<O9YggGjAyE)zWxS8))%M#t<x@e@ytw{Fo@PS(`b--0Qe~Z{G=wG_@+><uNX)!x
zxv=fY>Fn-&tt3wn#DibEM3z_b2o-fQwaWxsm&b7TF8<khOTmV7g+XlK;Bu$!2o<Uw
zG;gv=OGCauIczebh0IZ1_~N|%qZ(3>Rh7&`Jz@)+U^v2I&{)ErZSyB*jp{h6by&{R
z9vWxZFBE{)=WPssg8vS}Wui*QV~S|@4I(}H9u0~$>M)C?*E}Kq?7Xc`NuWgliS34P
zxp)yB4ogd^#nK{N1|+t3n$}LGw`;Ma6iL(Om*n9|s<NdAWZwoAILhl9#5VC#K#sUN
z?1#9T_DzI;3*-ntB`*F>&Sjbk4-$2X8a?aniSuCzTC+JIwvL`WL8F7<ndGxg$c<^t
zvKGWfMn(mO?VapOO`Db{n0FZj*H15V$5$N;#@}linRt={2vP^$1L9aH=K(||W}o8@
zQY@`rI>X{iUgeF;38<{&9*`x=f=CKc%MV6kt#}NKkB3|NhtgRGB0T}cyu(Us7lEga
zlw3IdLiUs)22)?Q%X~rp?L!c85L$5t^*tgnh+O)ZoIAL<KM+(XEZKEJhH0>>ZI?`m
zn*iv}LSV`sW1lhnQ7cpB(}JA2>=MJsbg;AS2L!d-qcq8y3J04NW^$B4THJ67NMZ}C
zZ;K^Bh=Z#lJUm!#P^{{bLN4Eg&Zh5Ww{BcTnt>YxX)OAbT6LC#G`gm9z)-cVGbSOl
zAE5_sHcN$e3~t}H9oFKFRCWfhlzI>y3Z1QZKZ~2}ou=?%X(}blP*@%&g$}L6AmqJ4
zzbZpp%FSL136Ejecp0n;O{6Vb7LV$>_A&fmlLN>MWrDdYJpa5PgVtxD*F4>ts>o+%
z^x{#~ycQzG+`;gVyIG-RK6R<7R68Z1W&491=UK#by>mzsdJfhRoSdA(Gq4pQ6G4E~
z-l9Mnd`b13&Xmq+D^13=RJ0cMxUx%W3qe|=Xbb;2;r3r2!flTS^sBso8}kj2njmL!
znS;pm@Q}(pN*xvRAwb!mA~g|vjSWVXIIA<ec_Px-G($<+x|)Q%ktdiNGj4Y9R`o9O
z@`6<AqUnw<h$ktPM35Kjlo>HFNe-75cw6s6utD;=q?=GTC6C{US=1DU*g~!h*mEg6
zT9^_^%{NM%0OB9DK?PaK*E}JE3P<y@E_zuM8E6q_XcS-C#!K7IU}XZ%T_4mvrJm;5
zv)diQWr@Sk0>Umoxa)zR#`BnezPC{%asj_l$}-KPSgJ~<PjI-M^E_G0WCaeHo?k3Q
z$I+Gp@yD9RWbi8naRPd<NUv)^iJ0WV3>5Lj$Q?Q1OzLtPXm5w}-w9YupSJ_z>cF3M
z#n?Ap(N6aL`hTMe9T9}qs3$du#-`C+j3@~bGGp-_C66G>4k7}0Hcuvd-Y|$d?fD*L
zYP}w3)M*3dwKfzt;T0ukyn-xBh7ld4RLdbAX83?188)k$+cf9qtD|O#^Nd<{xP)WV
zq=ba9gROxy?#VrC5L7xH7F)_Yh{RA~Q+z1r*w?^nanKV`W+;qjD8ouIhIGpy7(Qhf
zjI(-1X~%RC3EwXiZyu$b1g-Sg+ND^|HhEz>tOj~6T$xA>Qs#L#iarE(!a0HUxo<-J
zTOgm}ua*&WB*tVg@u%&cN?9eel<**&L;GqMdDE@Gj*Y1eN#zcmcgcO-&d}Tu`Ee3*
zR%%{#94;d?WTZiq+J>wGh`dZ7_QL1Vmf{PL7+&(2eF$lA1wv9Yz#2M>M9wHpTjpW-
zr`dp3svlR(&jsPPwKk)e->33U)Jl$nF@5C9IVWfUIu2S0Pt>K;5V6KShf2bL5169-
zgZ2^*M<#cRbAGs(QcPKsApGODDd19bZ0ihF;SEKB<3a%r%o^z-uCUMd?!1DkO(Ubr
zp|pi8z2agC*N^kYK;`I`Y-?H(ysvT0aQs;biw^+bM^E!%eBLw>k#(GsyS!=ER&R>r
zU{5?OLEDNLV~kZLpp2kRMPcsBZ5<99#Fd+u$KG)<e&4I0!Z8X>8tk2JYtzNeOSet>
z$Z99PLNEPwcBRxxAD{}Sa|>aVaTtB22{LZA_^xZFQkM?^;bVU=0Z(T0B#$Tkxto7h
zBwhY<L!*Sy*_756tP&TNUG!NY$8;2CrNodNjFV+g;ur~vb_tRz9fT)!=INg3?h2f;
zsWVn--lqBAX~e82|1<GP?6%Itu32AT58oi)$G{~U&KcoW9geE(N`|YXW`4#}3WpEW
zXI}Bx5H9E~uJ_XQ7>s<4>3}F)hY1#1H7WgQ5v(g1@Sg-)c6B0tW3ZwnKa1%*qr?(c
z=67>t!xD5=6Q=|ULOO5W*=8ltN^#SN`Q+DnFKcfMLO$>kh<xG)q{4DvWASPuIV+i#
zAAZb@kLl)i=aVAO``AJ&9-qsalL8S;4r^C6*`~8cZZ1mZ)SmwqjE~(IPCjOP<XkJ{
z8$&AQ(x?1wsC$#p9QhfT(>8*zGLbuerbWLdyG=hGgS1o$+us)BENojg!$oV>6_cD%
zDv$tN2)7Z=Ag!?c2wJTz+J#i%Cb6i5(H3WMw7&8{ILx7%cauxdI?CfM%)5~S|M=J{
z<-xcxeGSKOcdbM{m5^+cZ#51D;jN!}SgqEUU_?>N?1Bt`%-rjOIyjk%ZwT)qiGVjs
zFf@U6-mty<B2BCF3nc$Hy$m8rI%_XrAUth>XNVOLH*(J+Q%5!9$#qzAJ`h}Ra>pgC
z83kjWf7DQ{9))7%O+!?by7<=dj+uk3=_UNl!#UcLqwg>RgwKVZ6b2_YE5$|y5u0t2
zts?)-OtAQ!8rFS#)}}Dh!<n)Lx+w?33M;fO18|rp*JTiTPt;C9s@wOuFS2dgSJ2-C
zpuj)6W)L?oLM+e5m-)l49tb1bxb5vm7=5Nv8WrSj>MiT?!&2=h`e)zqDh(%#f(;m9
zmp`!GR*&fmNlHftG0#dM%<FiZj>DX1o+~77FqB2EHKx@UY<J;M<Q~oK0J&n<e5JWl
z)Dafg9W?$&+ic_Zi@l@-$^sWP78#mWwPUIYj2mv7Wm>yfKIiyOC=`2mw{x@UvF<XP
zS8;%ZS&IcI9k^S01!wu^92iaCA`87tNdm)hZXE9l?YLatsbZz*m(tDn6Gm3%#WlTR
z;YogJg0);xtqDqez*i{w((Tyw`~?}4N)qs87uraBs^CNgel<d-5QvW0H`&)SaXzOG
zoKz>?(}jj~pRsA2+5-EgN%PxOg`T>Dr;d*9fz5?6N8vSV(iO(zBfQ;~^o*rfm<<}U
zUCRef7YU9t4joOJ|5Fet-XVZLU{-0=4hu;d_>YjU-rT$>r@yXIg60njtdJQ*>w_`)
z>d#80rikXT9sDV)^Gsj_y{YGRoi^+a2{)e$F@UCqP2%PA)?x}?K|OpilO2T+bSqug
zrAO-hliZZ~FP4Idr4z7#jt}(4r&<eIozqh+5ag*_uY>ebgH4ue)$0VtP_puq0$xbl
zZg-BtMzJU5GeCA>qj`{`SOJEM>nrTa5g+Wx@1CFdF6GVpD*3+w@}V>Gv*xD|vsx_Z
zj56vqr6->vC`itkD(old%f5H>s#d8%kSSi})AQ==G;NSk_gso>L2+u%{cvSLXlWYO
zD5f*d@i~9K2Bxm#G8TxUUK)cf!R%ct(@fY9G){b)X3eE1O8Azc@4lb(M$<|{VLJe#
zAYtOai`ANykDtW@TSaI0|H^JGxtt3rdBdVi_1W2cb?!sCBhDn$s8C}~zA`!NBq0mQ
zx)gMBBOs^T#WVD^vH)q={KefkV&Vs(8?=sd*0BPT)41rrUDE$+z=kTeuszM|&zS+?
z>tMw4vDI6u3kdNGe0FtbIunecZd9h;;i%=qt(-({HE5EeE(B}Z)ORpsCQCNOKyx}k
zN}==AT1dVo2qn4@xUca*LEx(-YFpxHAVBeD1=6-H!$HVfxogyYO=K`R1A9uOU_j?1
zebJU?Y6^r3(}FM?(=%}CyOk4b4xm;e0ql1;m><I-ll<br<;PXisEJdfK`tInryJ}=
zzeQA8@?Y5A?tBmF*sLLi64GE7&)aWTCAzDM<E$=fV94wMJFhN|E%~)|Fvs)kdwelm
zPAnLYI1Uf-r9iBs=W-Bf@Z6H_D0<Q+-c7+@@kM63TMZ{8nO=?bRevX71uN!3hNCwR
z_f)`{!st>==9XUWZlfhn&Y@xrxjyq$GE!qsT=ROXW7VU2;J)vDQ4JmME9^Hx=A2+4
z8Qf??0kXY1nByQmMzl#nlVPK%mBZB-KM4Qsl=?G)OAN%YGV_OFWgVQ6tLMf<yuc60
z2kM%lR)@YvKq0?V%OD$lVEEG+mt-ytDUYf3rj?5OQhw!gN-;DKCVGz`7?%mpY76NQ
zAgLxxcH!e)2mwMc2@2~WJ$_n6_!u=u>?+4xq3X&a=iTnC)>?g7R%Ra)lgI%gDZgb#
zOI{ko&=u91mF;OCK?&MIQx>voIKQ~z!ZIyVuN9)YQ+Hl4y5oW<t!X0V@aK71iGrwL
z*gUw8bLztp0%@q@ENGoP5QzyLngtl^31P`OIVs@oh*3M70S=E!K;QGnZeY|tv}?e9
z4-|T({uspsxn23ccGVx*xOR?z0ie(wABf9SOtsjOD$Y0^Oo}xaK1lq-$}D4NDc35c
zN7N%Zh)X52;Kh6e<io+a8jE6_4iGEusfB7b3+M6_m67aHvH!S7B@q*gD9#nD2LbKK
z4oH4wK|hEGDYi?Tf>{q=te+u1<o^W0JGr6p>PjmB5*kHM-HJS!7ckC2Y|nPB{D6Ih
z5YAhif(s5q!&$p5oFAfcsaXM<JCAXy6Y)zXB~m{L-sXLUeH*o_xL@b}<EXAhEbJw+
zl+Yi*GTcI`D5_msw{ZPIwFK8(h5_6lDv>_%01-5V<6ubDD555TyDMNqb11c>_dc|8
z<~gfKf)rOW!REzG<3_O4=^SKEFh-^8@S?471X~+Z8Qu46nSN+>wDeK;4zax3Lm+H+
zTor_XGzN7u+09Gye00caKN~<3dhMtLvX=g?A`*9<@_3Mzn_wk}dA)VRCQc+U{oAx6
z8PXR7=4zPr+0)k=Od``t5G?&^P|icM0ICTD*xj-<bCaaD$gjx+*7L2g+ClKL@<dBh
zBlhR2AWx(1NU*H+!ZaYgbhWT9|A7K2qRdASZG;Y+gPqG#4=tf`G)pbA_PK)YI@jBP
zI(faf9EDu%&asx1#`MBZyF}*-uxohls_zbaujSt2oUa4X=GivWzsm}C$FO=WST5dh
zBHy+vULevV&0{B&g5k}XrnV!B-Pd65P?cVTxW^cTU*7*Bt^bZjoSC#zyTn6$fT%>K
z&@@(`qC#9XI-}#RJlk5=`7&iB;!0C!ADko4*{GyCw;8`_>w4XdSz^JE;7S>Q&BOfb
z*RG?KA7D|^qmbH4Fjv7O3468x$WnUw+v#6f-qu1XVHgNKw#EfQqi}=<^e@etMovEv
zwdUo2P2J8A!@YSr)skr^&!ubapQZeK?`PPzQC9jskIq2$J+3fr=_)>*5i8U<65*8z
zuy>j^zb?W<1195p_JGy6rGl?bU_4n}qp=x%?~lywxtdzGr#_V+%K!?Z9h$Xk9@OLn
zkgSjlS!E8Cnq5F4gDJ8u-MLSOJLynK;SmQ+kG}8mi1pfZ;norP6uY>hwbYUzKGm4m
zjPKF+s;Fh#xUw$kbv%#~u0irk0w^<Ck!PFAKeJHD+F}X48fVZEE3Pe5-0ASdu87p<
zg)Kkl36Lx$s$t5Ef>jz>X%+{yM|?9*;`}Ode12_LI=U3Y);PFP`qq4(L+p-4Is>HE
z7fO|-L8f*I=J^3ICn%p8E_dxa2*V#P^R(Kod9rMW28{VGQv2Qt@KL23N?p^zTKGJG
zMkNqxtak<u>7Kgpv9o03TD*i%r%gjQOP(QQ^SO`401~j;NcD>@oi(UJZm1QgoLQ_3
zp@e@Wz(a0qQi;5~YGU%p<{LHAL|kV2EF>#vKcxUq=_s~D9r)tWQVfkE`}K);?W~@=
z09wymx-9m`(YU6&6&hETXh|Wf+?a-&%|BXuNaIIHpbjH+t^BXi{MmJ&rG0z1AONS@
z^lu_ZX@7(L7D&GPC_XkS=vEWuy9eXW*o3f19zGsp19Lmed6eD@py==H1@vy~eXy#S
zEf@sBE@~Q8k*f>EJf(1suXfW=P@}l?$*kQ8*{x3u8A5%Rf!{UIve^M(n&K!qk)4it
z#F%w0b)i&e9v%VFm<NEKG4udRv4gNlv-nM;Oe|HFHi-<PLhY6-@_E!^5Lp7}T}<?6
zw$mxxD2LkJX8dC~DKC`m0>Butw#shVavRU-P`heF_merb8{`gz?*d3BgiKzeErD>d
z)<GYLmS|8R&Un+`3W<YAhId@Y%(3VSGv9W85GJFA+X~IYu%UtEPj(qm>EhUz(@+g5
zS}55b(zWK~4GLZU#AOYi+){3JW(9HVqc{+A^YGodF*b)+tQ6m|etnN+$RNbPioW4F
z-ag;UrO@{Wbu9XB|9~)79oVUQM5}p3*OIW(jT9sY;u1SuxZGnBJ4}`Z4Rl+7oR`%B
z$#45O9&1tFFnaD9;bb^FE-SF4;SjE73o;ror%*==#10sYMhJBj4Rs2VFvbjnWb5R?
zW-^XeGs<vWucM}u;}jmh+lRGDv=ALS$FB@o{`KK!r4&mMGAH>MWy>Ha)m^R4>mF6Q
z7d}f%1Y>-lAl+NFcrsnzOb`Ou2I%#_l=6M=3(R@HK>q5yj6Q=A|1d<=l#j`m+HcFb
zfqT57lTP9(WmQstq6mwO6K1cY9k(4z=<^1n?q;%EyIW8V@9GHMmSW0}i~8d5F#-)0
zOX9I<V$PogrGw@L<|pO-Nwf!H=65UKN|Z-(k{h@_$DBRhqpxwRWaFBb?ucewudIAr
z*WZFbkH>@u(0rM9#S10*{)BtGeUX=>rZr}@z%D`+VGDeG!~${+PQrInx`4tK(9vTh
z{zbOL=W_n)wkmcm*BO96EW5-bRkUa!>{lMLu$ZDcpUXd}C?g~}x0`)M*1S<<Ba{MY
zttrKUWl}1AE&W0gii#zs&R1sp8s%xEB6h)0VKUsFhg&u)7HtE^Y0D2T!_X$BVnY|h
z+10rg;3^jk=Z<Pb#|%Cz%nAbtKecE97Z}22xr!vw;4(-DCGN$95?;Ww3()z>#XImP
zZf-q-y`a)xD7Q0<Jd`PoI!dQe2L}lUMnM8?LA0gJSp#$zm5u<hz!Z?JLGmI=JH>wd
z7W*oWq=Ckwk|}2ng^#HRlZJ|I$!rzzgx@u_=EW@^%npx7034*}LK6Uq);`nGW@5R)
zT($|oUy2)id=bFE_1`B+7wUS+k=uk(>J==js|1BaHGZVw%HS@wRt8oJ3g+PoL3v~F
zTBVzE6XoT#PnQMf%9PVEyhkL<_?`lE$vxQs5S&pC_~bNHgv$#f_VW07=)yNCiIOtg
z0b=zGO&^*3l`km_ETt%oS7wi}gwZk^>I1$CqB7aS`K>4KQf98=kBtZ(%@<eD!VTh$
z)Dv4m&@Mh!tZ%M-%?y}Pys{n)Eym7oEW_yk5|Atu714s)3zNR2M;7Q~$x1&Z4OdCE
z9tvA;;v{70ovNiOn^y4wuk{so{mmz2ilsrsJY9BL>PwQj1?BaIe=??4mu!kPQ#X@3
z*Qfo%F7t|#I&NnoYL_Q9oYYCizzMPC=cilf2s*hz7=bSXz!_^A6O|{B_;DeYu<exG
z1`ylLvV{wY%68{ac@>?6@mtNpHc$Pn*uJ+3I-RsoDcqb1<Q)c97?4WfUJsWY!C>fR
z6C}Qza(8Y<l5G3=Y?=(=Y3Vds9~Qy4c3F|Q4C>3XExlGS(pN=FWB^Yr%^$rXyoU&4
z9XVmR$n`$#C1w`)gV;cK0>=16wa>+JGCt#6>5Z7Mz#^oO0YvG;G+!-rL9|mH87M~V
zc!EU@NPRdV;#lpSx2fQw)ICl{zL<iO4}`kzrtHnSGfHrJDo>cc>+4C#&oXYGA29Pi
z<o>rnJ~al<5B_NfzD=!3iK#44yQc#73Z$def48SKYZvMi3LDTb(DS~*gbK{#F2o#6
ze>s%WCbI2L&qt9KfFl~mTz|@I`AC@CGl#5EI9{-A6kEovR7p$*;ygRyeHl_*%ztub
zUy+_fZ~+VnZFhKLZyr`}Ji99{+vl(wkzt-1#o??bc?yVjLb3pg6#JHs;=dNA6{~-n
zRA4-iC@|g#VE>)~tR%WF4BNo<{RtnGS8f{pP*ZDVCG94i+d*n?3c{i5NNjRh4h=2{
zJK?AqqWq!?G6HNGZmX&hMB)C-2e9u-vECBvb5;<=(r1-oYsc7{-DIn1<zNlRc2!z}
z=!;ACSNbKEm5G=8>mNe+reR1P*q-W?((1c)+D&Ebk13tLqH=NmNW}UF9G?B6Ae}P^
z)zQ;#J333<|7ua|m^?)Cxqp!1(1dW+>h=$x2$xXrw#xYjp9AVC%VZJ;1t^gaO>5Wb
zFK$sB5^&ZIp6R;DX+dz8`eGc0t>N&-j9Jlf%f9+tY|_<?Sk6nc_Vg>mp$b0}BpwQ>
z24}RIwj`9L5`yXmu{`bTb8<NnGqHCisuWx4o|D^Nsksu>*4*=+%%>xyG4NhLw31w^
z-86<ttEB0B8PJ**S^%@cMkP2D0x4rv!IF0PS;m`pVEf+W{<lD;G4PGVCNakennLGe
z#Dg<2(Y?G+3?O#!zl3`a;KsN%g|qTR?VxqKa8>P;F>OI~Ec)F)oXkHUQFd_uAjrdT
z(OlNd|H{W0B;HeZKmSlYhXS=wI6?$}5@k)MM2gtn&I%7}ysfe6FzbRyRIlyBodll~
zXwE>}rhpbr>`u7f<GcZ+o*NB?t4N8F_7J&%b!NF)zBa?|BhnT2#P`GFZI1EfkZ4YE
z?(Q}B*~Nm*v!_b%>q?2NB72?Q&8Kne)vp~&6k!Mmd&6$*!E>%rFlaBtS?f*ZgSEhv
zA(sTePm#uU#ns~;!4gJp9=+TXF17V2J75~CuN$K_Dq<JD=(Uf=h}NnPB$$eyMN1M)
z6go`l-x_^fXA0rSdSt3Vei#FiR6oblxQLn{y!Lk2J&DnP@d<Oa@nnbE0p{TcZ@c@A
z1ay)#3_H_GVV9Y#`QuP-ol-#3i+!UwKrSc#sOl5q`Iv1n)$8kKm30`Ka7epC(%*PL
zzK%V08AKa~?t^iu%hPU0gAr$g5VbsIqtz~A-3;sb%c}P=zV_;UtkLTN0~7lb_Nm}_
zkw|e?eLp!Vr}Jldv&nC;Z;)y1uk&;w^LtRh*+s>w)VobouCj1=onLv;>mr^lTo|OO
zGe4QPY6v^B$I1<2@Ji{`dZ(&gTXBhj+yne^D^goCaJ}(CMCEJm&v{JQV;Q&g>)B<T
zdz&KGX56)U^Hg<U#vjIJKI%}->z^bLeDYIguiBrlk&$&d<-(Sk8xL6zqIkONM2Us8
z;#*O4NobliV*voaJt19ihJ`na=Ug;Xml=i9tdvI1VR?=Hsd#e{3(@)T-YVM|U@0n}
z-EhSG$Be*IXFD|Zrke)g&CdL)PkFp7-WU7N!A}ayZBGh&NhG}EnHXFakDJvt;awWg
zQNYw@ED%b&IX$VbUKHMI#to2?%={+MYne<*EqM1iky_h?<FbBr{K?!N49I4jZIa`C
z1rAty>eYdHZhekVIzI(gh(@GL4&XZ)guA>zFy4vPMf3}QQf}-H0Ocra;k+cW#=E8!
znr#c{Jy#ul4T=bGFhUDaID8#5e>ADz@8pPEr+>sVu@^L@P#~uycFd)5FTRz|6S;2|
z7A!RrOjfE<q<v5K!m_iy;5QDZh`^XMqLup^mg~8UU<BlJyZf6nfl#2Q{kbf9s&(we
zUSsOvFAG9hB}zIlTAC9YuD;8ukA0KfPl&^QNb@JeN*|DH_UZR8PP8fC;N&+DKZFII
zY@}`zB0Q2{6MK!ZX~*fa7$ew$>5AiPEtet&t^b;v5ekw^)a>4ZCW^R-^vcg+x-K`U
zJ@>h?&?2xdKxhran)n0VA&P$^ZnhFg5r5Mv$`&b?@^S0Kot{!BIeQ?|krrCalc9;N
z7_sK@tbDS?9m+LGkea@dX%G~k(|BkoW=kNvznl_|6NjV7dTIh4xQ3KJ(E#u+XV+Jf
zx=3Exm1oF6X$Q*=wG<bC;CHP_Ph5M-Xh59?AUt~jt3Uc!ZvG-bj4dq<0|gURDY+3;
ziF5lkGP}*7r`)iWX?ft4rEBab3NXM{e6;#Ib}9a@UP-&3O}YtG!MVj{;lcpYa|N~m
ztuU=b_Z8`MLCe|)Z+ot&c^qd1GRi46DeSoY-qV33(IEvRCCO-@#jkzlILCA4@phkX
z$jyL)&~-L|1U=j6yvUnRZW_{kER{>q@fHrIMe#*pQ5T(b-n4W%huQ6}Ls4dNZ;m@I
z!it?G!J~zX9J&Rt0&l`0qqWb)nDf-Y!jw_8uy0Nd;!3LJ7`5;)Q&jSy+S$CN>K_?Q
z?Ue~w{w=5MtH?zF;-r_RK}QPzHekYw1y=iw-i+%XcG-@j93newCX^!)Z!(G66L6dV
zX3P8og!huU=w_b+!$7v_AN5c6qGp#r1bL3Z*O668XBM{2%5*hKBPG0m>0WCdcB=y`
zh-;wD%XaE|6sJ(+R`NL>9XGd4%~`Z4Gu2@FnB{97Xw2IP&~?%#;ZZLK52l;ItxRUN
zJLhR_c=eYo8Fyz8f;W+1k#;ksQSJ;_n?({LbrM{_Z{AJOT1Vz>oGg4dOew1mSdS|N
zk-Kcu#9bH(LSK=85AYC?SjP2LSgPGA805OU>eOYL16Ts}DOKFqIVkk%C(efIDV_uC
zDo6L6A=yR6<=i?p)hqvP0TAx=4j22@YaMJix?$By9EOg&AhUTac|WH&KVe*Ibr)Jf
z0o3*5F73c2ul8w_AOeK)?~$G$S~5q2T!y+~qstht^C`)NC;mavNGJelZTaq+2|6F<
zYfT`1G;qk3XIa`fgRtG@6?BI%h!p##p&fcQDnDVg^N%9tAlhd90~aU}H>Mnudmph%
zx?_A$0*7VoT5L}i%mpaqk9Cz=Q=aM7Arpu57*cS>dagI)ZP=+x9fZi3ChFWT5&+cy
z<y*vwW1GUk)b(ji<>u#5_=Mj_Y22QNp~{$r+Nn(|69gSb;l|8Z5dV8VW(vp`>F#4k
z-mNrw|NL*O{MG+XNAyYuMA=5Z1(x)d2xTW$f;=F7XBST*AU_8Of~bv*O4BfR<Y!8X
ze0xd(X?w&vSS<{Dr-29!K#lg?2QGD&4u?QuiJx9>z{@z)D5_Ay2T1WLa~z~c-Q_b2
z7-A!gaoR$~26UoYVzBozr9Dc4HTzr;zH5(Jtg|S{e)YoVQa!zjkbv>S9RYTvpA!L!
zT(~D+C(g*1N(OtZ3T_ccQl`b{pTY&w@a&T%kS?b&$!L65R;0{j?$H2A^A2ZpX)p?r
zR-9g<`bv5A_yE%%|ECP|3y1{1%LWGPx(eMPtCO=u-WVXG^V2qhO@N5a5}6#%CX{K=
z85J3`j<&lJ$vX@9w!_L}osU8Dt}h$KtlO>6@9DLnvKYKgdI7IZHW*Pm9POnaYt-ad
z*sbHL>&6zLkTnlW)as$7eNU9&(u2Ys4h?&UBaG92t%Siy$6h}uX&peMk{Rl;13PFb
zu(W0ms)zzWY6h$uARfStRs^9k_cRFl5Feid6B72w33<p20l0zTbB!+O7^E^me2GxC
zc?E-g@1rRO_}}JHFC9v9fa2KF2CFx2UQSYhfKgaHF~A^YPJ`$I^v1}kNVO$ny0F*x
z;Ji##Vz*-75vY_Nh^$mEn0%2|Z{vIg{cXUJdv-<x;nrTc><^a0Ydy`;_t<Oa%Zm;{
zK}v3rszuEGHyY(J2NEBLyCTJQ$<yXu;#mmm)k62Dte15QP{3|l`OfkQ2NvxlMFoZD
zxcgz49!rt;Y#w!^y@W*R$)P#&ID=IjWs<W4K`Nm-Q;@x%Fi8HQd7MfN5%D+;r6HBw
zd`}D*q+FIoFjzbupeIS1Msw8Q5=?o}={Vn9-nJ?BlC}lGPQ6ms7%Ptp=;9JhfhZWe
zq~<w%2V#)V<&Kw!+~@W&?zo<_mbL+6<BhXSf9_aIE6kcTAN)X63lb=L#ok6Z3sh(8
zy)8W3*-AU`Zh2Hu=X0gSlY1|%r~J1%OB#T-X`1b)pPMGreMC&?OfoFRmd%(OC3rWl
z4V0~kpNUw<rHaa04w5Nro1~@Y-vbk^^uQNNci<!{!vZPvY&(Fj)NAtyN!=ptiWfrg
zi%5EoW}{#VF`3+6E!&ucG}>ii2N6Lwt0V=x&=|}f<?>9&azPjar;EWH`;6NAPlAoL
zR&U>3XpVW0p0m=L(tNGhqTE8Oqb~*%S?tk@L23x<xh+G&N~%bRVqVqmgQ-+jhK#u-
zBzBNC<f@QNtXfSvh^TbaXdG5{AjZ<-RSLxt7ROjIcGG?q^7O@5*l&SMWl-+2q(_bQ
zw2fv!l})kFp)y-RwJs!%qFI277QN3XRI@D*eXH%ga11gB!ez+EnCZp{BGoG7_4H!~
zHxdUajcFcp#_2d`=0y5jd8?W_8|7DjDCrt8CJRA~HH{~(uj(wdIEp7GS}#J36J#`u
zfpa%_24Qq_*L#wW8yiAVG^r}hR#RXAnjNWx9qy@|Y1$08OaA5BM;e9SEH0v9rx@Ml
zP1W!?dDaJ)Ys0ZkIcfEQKIb!RNe}RG%|3Qnk5A9<d93U}Bn9g5N@g{QwS{B|Qv+~o
zkGRwsPk`82g_X1Kk0;y+aZ38Yn7oNKUj`smV;!^D<fHluEzY+lKSn5B`BWL0qK*_+
zJxlGd@MpS^zmlKO!L<0DQQRr4S_PzLq2>uLY!QlBn)7wH=RXlC#Ne12wLI^hNUhiv
zM2!oJqmc~ES&8B~^tPGuD~+nRFmj(PMK&W>FUScQf}9)dJpjx73QNo%10E~M52l^6
zhfou{2@B2;5v0>$IDf2#tx<ei<i@7V-hoW)7f=-d8zO=oQt-EHDjj%L6|-PK+q=^i
z6sA>qVF`AC=n0d&u>H<gw5Fu&ktpe{KKgR~eaYL;V%oefu-^pv6nfNf;-puL!Gzv7
zGl@V<BTnH6?w1qWmd!wv4-)Ld-*ofHQY_Q`_(lo-y}P;SO0jAJR`k*P#>!9!;^Jm(
zph5s?IqIYbVmy4!@6#6=W@-<3@uLR0&N1!A%sUN)#34B6klw;e*ml7nx2E>ho`P19
zvn5BVh~x$BIFcS8NQuSQGNH#8E&8C_<ZE)(!axr5a`B>D`Yu%nrWWMQa!#H*BlgV!
zm96dNY1+G;1leU#r;{b3?^2i_UZOMx4QAf}vhDUwWp_1+cbwM9ds6u#Hy?2Yd(j|C
z;ysn*+?EJpNA(^QL-<EdZ7-thFeuhZaYLB6m$LbYtVJ!(Yb7CJ`^K3cKjP$jZb}}Q
z@Ai^A*(yKSs3k#r$6d#Br}L*;3(x5!KMxEan72Nd#gb_S4pn#(lb6gWJ&qdY$rkUT
z)L>%KP%hyZR%pq(lp>TJ#hH$${IzK;pT_zfk9QgIDERWS;ZB|+=3!6jlN>g4@O=)=
z4h8h$^y+UE$S(pX?%sOGmlc6V@Oq4zgRRhcFb)YdQ_A)vBv=5N5Tqmy%Q60P-6?%R
z3?LyRRx&2X7X(>9xDbw#o}Yxy=f1-}Ar5;)^RJBgt0FAM|A$ALXRqkHyMOA;;l@2Z
zU`02+60tuyAk`{|sh^A46A@PN!;e_0Mn-?@I(<J3Bga&WA}Q&2Y#Jh()Gv%IwIrRD
z_Kr*4jw;U$GP<1N`XBXSfY1)*>zb#PB8@>m@{rF>0j*lpgZUaD`Wh*%rH|^*1qE=R
z6Od5GEnsbixP@uaEK6<S#K6xISauyW^^Oz&aX`tWEZN%Sb)uOkxZL%GQj0xz^$j7c
z?>E?Qf<%_qSIX9I>QK&dqgg`&)~|UK5-L~^QehzcdflY+l)A&e(V&Ny+Qh6V2yciL
zb;4Q20T|(yK@@hgIhs-@E4eOR!yn}+yhtfq-^WX=QCzP0z<)paWs3@dqa~c39a3|&
z6k!k`QHr%>3yVTiN||b@jh=@wJ>a{t^xdMu0rg3?MIJ-PM+C<58$NchFF5)>YCkCS
z6CTYAyCl~$G^j3EiBrQaX=J?P3wg>=X@lpo#5^v)D8wyi&<$B0qWo0sq>5*wrunrX
z)5?a{W7M?*4-YwVj%h(o*9sKqDqO)N7llhJp;)G~Q8Z7_H+GdoQV?0#b5E?Gi(I0#
z<~R{dn~Bv==*5sw2WyDve#;7F@Fq^<{&cZ`eVa*0*VMJMiv?vT_+y<DAq1mb;#R`>
z`OOO1Y47ntxtBF3FR&#y{m`16upJ1XSXIAnNY}A4&2w}L!1)BoqKsBAtm+a8R|z`z
z-yT=#=aX~WB5@IVY2fn%agt@NL|}2c%W?wLu4ah4^mF+=Nf0S23sq+;glL+>RSWIv
zmoh=W<HrZ3V!QffpXY0k6T}d;`|UATilf?61$^5y-T=tA;+O1bbjmgaBYkbZG?#VV
z#-*zv&gS&Rf?(TH%p4yMtEBTeJ~?h4eU%~)P3tF%P$Zz0h>h!9R&w6BsM{VZxi>Gv
z$G?nFHWdkyjz~~;IDElyF0*+^&g^utE{4)p+o*H`+Q*18{Z12$l`n`{rAK4UvZ`mF
zCGUHWi~TOaVpoUB4+E>&#pDIA>0?Z8J4X}}4~hYvvTNxTa#A045Gi|@`X+ex`3?3P
zAkOE<a(N37g2{4*GDdzZ7ff{Pn;6AIA^ierf*rOv2k6lc+VYfo6RdeW_sW>mPO1l%
zS#=rAegoA4`;94Hf-4XGwkT}P4CEPx+UD`KcEN`q&N{yBhhedr)qMshwG!5^7})ha
zfqI%Um`begfpJD!-J-j?#_7{l>{pF_SdSH|a-MqJC{{1G(KJ4nOD`Y416y%OQSvCB
z{qkf#awRL6^pOAkisfE4=)xi^c7DauF`-3@Zr5hyi*kYzBRcxX|3s@QQP&~$EM2Wc
zyKLhUc@$T&1udB)7h2hmPeEP_R2MBpiAi!28Sf>M^+^O#-r@@oNwy(Nkdkm&qR-`9
zZIlJz6(s#Aqt^y_p*Eh_F16h*W$n5&>%<kYJIk71`kbmyqRf(T|4btewWahq$k?4#
zJC~qM1>_HO-O72_h8IM=0LEcOPGt%QVPqP@FwGn?qun$BluH@Jb&PDY_}S1keG?nZ
zI-;FeCq|^Z_rsPExVN=}?3JPJAM41?(TT<6CR=N1b~MP}%@*ez*VhpM)58gFQdZh5
zQn)LPaeHZnBMA8q7IfXGO`>@14_(2gM@9lL8UdbcR|zBbWz0ii5cA*?1c#z{4s=cV
z?GiOSh`F2gLZ?Pa5yb6Xv{$|jO<x7Jd0%0lkiB&<vHpZiU<dgWe-3%;J7JGu9Pt<R
zrV@&Q*oo#kxeL9k?eOP<RHHM7VV`;IXLVV*mO|O`uR$0!?`lxx{@3rI2C1)NKfy-g
z(i%~O57Wi{T}lt2tk?q+xU^=1O{-6^Yx}YbqiECiY!baqmtOojxUF<U1`1J<l^7(|
z97IQJRy>&ZNjyW5ZtrGD5IJ_=QvvE_%B>`N43ZD#!)IQtLA%P&ck3|bm4e0@WR~p;
zLcW{@#4E^CieTP1?4bbsnG4e>mkwG9FQnT56svnBz&~n}Kc5r3HI2nm{5;3o&(|>t
zxin#A#n?S@Lv}X}g1MJ_IYmf;QjIE<?)4nO2o4H!qCpzh{3DD&l%%8ZOlA5G!*=1j
zLGoFLU-zqCd8+45cPy->?L6Ef{p4sd@ZKF^kmM;^CtWGU*Cr)^MglO6alz=L+8Y}s
z&E-L{{6jkTK(Zy_L@V79M{9M?U<h^Qi423}!A;N#)%<u^Bv4^K_JxS=eQqA3Om0fU
z_b^rzS51qb14ysMDIC_LGlH=p=NX6;X>z7oZWJ}dG1xra#NN)qy|m`pW|B=2#N-0C
zgF7teT`XRXcG-hoUPtDW)O3pk$<q-vNhMQqJRMKqB8UX31i2lgh*-!>vs}ZOhmIt}
zC_y&bY*(C>=Gn?oZVc2<a^Ck2Y&v4H{|PbgLmPaD9Ib)N_PU;EwtFc@!Mpv~t9*6^
zF}}>FM`L~&8+jlSNYGL>=iJ-Ncu>vQm0zYgAcRsLDgfStlbcOi06YW(!<915D~y>6
zRu<WF%Mt}zRhEKCNxFIt{6Kh+P0I^ZT<pM>to5VE$Y!(VdF=7gnh$DS38K(qM*<B<
zKBkICS?5%brZH&!k~@@RVGv5Idkv9_nERe^XsNTl2N^Yw2?&TjuOP@#HNqbm2}%pZ
z^LNG+=bsB-F~WZCjs|hg9F#_hkorv~I19iL&V{Egm>PzKe*z}EeS}y(?~D>aAQiF3
zBB8~Y=^kRN^XijdaSOB%T6X3})zBIJH1vMCsRoYejGAN92d>$CYTyX~NkF#0&y+^x
z?MCVOZWM7$y$8{Gk{;o!k(|SJyxKk|zNw==CZk$y99Guw7-YZ12XQ6nnuSwzrg>T}
z+X@y$m!WmabywF7;wo4)h%Js)a$v=cD3yC+<Ka@Zs+EXYmt=zIZfPaFMrnPJuA6<a
z3Z>iUlm*NB#ZU;{v;wQ}jp<|vkAK1~sD#rih_KhDV%q?D&ihZx*$;M>7(He`&w<*f
zNz%+`RBeZ(0NQ$3H4ZO4Q`M1Yz%T8Q7VO2aghw+@JA%<lGi(qpHazM1RZ=Gde+l^V
z_pkr?DeK~$#Fj+6iuWPz0?A$g#|=F}p18B6P$*UvF*tY1sQhves@i@jl`gx0<ccqT
z&A`)wa=ip3aiG>54|=$&GN8v_hdHWUx<=GY3g!owdI%zxaLfYZJ&ekEl`O&5mLfcr
zKvWEDDfXmm`Pf0M*iS1DQiV9kGK6gtHe=5`af(e~C<L3C%UfSi#-GuA(FUjuO4jL?
z3n&I5{KasEn1sE=hzcP$5`z|+_Iz9bZF);$h)l)3mJ(EWOix@00v8a@4;IFi#7LSF
zK8`RYev%RMc3UgAsbAA&lh!w)ZLX|9^I)Jvw^9wc8WBo}NCv<r7(-h`n{yYSWJ3GS
z4T8}Jz4x5Y^Er-?YE4TyaXFr4WJ<cUkbOIyF|yj7x7^xPXE6VVk-?Pz&gulD1E+yl
zzBV9EZU;ipJe#mdZ*VZdB513F<Ud%6ia*&G-clurP{*T9mvv+X?AD@Fdi^@&xt{@o
zE?86=E|e2X4@Emmuj)0AbXPaRa!6Ea$6*Q*;|$1%4GNWFU$K_r?AfNTWUR2=Xdd&>
z!L5_t$+N(kZnGpmcs$b>ixG($xj4o7gd{fuPv7j#-YmHP=7LiRq^GBrn?zW;c9PIx
z(D<1|_Qyn1X6-<Pk&U4)^~)sjC9lPCM@^(UQWLlv35?PYlHwp4KMA>cUttW)*HPag
zsSJ)BHIxu{&bkPs2B|-_B1bMfRR!@g+5VXSt)dY@kxEO$u2M?fAp+zf4Baa60PC~|
zDxnM|Eo<CL5yUk-{8%ay9&#rZm3nH6fsX1z&s|T`RUJWn&gnJa5)Tl0Kxjy}Vm?Zv
zge==I5E}RzyTxa47LI|yv+OGkR~k+F!_qSsC6QNZK~xG6-<E%oM<+yC>Mm@S3uSSg
zgqc#B9@}w%)yeuEf1vXG5~MSIAd+;66>4Q1Gp@dgq}&8JWXqC9wg^x2fB7Sgl0sSf
zjQ=ZifhKZIH4d4QSITqEGn`qImZBS(T##}hIB{9k9N~0EhO^H>RNYDmvGBBA(iuH^
z)k6Na4Uj>C(C5!@j7;<^m$ymg>tpFIHU!ZHmog~8ZeeHBKDUqAx2!J22@cLr%sW7Z
zr4YxRk*b3dG874@r5wRFNxbvXGVhURWr;<f=p^r_hKVLBtiF$yTGWP;{2*Q{7<Hd7
zS(+S9TijXl?W4FHUSrC3>aO&;_+n?lPP`yz;k-Z|5)hMJLW!B=?qI2mQ<+@zau0P{
z4Tfi>jJYo^n)x1amP&;u?n@U|0tkI(U3f2fSV;lb&go+CI&}u=S)Zg}dETUlDV~+!
zy~rlD6fGvCB~Ni-ek$42SmC_iq}47zU=M$m;7`crO{Tv?j_miLmQP#RR-$juQfL+{
z#f0$_YQamQUx^VR6MbHPXi5Jbi<-kv<OfS$<Z|SLFcRr$nnDu==6243K*CTZ1mW-B
z9z~=$BKnm-@4h0fX+;R;fba+|1C;bi@>9jtMjJ#EBWPK+-X+6?L?P46B~V#B5Sn==
zfWa`j&!Ji^mOfQ3uGND`5O5LF6laX5*~hO86eIFxlw*o!Rw$M}ejY@f$nhA&lIjhi
z<HtWlPz3uv*pQMPubBmg<ukIUWRM*kfIT|1(jhL9Hi&!HAl69AYNO<F>6zrMf`K1g
z$6E0!>5|#*AO^4W2*QY;E!OA08a!<fN}^W2b4&AXI~mWQdUXZ&g}p&UOE6-O3McoC
zQ2>S!r^Vw%is5^g&MU(25zs-Z>sLBwLt8u75xM#vuc!=x&hVUXuF!BhT5`d(k&gmp
zgc`yp9G^tEQi2iOo$tux2)QOf2(Hgz0e$*6cq_57aGS?X*K-KsFGPtijZ&e<m;CP<
zQthl0e6sFHz(#Xk<p6MaJ!g2Ho|v&F1@62goWm1+NL<}z+&mEgRy$^rW1YaFuWRI1
zf}SouWL$p|x+M4u=x+ijHKrRA@Kj?9p-@~&ezRbC3Be>ua4P-DlZpu)VXh|aDJ+at
z%L4kP@7RalW<U%;GsvVDJwOG$01N{Ny{O66Iv^i?5KOp2C<sH$bulIpC+i#2GZ-9w
zgroEuLk~`xQY3Y91@rmVhPSfFsvBYHK-BbF38W_!?GeRr7$yLN%0}5`zj6^|569L-
zgFl=fL|C1bs_#GrueEYZXqzCCM_3F*dau4b`lDax8ANJx^N>1})Sf~!)MBs;HbMC1
z8mGANm^%z`GmBqNR}ur<N;FX-vOXmydJyUqBoyW-H%9E!MT|P0xIBF?^-605Q3yK_
zHliM=3?O%?F?c<m<1LhqJF9p1JOB?V0P|5eOHg@Hcp(U9?@WV>F3FAv#dUqIcD?|d
zvj91xuJ~=*3DMg*H|&g(W3bCH+6RS|^6Zk{5;2}JSm$7c7o^4JaK>qqqHv0q$6@Kh
zXdvPXEBS%Y8aCtS^b8mYZ*@UF-;9{^LrN~h7bxL-AX2)`V{u^RF#S?QbxG~VQX9lD
z#hRUSVqm}3pPI(UJJzQh6ER2yQ#Z)XG0O|$R&XKGvv{_Ab;85l%v}v8kN}{15yc*{
zP-&C3_3)q!p|@z<rqR8!I>~DD(=s6MJvx!<=XfQ(N5*&B$#|dpD)+wylE&x<gSqAJ
zs9;}ZHZ-kfsH^P^R@+w)WKYsRQkt9B12PA4q>5(K27?ZbibVB2FYy_K_lu%@2bsdw
z_9wqa6h$lK_h#5&J*2!YNxFF}agI-~Cm-?bz^NyV<%uf!HcxrybV<q@#~XG~)?p2(
zRj4;+9Y$+YUG_GOuu42KMwIw7_mkAt?@Ao|Ugm|Y+b3tUzF})&L52y$0`(nlCAB6H
z3apd(!|YVewbM+SRBn7tl2uv~qF&lvi=;GBl2=SKc2!eCkNf~Iace4qRjF9NdG)*`
z#pWF;mO|cb4kzHG9hinYTWT+|D&{SINQ{Y9vFwyaW%Q#omemQSXr{N`4%mdFS~MfI
zb1YwyqcL8aO9j^is_(b8L>w99PHa^3GGcUpXwoO#JXk$NwvZ`;Kcl*D6vjzUNWlBV
z5ac5o34(cS(^70KgSt^oS5S>&5z3&og%%jrgf&Q6db^b96>@yQO8wS!3n`fZXx-^b
zF~auQz_}7!1MgZI8>K-i21ZX^Y(@#~W2p53i*T%ze@V;v9ya%T2xpW|V8;VdRg0cR
z6=-w?V9CKjx-Z?lc6C2%8ITA;LZ#tGEui`o*#k*rn|H+cSJ)?HyP9BsLVg|dsQ{?6
zxGILrW9Y5`?=VCFMNu9Ss!?75^#_BLqMdop)j<z?;HL{x4gozm(mXn=>}&HJ8Rym2
zB2#l#qNbb2Bjdjv+ORS(3Sv)ZC7D(BO44T6OrnD{*Up^3r$}L~^Z?JKi!}n%aNMYN
zz?o-S4o%searzwmeCN?LgT=vT1XEnG9%rXZ2ORFOf*^|&6u=Ydvnkg*8q`&jv$n(}
zhUM_e2OU|c@{<vtJJ0o;%=B}KL8QRX_tijg0tcJ3b7X-GO(|08d8`vhzOy?~#42UH
zg=)egQDs2d5&Ael$Si{~6Dl+hh1~T#u_NoX#_vv+2OS+2|5cW47GH115sbx$I1n}a
zhyoK6D+{UUwIl2y7xVEo>Ms(YSk0z=UpB}fd!vd0%D2xY<hC(neXWxWad~o)2}I}d
zhqB|*xrTwEQFjZeC(QCgT=zd)TdW@ekc+Q0h}$AjKwQChJdhqXqcUV1OKCUFt!UFq
z@fO$&(zEVkoKpBf*xiYu%puS9!1Mu9q=gfB-D%TZG%8f_WruF|ri*z_hsE^_#TKHM
zxWB7aUS>!cWDX<B(t@IiK}z#9&(=$C1d~<5maMKzU124w%RD8*L?NnVVVOSjC<uo1
zSUB{tItbE-gj7c2YTi#m-n1{EuK@QQzKlp+NaQ$O-WR9IqwrmbwGp0C$}S(prGi~h
zu0bw0Mt<Ed4rUXInsRnDWrnD(HCGUyM^t)y_qfaS&uPlibw3j)G;IN=^SbEiYZY*U
zt&OHDqr1G>_Y1Ag&CAkoL9~~J-|k-8Q{Pj-haW#Pol}y+au&gZR%LObzIpf!A{Y(7
zA_{fw=7IU&?pexnMg*o{x;@vD?nKT-MAI@dDC+<S=6dC>Ub^UZrpY#=?`kYlkFZmV
zP+ucla5#xVa?})e?RsVl$$kPjQw7+Bj&HbWCA*FmN1r&F{0jBsLh`FMoBqh7;c!iU
zdym1_NUIzy{2H~cqtt~gb&Jy}-7jk%dlxs+7hG8qW$`ZX4#c^k!R*PS=VzL`B@SoX
zJh46}5GsS;;heL(XTf~;?I9HC#rk0Jc}FFW=kP}7Q<C33)=x3>nUJ{@Y9gFr*FqJU
zM7c+(Wja$B9B(wBsS|5PMW1;IghM-OX?J=HF+_jHaQ@Mk&fZ1kUbPIihIOo_6mxXn
z0@d-{@rZrn#QNO|)=t>xkX*(EuR5Nx=OE-sGrs-mp%0s}1qGWRRK56MC<#)n@2rlf
z^sIz<E`$^1;^=W<cZHe;=lw2Qj44{tpiiQ9%Ol9S{_ss)3D7s#Z-E@)PlYe`k*uTv
zwPf@286o7ISk+6^I}%cpHlNT^djXi`1E3zWI3h+Ss}mZ8fNoq=EY7@<Q#}QQksl}7
zmZ~9Mz0qx2_rhxG4tDONt+A3XzL2RF!(P$o0e%4zzo2XJ&GR{Klu@}d_LLh}0X+a~
zW*P{3w1FTLjA>xXN=26Q)i6-G&lJiTB_Qbu15P|f$6KQOovz&HcAjQL|MRK=xoi;q
z>{>o0&0sc7fKfQm=h8Yh9L$x#HdTfu)&P-_vVlrN^<k9L>Zk1ESIH@t0%MN&mA>pz
z98!En*`bw~7e03oXTp7bj~6$K5v<?w@&Jt_UTvL0s1`g`wYOU`LF9i%1t!k+N@~%K
z-Ze2QUc{cIgo|#^yEWCA%a@%jPoJZBOSF+*L7Y*PWTAhlH+B58aX31V#l#)XceE)P
zqaZ*!N*mLR0i=)nSaQzZv>(~b300V@g1>BY*^DsGt34<2K&SgcBU5M_GaQPi<f0R0
zTb8OfD{3AIwR|;SSHM!ziUoylc@GdNoiDnewUJ5hv1yo)qZ=YoqGtNo*)I)dxA5?J
zpe&v*<vExtkMrvzL2srcMwObHq;S^`U)sP3R}o7bX&$8>bwyZAU~E|w6rYgtj7);k
zlMt~9^*~u4;X#r_m6I9bQW$F8$8!H9;+@XoKf$PwFOctJ%;PPT{mblEwWFQOE_AJk
zISH1V!n2jOW{0cCGd{9Cj>Ay!t8hxjrz)deFer3#C8C6j&(z&*iXJ0aNgUKgNDD|X
zg5bxlDm5>a!OsXr1)v1q62tbrv2T#io<1K|-kDJGHu(av8R6KSJI<vvT1@U((`;Nz
zJBZ29ol)+4ve#>4oOSQ%9`5FfB{Fq-Ts*Rb4@-BfP8zS9RB0l$5=@E#BXB>b!h=w&
z&8sFeL7>;l&^M2}UDs~OWFsAgOG=$43qdCNtb*bj2(CG9M!z|)yrW<ZCcSYam}~kW
z!5n}jxcg70Nm!q>)=?PIB?+!myHQePM~1wcL8vGUe>x&Wrau*iI!#;1_1^JllWbOy
zdW(CpO7p<U!b@7h3d|)k&C276a!{ZTw@tz!jtOrtcmTZkp@hPzDSAh1-w}Wtyt7h2
zaEnBe`3Gx@{UcjCbXX!%R0tMjyNOf;;BVkc;f6~kmGRiT9`b3Lq=EPitO%8O$6ZuV
zqsXM@>p}XZ@<Ak?h7n;=>E2jL%Qhjvrpk!zX$l_S;sj{uzxOVik0lNLI#(<?xe7uO
z#-i221(CMXkD_C3zR{EgzCSffFxsmdc{qA4y8dKR?EI6I`qWq0ZqfZb>f0FDKQgZ*
z4I}m@V=|fdWf2sbv|p}()#%sN#oJvi(rE$us8aoW$;mE6OARFR#mqSc2#<dnwV=OC
zpB4}ar9AlelZv<u30LCZ3x(9ODqA{$jaKH{^FsV&=pEj(7<)@dLm1r6N$gP~R;lV(
z#cW!=cfrU~Pis~3#yL6BoCZd$&w)|qUM1r8>1?P42QO4cC3RsOrD&So@Mv0|h#;q;
zyQs3~)P!s0Gb_uJ61%MFxR5u93@3)u`f?)eD*OxId!o_7Aqj*B>utJpe{Gai{F$ho
zj>^_O(kOZeYj_eej_W8CB!8JgBV2up)3PQkpgzlr)wRRx-x%?yEfzyFGw10^zbU_t
zotju|(dWw&uCb>itbS`MA^R+?VuKwlkxX$~xW{16!A=VVp{Id6J5ENS_E#As{3x0?
zDfycM42!4P5{%{T={N_iJ#FaVuvjTmi0{LqC}-G@kUj$j#W737?haNIsx2BI&s5M5
zgxs6v<){#vQi#^M9$2k|NyP|ClO>Mkde1@D=$I_w*;NX`tQr?%UiyBlhIi;FoUX~a
zm9Tutx8@;Gjp^g#La=0H9?u{MoCy9TY^kKLu-^npbmIU*7Uh@~Z7TfxSb$>?qS*Wp
zwC9l(UO>1_u~`rpz{<E{&ut>7ehO|8q=U(D^ky_;nLe&@YfrD{%=0z@xKD|G)3V@M
zc`)H0mIJXVpQGz{m6q+K<Z3r(BXM&2lq56{H!~6Q=ecN=hnkmz4vj(N%vw7U@DKCA
zY)Um2jK=o88bm9=2N7=&Cmy~Ucn~Uz^4~lWTB*i0F=9reY^KLsPorbgge|@QSu-Td
zy5sRdX)c>$fLWPFVYfQX)?ijqp-0<2^#U!NYANnLgUrLl6<C3F^;u6gR+35Hg2?~a
z0JpdVUp;4vz{5&`LB2yUT@@aWE-+AN1SxUrP*6+Uw=||)EgvjTJuloJnNPB3o}xe-
zm)PTdSSf?qLd@K`yR;n?OVvltWpcWrl^U^HNaP;`5%!<DEe|H~2g9Owj^VBOD3nN`
zp%VxnILbM77g0OMM}Z`m8b)iCs$?6YfYYD=lvq6E`s&#bwR@hiFaXme=#c<!VgaJ&
zB<MuPfYggqf-+JPidusi3(9%iONjHZV?*(mLFrH7Z7*EQWyJDMvWPC8*Mk|0mkIN*
zKysmE6I;p(Ci+Q_YHiZv6Fq_KYeHrTl3=uw5-UjVNIpxNm!h2h)_0ticYyPrK&p37
zR89AuN1bgdW+Kv(wr8QAggmwORq*$@pGSQkGnK(I=F!x}osd%)Wp{Uf0w}H7Z+$G8
zQMbL6t`lcYJ8%(x4xR%8$!S5kkVyZQ=SFE={RfQ#DP0>RRBYOOz5O~(*B@Kjg*YE$
z1~5c}aJ>2qh=cdS(^|;u74tQ)vgG|hx;_p_fkK7q7UHRh>^$F}F;5YtM|yh6G{o?v
zoTbtlMIH<)4ozdy5$Bg*5L&aYwL!Y9(lmN}KO~JE5tN9hNGki+MlLw>Bq~mmDkmr)
z+6>R<!ik{5r`WA@6PD$YIvo)y{i{VV4ED7$GOPx<G&qr`M)IeVW%-nJKnn2y^pM&!
z;pDgMQ^XU22ik?;<XvYtXK2B;(oOO{6esW+BeGD5x3s_gB=BA7nSNR0ZIY@CnR=lL
z8j@cvd}$g%&8_NhC5HIYaWM4v**dy9h0r_2!Q|EK-84cxFAhwbC#=B-gryg_)7?x%
z`lF3HtwjH9J>1qA6-E*O<UrUkl<S$xP-36iT))0L>W((sVn^sfxwNt!jkBm3v8<zE
zhg}?l7N|ZL0jrDJQhbzh9I+OoWRFz<^V5Vm`FU-~#_*b><p!;p6=x}|Hpu)14dole
zcm#rorHkWH&eNGkt)zs3ydE95qxPD{=`iXqsi7xJo5bt_r~<2Cv1l5MqiW1l5R|Bj
z_H0Dr_!nZ`4!=M?{+m=y@W1{2Q#pv#9Ni!(xH^gL1TRPY+<{U?{ZbJp6UydBw4I`a
z`C?^52;aV65>TMpy_5Yqh6tVoOgzelboOGN#W5A{VKG({XRsx3O~vu%d@lE>%UJX)
zdzo|2tAa$QPkYvn*gWdCy9r%sBd*XdQbshRc;FJ1C<_AB2oi)PXc}(mF|RHMYH@6F
zn!J{*AZ0GuYWm3i^sczcZ}v56jw_zSUYt<oSq2=F#UtEVS%?E+XM?06!-;NF^i#>`
zG9-QG4w>8%Bh~joc9ojPO32}x$17+}+NBr?i9n%?a9uzKu@@C6SKM$*7oYoaI7KV_
zF4HPiuz60`l`+P()49rQI1jN=C@gIaLMWiYN{(_aSL`R`<cp26^$MM>jyu~GM#~@B
z4q|RYM0@9RR4J#yQV3LgSQ}4+xAuN(CjbV)6@9-Va;Hld6-k%>Eg~GAb_b<Haq{*<
zU0Qp?fc(dKd^(hK_u2xIadpjOt8-(*oyCcK#M{*oM35dW1rUX&4<nUi6_MlKlU6$@
zI!Or@$LdA{py*PIO^g52o#pX)%{Z+2`44!`1-C?_Zim8+MQ_k!UdgT{Hsjy?#KeU{
zLv(zPMeu5Quz4axgNmCL6x9lxeUAWfQ>Z;s&%!444#U3($uo~ogp-FoWldL56jo<r
z*FN4T4RwvmfhXTVkU9uwvaQ%>I^~$uG=$>;9Py-Nc;@g#r~IrRI^I{<H;ChX9h0`%
zFFp1PP_YmfuJ?Gx>0?ilLgxaM9ZDNx7+DIOK%Fe^#5RJNBaURA$!nn!t}<5`NhnIg
zo=7mra%u|lmhsVkMmTRqN}%hW_{TpA@$*BwkSTr9N_htoVXy_$@)-CvJy8E=m&DiR
zD=mOEx}|Qjr5AM<kW+lny>*N=A;vZ}UhpT<@1_HAaeHF{W9)g3qHF=D%k6R2kq$6F
z4PkR-p!Q~g=$u&sL7>ISd~RHhu3f=boQZw*SPc)=FFDg=Lk6Cdm4g*wwSd{~K-MBb
z*4QkP(7X@(-7^3JI-e=;AlGdrI4Gqa1cx|F`GNBzD82AQ<a;e4F6DT)12)NU5V<oS
zZl4sdl}a!yFbgKUHp=Sm;DmDvRFDty#NG`ei{T&ksR3ci#wbBvyDITYVK#4n?0gKr
zt-!GKra!@fnD$UFag3tLK)<mPv6uiWVN-fKYGMi4TuNZcj$l$OhgRajX8A0}Hj38r
z1RO|6ObtnRQ#Jdk@XCi>ta1-}q&14{mZgZtJj2#5VPHy~);YZeDPZAF3{3R&q8_&2
z>qgn9_&>>z5NQl0&?T%?DVJeekme8zTReSPnzWnG5-+V(*6A<Bu6bW!zX3v(_KVt1
zLBq!ht|#R&#0j$6HiqsTNQVaz^!P{acQ3aE;dVI%x2@Y<7UP%0428GnE~+vGQTc*w
zE+EgLd4|U$9CC_&az$k-0oX#Bbo}N`CWF#sL2$m|#?TZp(Qt6M9Etk9At|=x+H6Di
z$P-_8ce)1PP5K$*bikq>nwf=*$$7$uKp+r}`aEIQ!k>cla9vO2$jhBQ=E{iyZAKiB
z3>Gk!cj}28K_N_l_>?W>=Bmz47%7yfD4@W8$)Z7!H;CUL=&+>|(huC+bIoa>J}jF;
zi>45pRzqKqrVYaOwGc6{si|Lp_LYn!=ZfixlUsaSBImuy89)ugiu_(ya$XJCYG`|r
zrzYj7E74?g++6b42JpmwE!{l4I=dgNJOE1_3R*qOGo&zQ725|f-0znci`qeaf_Dm^
zJIs2HHi{e$A^<r%@Q=n&*5!T9JQ;t_Y6ua~ER_3Rb~}{23KCgZfUaEaiK+8UNHA`?
zMG>z*`ER#>;vIV;U=RnZ)lA10Wt7j?V9cR#m@}mhtzBf&n@b-L(a{b?VKFLGRxd*W
z<*uI3h=P2zdDP&xO9~u3Jki^=GWS#rq5jm{+OqtSj435M=JaoaXv&^!p8D-KiBi9N
zxU0{hW7(0Z--_>TKxBR(((4C8#%bCQ89%%HN$kJrfp37LEii_t83`Bw(b=cEkm-eT
z-aP-`4&pj4_!vV_JIGRd&0|2$fw5h`fPk^#bxOs_YvAgMC*2z%irTJ?gNKaQV63gv
z1=XAOeqKL~vr!R0x5{Xk%Y{z;cFF9+ZcOuRFL*i^c2q}(v*OHe%CJ-QCuxej&G4YQ
z)~NDseRl|+m@vq7BL`9aYzzk`$GLg4&4+5d#*x#L2L`cfB9za;{+qLLJd^AzM+t~B
zlc(Mo)qJZkSFGS!P8z^^%#|2=z5>fhn>iA5rTM7gv{H>#IY~l(N6OyTvz-B>VP|ga
zgyTj4ie4%m^%;>0%o!!5KU)!V^^Y<x6rHnWajohfE0H=22w#DMv_P4Y9jYFij>0z^
zN;2o&lQ{FUI+^@}(;!j?2;DZjUDQ9ga@EoMCtDGE#RpyT>>rAlR)TQ7&j&5e8-!3N
zZIOW1V}bp{HYt(OKmwrQx$tvx7@{&7@yvb-=a5d@Oy5JP=>UtaY8%hFFM3`e+#QBE
zQ#5fnlOI@rL@;vNK8GJGiTo+|!*sfz;6-+T&sht3qj;<SSPr3b>*h^&P{8(Ucw@>}
z{aNxp=KUqi`M!?&4w)Q>+<CmnTy~q)M;yK75YKnP=9GVaR0XrV5<XevCXUsWg1E<Y
zc#qkt)p#MM%)U|ddySk00}4;AWLrJ_T&PIrO`BsU+7xjLs!QC&U>aTqporrRX{VkO
zT5z6JjZtM*%LVXF3TR{9Zk`k=>WDf2UC(D>qBQ0h!I3m|NpuuC%12qzbhKKQA%s_q
zO0^bB>XMnKnd`-fVmSZ1jR_NK3k{-mG|V`BnV~{SPR_V>fsWml_~02q8;Bg~fiNX~
zjsu>NC|x4UGK9c`%%Y=Jyp?TV&@A&(eg?U^-4Y^*$_Z3I-gz%*mZd5zjia)w#rP{0
za%9~Z@04_&^s+IfP-gZ+7}<9|4zP~?w#Tm0el1i_W7y(72va$~^2dz6l?1cPbK6t5
zyjq&a+R{+U?-|6o`v-ANbzs%DRIMXex4i-ocxh)?lJ~*<1%F-m4wqK`Ot|bRwqS}x
z5sq~e78z9-w$svs?p9f;EEF;7b7dm9Svyi4vT-MdKYU_%5NbE=&<TVN=X-^8xfpG)
zw-u%t^M&nBXy_lQPsIw5WR3aoxfpc<vhPj?Y_o)3Um<B$#NDj%$9GSDJGo$#4?C`p
zYWkO7xzCjON#x{t`bW8^q6ABkzWN@U-xahJB+Rv2MrWq<tAMx3FEalLu-;Jup8!J-
zAXO0)X!wXt@QbnvU2#}v6qmng`#B+%9C6M`S-|NY&WX8tCb|3zc}%M=S>m7|^g~K<
zIm#7X2-Y0B{Ze`tlA6cvlo<@RXB(DLObwL=krrzu>{X2^$R4&Tv4Q8y1DAXim-;Qb
zBE2r{m$Y58m}pJ9CN373*2mF4MU5;GP7y%oy!Ty7%U1yQZh!fZ9@s03Y-icFWncQu
z^pee#W&hxfyG!jK2`EnOH``SnodiVWy6ln<E9I(3Od<8v><R8)wtLd&D}|#cBOdGZ
zIcvtB6+}1>PH6#JfUJXPt2_%(J2oIjTbH7F{%9*c!}DZ<T7V_YQ&_%T@VS35*a}{9
z>njO25A(!w`$t){ouNBTLD-8<MMSd2{Yi=cpe0XN?x8>Gw`x>Qe^epvl{_PcJZ=Ag
z&EqMADd|;<L-|fuu)ku8>1q<B9SwNghnOll%g#rs9ED}&yOb4yJ$)7t9Gs>F@%`E=
zqYoXvq&2N5ZVJZJ(58T)+U}HN{?oLQwY$yGlDch2yfjs}?}Jga$cUvm??K9Hlq9E>
zT+py~A6cL_7+(d>!GtvaVH8e|$+N68Okd>=6~4*hZ-5XXQp`18A9fWaDZpz|T>8Ic
ze=x~bgv;M4{ZJ7p-`u=%8xeN_^YW9GSj%fxRr20|&F8L%Q2>Mtkd@hxoWHf{1(SSk
znm_LM#dts}+>i}Y(zTx>-VLvcQSbe%fg=kTrsjijdu>T@E7{iP1bs7L6?*7o<tZwP
zgS2@`wmeTT8Q<n*9$BM`Sj>oR3f<*SkyQ95K;1mJP(Npvgl}`WJGp!l6qK`&{I)<b
zsem$w-0=j`_FTJjyo!&fJ-}u}f>tWqmU8ODRj?Dj5SCn()^2w|GS3FJW<PL{sJcei
zpD@?TxF8&taV)9T+h{LfF7NdZa@>=dlVev|_K)4vn<n85?|aFS;4qkqL_$t)tVPI5
zi>vz6^o|vE>5U3%aWbYYPF;;w{#ZpLfUNWW7Z0U=N`@Xy>L|SKgA;@e(b#YuEdJyP
ziMS!Jq2i7|`Et%eq$Y&)YZ;+_NN=2_pm|VO3Mi@wMqtMRp2|J*a0dK=6;W0TL}9Db
z7M4`+i3{?2`V)w@+PsB0!$q?er6l$nrAxDvvPWuNAO3;Iv`)5Cf!N2qPILI4mt~v$
zcadGw5V&6i3o=u^`tI>7*V&*O$x;l=_@TOBFYyF{`sSf;&TEj5H>_&R(I?Z9Q>xh!
zq9~<Wmx+^?+5Il(j`vOW|N9UtedvdyH8^V}nSv6Ao+n9bKvt(_j@_~ZnZb#cIZat=
z(UoUrFawB2o)JfAqIPjcQRV(2LKY?%e&jGnPF9F4sdnUFq$j=Qh(L<^aGSH!JNO$^
z!K=<Stn44g;QR@eIFua<#z%l3qi{^MlQ=*=XTOR{6ZU<OcnPi+m1GIPdJzhw!a<a%
zDWKS1JEIj_83#3lS1f!$cz*+1J#ejzr@aYnYc%7Q(IZn}xuOi7&+!+HY+hnqg&joq
zf2&Ju_Uk*fz%8H+qK<mzaR$5R5KKAHsYDO#PK=tF5sB}2A?MZyDbZZ3T24ZdNU&Hh
zh)~`+OSEa>1&L)dVIXztF(Cbd#wy^!e6PMcAFg^c<P~qP>#jU*5Im7KZ7oVa<dH}$
zp?fs1EI$Bb$pCf&VN(Uo!|%fjizJpg^9marPb6^$(b>K$5KvyzZHVaZx=wkAs=Vi5
zd&W@i-tl<dLB^V>Fnsy%)Ad)2DUw+lvl`2YbALZf74{VxjxCmcis?P}Hl2vWaHgdb
zgn4ZF>U8i{LSYh)SK-?N1eEdHJWQ_2ngBV|SVVTgI~vZEV6R_=un57=ygi|zWvE<w
zLZ8-Hc*a^gLJ-=<T@#XCz?A_8QU94cOZwH-g3ZsG(vaWIT4qT5i)lZLc}n9e?7t70
z(wKTkX~YM*x@;>7_xgNy5C~ycCC3Lv&hf$8(=e1QU7eK(!!<?Elt;lP*tBm;QHM1)
z)N3hO9)<ZFS!KLifDwfYV`%~Nxc*Ei8KB42!7+7i)%xnv?8T&lLYy3DQVZwjJ!<aO
zMI6_$xJm~GWq@J;qxK^@>o%7Y8brBZQkAEll`>65tHyPP`v2?gUV1fcuCtEM`&0A~
zMz)DfoFOM621tM`F-DdHL3RRm;PdnQU+aE$@8117?l?Az6!*J!RozwVe5!hI&>*sD
zwWPQ7lm=&@E;!xxdBUgv@>LL`9|@OExRoZ~b<XpoL!5bq6;8)u!`5w+4R+g;#kR{f
zm9@Ym_37iJ0mMu(0u6xN)0-Gb%NGbPE6uuT9F%T1;0UbII-Ju@qm#$N!Fs!_n*&Ql
zof2WTnrC>*fVh=~>2tAQO93&7eO@1NAEU;&#~?Wslg&JxWimSnF%1J?y<gX9Md=+S
z#pYeC-6puhO(9Ovh#mM7;l#m(s&L8P2<r!7@EjLa=<nNQRh3A<1+6Nv&y{D3zC4Hf
z9F>ijcz|Y(<t$wpGzKHF<wB?L-QjedfLRm)4AMog0DfckhRlUF4X?@#9&BB6uwN#r
z&*h!UM%0*0C_|jR)sNjgq+2LTr1l;_5FFD=Vl<(QF(1XQc?YxBBZ@D`=1n-ig-nR0
z@XzhW_^joGIICW%Z^BR#UlV3YxH~kb8M3M`)ot1CwUdosc?{y|5J*nqw_VNZ=QBfT
zwpFbh-_FPaTuUa?6*C^*mDt_%s2cTRGYK8@L<c?L+dBJg)oza|CLjMW=Dy_srC3rA
zvgJ12HzR+ORAYu<_?g=g)5WYz!8tHyDYiNoC9ml#L8ONnT-Z$!_sUNT(e1uP?K0Wn
z!=T+Kq;#3eo5q1Hp+WbO>9H6hmIffPjMB5EM6~NdHhp|apmU&j8W=jCvOP(g5PO2i
zkG%~@a2ivRXnMA@fi%yisuS$I69f<j^Aw0M%kKc@sT*hvNj}eO7li!bU}gK;!2*j0
zP0!i)9gg1EuSf1Sk`Vt^^3s_-L4j|aGAyJHOA?09kP1|XOR14IIa`RdIg`b~9B(&3
ztixind$*svRL~7W_W4#)D}YJ3+4alTnHorOuay&^`xp_xKXp`xU5d9(w)lv?y*)y*
zui-WF_}GGyROWH!v2L4$Qp4P#Mfu|jW+jC%u3hHQ+OCm}yK>x#$G%s_Q7J6K-$M0A
zfncw?JzAQfn%pqK(oSv4eD6__E*5|NKSAh?$=la*YMYPjZmr4g3$m4d59Cei=OPnc
zRLpYwB!RS6@$DoW5^8(jt|VFvNoJ>e%fu4?_8^>{_YM6e4GA2kpK0S~s*Si|O|h%P
zSZJQ-FjYZ{l^Bd$05SRTJ+;~>fg2L@<4+0r%Ur5GQJ~g%LM{hN`_HKx%EflwzLiBP
zThSP*tqhc1a<&Dp4@|7=i2_z@4Vj%cea^-7k9nSy>1hkOV4+}p!hiMAbQ#{>QajW!
z>i`08f>DTbBy9vf*CqM|Oh7{RreU8Y4MB2&_mkn{i?EKdn^fT0x45agYFxZmX1!|?
zOb&iD1f!%N8&eBU4-LdALvHqrf!VVL>!RfL$q|^vZKbv52Qnd>=3}(4m8iRZ;;{|w
zH$V?yAGkfmz7e~4(-sSH7Vf2xsF6<UTM$c%1=LL=y}Y+U^c~Di<N0f8!{B+<HH3z2
zJyNh{o(_ZviIH{_Du-Q<-N?qzUNRD_P7S_~qfAvnK+T`g{|Q(^$)sK&=U!j@29uH?
zIEgilIin*Lbr4<MLHwz*ASNl^JdM^@v`2Ouw{%L=gx`3C11}e!q~Z~}xoIRo>iS?j
z%cOS>>Om9|n}-!^y*F+0*0h1P(m;P0kmSY!67aDbJjbq{6~Y5<d>&gUcJ^w79Y}DD
z2)Z?c5ZPE}ggTE;B9x|NoTExEHu{xoIj)f1#5=qs*^q||x>kw{q-dAkAM2n&0C(XC
z1&*t?cE9zj6Ta_b>gS0+8D8;VJE&yB=JgiPtF=AT+kZ=c)0Rd^5fCLS;k0V^gVk#!
zwLq3KbFEVnrniVZ7t$s%@il?=qsS~?qjFE(_2HFMZ2NCA;OiO3ve1o?F)kbxs2Ci@
z*)ommL=FVQHi|fKwD+iz)G4ench}a~%QRDFWjre`a(nq8sYMVb5F%xvl*Pgk87hD1
zYxxI3XbY~ppOUuX0&);7Ely@@3}`3AI9aJ?<%2KzmF$I)j$IE;X|!^STS*GTJP;=5
z=5d{RMj{xeuGM{birM}t0~E0D-Fzw8rmZnAro*X9B)rs6*TZ|9XD!sF-}YcjNa1iq
zZyHYo`{2^*?L7^tiZYDPkMiNMX+)Zt1K_nJ^Su~^V-GE)5bIWDsLe3c?KS|*W=r1I
z3&IOZ$H=?d)btM0bsq=bPqjo~+1nUyG81`ojO^DuUVrVXfzsXy1=DtHIuo^rp5zzI
z$`3r!5imS+Oh|T~*JPGsPVK6W(BB*z5xIHgG`=YLIe-a|4W#wedD9hGriAB9!a*Jh
zCk2nxe}R1uWcs4SL>&qxd$sue)J3BGb~O(PjLpDZJvAo@iOC^WEQB@6U36Ek>J9ro
zt5#pk)FGJSUq5Ed`CLV(g^F-_4hT}n3ZjfN#^YH?+BsrdDEy@o$@gkm6f0-pQ_sjP
z{6>A2b804Ms+%|ExvN$5cHxqKD|40o=m)2Hyu64)-ipOgB{0z8;w<Fb^E6PLW10U@
z#+o#t@w}?676`GL`Q>)d{vjnFS1Ot3n6+(GY1nup^HG!^MEo$m%g8V;U@+BV3wG9K
z`W_mKEQuo`iw*`+EFLy76OqF~32jO@!N$M`*_#z91V#MjJ$2W_alz?8d(OE*y{L}O
zXpJg%=>zCZXA!GhxTf{F1eDT1i2ZK8)JYIBkF5>yk;{(}>vNoXs!Al>QlqEE&+_#-
z=2GB3JnceFyIkjy&%rQMM|0vOgae^kO&-M6B-BHxH4KF(h5TwxQB+;$Fif0}>MU~*
zdQXnc7>cYOrctkklIG>CZ1vJEOl>^oGDn;U8@15}kuYsueWGW}%6=`ES=OQ(JG7>i
z@=PfwE@O`@!eXx%50WzXJ)Ex=c(C2YpDZkeZeE=tGAOC_4or8)7?`sJAdhA+O$rH2
z4VzC9SF5)Jf0Woh_Yvj|$q#b<?HKd;3&!n&Py#6i?q^D9Y6>~a2j*><UZf-|tL|iO
zdvqy?@+9d4!9wF9Idgx+GGKe=p(kqH0E8@xLj{TD=Z`4_Kn!#5?Xu0|wTT-b9!#wR
z6M?8K+5xSt7KQobZ*#g=B+kQ!EFNLca)41YMa#WV%j~v+MyKOJ)bsirh&)HgDnqV@
zaxf2lTM3oLn1kpY?)Bu@IT@80(mItyQZ`ut98(RtJZ~@Cit-Oqf0&<RUOJ{7SfDnv
z=5>ZL>r9CTDeqO+-5|^y<aw<betPV=F|<tmLp_S?I;yp}T^tb)-cs{p!gV4zhxcbu
zXm#<L6%yCpq$Qry)?oTgJ>W0t>3Dq)Bs2!m!{>a=8TT?x)zi7_VyrUG1F_FW&DP10
z@{7H!Zf!n0+<`FY!;3wb+xc>esLgieZV%Q5(d`{RF+v^5tqq@*E<2xI^41DLQgxE&
zPP~0WP)&znY6`f0`cw1^pHe5`1q<oTj0~sJ9Zw=L!f+A_2tw4J&Tm>I&A)_V8C0?*
zeDnK1k#GB@h=m=lp~o)sWqggPFfC@uO63IOL}v>EJKdm)r;`>e#*9pPD;y}o)a`&D
z^a79<vT<Dw)J;tsNsz}glOV_MC70xwt{!8M1a&IvhJ4zBS_BD_Xi6hsf}XRSlre6m
zvAh`MK)7yN;}Q)_YNelV#5`U4jp%<5B&E?012{s>P*9m0=(TfZW}W7c>d_O#G>G?J
z7uvD`z4zW`q!sGj5*KIusen#g>riJ<bm0|Xau{#%67>4z3#t&M;5zm&Ev3Em-oi=d
z6=}<jKxe^qY!yVQfa_LRT9K@I)K8c4f^7>rM+j<eD7I2n!}aLFy5TR(rxP>`Yj$L>
zD$8NfJt@P6P=F0e|0Pl}NFnE1M!Lz|v>g9f75{Sz2m<Dlz#<wTTKN*rShRVhhMk?t
zz{o6dqQPITEkM7B1DD}U0xN(eu8c~MJYuaizL!*DA}|H)uGR;kdlLOh+SoJ^#<qzf
z6u?yb^yw=$TC{@21YH`t)g3tB<W|bmCyJ%*nkV&=R-MYYUA50g&{@uY=>V|_q%k-o
z54L#(bv0mn*!9`)a`~3_NtcH@(O^<e1E-w(r32ZKr7oO78a$*E{S-ccJ2(LZYfH&E
zQvE(YmQ~rE?UYbXD-q#Rb+Z>W*H0Nlm>=<oS<l!vujZ^220mCxRnihi!2nkAo>?q5
zmudixUv2-aM$r>($P~yJ`x;(l!JEcmto9Q}n;);HS10<hy+F1dq*h#;529BhR$0i?
z=T;$YULn(IZ31M2!5HxJVTl<6BOQnfT>ad~2YKyu-@v{D;(SRzMnCDt2!cc|Lt-qG
zT_Y^%r5QnNy0m9v+`ZI&Q9kGzJT-caVY#C2PzB2<qaRmzAzxa9<w$GfE_2=L<<x;O
zzAG!#d*#8ZMD*JZYc;LCGnd5=ImAb_e2tg<%CR{ZoA$I`(w|1LFNHsKI&#IaYnK;F
zK?On5aYC0Bctl`AoNlW2V@kWvK&`_YB1;JiMw&M5QK%72SXav?Z?^^m4kTg;9_!|m
z)^8yP=#pm;x1^^vL^jn>YVXv!&>)DW?$+>WH0fA`gkS5{_AK{Jo2#fHm4#s2(V)a}
z8K<?$mzVNHFR9Sg6hx(Y{z92uZh}#8U)M|Xbkf+teAE^yc9DgvslNMr_{W}j5Zz9}
zxZQUT!i=>}DCAM=KFB+{9Z5G$b9Z3%K%?+QmzzS0G+h@NaBx?*v;%kEJKdCP-^)qd
zd2y35XyQGjdR|RWQ$@MEEW(P`kef7$D!8O}khQI|G>U6K34-)p4C*&@xGjCHqRIUJ
zxCa~eJ?fpOwV%w{t%tP>ccCH1)OnTZDoVAvq^gXd_;g%XHbs0!R7w9>m9DZ<+p~c@
ziwcWP!wzG*xW0UA5WS`?M4=Xed@FYM<2zrA;<ux|h5VopGvR;znaZU!lsx>4ALQ15
z{}Lt1lRN0|N=wE7aFl1|pnGI2E_r!YBtscVhEr0Fi^6=>d{+`Q2N{Gk(n${8Qfw+c
z#klsUDG1-8p42?4OjN}JmnJn^<%ZWnZyJu5r)bn77Sr&JqSHY{*NP1JQB&txukmZu
z0)%A2^KPrh_OdHq;Ebi};FAYlM+H-*IpET_sh{FROOfU_h0h$uN@d!rhkb*TA41f(
zqh1gzJ;;nSt?z(gkAd#-+o~@RG3yW_l+zA^v5bP_*S=iZw=alMOG;6ep~iukamVPI
zU*8m(AB2Suf;Nj)o0pT`ynI<H?yY{b!L_-{wL@`wOGk6Hqh3n&p{UGn&Ri6QzHsFT
ztQCm-g3QKP1GIV6MJ2Dp)!sfB;d|=6eNW-E(qD-lKt5oFbbkZ;F350Pr&!gsoRUTH
zaEy&u=3FH^>-QJL`3077NKS3IstU!?*ce79y(=0`^#`Nwq`Q=%7?X0*xg|78EE*#Z
z>pa5e?b4N|a`N~kbe~a-ms$h-@j_TJD`np%Bl)7e*5`X*vLSg29P1U^8Ba}_c^FlK
z_{@UmB0f6JKe*dV)cPa52IGBoi=$eMO87y{7nE=;1mE-?7hMz1f*I}y^>_-afJeF!
z$#)Zy=F>`7QW9SBzq&s|RmVe>j4(s<@-EA?ImE7#0k{G!DsoQIZmOT{%1LM%yIZ{^
z1ufCmHc1Bq6W}SAIh0@l#3$OWY5YBjBv-q#2erPmIPWB5TW+25==+G4wa@#Xi{38p
zMzXauEw(9(@-wW&l=tdIrz3P(19Z8!_QHW+zFpb+(%v9mr)w0`RDG}NSHBwM7D<{F
z3OgQ_K<f}CCymKaNFMuq8SzIot3{87JT;kUUPh(guSPpRO4*=%NQ!vZWy)SxA+u0R
zi!tsIfH+F%6tDPPOcN)fw9qu%XaC|>{T1<HUinEf*siG+%*d!HT7`^a%emUU9Th~;
zUX~q~Q#{i*<b(5zgL&=3`9|TDCt)C=oo@ahdXVyhS?a{`4Pv3+3rUcLlj04Uy1T%u
zWXWHF)idjIs*QDxt|Y!DnMNfbtAfH&uN$$ktTD33LgIsZ!xY=0riv4}r>r<R{D{<O
z0Ld;K#My9pU}c&N169(6JZc-+3y^Z<y4okaz(61hqgaElBlEf+nW8QH6qX&7o2*Dt
zAwku`;=DVY+voBQg=j2SdC1facZO}nUG585OUqFZQ4ukwlNo^a%}PYcE;AxpPHa`c
z=dv<Juh%q4uWA`(E0AR+OQx@K>Iy2Fwurew+?}pWCXR}SHqI#dh?HbZvWv-7C|}Sv
zSDn^Hni$gvOBqfc(?4-QugWHma{-e_+@5v|=2h=x8{svTY$b`AAmqOr6csn*`I2l$
zsrq;OlwoR=Bjd9>OL+3R6G!KzW5{*U)8R5+Y>&CcxHQD|9%6@Ghex=TE4M6+knU{}
zRhHNYZ3^$u#<wW=ncIW#0Z3H%FF<@sLU!NXf-aM;Zomn=Y}}|Td@+yv$dz#w8hceI
z>0nHFrYf%3b;y`d&fUrKuX6^19K$J6l-X|@3n0~Hsp3gT%et2q>@GiF0{TJLlN3Y+
zZ)gNttv7BiW!NC4T1Ub0q66&41;|Jx6O6!=FOb4qgB&sgo(#sXi4vC(&At&-Jn{|f
zdmt~dR}X>$;_GVa%2rmx0Kur(IyouR+(299s%!Q=2#st^HMe`1rBTpfuWBH;_^D3E
zUe#B6!MY*3Nw6-rysN433*=`w8ic*Nt{H@^VU<GPLjnkU?6nA(t_|YmDYRgNsv3}L
z9wG0dM~`FdGVUN%NA_GszsS@)niYCJ1!MK42Ipj9TB}e_Pel_}TFK@Lt8bo~zO65L
zkyY9}p|1Qk%T+QTgfBzJrN=mSQ-)ylqdiE2aPRJW#0NG@mT-wSPwYw2N}}msI96z0
z=8S(wb=~To1F)+SYnjoZv)+Ut>I2iFu*aWtJ|8Xxx<T_6{Dn{-g2f(9tKxEI-ybRF
zHYEVBsV#=pBZM#@f}`k}R^opMJLSNP2`x0;UIqY@L~fh3;g5O0Z6FmtKJU5vcIm1y
zs*m^O&F*xnYDCX8_Y2@R4_Be?=H1eGtdwz|OJ<@m+;P47ot+GFkzz%blI(+|jLO+E
z**6PqaBF#{dY1OJf|qE{_}<s1G0G{?htD*P4^6{j+1$iR9<sIboJNAV>c_p8v$i3L
zFKmIwRhsT&9&m(!YTqo4btr>5LPW)wm&PcJNX7*3DI>-<7ce>G$f>n~@H{O<TG`{B
z4NM!eEiv3obNpqKRa4R#Yo!4AO2|imkFchFJ?dM?R0d5>Y<g3Sys^erx@RYSyO+nr
zD~Q0f==$ghDqK+NHajA-)fk>)^;3jlNf?A)I->)1;++kyH$(Ci+t2>s%x*~aV2>{M
z3BNs<1`#Fj<ZY~kj&)*)`eAg)BF(+@Ea@q&aK0`4vxPv6qeV^YyUjx33{3zcfiWC_
zaN+}dVmWFhQC#!KSd5*JNj54wS5{({qpR$_b)<pt<p<$=yKHmPrz0Rw+y+2I|A>Wr
z0!zE(+Awv;t}INwQoXl?qn}YzNQU#|P8La-d05Fm#;(LOA0^Q8WfS3ga1vpPDc)#I
z3K+F{y%=v|tx9R@MA$RKjdBJd{UH4iT>w2M&Kqx?T?D$^Qv9B9HHhvKIrs=g731TE
z`dS(Ft4<_~`H8LVaQmsmmYgdH16B2s&FT)}2tU<ob|O7Y*19tt=0r=$p+MQiPR5Xh
zZ2IS30S-o6_<qFngzHIARy=}ptInmRvSSmJFA)}7as&Diu=s?d?`$9xUQCF+U|>wK
za()k})#JZ;91*TfudES*rtx6+K0yIxb;%&>e7fhS>@EIc?AvBMFS<Ey*65Y=FdF@G
za~|w2?k6d#0O!#p->e1cz;lXQd086Ff@I3%V}pDpt=r~D*f*oL(#LtC1jv>>N?v`a
zrlXU6#or#JLy0Jmq-#pM7aL_dNj3a;wYWzemjr@ipgr6aOl2C^AqfReL5L2~2W=ur
zZ;9gJq7z(hsq`~};UVxB(sv+~fA0`h(1iaY&;5)LX|N>cqVFx7ZIo?lzOoV#VBtY<
zFdxtuyjk}~5NVC`qp8J=bZ;7}`8Xb(qxsG8^4qm!St;KRO(d?%g{ImHN4<31D6y_E
zZm}odytfcLjq??aF3H~8p4tG*v@Ra4&=gFDq<A!gNYrH(Y!4cXQ2no+3ri$cQZ{8X
z<RBWAv)0dcfY6WaDiLw4qFDGrKCbilq<K;8f%S8p0Vsi<S<C^T<XDBGb+2@ao^V$p
zQuw<Y6g|BtJ6uY~VY*D;;tpM65S+aQP@GNkFN%9`*Tvo4HMo0l4ek&eg1c*QC%C)2
z1$TE3?z)HMegEHg>zt}v=ic6`nSOeDdivKr1zWYx^n~f-RU1i{3Mfkv3JzvTFgCOd
z?r4!T+EqNg;0OQCRn>a0{Wt;OciIm*h=?IZ0b3SeE;`Grw@?i4V<;cZQyKzZM1kM!
zZd7;FN$29+qkRS<;Uda(a+j`FSwmOHI%lXOYlJ-gTT8#3_y_jt{-<db=0x-hHi3oI
zYocALQNvHQ!68wjh($UU$fk$baOp86J+*2X*gX-u`=1RhwF;F=7|z9d0n2e2hW(xv
zba7YNhyh|Jwrmq*XEkkEEu;tq4i6!-ur6x_3dfQJ8uDm%0|^!&Ma(}6U2Y^hlkN_@
zV|_h#!1q>}hXFXWCk|Zwaok&~XJ!vHxOeiB3It_fk572yfmiK;@@dE#u+hzvm)#wP
zq$+i7I>`C+((3V*!{ss(rAUdaF;<H(j}nB;42DdQQ=h>!l+uDX*c)I-+%5CKTCq;!
zTYTCjtrr)s>oG^pprhEtwtakmvp3aVztV1&C8Nekzm1mvFr)p|_bsdo0`iDlL)dJG
z_*p~`>|%AaGB25?fj|?>kEJUC86jA3T9qJl)g~J|vXUQWJ*6DQ1T-kgeE1nJK{8^&
zKSRtB3oi*j5DQw(hQ_RaeQ(bA4)TO@q}{5NG8VIkMLVfV1Wfp=WC;YHq)h?pQLx(s
z#23c#9?eFvej;}44e5EEcpG7R?OMM>D63Z;oK_neQ4z{4EH3<luLm5}wf4m_ODYj(
z?VjO=kgSEeOed!{U(?!Vuk>5t@O&WWR3hw$DtKrV(R_#zd^+3$Pt5m&Aa16DI9+eO
zzDZ$(Vr5o(6d<$;>kLZc)Idp0a-i_9*AC5jb09gDqa;)zPS2o=T!@^V{noP%&qP1o
zCY#6#3qwl60#{OIKZ+C7%KtJVigW7*N+WzENOng}7m(~t$8K?3ISQkJq<rNTPyANn
z+T-xM@kq=HT6VA%b!{B~4bz+OD|S5*vU;{B#FBChNEhJXO>a0%fPnQy$C4RZEvnmc
zrT}wnKN6~XG|kxGKeHO1-?N}<o}0g}WU6M=1x_@^ca~+nk-<D%uTsX4ajn{H@kuKE
zAjYkGB_1QqS}IW}QXq&I2tdLtJ)>x13oUTbs`WH2C|7zcfp^tCrQx8ib&9t2w|G7^
zW}6yFd-q*N6QlA}N<|Y(j#`4o84SveRK59mrYpfgW5|mv9t`pXW>M6c#eYXh*zOSy
zA%slflfoo6hMKpeY#BIo<OCR-scU9RePf_k`a}}?=&95F#Z1%yF)|Z?^=hBhM(|xS
z0M#>^OBc#+N8crBe0StjuL+td2`c~ktc`c6k}Z69!$0zhHI#~zvvhua%HrbgKH1F<
zI-V(@+k}@<H)ESq-12Y&dO#lOtJ`tH#E>*^l#&GyHzqs>*Dvax`Q>a>C~(#0hoMHY
zLDzJRed4ZcAE}XX^8*_7cuDOY=j1v-OlbRcs9D5l(qi}fxdFu0`~8*FJ42}8yht_C
zYunANHAYh^RPm4yvn}V8(Z_|pb)j8PA<+tipGeStY7>FN)hWPn3PTi9f|0ir;a1Bt
z3OkD`bgAy(fjS|T#6j53u=~k)3BqkZ2vKzYJeB|}58lzOr|6J8ACfgna<rQuo$LPn
z)Cjo8*9PdI*v8)NEC&Lhcr~StG|;L+5tB8LwZ@P=IGb<rQNJ5Z#TCvy?b(O%BP@65
z%jxjVh$jgc4N56*USyc8FLJ4Q-T<((tdW;9{KXcOFF|7qt3V|u$?hQG;Mo0C*{;6-
z6w+c+>VarG<o6ZS2Jy!;y3`9nCTT(!4B)MOAQ}FKP4%^4)6*GrETjn#fwPZ>+V(9v
z+EaxQseBS5PQw{8*ev4JoAIKl@9q&&<4{O8-UAg&F~3K+-`H}1JDe4_==hfz5`RuC
zTyvF_6n6h}-e+X#iWOlbXCXs)zYLWbRzk3q09_TXP+4EH@9Q7$H6E}b#7>zCX{~wR
zkVg2!pg(p7z7E=F*(K<tsZaD?%s5D(kZnq9K_#u@YZN%&JPv$=rPQ*J>*L0-ySR$s
znFfc&M4xkOY762W*7Fbs9k$GL45zc24X?3F<D;!CAJk|hU)XOO0#j|Ca%Rb4VwLLG
z(`hrdANP+M^*R)##B9qAcDe|;IZ~~;Vl(V)(p=UWz^ozPTy4Ono!)ljxrG!~a+Kya
zd~0J(3RU`!tcKcNe!<3=FI6&)WayG|_E8EeRZy_rSz4;>wlLBW*Gb;8dF;Yv>cE?P
zw|@)tj4AAm2&#a-)txc|r)WmJJO<0woT~~WNTE6}3h<C92)a|eyK$iQEiE=vOv(Ck
z%$CAc(g1m1*^yyb=Sr{6Lls<#Zay$e&Cs$f%lTYh&^Ok1p~$NeB)8btIb%~gUIC3-
z0CN_Z6g^6+!}u2LT+-Sl@r0jIug7ZTB&K5_KaK`U-f)S$D>iG=dc}3V&&L??N#y&a
zxMSO%;k6U$C;2G8JZPy}Om1iT`k@e-;-D8{`Leqk_i$TIyDIH#kCKS{JzDFe!AzE3
zA2{$FWgq>qFFp{`$n!bMFcWXTq){Y;7W_GdRdYA%NsNM04Cq)8_R6u$i|`*u72S<C
z`A$eGFPwe}N1646wnxKlmSq@{$LeVLHVP#Z^owvJ1$<mhZJnXKP$=UpY%a^o7+#xH
z(eJ=*GV@MhJExl{1mR<F!=x?;?0CrQW(R3&+ogx@3FaKGLTlt&E}gZF4UU11?}o0m
zfzyTYq~f$27j-LE&#mZZx6T3=<m*~-kAxN8kK>IP9>{_NI0<TpZsmg=nA-Qkl?9l}
zjj=OOB1^I$qX-dp42CVQ({I$Kjj&e0RJqSiH90Y)mz6UyRV|9}WKM6zEzt8@*sMrh
zVl8pTu2;#8c1606bhZM$W3{XG$3{E_hd?agyV?qeOa!Ua$y~{iv*kw(Zq7wrWMTsx
zi8L=Hu}ZmMpyTcXN}bo-i3fnkjxxgf?Y!t?iJNyNEAB%=o-i~adu!XNPU9@PdOJRZ
z>Bqe@)j{Gqk))XV_%%YUV6!6DgV;TS?7v-%nEY1=$oQi;Wsqd*3iPQeLav^06*EZn
zp>1bxF;Ge5%WwB#!3Rt>*K~RgSr5)@=leg$^qY#|Yv2VHs6A;Nr~ROMctaL44iw*o
zpb%=FUHD{Hdt!a+F|lyf8R>(<r%vgDyx>;1*S?O^@@4Mltkm+XS!QJ@n7ic_3&jTA
z-hDuX{E*vpz?s(%ZtFp;L@qmY?)5(DgOcYg0(C)r7Fw9OGxk+$&cz8=mUP>AE30hO
zQBH+u`__s+XZ-?qF=#XAjY5&1^n!^W$6K4oMO(K~P_{Y|YvsyH%&{bES!chGc$uK!
zH;^Bew+9ZC?&_%~wh)DVSz@?hla5;AQ0hwvC#L!A)=FQY$AuYbCbRt#qRT<^Q8cu_
zQ#q_g_;omTm2xnpFnkE2;$eo+X@Qnr*nCP4pK6wMAIkBYAh-7Ow=$<{mR6p6TZjE0
z027ufYj}Fa^!RQL2miunTT5^S&e2P`XRXn*X%YQCy;$o0vm?kBQ`;CHhJ1u21!+=l
z9{lrt>)_a=&(Nq7=}Io3SI?t)oK?^?zf#2wN%eBwxFa@p3k3#E4g7P(mFO@soV>rr
zSn{cSr$wyaC7(Fu6*Y#wXNOu|l%`+A!xV$kdoxFLbAStFG2QWFv>`sEy%6UwGx0$p
z*jJ+_M8Pr?c~C|o2|;0pL{lX4kjXJK2p5h%sBirhAI<VxsFYLO(N3ObGhQZbn4w4v
z69tLc%0*nu2e+Wx+keQeVIG$B^<I=X%7`BAi)#5I6AT+=R{c_Yf)QtN{W$&<Jb~9|
zmQ1=@vzgyTafV0(xS|vuwrs<rMC19(CznW#;UD#UaF*)*=$xYZEE<o8(FbrYN&22K
zi&?8jIU10u1?Jqdey0fhh#UHmW|qBcp~P#ed&Np7sYjTy`Gy}FZ_ZEbqt|{!16P=#
zXoxZ<%EO?+fE_q2j*a;kcY>hNFT*F%F5;a>H2tF_bc<9i-;!>wKeH3b=|<8D%=Cn4
z4dWs@x78C1rGP7mh<QCyA6Y6ZKIM)>OE-;9Lbnl2;zeSS)PLCCK<+oKu{T0tRk`=z
zzE`2~z?-~Q{8k|qs>wzJ@+GRnIx|j#J*pV_w;#k=6lUQi?c@CTcw(t5h#!R|9?+IL
zACyA7pyS7?7dU^n%<mnYOjnA^ejb@XZR~KIbRlIugTFXufh*S5V{Jf*JD)S~h-a8=
zT&kQ9XbDvx-4+?+>6c`a{yqiX$6_Zh^ew-hHb3{aEIx5b-FDd1UYP2F!JJ-Om4B$D
z#fe`UCYY#=TR7CZNR#8CFi#74gEoSIEOV6)PBhvxzW`#&o^XS{{(V=g*Ey<*yfH5^
z)gnGS9E3n2T(s2fjR5RE5pWW3glzs}r#Cx^CJo9|mxhX;9I-qz5UzD=hM8Zalr{nK
zESZhqhlkY)OSxC6P<eFKQwXZIXKxO-*qu)aPvEaY8gKboc=c=!@Eeru)4dQq0r3Y`
zE9g~tf$>>NL7VXC^8ER;fdC|qAQ8gQ98`RoyE&0l8;0qI#Luf_ontcJrP4Qw93Sxd
zhv2qk%h#?g9o<F4kpk}6(M1g<d#?720=91KTiEc6PKnr430U4(9Newa0B7SpdAn%C
zm^pSrQx@v$68AfLH#D<!->S$)Ir<^^xCi2^mrw4nq#wSzSZj)OT^QErYJ|G2D3<GC
zlvVSj8Q&i;!?68&6p7_c9()X+oR-F(3vgst97QDzj1QV9EgJ(6OUM-qP@2=wG|s*9
z;?pmomh?k$gZ>by%|e2k@dC|pr>l|=+CwWjFYa<P*qfEU6<0qYKOQt_B<r~N_*Od$
zfB!<Pef&ehE>W|j&h2wXsI(nb@X1Dikfw@ZZ>_Z-Tv!LHzI#_Ox7cKHFAm;nKJmAn
z*W<yah@^e%Vm*8mBjk*Q&#7r@(qYiC8OympcqkK8L3T-Zuq&JPP<zC62y{5QKW?IA
zgxPedA2IEcbAhUEeZM5CAG0g(E721^8I=Ygjj0ng!y&65k(aX9IaDBwa#t7!hb6g2
z<NVMxq=WwwknZ&bjCdzI$mm+N&HyqnJqUwEZ5F0^nLLCV<m+${3KvKncSrqPP2*=t
z5R_mFt-@q5gW0rh?`ZtRYqs19h!pJIwFSS3TOmg}xAW#f)MvT6;sNjxhachM4!5&X
zsRcVSmf(UR=%H;Ha@h%L-DU<%nQ5pP3*;Oq1RlmcdW15uKbE~?aCFe@n4lQeh`|OL
zbfszo^<`D^FU}Hv28~1H%UTyND_l8*7qXmtl}pg}s4VwQk(uG3OsN2^wYPrhoEA=Y
zNERlGMnig?YG`99eqT9smW{ta6g`w-KCOT=69wZy2E!AzV@evF!s|d-;X5fI_m@+v
z1yR?JijxhcKBvS;u{HA6jN=Bu&gMk3DkvKu3iF?H&l57FHuL9FzlZ2XTI(q)M14tQ
za0-#a6MLs#5Wc0SR3Rc?;1KLBzjc^vihcUDFqB{eAAFR(*JaduO_t=V%UP`jSw5q9
zKd%Nv_b*o1V&#_iT@p(IuLpC2QwJqGOo_L3z@!Wnba*Y|I44i^Xy?j3PFCJ6$!rMa
zL)PV{QkFBIXU2zn48K|E8c5PU-XL!i-#00Ew6MXF1a)+-qXt>aqG~0wAD1bkQt-%Z
z7vW*X4IKUwM@yBAxZ{jvIB(J``%$?>>2qvr!R;c+$6MEM^<)~zhaABQl9~>54@!!0
z4`URej&Baqosgq;-$JURsbV6bs7EsmDkv?l@EN0ptf0OJw0yb~of}o(9mg$s4ngeR
ziBjKM6$;*-)U$3sEVOLi_Cb+dFe)tUq>V^J-4GNF?h1paw`EgX5_#k!cU9W1yY?sq
z&~RF4=jy@FIt5p`{1gNKb(7M-7j$lPd#D}h#{a#iwb>kf<cl$SA~L^z*=}w+@~H}s
z=v6GM>I{xDoVbIHC3uvgIS$fP7>^@9s`j0zS{#0_`VZl2c6(!Pi;Ty3CWQ#qlvF6F
z?N#{(f``E}l7L!l7iLR<j3yjO9oIngG6V>rx=3t_hCi3Bo}i_Jsw*+n)w5{tZNo5m
zH<95cXpb(iZ-ih1@eLgI1p7V8H+f*#8xl=ff>n0)F7T*b@2KY6C}QTou<^VH-2w#0
zSrsYS+584dHq^Q1jgfXJS@!3OwgLp>Uw{TyKW91GWMZK5?AQI#s4|$Ij>oLzSTb`P
zP2El7`!2-aCUV#~2Pz{DH#47P*({ZX+o({=(=K)V&5|p%XODHVtUP5cX6L(1B2m+h
z1EoP7;A8+~Y(!;B1i~=Rpiikt7f;x;yC|r>WwwoQU@%At(-kV^X23}i4JnR6>L#fL
zjUY5-dn%$rISl^;tf4v=@QKRn*ouBkIIIVLOWx0l%&bVnz*fo*uu##AFcr@>4ETu2
z;@ReEi|RMNd&?E5vn_p9>bk5x8{*38$+!Hz?I1(s-$M{a>3qKQadEa;DEbS_i!je}
z#@s<4mHH~Smg=2#Zq8=L1+fFki!NPaGqh#6XWMxWO)&t_uzS;plvcvyzh=rXX;{Ae
z7Jy$drtWFxwU0wlesx_duj?`(=Z7s>pz$j+9CR%8x=&=O8XzBbv5RzY+=i^tTmsWn
zyperV`T>V;b~yKfo1cL09NJ^05iy%kMDDC|9*#;}H^tK^EmsOq6e`F=oxinR{vow%
zq%YFUds_5FscV}~t@k+>FDYUj46`+<6Z1;oLFsoFxFcLZdS5>bS@X_0@1oE!zpPER
zXC>~*E<jltD()e3jIDPQnV~@?ke12jj^6ZUO#Nz>Swl~H2==XT<uf*C6|duXKBDwv
zV{3$Xw*7QHhfo?VZh$$Q1+jBGUgcv6n7j5CH@&AS-C*oqO~xsOzSqM%m1>%|K5c&2
zOSxAbu1?Ai9t~!jb+s7N%w#Xw+!WTDF~`sCcZu&agKL{<bgrL_Aa;n+Bs@*1A(q@<
z3YF$Mu489{OBj4Sn_QulScN7<x^;SVh%9=S^{dB4LXCP%Nv^3|Q-vM<a~?ll!N}63
z;M1LY354*=>J<1ntY(P>QJ0>?&nQH>+neGYu{Nf!8J{@jSpUsE<hQ0}(ZWJ<a-fYY
z3i4q`of_tFCTonAtqV`+?WY~T40&z8CN~!T0I(XVLtXevIVnto@VqEp92ZRDptGLB
z+B>I>+OBa@ibA(OztHi@@ItbW8l%lj3iUm22w<D4{V<%YQS{S=606Bi<)oxqS#UJ3
zih8&%y3s8bJC|ButS7%ycVUGRSJNew%<TvR1397eWOkQ}deNb!B>lRETk4GUT5N9Y
zb2*Q<Busc#l03W}Sji5~2ixJw8>#J4gxTdpev#kq^=s_fi5J7nFAgU})BJ`g8a7Tb
zk$0@L*eQ20@<zXsQ18NgDR@8<J}^{-T)AB}|N6wJtKxWp-eqlUp@>-KseFWWUEYcn
z=nvy1DWc_XXnV5{u1Um%tBv}SuvRsIxA#*Q2SF$irT)JD9GjhfJR3$hf9`Ykn3@!x
zFuO+&*q#c{&#60h8TJ^rF=T8t>ylMO2rK8NPaMl9j?sW1KhOo8Wj4?PaS$29H8^Bj
z(F3w&5E!%tk@v)rwX-2xJ@!crHz5O)ieIc@sr>b*y0t|`{q9{lSsdFxZS)W&%Tk~W
zJe;Wp4xsJ1w~7Op$oE0&VZIjQCw<(JJY$Lm1cQLp%qfJlv_k4`@8Mv+8&;@Q@T;*r
zR_tAaJXcs-QnigJel`yP5Pq`Ba$1@@;ARA;05_}CU9ut%>Br>5vj#F&n1Eww;`QO~
z(OIY8p{GFW-f@Pau2(S3+QAUg2+u(E9|@RI!&N-cue6r4CB+pDx2+l`Zv>1IQR)z+
za-`7(+eeug$OcL=t8}%=ZkK~nw-y$QG@vf#3U&n+MN4M+hpj<U-FNATd+#{J*9&K;
za(w2()aVu4kSQlM#L);ZcKo@+2@{&W3s9OwRhn*ew`r=|)-6rUK*NAql)B^_IH|`O
zG_4;QC?qi*?z7Dk*;q^#ttQL!SL7>1S4PySQjN>0h!7DlgG|5Sw$eM8q3Si*^)4h5
zFwfel`?LhB%W}4A=6E=!Gq;=4Ikmee;${x{ij-!k|DyFJ^^X0!@(ZrP46qxVsnaaH
zI$E!ghtLSUKf3dm_&6wYQGqb>YC*#l?AU60Vbqrf_T+RGagXx58x~CxA`d?K?PN<3
zdG-F@F&+o$!VdX7gPLB1D%HbdeXl{~8sAyPE=s3>OG-oe(3-i9$t#NebLI%XXw1v5
zN0YLN?@h_Zl|xB%DIRso4m(N2COjo?wPYeR8dpBHs`5_1;PcMji`9DtQo+cgV$HFG
z7{Z<6J2jhm0>`L7Z+8wc&hN_?z%9nYlBKv*{es>lh3dN?NBvyLW;&wd&>ULt-K%Nw
zLs|k|oCHJGs?j@{qr32%nk_6N^tSO+mTx3V`s5FDT;%Z!rcT=Q+mzMBVMx>rA>vN(
zI)si0H5XZ8R<!A>BTDURbvR0phHsm$S@)S%<oqh^=^e83A=I_~y0nwAsNkvfTou7@
z`8_M9y|Db8XZ7gvCE}^ZSAF>K^8^Xir(X5AFrW77B?1T#$1PA&MX62S?)#HYT$S>w
zi?j2j<%KG%n*-|7Dfi&9EzrN(T<7c=Q^%pp#38Ywem5nZBT=`gU{l4f;KhOKK52D(
z^eLB`RHK&RFb_WH(YUoFbZ>FzKH*D9<N!7#DHfXCHpMTt$ILtuAP<oa{p_45r;;`%
z9~45|O880tDH7F`Jp81k4icvtIxhgN5|HkY%H<!2lj^7C^}w1h&2(TVN*V$hCk*j@
z0TZ?qKFY7#t@|L(f#=dJo5OMx4?<;A+FH*TP`1cOu);_1=?H&8QU%1y81e}D1r$K9
z?_{@OuoDL*+wdF8MXgeJCB7Q{u3<49s)wq~<L2tVB6>MOR|iU>t>McqZL-XM2zm4a
zk2empY4{@FzFh}2J}Mp7L1eG%sY?#^B>@bD>f>Zo$^G*3E35E!r!b97ol?u)gU*rt
z4|OaxjmJZk&dwq23e)dQ_hkL*rM_G+`%b(^ptt<3Di&`7DZqTuT(W6Nd0~4pOa7%k
zEn{@|06Ee~V~q?FW=AU-l3<MXy3MZJ2Hh~+0vU<b{koA?=#P6mz~?VIgp;&fb(#*L
zx4p!{Z)rv*hpM^I@Zo4I4HwcE9d1xdrJ;z6gi*(mT5R=ZO`Jz#p|&{P*uoc;&G|wP
zI9C8EKZ6TmmC3#iu`^Qz40gz;&@m9j`|qLN|5nd9{j@oY9XV?B8Nc#(tbj?8$5?Z4
z5QeP3<U}z`{<%?uGj9lc$qoBC4uA0cJ)I&h2L>nYwtNP&`>YIav9`->qk7zz0P9lm
zn#7K@0~=nP>;?J33v2zbH^tiY_ZY%QsLLYyYI1>X5#_96dd;TYW=M!32Y&zL1hhEK
z#n#!yL6MjaY<W%Ou9j0V!Fb(9hGDNQsxLX_KCyW}zMbiRhGSnfALETn;jH7Jggijl
zCf>g8co_PcIXpY(@_G-Ilf{+46{=uI{GL9%O3}B`iusu?5jYmhlZKdcjqMH|welGf
z1kwC^J%x>49VwdYJz=_9m5z)FqNwwYO~|g>HHEm=@12*RhV~zbA+grEy4RYEl1ww0
z&WjAi98&U;$GB{#ItyP#daR3BJ)rcTJDAH&VFLk?QV5a{Kc%WhDvPCGu#;M{nRd*q
z0+B#_ef@y!@%Kk7uLS}#A|y9;D{QoKh=cL2`?*Rw96a4wjq=iwX%@2rvjg#+6nrEb
z(FcNQ1BC*Ssw$r49Z`YoHO}W&HxPF0B7st73KZ9C4-F)kS@y_ZAkc--4sP2aHdI|T
z7j4s;a3I}oqx?tf1-`#r-AP>ET0R~-6_jFF#_H72dEC6J*!S7uJ*+Da*5pj>9?)mU
zs@nHni_YS|H%&0_BIcx-nr;vHSPw2DXle1`qzblLIA0`ILoA^a&J*nQpZ&NatT%lZ
z2I&dnoEWSuMHf$cB56S%PwPFYOGH4VUJ4)WredDI4F2`DA?KZJ?P)m2Whw{-PQixM
zwwKT1m6@W6&6$)JVjP>{U#RQPJZs*42hI3S#%~o4iISdRHi3?I;c2AmH}6*Y>Nybg
zOl2zbGx+*K1c1CzyZG%uZ+{f2m!FsN7x6VM?tX2a#YAjC5jPuBLr^Ht<2(?VPfeB+
z2xn~2kI%<5MnyxM!WgPW#jr)Am@S;aC(Q68R=%bUcbVD4kB46AE7@?kZE)m_OBdD?
zXIZ_CRawRn3w3hgec9R^+r@G@;2jh++yAna(M2g|dZztgPR+q_Km@t?7gY-Qwl!yP
z^`XUWOZz^L{f&nPItG=KvEhVt^bDWBPEo<61)RJ-U7s>sgAGd=<dQv=YAx#d2+#tW
z??fH7!-8&|uMO7#t{@@Q8i`bXhGjyXn@2XBT^Y*|<XfIf)=#v+LT>Oii{LKn35W!7
z;pUCh-sI)$SX`H&pfyQn74+yIUX72t%7E?0ukc*!e9(qZyIiodp;nXpW3`RjJZ=X&
zK$BKx(CyQQ7B*>yh`<m;U2#ZGQmNNZSK#)L2=ZykW0K!WU2j(p$bZn<E2KTni(^C$
z78NL_;FC?aanx7&#U(m3`$eYAL<RYOGO~g56bS#QmJ9QOIK1PZD#Z3x`$}h`oXqH#
z=w>7=mwVw@vo3qm5Z?xMqEk2K%fJElue16}2Q~!-DAjp{DcvDcqgL)Y0yIl};T!pe
z{NIGq=L)|P7EbfbT~z=T?J|L~6;xLyjov!X0hIH)WK}ycLo$ob^i7_Ojx4p(^_(5n
z;6^e*eafWR(zV0$`3NhpOc&qhnL^3MFauJP-z<&d<OD}FS4^waoH0VaW}BM`nGoE=
zkF(&Co0$uj2w-``JzD9;a*>cULXa3^ZYBkZi=qFTJmt>;wDY*4F0pMym7}&DMrEk`
zAG!A!7*8HZ(RH0$ou3J}j&l<fZG8N;?KXR*qQHz;^l@yvgavD&#BrL(jT7XCTn}tJ
zT-M79;)F%o^OiCw`?|!7I98-CHeG?$7~ZIlvx*9q_qJ?)F)+?Ik$f!gycN>vtckW?
zSTU@O<5ODTU|fpBcut~Wic=IMO*a1zMjs<%>6IKT)o8_0<$Sx8;ylI%I0v`x1VrKM
zUe+~JO%HEgsGE-X<r=gDVMhdtkf>Db+2H{DORp;YNq4uxCikKmemkcQ%%zl8Ni(?7
z*C0!J42((9T-m9;?`T&?#>XdYHZm(FGb$Oc6?4mb5>l_XpFZ9xK-4G(eXk-a^UPvu
z=p}~z?vMzoVxe(IH}l)eI=3KMF13geZ9>?M&|MWnu_DlKSuuX=J97Ps6tZ4Y5<oQO
zF^c%P&;A(m80TgueYC;~M&ukI%YmSvVhz3D$rk&fhg~vVI96#JVrcPo@S`j+)U>QG
zvW)@3WOi0O@@(HEj->EmD~!1<2!c|-suJGYvq11L=PmoapI9o#T?RWnn!9y0lB&}D
z;%ok>@dHTBf|#Idal0f7hHDj!<~IWk@CRj7ZNR4OYOp=tH4_a}sT3K3>7F}%(xP>#
z(l^%_E=7WU7XM~R-gE_n&m9%fBIq|BD+$eLhVgADTHe}W)w3CUDyw{VCXa+z#Pg{g
zyXwqXgN2N(@E*^3tM9SOk<;U;-&(S<Tc1z9QQy?k4r9EkE=2l$PfH!A&C5YASKIYB
zK5rM5j+cih;}$VJiJh+6t+p8OMxn`<s;lh(ktfWpo8dwzI`SGJYuA;4x*yxwFUr>)
z74A6akixx-#(8J2)46`-<fegSrME5fj>eFPm1F53kC9_+rp_B2(C9W2zCO$GNjv^Q
zjC4S<XRtl(EPW`~gZa_14sN5`*#mv{rsf&HKySz<sWOsJ5-Z!vSjdbf-HsY{`FH^m
z>!90Qel0z(6q@^rJa+trYOnFByZjF39lq9G1#(kFk0wBL5wym$Qe#|-uBBj89SxWC
zQ&Poln+C*EHT!J<_D(RnWT9Mo&auUmFqN<@A@B|gT22Q2glMp!dYaDY)N!yV?)4g{
zr!o^fMg7$cDi`6a3P0iZp;KdZn$$c!k6I8M3ubFl;09rCIed}u5%ojM4PydKI)pZ<
zFO#Jb5J5aIzU_eluE7eS)}9S!2J4He(a@JOKnS01V0fB~KLEN8!m((37Vwax%<kh#
zZJVW`yGkC%@MV_D6yG8vR)rh@(~(BC@C}*Lh8|KdY^h}&dEw`eU($zQC*QK3G4I)8
zuEWxLn&slNbZSn3>O1)iHd#&jgsd>O(av}MO38+3C&nj$wodFUY*;Cco9Be28Qt0Z
zib@T-l_a&T?s{<f-szz11?k3=>lSykGI>(EOP_FePpoC2Q71>ING!e%@JQS<wql7R
z%sObqfGg0*@1xQH^!5g`Gz=;BiPNV}1E{Cpoaz`iC^TszF1rAGVPivhUmoV1B@{!t
zL0A5<7Rt<ppZ)M_(*Bs63f>o;=6J_f$$NmZ<QSbP&C>RFl80&39Y>g7YPDb;$7#of
ztSu%@(P3=;TAzn=!_8;{L^{oOs2tl?osgW5`=bjnN9*MZ&Qoq?aLNbrS=$d--!2;x
zS1B@4td#{ue1*$zkNoY3k0TpY!#i_8DNVfF;tZ<RexlqiMfS?-M_pYm7nNuRx#&Ev
z(QUDpj1pLP4Yy9fC7UA1e62xG$@W^4{+Xs%87EQ*#7?dp{HnvNR>DQ~MVFmD{&p2^
zS6SOa59OIEdsV$6DrC||rrOc@=bCi;E)iwkW7>e68fo;M429Y<_;%%B=KkKNDz9>t
zN&*~}w++5^YOmK-G%3<(FS9%s+B0#ZH#m`Kd9y<J&X1~A0OF-DEF5=CbSTrij1`(6
zg#)ct`<Fj+a8y#}x2W`_7Wtq%u-|@^=}gQS=3re&Vu42a*)YDAaGe6}Gys4J=Fe0m
zuC-`aB;7e1|1lqJ4+vGU$WoaiQ9n($K>-)if*RXH?q%_ev#hK1>rwj5luOSuwM!f*
z8C2ic@WtJq)C7~TVgQq?@eErTj?`nAWS!-thWc!sy+qYR+xb9C(<GZG**&AM17DYz
z`}=#bp{OdA+L|&%8ADX*acs(90jK)+Rz7_<Q+ApzXV&kda=DaX=vWXiX0T5qBP;3w
zOS*WI&*d|!3NsUv2sIM@fu{MQTTv*Xter`mA)<=$-c|}wzJeySHopoqev+fwQs`D8
zksO<jn|>kLu=ejT+hh$n6TyTWO3Grq!!%jP{zlxaxB{1JeLf-kaA_U=iHsw(ilu_A
z2PI-1+v1V?J~p;bpPwVi;PYCDF~zTv7CrppfMFBcthK<lDI{xM$fR3S(TYGM^4B>z
zv~ej=5|#KGu$ZaBE_1ZZFgb6iEaVffM}{#SHFeC1HcP;-OE*7gn)w_1Cm(DRi_!E3
zC@>{|-7J&2rz2yQoKpEASLZYaavV}S^NmI&{+|B(j-M?yDNq)Ka#ISR(6f~W39tux
zp{Mp<tEcgC&K>USgEoZP$_pk|XCXcQiMSa;i$ZCyBC=w|Fv>#XV=ynbJw^E8%PR*u
zfgG`rJOheBxl*5nSjU`YU0+X6V=1yG{OYxMzQr(pH`tmArKS-;P>*pv3b~t@E}mgp
zb5na#%q+b*3X2(ek8A2g@{6mjL~Pv#*rV^F&!64iYvuiFzm5|r7>_8piZ6JeXHd&2
zkKAOcK(Tn^-n@gP$_@n1L8z$<`u!}ZN>U^*)U8W82z6*dk4df?19!Zzay3mEQ@+u?
z3GcAdv)8EpG;n|(EmzxRw6q6X9@{bq14cwF3~>!0GHq}tGGrW9PZR3`Xj{al?5(On
z)6MuTl4Z|RkA50Fe~>eeC0w!es=p7)RRKMdfpq%CW9GZJqj4WECD<u!^UeI1<$wqD
zXx(|&h#LgP7n*d!veJ`BEl{`P7xA#h>R>l}{;%na<PtZ{W~Ee=AuF_sY$@^r4y)&t
zz5}n)>fo1|<16_PB)0+cLHPX^`QR1m*;eF6Qo)alf|}Rk`H9iqZb4W2cZXifP~3D_
z^ufPJn!H9`lJ8m~vg!9BEOK<GvaN(6?}MLd3QS=+3e0#tBtUk`QlMuo`zR9={14=5
zUDaQ{sF5vndc)(|SlnECx|FxGb9bwUTw+iILO4$q)Z;hn5_&NT@z{<$SEjGAT2Nbr
zFw%z&ChS1z_SXj++KI%nRnYbEM34jyYoFZ}<jq?Ptm(Tq91!H@Za!^Cf4!!igU@s{
z3aV$9{Iri%J$CP@g(rqEk~WTUCw~>E<2X`rz*}oxDZ(Gdo45<PLrqb|$?)-Cixqi4
zTyuL`2sg`z>eKANsk!UCw=5NjC9%%@-5fS6Sj?w^5M9DbtfID5^&O;woYB37NT!Vz
zK4o&ZacZ0RV3l+DYTg;V{*J6mFLLKFP`_umd)-(uE^&jTzOP~E5O)Wf>%MR;0q#i?
zL^qCQ%aJTILU0-NCRm#Ov2)C^iN{$lh{?*Txa2LmETJgRpn^B?k6c({#P0`6IIxh4
zkZm;Onk{Z22g6~daN5achHw$ghI{ZAog=lhGRGPZXM<+Q{EF{!u6(xRJlBvlNU;-f
zwPXhD05xSy7EB($-=;b3qx)&XN1KsGYVjMN*ux9I$k~pty{V3Y$bqDe+)+THwA&Dh
za<?gSP>Ytx_Nmc6V2FX)%xCJF!c?zz2xu%+1=JcOx|`w_B{ZR>HH-6as#K`zZVhhz
z{ADq(48;*C8e>w&qa^hlj1^x=_W8zH3nw8%KVh%?XDbDFH=+6nZHre?z0R{CxrW|g
zyko4J8EuJJYRdF0?1l0Es)yp}n9}sS;p$|7wKNrb!TL73WC?M8BI^jJ2BbGBfseib
zlbKN$A7bwX-dXS3j@flf22)^LM2b(f{;~Q67_rKmp77k2IJflA_fsL<M*<bG?h5XH
z?gVhEghV8E3VqMI(aq%AQ47Y$$~7hty6qvB{;^ZJs5KVcU1|InTJ2B+m&J<Yxbi1#
z`P&U?j<SyN)b{n+j;Z;~8cjXvnav|TKdrXlZW;wLwf?!$+vF<#(iH2gqswZ7D1Y%$
z6-#_%-)E|Af^$-9sBK#Q%a1d{NAMnUy&$?zH@auJ3_k^N_%@4zRKt|!7f$EPQfot&
z#>gY0(~@?1vP(^Bn||3;_sV)pjBoDlyovsdNqZ-|nx475F<3&is)wW431TG%yBE8O
z2NYsGEEr^ovr~ZHWG(DioI$BGG2$=DreMFND8;JNw<yC;*PD!75O(;}68rm?d4Gek
z^trR#W6cOrcD0&+O7Nsi5g9Yp*>CyjLVc~(UiwCR4mmPErm+=m^lVa!-uHFC-f_<V
zcgY3KB!k#PO-s#$>R{_&yYhkN>%o4G<(wQUdHz{4gi5e?6vP9Xh!m6IC%NO$-L|>U
z+;LJ&&~?IjLiw-}99Sz+K>9XU<R8&ZlP<+ZaQQ@Q7U|KbZOQdfWA1weu-{;~SD7{Z
z6ehA<vFpp8ao}Pr`*PgT0}A=`k-L9Ts$R-a)~kMF7>w0oyjs|v>#~MOx|gH|dCHb0
zrcfnhu!w+~r%PGOpN%I-+JwPohDP}<H)cQ6@?)IVz?ut6+Zg4$`X_kM@(2Sj<yOR=
zmQ6kn&%UMNF~=ZJFCG~FbrE@5X+B8-n;UCCe{AchtT3f4@yOD{obi2(0(7Ix{xvpV
zGLxw5A;*|i8BBH<r>SfK7%RIaACNc0ZkgXMyg5$(OA<cD)Q-H&)rO4o&w8V6CtgN+
zT{}z0Fbd~5D;&`^5T#U~zKwEPeHln>ow8Zr37u9@g;qMi_b3sLTwZ~!n|%r_qQw*L
zFW^XFB<Zh5wQb)_8c9Ke+^P?CL)q~kQup8dCDe(*z9J2HK(%D*p$G$872OX)8ry}~
zM&Ii=Wa>Y4hKDZQ#qhm;@v3@eEVw+dE)@p(ErAHYXYlyBvAnN4OJ<|PVu2f7IZr(7
zlSmm_%PJU`e`XtR<1fi{5oP!6<LXa?cj1bq#%ImiQ&o-b<4=`b&vC~=cv!&Vv`UUJ
z8=O5CXn&RuekT_ec$+s;va8iong6w=FvucFRbQ*-zD+!?DUcSeoTxHs#_`<~X@WC?
zY(ki_aYsM3j$95eH7D;kK{Uvs_tI!#e_AsAX_x@O5<J)7`w$ufcXCTyhr8T3e|qAR
zyM0UagE(wADHGznka6MhBH&ic&`49HO3ZRk)>_2w+?Y?XPF)LZR=@e1-Y2d2J2*e?
ziRw9}qZUh^nr$B@fcWt<1Pol_YdGv8@=QDabURA*I%AqihR0Pg&#wd`EXU~MdFP@m
z<-~ag;}>^=u<E0Y!7z9cCw3|tZ>4ckQe9_h!#xi9pQEv|T~D&Q5U>qSMfyy)p3E0s
zA3rcdN?F+VP@6&jf(#VQ4eDo8I+J<Tj#&^c5pJG$;PPrq^T(?($wDet9NX;AS6w*S
zJFqamy4hGk{-V}j1M<{cMP9PN2JYV?qR!OXFfV0zUHGVG5Ujt<Zdl?B3)COzPL;l&
z|MF{>c%~<c<a7+%rK@bx<hXz>G{4~LvjiQ%sp_CkT?RQ-dHLo>R4i!ZU54gptYwYD
zwp_{snElk?al81F4!Q}Vnm|E-P@p1o95G6wrPB1pyh!Q~i8YR=<c;XSz~{C58?+r3
z_fYkrWU>G*^`6Y1@b5#1G<eT8s7lzh*V3UuFp9_p#i*!88edSMXyU4Nj0-fiyc#t?
z68%FfpWq6lo1Mn$MIALnwVWI&DYD!?O;{^POdKQGnNDG57<x^SB-+2<5k!nR@bqJa
zayw6@HVLB;gEGYS?;a%WPn9pWH}g+c_N8!(AbQUWK%1q6?+!#@^cmTr@LOqRe(qpG
z|I9_>@7@2ks?P^E0pwm3T{(T6HkW^lAi<#TAdE8kv0q0o6tUO09HnfN4;gX@Ir*3O
zh3B^<Ry-#QBd!JSHDc`&Kbrfj>K!SEMhmX2^VH>GQYYRX02S?V_Ts%pW?lBq6eFV3
zW9A?ZN6&rq7beFckT@n_wOo9yYB127vBc(@^ymQ;B9(H3g8U}2Yn3{A0>N-RPyi2&
zqeoH=kF)SZ8ZTB_NZu1oXlClnX0pUT*T^+j1ye`(2B5^MIOGXKMq*|?!`xrTfWRy9
z$@>MLnM-v!Sk`&}m#ZF0de7u(hOo3C9}QH*mZUzKh~ui{=iX}dU}y3E{=8cWQESPL
z+$z(s3|nDxTvP&N^)e+zMH;=C1Q_wlYn1D6SC$K3aIt>nq2v=)_WTx3jdJ_Ge5Hdz
zXQ-%9dS>sAf$;z@QFv<s*C{cnLTGa5`PJ+~Jc;8f?23yt|M=6VBU1VF$t019O#Rl+
z0qIGhHg6Wfw+pU3m_bAMp)%@%8$~v<N|Gctrrgi!Uwg)QjnsINlSR2&)-Q+~WKLLN
z=I-)9hNz2ApR{7w1JNnvi)@tLckJ_!Iw?HoO46y@M<jB%hAZni=s)SDAuHeRal)O*
z)Sjt-h7B{9AbfOMzwC-87Qd`nI@+NDgA#Qd&<FwDwit3$o4huQzqh)H@kY1WkG=GR
zvqSj2vG_=IbD6iJDw?MY3Dx?GBaGLVu20<5g`N&Eg;$2<If3UD!NjGCxt>hurdD@W
z+@Yha3_zzd;4e;({3L#ERAXmy<p~g^8jyX^_kF*5zi{n(eeDtingHie5)$Gip3*0Q
z&sd{);DW%Lh)u8eX-1!1yr&z+_vahI7bM@8hpy*4LEviy@acH-ZRf_<r%CKC;6i&x
z|1Aah=nJeR7uZD2)@!30Bbt7{WYF3<)K7k#_I;kW^L;7<-aP;hyWXB>?SKb2G4F2|
zKG#oOz=;DRQ@3@8+BQ!Cb6Wt3)M#{DAbIp7k<SgI0C2U-sQ^*!sPL1*Fh#b$NcpW~
zG<eNXX)51{f&dUV5^tRmlR%b=uw096sDO?w=u#tqS+K@e?bEB*?m61vK)rQY3z^1B
zGucgwgN|T}C+w-~DS1lG^2<f|#`(y1#uwVj8?XH_;rG+SF8<QRV&&OmJKwvfE}!Ss
z$&1)W98_SF^0k9BFdcpkOHhSLbU61nBciF`Gvh}Td|zI=p1Qi8Iei~ayI#&VUk@~V
zKm2{#r@FFJ+)3#=^*qjgb5u!IqLW;y-ilDQJMGHk)1a7n+Kf9(uz9}=ovpmB^IC2P
z_g;FnTHYK2B~uasf!_P&zI--Ia9Di7^&M*2`^NE_ht<+^vLTMAAI##Q_CQknO^Q8f
zlIVAFwto$|u^%g>;3`*ZGcCkC;APLC%1+U%)pd~O6;&Mxo^MwxCTqq)Mb4?n^i)a2
zHSn;lB1NJ_gS7KE61*25Ecs;s-z7b+;AQt|LP#9g$fg$wClDE}UrO*<o+38SBl9>Y
zKSmb0$_ESWHGd9-wIm_{i;4ZR&Q<nO89eD+t*vtbyoLOWX{hfkICMH)*D+}2?#d<Z
z!wh%}lsC(g3=)$_8gmie#%*_-gPq6Ly2p{%N9($I+nw^(F$;bne;puuxgNgNGi*Ib
zWZ*BTjMhH!9tZoLm<FI!5%;G+mX!kSVC(66?S*isA<GVAeQ4|G#hB<(@@_3En1y)K
z%%j_N!`9NBf#8;C^VBgzy&xSKpGGa3fuK{)M!3I^vW?83NL|%(8n#+nFs8ll?`^wt
z^#2nE?HG8fR_`-%xq%Yjmr<v9L3OlW7v~906WMxb?cQ51_rJO|4z?6ZVAc5!;U&0g
z#$`}m_jw6J%dH_5Zp;b=3p$!@7U%qvkH3rTFp$iD)L=Jf)aRgq@lvIbuz;?S&QRG7
zB3*4xjX3=BHt)+)qt$=9-$oo@*zDt+3zfU5?2){HaP3u-R6w>*guttbC;H&pW;W=f
zc;2P{F7<nHv<s?4;2yB;+5cYnBIq3heyIgK`z0uOslaUpbbbMT{L$+;QI2^6K0*6y
z<eZ%qK0s6*sPvKQbiw%KkTPI=-)hrm{GHm|g~Iny&-6EOvq>fhcRDa=>moSu<oAyB
z8Dv$V9)$110H?q2@{;H!V;fNN65YHSNq!ay?KSyF=ph+Ubnu<1@Ng66o##fvA4oml
zUPgV`>7#h#dl$6B@*M0{anJ$0e0(j|B5fN)-tAPs(Q|e4dS|r!vc#JWl=J3%IK$JQ
zYc~Pz-UuFi#~$P77XY^1iPhe8>mQh&PP02bcK)7Zoa^%5&;EIUA$5`9%fJr2_X9Fo
zW-WLl>@PZOD)_uc!<!JY++TnRemk$Z(+4Yqac=afhV*$(Ak+quD>})TG`@RpQC@CR
zZb19gs?;*+L;F0he2m%h^H6F71uhddysh6--VFU0HQvMgvcm^E9}nSPHx__E)W;5V
z-$kC=p`Y#J`zhF-@NZ^xYUS!izEw|Fmb|V&xf`ORj*<r&@*i>P3Kd;!zD<G8D+V9O
zZ;SA9^?y7+h;Fa}+Y0s4fa_SBY`~N#{xsm&IZ!GM_~pP;_Km3UX>;QBaPHNkpn&9J
zV$n0aOXmI-p48}+QB!;JX|0X%=h={GBFv(G%%>^kn`)N64^dz#tLCI|Q|E^HdpR)Z
zq=9jhc61Uz)Ah|Xs*114H3C+C#gpLmVcZl_)erZ6Fq&b*%f(-Cp{(kmb+RM>C7Z3?
zw*nZP7UK+5dA?;IpX8pXdf%C)#ch}JK;o`gf64GLO-oUU2|k=FGv=3n6OyveJa}?@
z-?lrPODW?n)>D1uy3_998REX<-aDKV6m3L@cKX1L-n5<Z{9;s2O#Q}nXNM<x<Jtx^
z&U{Y0e@VSni5q{Ad=?xn@vYFGF%)|g4hM#1JjWMTI_c-!Gn5SN`jEPhYuIYw-7u6D
zBQy3f8orQQHBKa*Bwo~c#Pgk?m|k|8Y*)6?ETxohta5Ic-jTVha*l4TbD7ZRwx=j;
zR2A18O<XdRaoT;JKU#m6KJwxkA)>vzV>wIkZ7kn71+S_Dx*NN1q`_<dl-f!*^Ok*W
ztItwLHGX}UlztmIQ(v2N6R*izNm#9T%m*bqLFCAnH<_b~jxV!dy&V;_ZG(A{-Vnga
zJjA=t6~8obc8ePQjQ;%M0B4D-I*3zs=XR6n7v%n+ODHpbd~rXt_OV^Zqy$!8FGepk
zz=>9DGX+JPAD+8cmjzG!1x?$V8Y3M1<nvuE_#qcLbrqq*7Q8Zytg71eeBPRc)RYnJ
z90Vp5VTT~0we=Lfe%1Bl>u74v@+$iZ9o#db=ibp|cZ)C*0pIMq>u-jyTP+^s(9?GJ
zc*lUbx_Ps{CZT;Nj?3^^E2wjMpL9s(Th8!vWM6<g@)hUW!;Z*p`-l{aPoNtJ4*uM_
z4rgj>;^gdTYH0I^voo@UW90-e0sb)TOsq`Y|B<r)E9K(@Fsi!Sn*taW4bA?xj;6NG
z0M?ITWdNhHsgs?Hqp_(IfR*bXiKv~e^M}HRfa4#5oT-V0p@^LuoHo;kfSHMf4Zz94
zr3(-c_|IB@rvCBZ&svI(cE&2E&H(KXR!sb3ZBsXA0Hc)6$KoRY_M-pxQUF~5qo|#=
zoui7qp|L68&va2IX22gn%5VY#0LIU5&JrrlhR*+tN&FdO`Nt~>Cl&zbKOp`nihp?h
zcfP7BGvFU2f5e&!MwX_=&VL<~vSDTdu>ZCFXMI)x+rKgR7+?W#F#ls$%7z2L#{EA$
zGY5d<zYoj+_P-BsAJbU?Z2y_T%nsoAk6lgx`+o-jtpAzK24MS>l8=~6*>C~a|GPFT
z9LIkj*Z>^=(P9U%{l_Xdfc+o&2de)D{x6#U3B0VSt(mhqfc@V*{*&{60{~!DaWQiK
zy9@qi0>G$YVe+B;kxNENQwuY5X8;T9hi4zDceJ;&{s=gnv!lz$Zux&?=U-n`<P4px
z0Gw?9U=gu!c2YET6t%Olx3m4Tued&PVPXAY=A-{(N6ggN&cyU1nQ;H^S~pN*18m5A
zVkTU$e;c7LWDpQ2HxSVOb8r6z^9LXc=l^WBzghd=Fth#Z&Hoi<RwkzZfd0$>-=O}Z
z^MQ`>1FNyAy|as<HGuK|4ZE1A>i>ZpxCGn+L6#Pm5(fbV1p$fu_<#VnLB4->v-k=E
zA}0qz0|Ej90|Ehx3j+DUeW-v4fa3j!7YC&R0skup0|5!K0D<^dNB*P#Lm$@u&iSVY
z&jI~c`@>ES*#BsQ(&d2vm;W;jcm~3yXm00h=VWeY4`5|r0^t&ol7skT{e%AU<bPS@
zIfBUL7?4_s<L|JkzaK?>fZZS{Frajxbl{*QAYdq<;3%NLeh{J$FCanx(%)$x4Ja5m
z1SAwR3@jY{he87~2pA|hI2Z&tB;=oEK)pZ4K_E~dQHhy_q0p2Jp-CLjS^VO1VMs-4
zdN7oyFUeSq9Q|S8FtM<4aLFkssi<k#*f}`4xOqgyK8s68N=d7zs;O&ee$g^EG5u<0
zZei)<?DEak&D|p)Feo@AG%P$mAu%aACG|&IUVcGgQSr}`(%QQEhQ_Amme$_B{(-@v
z;gQjq*}3_J#iiwy?Va7d{e#1!<CClFo7=nlhsUSqKe#^P`46m*_8(;b8!nU&Two9o
z;1JM%aDjrk{sE2x0ZGgZg(|EBZRmhT!r}*mE)thp(*sM&s(guI<Twq7NyfHKe)R|1
zUu6Gx!2JJzA^Q)o|KeH&5e0$zOK?z7aENelaEPdgAB2j9`iHRavHlYNzeMtvDE|=M
ze+c+t1QZ$?8XgWF4Gs>Cfe4p~;r}xM*FUx;8gS*~_HfXT%><4DA_#JTT`VtjdZtvO
zvf2sFcGdhsnBn2Wj)TCvyEX-uJR#6=<S5DKd_O_Wv1LZ!Fu;d0i$kFB#0D}zBQDOw
zeOE;Nb(as}+pDFKJ;)Z)B6`?OLS2T(w;ZU_AT9zRNG4Z?V-DJoptPD%F*G!3_GN)R
zMi01PHadt{PhEHS#k*T^EHr~7bg_rwYAm`9VP=<>M>6UDF8-EN_TYE4%t*}}C6x7O
zBzY)HBW#mhGFJ>lL~-WZ$p#RJ3{O`e2;WplOrr6L;G0N>!b0pWsUYW}&?opN%50tc
zA{)w&yFO0Gp&hs>3Fq45{1$I>pb=BwoioL`{}+329uIZ@_6>i>$RHU?A!DggmNr|=
zV9ZF_vW0d@Q7Bo9jF^!SCu5g1jIs>Mk`$3_F_su1$`Tn2#%^rW;QpT7zw7l}zw>%t
z&+EGG`}v)J{r>Y3n)iH<&-*xz_vd&Y1LJb6Y-3N5IU~=?JbV)7I;;TwU!US(o#_Hd
zKftHmmFlwoI*LuZWaSeD>FVbrLY5p8+KvZLb}2v+L5QxF!VaKzc?(#!;t8vnByAY2
zuVid9D22q(gRMOT%V+w<YOcmxN>>q-RrvS_!im7N(5xW5GwP61t@Qe8j=F4xAr@hy
zbuCOiJ-r*EXIqpv>MZtDP<x4#miLn8QGgP!mAb!@0plr`BVmj@vSmWOjk=1)jJ=Jv
zfD3r*Fr<WIdMOZD=nc>`#-%KJVf}rHC6Iv)K4mpq5nIQF3|^fr;1Q3`hSFz4h?T|t
zR!8uIQH|vf)YJ=cwtxf!glG(1qLyRDlef(`7J?-y0*WkdUgbwSne@6RQ9_J9q8K7p
zJ8sT8-SfoCTx5u=5KMx)2TAmaS(<QxZgq?eDRUpxESSsMs}6ONweBKi&AL24%>p4f
zK`|vD$~jw?U6-3n(t>-8-_lf=bJk__i$V4;s`h^KG3;(UAG0)L_3pDz6O-DpnkSNE
zcaVT!XFvri$xt$z4w}-1;rdhjId>RP>hlfP`>;77j&BC<_4<$wcJ>LlLfpU-r$bnR
zIh#HbT<V>s&Cb|{QYgwD$!wCO`&hIKLx!zBK|*UWmf3(2{paTWISYouArQ8*Jse6c
zDo`%8;HSxSL!|Cpqp^Boi)p|Hy1{sO*QyC-Er%z|D{hmID30;sSUZ&=2fSS%{&c-0
zQ7OGMAryOpDG<BuNUViX^`xmUbF3X3my>b88%?{)wA={^J+(@EV8t{4O3#s2Evb=F
z#QQKHZVTwmNr$z?WXx<R!G18(Q5gb&O-poj%vx77LThRFUY_&P`YRi*)hYnIm4(}}
z9?@<wWRW<3T2Yo_*^)L%yV{!SiW=|-f+(gy5au0)mMyDgMle0)jcT9kA$tq!t!R5~
z`r!DjoMDt+PUk^w2WxTy(GcJHs2<we?UU{T>Bq}j1|^B;GIC*s%K8rnH>n!0$|uTY
zhSC6BWkfATwSOUR_X&jX7Le>BsqmcfJP)cOAtyv~fjnZwLUeuDFAnZV=YtWJ8c^HX
zNAxHgw{8aA$*=V4Bg)_q@7t9Cg=7W2Zq=HWV%ob~Dwm~w<|2WuFXNYkV=a5vyCenV
z64*6cz+QLBFsbTA@C#2?w@}bs;3<mU3hu80f8qiOwFT&vj$ka**Q~{9(z!fp8PV@i
z%WbCRbF}phC2Fg#LvYVCA`XCrEN2K@Jn<l7f#eFsVvoT(GjBpS5?F1@@%VYHG7$UF
z2pbOVB&w<RB6gY8)~+t=E=?Nqbr@aEQN_XKmnCTy+q4uELP+Ub0K??%*^f4Ke1c4f
z9)r?O6d`5P);I4)^1K5ik$Dq3n~AEt!#>N;D}0(|He4X<I~G@SRf~5svF%9_$gy@|
z^z*0l+M)v+m<dQmGDo&RNxqOT5XKW**0v;s&0uZ#7+=^kNb#U;0bg;#1FFeQGzS&^
z=Vi`$fD?mz3MdS^IV#*ea=w_+N!)um_#wtZ$zWmCnEqDVu(<}sh>N^A9ApKzAde8m
z#)!4dp{@csd7qG;=qeRqd<>p%9^@rfbH+A=vn#Ub49Dgv-h)A2>I;ef7PJw=G!T-(
zgZ!{bMKiM1-Hn@9m$Rk3g6RcH11iGk31i6&m@^dH5yLe0w0(X3)27&-!1ubG1yHqx
z%BNR{!G7ZS;S0Oc6U7J9vY4DM<C9I+>LHx2-MzDpF;gx)*4t$=7^zpjNu!rna`@!q
z(_m&>fVQ=u19_N3&<4D@LjfSac0C5TX_jW5SW}0ZQ7;R+y)o@AaOkK}S1zK{i3I7N
z*>KGw@3ep*&Lq?9HiQ+STb-l2gKeb@zpHk?NVm+CAe9?<f~lUhPgxR^)Lpqgp-E{W
zij`xpn%zvj>`6Psnxq)ud}|T0dMR9`$cwl>7^8`s3;C{;JU2O|RINE@7KF`~l8X07
z(=^EOYF=yiG9d5Bv(1u|oBo-%M&kqSPI3gVKAQ_lnXzyzbpVX2vjGi9onljtPfUT3
zngH+8#C?rQixDGt6&>pxdCOcE9vsBZ+lbJTVgOH!<zdg5|Dutq$~O}q#j6BS(g0(f
zaCs&LZ~h6M;@5EM?fX7&BgcNO>$gK(yI&01b|Rnb^o(Tl7J&U}9b6eTugxKtI!k#A
z&<VH1$FEDo)Dd^&8X5wVbL-vmFN9`j7*AC?(*})NzpqD*yaomZ&3+5$A&Lm`h(q<r
z8?L`LuN6nZ?Fk$AL~hF8ndu7d|B;rkgm+%#DniB}Gc<cR{?;%9hN+@4EVdH^ga>mG
zlqFgZQCz_nm|U~+q~2PZX;(5~Bt-cQ2PN$p{>1&xC8Pl+A9gn(Vy<php-U{W;qG5$
z%~Vi&<uHvAHFfevz-k683^BSaZMg+pBKj<jdU5kIAwFHuIAdc4FZYjC4S<sMXRlb;
zu<Q3euWr(NmT~xDPc`hmm<5i_J9jjgu+ulYA-i7gS}iszqE^YFnxJu$q{I=c8*erP
zwQY*2ynv@7BoeX8z^F$irsL#xEyE(OQzfRfmrgGY<MDnO+Z4!mCN~3Yl0Mo{x@3D2
zVCBR3t}|kkE#NGmWS0kv>;Fhl4wa5|Kscux6<F9p%7rPR2gf!MlzJ|hy1GW2TW^?P
zEnNBd{Dkq2IRx$9DUR6Z%!M4Z!=pk=LQytgQVRuNsNgk&FDZ_N@U`(IpLA^woQn67
z5CfhE507@nGRkGhH=ow(a;$&erx{H4E@y0OG(zzT+8vvJy<-T<WiDl{d(m`lBGWS^
z+Oc~9_YVCX5AmFxn95E~Phf@BrsC`&Ke|AA5j$_Ny9Q(zh?_`#`eq8(_48%O<$1|T
z3mvZ{NstuTUutXZgq()QiK4bU!DN4iWz^!2(?<}<-N90*c7a(-*|dZ3K@?3|7|US;
z13Qg!htt{PC<zG;Q*0z_rxZq8H1#oAMar1owQdFY3@LPM0gtIpv071-rAXZx?Lbsc
zp-)Iu%q_sj@H7I-TFzmjU}A{SZ6>SCs6a)VC}?m0TR`z_qcIB89vE<@3xZ~6OQIE)
zur0B1QEJ1!U_kNF2c-$vmf*efVgY1MXEGfcGS?u7ZbAeP4J~Kz-t2FQwFum{j}=E=
zrmscDJ_o$|vki?g>h!BL7LH#i1X>uV9Ry2_-Gd-I_jcIWdXZzbN$hZvPo>^_Fkb+P
zAvJQE*rIH--i^^~M%N;voKXnU_bq^B6Vd0H*_%5;L>Trkkg!6fY|n21;~iM~P_mEC
zV)Q;-PnDQC5*OT0Vc~WPQ9fu>8ebgRH>R&ZrJ6oL+mzm&Aka0s%0rsRiMv(HJbo}z
z&z)*Q*XDNh&LJ2dl^T4SB$lPCF9A59+2Q_Nyi$J>4v=k6Es&fLz@Fi(=FAMWkU-w*
z9(^X~(@40Qz0cZ6A$<qRSZoG!x$B!1z*LZFB<@AEPg{#bhpgtGz%}od{QM{(nAWjb
z3PCzCbBva$c_?{LqX(&v!FJR0&lk=#HGsyVFdT5ngZe!>V`wRBK$Y|<pc}n1EJN;0
zf)mja6L_zV4xUi!_vmF-q}D;r;hnAx#h5o|W*M$cY=&&O7(`A8&ATa)6Z5QEhQct!
z$*M3ja_eJ#XLw`WLHgEm{^(_XAPivWedr9E>yrLub0PW8%VkCZpd*iv&1g^#J@k;E
zPiaquD$UW$EE^x1Ae<usul2-|QN~-Oqh~E+Ig|Q>iHXq-bU7y}IfWNZSA^iMXRUxm
zpy9=j)|Ne4vRd-<O7E>a)ziOcz$!u|uTkt(tzO%4sj|V@GF;g+eW{<~$T9)xiNMU~
z?-IkS8kM&5!d?Sj=1}FD)zwCq!E`DWu@|sX;R*?FCX%BV)kTX9I{4!HQOJ)}&1ELV
z{uFSu^L%g;hY$^H0X1IjJCuvJFOmawg2a~Pxc#I+3v3dg{_ZkqVDI%Lg~EVzFOUUw
zIG*rMvN*~e;JN^F?fyBkvyiwUu?3>~WLHnhWz<k_4^e(_$rlVQE8k)AFR;GP%l{@P
z41Ydp;kNt0n;1tNpPs{o7@X24*$PX`x;Wf*Vg8Y{r8~n5IHATM`wfCD$U;&?Mu_n@
zWIX;lS@IW1``E3o4AL}vCYV$TpxjnCOqNBX1)lUxHXC)vCP}t;ezJ!s8Uv`(%JjJt
zlGXrS7rq5t(enE&fF95Kabc8=@aiP)H}CgN2e4)V<5@>Vz2VZen|I&O*6;+q-DANB
z0gpDMJb{kv4YBr#BKm9wDn$zVtXBLAvdvJ@DTZ}#KFxrs^gZ>UcV<E;vutT>W7b%>
z0#)9IzugEaJps|19MC3dFBrj+S$!!d=KY%|H}7Z3L%JO}_c$HA?+1h>5@w9+qlkgO
z_MTF{U!$;?JxFs1RD^gn8nZfM-<hyNSU-aIZ6^vF1tl_)b$w{2fV(koQ21ND<M)~y
z^(QB--Z(7OuF&<C<!U9t<($L=?nZj)LrD^X5QJb<p<yQue8=&f45X0ua&sGS)P#`?
za$ol+dIobLTS^}_>`O1eR%0;L?Jkfi7#dd0IwN-dyM)|Qq$l0VQ=4Pc!j!OwUjiI-
zA7pYj#g>nrcd6CeWIyv3INNxizCLH#T1sT-)%W)hB~Bl^<hwnJlCsLIE_4BQQGUv>
z=lOL-DK-=)PN;qsB}XY*q81ZIFnXmt`pt5(7K!CoEn9mhaiU{?+zFyCWP5rGI!ni}
zGs+Gas;}?$RY9?ELh_n?0<ug_=N*T&Yov|5M%|@KSX{8FSpKj#hQ8JT)%2F|G{^2E
z4zF;{CBcRZkPV;2S>xQCF%T4^zX%%&Z1Yp3+vB$YOO~0uQmx16Ewg*{W%`s-<*+?`
zIRn1cGio4$uAzV2A#t@r7@Lymq7;jo2q0X#ru>7*3Bd_pdyTVr%1K!7iqT!_D&SQ?
zqOqh?r<&blbO>ZC==T(%cq6^;pY3+37T&;5m-R#d#=^n*z4?r@JPpyDoj#ic<x_6y
zI-UVt%?91VIt0!H503y67TjCSNVOAkF3Zbtia(8jk1P3<J8cAl`3jgpkk)caUjL#Z
zI13g{?J5?56#-sGLSA%x9k3gzY&;R=_@1?K3uiefA-!2D+PGcBHIsLE(@`EQ6#*M?
zUI9n9&*0c3NqCW9miDgInkLP>D`4Pwv=}R(H&^Yfi6JDa9+T3UD2#Ii6NjT^s}^GS
zGMF$_Ko=-RfXTa(36+at6xm}<PuayhA#(`niPOUl&I%p(xD$|1FerPn!O*~2o=fYJ
z>-6c~i7nX2J5P85Y5>but+n@hB>Nxr#ArLNck;ILyOBm02{PStu{+BLEFX06<XI1?
zHqC%RNyRf{pKd1BNs*ZnH0)-@sjF0GClT>S^MvXTa-gx~tN_&!p^3`b3FwAmes%Ed
z%piqNS`4UQ;HJ2msPut_Ms*AM&?b<JRG7NUGT{r{$vWMK76f{g>SH-?ZHI@(4cMa3
zmipfuCD>r9JlCfNmXiWP;b;V2=z8o<oIn#Rp&1(u?zt8+>ZaIlRCBrkMmgn495*jp
z;;6XXJ=7$Joh=o#q!m;}5R~+9YF^n-6q#XoaXeLVLtHrs8{7FTuB&@RdeWk{(f5}R
zPIjwz6ru}Y{57W4g;fYxR_8Oi8DcYq8vku&634HW30>02KHIPJ<eMKiFT-IZDKV*C
zTXv}pkedwK7R(`Bl5+V~5A9#KQbQpaMffYveJVq^f9fz$0os5bqlc)a$W-W<C(wUd
z$0g99)ZMa!^3a5J1jy5dQyT#UN?khNdD6hr>9|t9L7J`*b3O}oB$2C*+tDJ#K+O>e
zm%N}*X}z>9pfN4}NBAUdNuyfrp`{oQMcwyQfXyf?Du61);?u#FQ4r4ikRYg!+$~Rn
ze<XnA&#;LEs!eML*<IRy_<C$Cj*bm;t#Kkp#a!dAWo#Q>ibYRGs=V?Jt(Kh!fBPz(
z8+rTX9li2402PXwu$<aqSlfQWk(4$;yFo9{5Gh!K(6a%p1R{!)&Zhdvd<t$xV?&Mg
zC-PN$`$Bo6L`j}#MkL_UIQUsBARv<9R@9=s)Jc4bh=o6AVl6M>gnxF#b%_C$de(+U
zx=9*6Lc&JfOj&w?oMRa%Nk!gQu2%+?1Tdn#*C5phf~nZ9SpS)HbWT(<5Eq5Fc?=zw
zuEclngf!PSV*K}Kwp)JY+jdACV`LBZlm+GwAmm{`P<2v(xzB#sIAwT&N5wmE9X#dZ
z2qwvkzP?$SpIs#;2;iJ_XJjd2^V+L4#Bw&Ef}We9bXy4q*GlMp>;?veO_?CEa=HgU
zA++@SlG^>DluPcr9}oC1!%~5>Hx31_L-ZB#v3ga6ON2T8rcn;w8m{%6Cc}nob&S4F
z9u9EiDh=Ak_4g`7Mwj_9hH|NF^t3<SY||E?3e`ioN_;=kHYx-m4qokWB)Jp0PwIZ{
zB<&KQ$%H{UU1fIxA-_4Z9|AN<X*I<g?j|TuD!{k^2V$hL$TKn+^&ix8eHrm8m|Lo4
zh^Pf_HTaZ;5Px?0Eb|)swV5?*KBgSAzl-Zy8!-%>n^|Ln`iixdYCC3q)AoZi30~;>
z{B=^hx;dPCD2C8TJfIL`jiwd)=Mvq79Az&_6t8>h(|TEJ<LO>y040bG3|4>Q*Xte`
zQbbng_;76Cg_aDnQ72)eF7OYR;9C7?FpZvT(bU4g_1r{akjK(`cd-AF$!{dE&H)|)
z2*Pq+e~2fa3VvzBRWe2zl*@Xnw0tcC>%qbT>7pC2R|W5iw1V0FS)r;vi@K|qlPJ!H
z4L~*&AwRuQqoAUQ%9bC^Lk&A>JbSo6$;}ZEkavg+>Ef<r0MzFSu(w+AeBNF|6jLz~
zZ&Wt#Zg8jHTfn#+nI1SHMVty;I`eYZVmhYcZU+2WTn&37089<{kg@*Lm|KVAg2^0G
z3U|uzP?^UhnV=m7@FRn1Re)|D?ehS|f|4yK7a;Qu<h-uIj}}!N+fxZdwepz;z}VPM
z#1f+&W#gTR!UV|p=Pt4uz2+>}Hz#T~%RyDnWOym{B(JxjKYe}DP`z1ff!10Bc8Re(
zzZeN~X0>{6)n4n70|?r#&aezgFqM5_w7RuVJCaFT0CUnPg}={Ry{R^16d?p9DW0>Z
z0;_)p0Hh{wG+w<g&bU_B=i92ra05*`FpuacXb$Wkk1|=N8N%L1tTWAVHOzD}DC~(4
z1C80>OTS4xK$o<C%g2a|S7mi(^X?*<ut=`2a5}y*OCa$-v3pRjAi0tuTBZQp<K|AF
zVIh5Sv3GRB5gpJn9td(lT3PqdU4@vgrR;0pUNh3Mbd7B`z2IgoT`OoWl5#ajsbJNI
zlo<TJT@99v4qF!DN9MKxDuw(=6!ytdHX7@PmPvF3-g)joX&Q>dD2pzTtRy?id=B4W
z-2$m<!Fso>JrmrhC^)ctm`%e22HlPbzsb~~F|5kmw=cxYz+JAAPZWN+9i;(Oda8X&
z;G7{ly4FaWXoxW;yToQbTeht);C39qDO+NylydVSc22Se^v<+mavY7F4I}!nSTThz
zkXJQvZ{$etr?ARCD#*hh@SHAFqPNc7nq_X@bK9b;^`It+;}?`MTC;sxQ^VAwFe6X!
z*A54|K6}h88cPMv%ZUhZm3)Ekb`GSkQkug0$CYyd;XqFvE2wYsI<bFk3osSvj~Y&}
z)Jb7<<$+A<Vg)nU6axmc$fE0aGqIXF3!8zi7jZRmjzc}sFG10w0g$u$-l&&2Q8U*F
zD?lc6%wzJ_C0fW<yy3I+Uen4v)55^!+5OR<6lXRA)vX;7qLg|K$W|vKQV2o%5Qx?G
z<R$yW4Ri{N@2Hv3?idRO{}#X<m8LGvn9DimGO6gz(lJ>@x`rDwR$z68ox$g=cXoeT
z*r6KPR(7VdG+LL*U3orlsUWd=7pRT(M_~fDp}l`(VmCjQPT!N0y^hv!V2m}w-Sz_4
zY8Wx}EuhF;E^3C^myT}tilJVeOf}CCijvKk#0lF4H`9I^d#}@x*fcp58ac`3*tVQ4
zho*x^e1FTXMJ8rKR&~IVW$Im!P&;ihY(v7A&$IzrSWQFt+FtW~f$Jt%(<feorC!Su
zO7I`ewe<B7BJ!|>5hCWZjhJJuoFm!CnvFtIvyqLkR`8Akyh$kmzop3QFsd?RE(pl6
zX$3l?J3_G(R0hnLiVz}k**V^N%f=FS8r4aL!f@84c?<e5A4Xs~1E8dkNr6lHP0;rW
z^BKcqCXISwDKv@6^ieDDJL&KT0bMYR&M!F2(wpnx(0y?bOstu@H;K}3RY_HxZU@Ma
z>kL?@>x4>*F*>|rI*CXjHE*mQp)Oq*=D<I#eB97Zw0U`E^SD;~hgFdAJ1l0u&7><y
zsLDq<Rujg0vi5~x|ESs@U6at^%SYUH7OD%c=eqLOOn?_h+`R8fu>(vhmC>s~-nlyr
zD+3C+z)(CN{5d+CE(x1&K<=#ar`<|Yr?&=ovss)D;Jjb4bi+Qz+8fFxUtu58pciHH
zt;(ED2&EHjvbsi7H1RtvbCiC1mrFE{GGltkw)c?BnUIP?f=~yPU-28POy9VLGRW#h
zabM%M1*IvUI)}nw*1-S<92$Q-m0;*~&(NeiRZs|cZ%^W)Y8;)q1=v4?NIm9kU@rkt
z+77`RMjAc!4kE6QItKYB`Rwa*XC%1;%ClSQJZegZpl)h=SCVFLZjv^zr_VJrgiLmP
z-v%74jTfkyN!0_5yG9n+OFoW>xES}ZB2cun4xq?$qg9Bh$L@-fQSXLs0aKaY%vfV8
z4;qPBZ5|<tZ2VANr}QL3%a9V2k-Pmdu<8P(RVZdXgO3ciEOdQu7ppo+DNu4yeW(|b
z>U$pGY#I^)m_>Shh_Qa(g#?<l>u9WDfVC4e6qzu$;R3*NEYD2FnY$H&g5^&OH1D0!
zrRJ=|qv<edy4f!)sQz^{fG0tyLUEOVFAcBS;Z83ed6p1GQtzz-G@OyQ;%Ms)O4}@a
zXeW#}ZAW;xw2+xL#cO0#V^AqX29T6QPwV`;9-E$GEij&a9VNkh2g%8W>FD#~N#?-u
z6Ty}8N^Ff3S$}_e?iR2=n}1X~Gq|^GDFd1w>IGiusX!}9=^IM4F{~o(eWQ}6YH}l{
z1b$pZ`7*SqS~dxkCgY++0>NUX?lM_ehvLDq7<kW|XJ%`72ie4HJ61Dsf?2P@^~_ES
z>$V>#BN8+>8&Bh!Yjk&Z%GC;OX7!(%rMx8e?q+5-FW$#k3{dl;L$guIoBJxe(udLj
z!dCaV7*W{2-CJ3;EDQm+BD5>sY=$ae!%fAc-`|AFgb~G(uBB(NHC{&T9tCrFf!tZ$
z+~#Esk?1fO#oz}~L`B-$BEUE6D2|ap0(tcsEEmgMpw82dgv2bZMFO5p_L&$|&JAMY
zeGCrGoNQB4a79ul*SgRWk`f+u!~@dWGHI_*H%Y%?nT-l5v1oRC?*k92pMpK+r+~*`
zdBMpei-yFpnPTI}{PB=>2u(H`P_+w*@|oE*Kb_o!So$Uy>L>?<>n;Xt+HRg-tERtG
zgwzy2U`kF>#`Jl|>b?G~)vZ^gESVjhasvX_;ThvZ>3%QzPugM@*r;TU!CTw$qJ0Tz
z-yBph)%2e@!4FK7HQvhNXRByTN4J|P8Ja*+{gJk`EGO$hXtIJ(QXFC3Bs4YcyY38w
zyJU_&ln|2M9Vu{~hq1Vs2+SpU>!fcOf*#OD7!@YgxhARm@IEvWnn1+ChM?<K&<jM|
zAZLj(W>JHXZA`McuM4Lyu4c(8uC9RjyaSR9j4ptgeXo@ObAge1vbNnqy*HN{pQhS1
zumvD-JFc}`;8V?t-HzG6AGOV3JZI6mj*G$w5)vRAg+{>0P8{o*0WCxTDCIO~pPg<n
z@~B_V0`heHnUi40L4rcool|`^ixE4j(Aj!KugTses!tU7)09O;NcGX-%eot0oKEJL
zR5hd@EV?a@(hjr-66!l+)$T&$x{zW3fQRQ`Tn%-Y^BRLK-o^ug<ynKIm*551*D(p9
zJMLkrmz{xo%j3j>D1>ZF*pV`?Ns4_bP}mPv6-7VIbykKM$meLV>f5x<N()C1J9ZTq
z=3D--#|I2s@#M#QqcETdMX94ue#&=hs=w9W7N~PGF$diww*`<pc#7A9&d_q_aD%16
zEx+F`xRfois=D3P<P0kW$0z0#*F3xha3*XLLJ?LcVtv`j-t6NlXslTWV2R6ASo3EY
zdw&uVS{={wxK@c-n=wXj^D2vl=?2{eI>ZV`)G!!TL!BH$bCY5+iBD%&?;;q77ogqF
zQh_c!DtdS7qd>vp);ZmU;90oF^u0kkhCkP5$sx**$z8y~4>QNEak_*VT~yYZO$ZO(
zS#MA;u|rFQ&!=CPpbUVY$>WZvEV^1~&kmAk`^h+6ce(UNA~3w;{RBP)w}VN<iuQwd
z+x|3#MXHDi2CFNhy#Kr}gw>S*w)dwIq9h-RM|&caLiVDesSaK<+zD&3hXcPxi1PBe
zO~Bqi{Mx#z9VuOJ%`_RFlACusy=hQs%PK(2%TCLSUWL??^1JGj>Uph6Rz<pUBfv&7
z0hy}-OuxQD8wU%}*C&Jmm*_>7+52-RY2!-6%y0N5oDfpihhC+e{xY3FFF0<iX(TCj
z7vgDge>G#<;pgp^qo~ch^L{eIUi9M<=U}jfwxfmvNBJ;YKoWqOK{~$!1$wW3u<>Md
zCLM-~g7?v(THjTdGx#3z`GP{7lM|@hO-iKo;~4W9uccv^08sQHLZ!Uc?oxS-P{Upp
zc0xkV+$Gb`7i3d{Y=K6{S_NNi8?kWf`!ckmVV$mCi77tJ{Tz2IZ<Jm)5ZQ7WNSLH_
zv#GmePRl%<x-TXp7CNmY05Hk({uvP5gGZcuFs|ZI?|a1FKgN|7;b!cqTewJLNy$bR
zo|_4477)GeM!5$mP*|Z)@49u8wRe!6-$bCI6~f60ysxMcf!q0s&6G<;Fc!0L>S3_s
z$TA&I2nQdy12}OW^QL)!s^6YIVH7ORCa^2r5Wjg`lDEuW$BOqx2|t>PQN}^6zE1=Q
z5hAjzU_vxfmLO2u5>yIwo|nEXYY^!rf$X@;ShtQhVaPVYd!EFiX9@I6fU7mtXCH@=
zeUK46KzRVRTHhN_BN)A07l%(fGD%gSEVVt}Vj2oI78|!bPqe1%l{PfFd-e8WvvuP$
zV`!0JZ6|wd9LrhHjyhJ|#g`(WFosxa`m^I%y#pSoV+OdL?zO{kDs}^J2r!_%y;Ubo
ztbL=LKPp|8_i88T1$6MtG#WRdC$MQMfO;*h8aYqR6-2X0RFY+9f}ja)*k@A=vJYa^
z`cTPgwgvt~8b91+yV4GxZ)BCar;rJ~+flXvz&h)gOn77Im(*aN;e@3~NV{jyd%e<E
ztSB~&-2kY(bf4rbn0{pRLVLoF#D#P_OZ#U_o!5EYi}1?;-k})MQ<^rbf#uQ`uESA6
z!c{H~X>eI4SbgV<OE&6sZ~J;*Vd>?Cx?uBG8AGEEkcoQ7nx?rirZGqfdsk26U+=lD
zEq*ep-0}?mcZIM;8A`Ompj=GRy2c7P6%_T0pzN2dBEZmv)?`3EWHr%~XRxp_R?JdQ
z7BYBoQ`ctYwbgm<>T-tQsOG#s$f`H9`h$a;Hz~|cvMniuw5~CH(FjHw0N)6SWAX2~
z@LRDm!?Ja;@o4uSL(KI~(RkxgzZsnHVVsb9gT^~y+j}cw6qVtiK-ae5uY|pT$NVUQ
z614VQ+~W+zr+H=4RJB8tvxL+6=>FrwO(If9pthEiiYGfct&FFXyXDc|;R8B{iDE)4
z8IWg8`G<iVM>h2kv?U(XoWm=(lHH7y^I}B;{tkTbU)7=e6d=Jh*qF{tIpK@NI$cjg
zNKaQ`3mMx6&J=H^r%+*5T8g}TA0rkzlY~*AzQnSEmN}z`;ildnZD-b>tOqQaLlue{
z*$_h%EPXH(I3DR<D?vR9qaqk!R#nDT8p(x9S1jnGQ5HsBkpRKU(h?t~+!X#?@8egw
z^>DdDB>=tc4b5Of5dggk+M9{n4y{&Svhu2-k6`IyUub6%W;%)DXxg=|E^efOR5;BJ
zp9(>Qtl!&E#?=TR7Utq`0uQwrMXS}c?EO*mc)z(h<F?viXiutixT2a~Ico+dco_yb
zOX%JmCufxpWO&s`j3+=IOG>h$x+0u-k6F}b1H8}OE%_4fAi->A#_O=65Mqj8!`3@s
z;7ren=qd}PA*EpwCKoJu?`GFv)WOjj1luic%|<PY`)LDBTeDfcv;HQE%tUF_41J<K
z=k5ShR0hKs>FJcTL#TH6RXaA7s2=|wv$Ua<71EmrRsboyGL{F^TG&#rJFL~-p_%}{
zP21fEPHUl-H^2eR*l+F122q{@$0d*m66Ml;BuRZ1AEW^U`!l*yZzc1FO04FYmU+cZ
zV+h%xn)|$F5+~HWxf1AQXd-cq{!XdZLglNBFdkkAj^^-0_g|*k2iTN|%aa4TaIrhu
zQax|98&Ccq?w>vFu(TdzyL|nF3?WT!J=kfOP`Pd;>U+n2$le7~;`Pwtd^w^sf2U`3
zLa!`%k=OLoGjN`u>;Z*<F^<g!%*&v1K~-37l!A|M4hfEoX?(KHTLQeNx%w8+xfSyP
z&(1cBYu2?9_SO=Nbq5}TO}MuwHP|FpCEGjj)FJ61#gRCDs7DtI>;%zrqEUCnHa^8X
zk>K22$%$Pb><$3mK4{?>Y+iz~ZpB-Jmc&$s#4NhL%J**%^v{yk(qeS+g`w@sIX*an
zRbwP;)7+$t<TYcI4Dc?bLx!zoLdIn66?wFVxm8}9_)d}jU?w<ra!&JqpVge*$PC6u
zbKu~Bkgz2y67nEPA;zFDT{6-0{tW%6u?g%*KN!E@q|kj#1V=C;SfR?;U!G(%X1x8F
z1pOm;XZ~euh$tY*u~wCT&_)E=G_YfE;SBnlw+>-B7h>W@&_21n*~-F|MoOf~Gr+l%
z6<HM&av|$ml;La@3A=H(4lnz_I<)?!)1rDa-3KR(a&wxcJxJI*wLSDqX~?v?!A=X4
zW-)TSp;w0$Gy+uShWb+Bm?|%0yHH+ySHI+r8OqXn2Q)&;Cw&kUA0mpq5<nSQ@4Cs<
z4vnZ`kW!I|MYut#+0LK`fmmVotA_JPumU-dxa->p5g3{dp6h!SCjE}$XdZ89jpNwp
z9}u7$1mm{H0|*3}QP%VDQ~d6#weduvBkyvCgPM>qfdlGse$cl73W<&0ci=+QJyt@S
zkXJ(Yf__UneBn9~p;jLpCX+a;v%JcaNc;e3%lt@e|3TTn1J-9_TC`W%jeeSDIgSm-
zSP-<&K|S?8>^*g+Qs(>Sb)wiPo4q`e0DEYNVx>lmDxZi7oT(1GRaf{k-XGdWlq6|6
zW5V#A(dB&@!X<wz3(OlcnBWCrJXn&c>_}i)D>4p|@he$w`R=?+-M%@Qss~E+SsX#Y
zE)T1UwIFQRcGzmd5lqCwdUr&!)o41E)XhG7(=KWjr0Ndd!wgXQ@ac?l5>05%R!}Nm
z)`;iH0CzO#B>l?t)fU7VyE%(>wamKXHxs8BPy{H?P=SOqvD=JM)`MQGGydQ#C&(1v
z|LX|(@7eG_=fzc3HPux9V~YIuxc^_K$Tk0AE%<Luk^i4h&i}(!@&7eF{{O?|{BJOS
znVkRAi|`lB$N%(nfS!bZG3I}G68^=Qe}nmF%)i|mf5EKvw_ry7<A3=VWBv{1pE3V7
zsr&`A=HG+)A1CNvjQKa1f5!aVjPn=F8h^`qM*TfbnBQRj8S`(?(O)oY{w?kw)ZfHm
ze}egE%)h-=f5CkG?|IID6Nmi?=ASYD_K^Jrv&R4AJgaN|Cz}`e?EVKnFZBNfi_LVX
z{%Mq{%UHI&BP9D6cddp9f$|ASs5t!li+{ff|Bi%zpMrm%g8!RSFpO3Cr1Agen*E&|
z{!AFE>Zs%Y(eeCtAOAIr{3DP5YpZ|s-%}N8{0ZitGv{xY^<OX_|DSk;|Bt&o^xsnz
z{s!~Un17qe|AHCJ|9?Z5hyI(Y!au?M1@oWY_`hQQdt&?VsR}j!Yi$4C4e%Gt8h=am
zuL>IIe}~h*xXt^G=AR$*?<EL-0e$>$dC=hAi@yc*Z#4f58ucG-(4YG;{;}l&^^d(0
z|0m4-|Lk-SJa+PiudCw?Bkybe|I`)8{qOA$|IG*d=SGVEwB3OSH8e!+il}Y++|m-I
zRNvInK&LlE?yLQL<oS#JwQW&OJSoiw^H~$Qhg!mv+nYWWj3$$(b3V24sz<~{JWYyD
zvl-CHD>%|@OHN3OPLh;w{?u|reqVuu$Ux}>f1B9ghoz51v<~fpLbsPa3VWaFXVzAd
zY4qglr~5jow~amDsHl`I9{T=htlQkqXKHi9=A}Z<*rV@?3(&#VI_hZbHw^-_fhvpD
zt19*hvUw4*Q+9jD0}Fu=;^H<VnIO(GtE(Qly#*>Hj|v`FFPS%%G`c&BpC4PDI|lc?
zXDD%cp_qthZK^wP=W;2hj};?(_3Gs-PKVmI?cp=wf9iBp+iPa(>q~__H&XfaLxU}L
ztI|{7UmJ`+z|#EuSxp>rNsuqfZD)^bf%I-k$=%XNTzhu9b!0d=JyF?i5_wlu(>KCQ
zP&L6JJmO76?&S-U%>vt7Cof*i{iEjVoB78r#sXfii#-KQnjfFA6DSFeNDBEQBq<_J
zw1s$K`&~uku3hp2wL-ZIDi>|{0&yL7LH|_^{T(-dhL<`T^&gdi)_;)8e~K@ye{B2s
zcYOUjzWyii^*e6<5?{YHgujqB`X4)T{#)_&U-XNAErZRZ`PrFo$<hdA6{|gW=BmOI
zOSKM&T@+X_=O4TMAi~2?v)O|Gz@d{)r_V)%y)ZGT)X;Dbn5zhy^YN+f%<wuE?Xx*S
z4sf6Sy7WP|XqC0G`JkQ2og)}LsCSr{n3$B5kSM-zSor(=kmllclz_*VuC6cFR1COq
z$%-w^BbDKXpOONf55Jm5knQXSbU%D}@PNB@=fQ&yA9M%o$Yg}utHYnoqV6MzRHNss
z8!xVlG@^8O1&2n5{1I-6Gd^i&YG`49jT~PRnOYGRmXn;E{O(<Ha!yWISVd}NN&Jh4
zAIMQz<&Qz54_q83wLMrM!yqfuYjf9xQ_KB>H_r(lwTE0&ReJy0RC%fo&zE3s=KS>O
zu?tSFZ@cm9kx81G?~1>_vU`7hy(Ifw@^<l*XKiZ7)7>(t*@bHEuU;jlh+yI3I)~Je
z>4-7xdfk`xJr5;m#tvh{<KlasB+F9sv$4%iIqP)|J@0O7ax3rA(l;!^W6%`c!0~Cc
z*6NZ>ahji>j^E1X$%J+zIC^HN%8^yg>iu@%*t-;+E~ohP<f(Gi&g&;03?N?d8Y1=|
z%1pRbR=qbwUq$_m*P>vgNo!1RhgPcl&DTz2ebN2CvZyKVac=fYt-x6fdpTfsYwDhr
z@kD>|{JdXrXn1JVjvd1Ijj1so>`?fs`%pQ)dGPC4Q}C6`T7?%~Z>Tz_#-%sj_jgs*
zx3^H6KXZ&B(tbhrq<Tz7O4N(|*{sQ%f4u5->-)IXWKz~@uLtMa^YMinog_TAG_x>i
zZQ_s<o~<6hR%c|0ynFbN%RT1*9!+_p)@dETlYu>H^k^IG<Nd|qmF3e+JJPhzxAH!G
z+;<HF>9gA;RrO_r_Z-xPZn!Kf521V(B8;QYetGJo?a{2P6TU%fw_{hZevK^mKmN9s
zRr-1Q!^0ONoh6Gc`BPJ=eH9!|SXfx2hZLfxxA$w0?fJ9k5}zcAiSHi0;hb}@f%X9&
zxG}Pj#uB%SneqGPaQnDN#q)P19}-n$6<E2W(a#-gR9|~9Mi?K;w^Vsr`K`x2ysLSs
zcXo{ftBx@@ZvNbSO!?@`-2A+k9&WeX-Cgh8xpVurhlfI3S<z?#L&D<S+qduDm1<~d
z9q;b_YI`<uw|G!<yRpe*e{ptaFEh3BkFJ#+n#ngCIa7k2`}sW(^%Gw_<TE6nqVI=h
zi+xqFcvj{%)3eb&+dIqI7IsP@>*m;=<iztm-N!W`*M?8;zZW~xYPnP3=a0^TZ&v4R
zE}pZCefD&xtn{7<KW2XaLg3||!^gFrX5`2n_}tnaMI(Wqecd6_VaGG#XuE7ae&ljl
z+hlk4<&O}L%w3%&OMkTH-<pyVZQ8g#u&gcjS#)$6M^4#7AK9nez4dyvAp!QT@X9Us
zS5!5_C`v-8fKJJbfTV_0Ol;zdoG;T2FUw?5_nK*Q%fDijDAgjZFXfUiU(#2ocp)`$
zTWujHtS?_}<jJeim^mKGK*jw|uce{nH$un7<U`B#%?*`jJu*UXG_v;6FT0oZuh$hQ
z6b;d`Z;B_M>){!%ZSeLG=Z#oMKKOV({^7Lk@C<9l>p?Hy?WH_z)6Tj9H>9Xmip$|$
zhqQ=2&)#+TE<t)<!nyU>{p6QZd!Jo~9gwWLwizT7F+U#G*V6fLIuU;D*jzxmZ)w>@
zhZis9cYJB%?;C7m!-sYaYfD@#f0UI3u=DSP54v+cMsO0JUbVh>I-p%_L}b|M$APPA
zyO8$Sk6yFGdoFL^C4E3i|L7jBvDd-Jz9Oi#17dH@51+e(nGRxIba6AaIOA^)ZDTyG
zds;F#e8t8-B@MA_ggN8u@<$st?~>rigXu?ca)T1uhmnV3nk4Qamy({rEBvwBH)4~|
z+g<E^JfR+1J2!yj3|_db|Jgix$3mrldvnnGfXOZIx{L$$y5*|I#@mgfdnxZfxo<s{
z3fc!$WaWR1=;7H|`on1d+qaru&+dWF4lCFf2J{}&{Av?F>Z~Aib&M~m@r`Fh)R&Z!
z;W=pqUD>J#leR;%z=qGBYQ_~S54G9EiC*|oS-%U%2_+R|74fC{#GUf8C5w@VrrIu4
zG&c{@up>5_uS<j@CWeAbjtzYYewLE9HrsHd4C;F>M_cf^?yLG^mJiL;UoV|jl4^hZ
zJ!mA~!^O@}-+#u6$NZy2>>>Ti*2OL?FLp)u<DD^bgz3%)ZuO_jYt43{cyD~A9=0o6
zoxZcxG&&GJ6_)&NldZ|wnbN%`-7z~JmOnzydMy5<u<|@z%Q|U~gL9qmlUcEN5p?LN
z2KC5~`}1`nTC!?_hr$wl?^d03I-+#UIL1G)chGC&Mc$O!Lqx|BNxp5uu{XzeCiiMy
zsaQ{8CX@+$Zy1f8<-mmVdPN3~>^S?0zOXOmsPvE0ZzpXm9y?Av+j$aGezI}ubLo$%
z2OHmijeh7%-AC=j*x%%zZA^_Hu)G$OZZz}6taoonhfIqpk7Qhp(%~YV+o2(?(c*D=
z>tpxY2)Ry^q7#;u`>m}nuN+w4cypUpc3Ayu{4OWwy(MEiMi#$q8!L4#{1(*GkJYX!
zE|FRMX}R_B`SQVd1(x!n4Kh6-?OTOgMOajg)v~+<pRQDOR3rOFzXcxl$w};-W~q?$
zvBBOy1naI`JrlcUxvus5kCqGOkukfm?0EUClY8t<zUKX*r86`i)2x`kmy{KE=wV0U
zVY5FT1kFq|o-$-KynmjIuukR`y>;|Vw#oJxl3jpIlD+L$l#pZU&R<r;8n%0~KCV_y
zv+3Lj!8(M2={wcORxw|mRgTvjs9w#hx4|f8HNPGdHeEb`o{ppaIQ!=9jrDL+Z0wkU
z>EPXlqh;Y92_J2{;f$0V5u*|(fBWn6SI&oLH|Fmg_-s(O75vL#L`>S5{iLdOMr+~y
zjp4<xgw>3inRl?hx7puiuMVQ#eW?Q;J&OAo^HP)d_@U}oh2Q%^(vMv)F}-EP?}~#9
z7w3hgh_16cH_yH)&GNtKNhmMXe|X94`!_tbKXbmjZmMx#x7y5}ybV3bS960KLDmzP
z-aF?Kl1^^Axg>;KvhYYB^qT7x@JF7=C47)`Fqvxc*5k9oerPwlJZ>2VdWLW9P8h2^
zwsz_UNq&7z_=ACQ=MdJn|Klh;OfyWFR;Tb%hu*&K>uIfj){$l9W=WuGb|6n0D}R*#
z@X^a@5Mecgy>6_+zV9oVo!3)&OgDPd?vfVI1ACA2P%rrgNl}r$bB2*8+^VZxsE%@;
zr(K_J_)MP@+1ZV(XD*+Rnk+jPWWvwZF2(1hqQtxA?hzgb@i$3b&@RVBwCw$&KNw8u
zCOumD6<+x42zzWT=p~65<oQ_H@(solqoPW91UtS>^O3LpKx=D20hP3CGg|whKHH#w
zpnc5#K7PUY+*Eri&+{ubi97MXzEynRyVI^ZFY-~k%=RsbkOm#y^oH?s8l|Mikss8*
z+LQF(vRd_w*3$<|tga@D^EJ6(pX|;`1vBBN#%7ke^)>UZ#}<)Sat*%NC&|is-Y8mj
z+6Fn-_hkC9?H_q<o6JvDev$_=Phk~5KaYBKASdjHc1fS@#Ybs9<8TA|rvuq<9G1}4
z-^h`1Gi*ho&Rkqw&a}^Hy^R#})?**F&bu{yCHrHhKQ&Yyg~{)+jUgx7JCmzXhIi%X
z7;l#P_e`1ksDBaBlumw1m>wM?+1Dy%HWKdMh*^uPvkXoTcqKG?UqIu~?HVFKN&Vuz
zPYSwk+}LX|v&EOEOgm4w%Un?PKa5R0uJIaq7j^F1m?X<i=H!i-6M3_b$h<GomS@|)
zoIS|kz2E|oTEOqW<)c}l7t!`|@7Z%jyT&}iv)(mEl5=4SJx@vE*R%E9aBWBP-QDLv
zip$9HUo$V66n0Z_Zjw~%S!IV^RIYO<%{zpY(AKRiALkZ`bFsU>l7=^3uO0)Onx?qr
zRHo+Byolm6;+h%bBE2P^<zgvjk9cy5wlYPz0mc_?Qs(Odm+bDH$*(iCI_+|7z-!Fh
z)MO*qmB`(1?VwmPkx)(B<Fn&d-NDSBi=|!aiUoJs_$v2_{>!Y#CPhcx(~Qi&#qMc%
zD?U@PS18xWrYKKp@Th`u!E!@$cW87*&!zIETb_8yNDgcOsFX*~kDT+lCpvWjt9|%c
zZcc-+rPwl@+<Z)X|F62__qXc0iRR%qcAuflc^*(KaAPkoS9HyIhY9J_)CZ9wMYj7E
z@7h!mI(#DEr_3Iob}913EYDv5h#HGUzab496QX}?w4xC7P0iZ(E&K;lCH=P*ux_Vs
zpDd5H7g7qFj3jLT*ll1rY@_j3XH`vd`70*=ppoyDGj&}yx1+}V`MT&~XC!3&8TSh5
zJ0n~Kx};b|^0{(YJ>Pf7<Hz={6-#uh*p(Q*v{-B0-ShnG^`ckR@5;JIX#>~~4_=7D
zf-(XXwGrW?Cs|1N^`+aF4O>4y`Vp}?nzoWWHDD}DYtSBXgK8ip4!=x!mz`<pWWS@&
zog?7d6f@J7^!=xO<(}N_Z-knnh}%T1pH+7qI$W7AIWxVHc)Z3vze(uhha2tpH-l3|
zoBnvfxY>7As3q5B?~DNy3yc1+9eMml9>kqRZC+C8Tn(527GDe`zIC=gn0fqj(HUg1
zROBwM#kaktK5X#cLT)6a6mwHNbYIKdnOPR_y?sT08l!ON&Y7MdQ_aV3iyL1A>U~*%
zo7>OYe(SND3Ucm)Z^}!4woS>T#Cl`fkEwOdO2M~sfd(7Phel~pS~619R-e_@8(lw9
zH>j^LQnBZLJh~M7u_TOpA)fuYp$8XVC3{q=zD7B}a=MAJcD?jx_xaBGfUKU1x^I;v
zf~%nVYSs2r^iM^)9#8y6#cf~x3Qj%z9ewS5S-bV<jp^G3!h-vqOKOpdFY_gjwEfyv
zS(T@IWcc%5q^qyp5T7tk{}Ve|2fJb0_c-!iwH5N{Gl|vtj_U;<^ZBJ;$W?k6iFZG5
zuOQ@#HW#)9_yzX6ol4is<L9I8)7dRH>a)9VfOYJaN>JPGNr>|~DbwYKKO82Wo+^DJ
z6R?;k_BLR{Xz=-dIC;}rT%KET>_j;84EfE*O((s4IVdhV*Vx=Wg}QOqzwl~~kr4D*
z*3YRo!IDY24}~5dPmCE;qF*^T5mCZzaWc4Wdu3uxu25oG4r;JN+4`!4Pe8BTfge{B
zrz8%CzglQ)_3*jfk=zAbG}x7|%!=;sGl_S@daQlf^{6x%5s+#ZCfpz-cKm)^<H#Be
zwkLm4ed87W(=ckx*=;!zw~J9@;+I7$domq$BWUVZ&D>-mYF$m*JSybcj>*@Do97-U
zg$-NsNQE%0|NP8Jvop|3WH_H@UcqeZua_%bqbR&bVW;{ZQ~l*1TTUKotc?vLoW50P
z92oQ<FInWdRzu@(`R?&)_B!t5#t(;!WnaZl+7De<rhUKcU~qx;Jzd~)zTw6Xxr-rl
zFO36cKfLO#Ir#GU-ky+#frU98o&dZ@q`8sEmn)NzVaLxp7&wGnKlWw%d!$1#c~QM=
zDDu?TRORCSsU>9L#_j#}KWr9^Y4W)@W=1GyLi3LwcL>>SvY>N4uW_h80}>W|<!0Z_
zqTCbRmu;ZSy+y;X>yO<@Io#Y=6%$>%ly^}kFgY?gs#|}DOyzVJlD2NDJNWAx`|wUf
zsiW1cMMkF$r)mzq{W{KDxq;D7e1F@)Kw8~BosnsIV?txwREFU=c{hRm9ew)aWsHH5
zNY5LLc%n_eVL{Q}Ws1SAg7$g8i}^|&Z=nq}M{iGgvJAX-Y5xklrQi9(O2q44mssA>
z@1km%QzMSYI?vP_9q;T2zNKV|e~@w6H_LgCI+wXKRWi?bubyBtiRrfdh%m9D--hyS
zPyZF+ax+WW%^IoN6VQM6qHmZ*SqHejS0g#?LDJcfn}#6ezO~K4=qx@FJod56%=D98
z|CMOmZNppfVf0%?tpTjpHy^q<i`IH8r_2Pb<ss4t23Nji<;0^XGwP$-5&V4gqSs)9
z<J@g$BYxZr_0p6OBzAH%AkBhySkE=Y`Q$a^t-?H^$|}9Nnf2=BQy-tG3r#!ToZ}OJ
zXv&{-hH&8cZo>QzZF5ewH(v<j>}%aw%Ejmkk^DFA1!n#u8U%#+$}?8IiU6x%g}>EE
zr?=a1heej=ueQmtRGz3IJ6X)j#DzU`@B=P?#Bg4jM2E(uOC5|*B|KBCtI1R8{i5~0
zB#CqN_!L&uP-y4uESJ8#52<$Au4dtRCa(tn4$nZk@MT3WM$^L`-UZd16ZeClQ)@0Y
z6;($SCO&%?csw+x?ML5RGPf;s1@`Lg<kcBz!5e%LuI2N?IM3B*34-6(f7Wfcm-*&S
zg@%-Ww`eOS=*#OTPhDbS_T*LvZ3~}axfIq!u+Ki1eDQw7&GV=>(L$={&T$HqEN*a`
z_gb60n%CfsQppoiomOq#1c7^RzU(=fFX?@Yy?LS2?By}3G0N#%ha=f`9&)BY4}04C
zjV~5wgKRtT;ys&DP;k)tl@(geQ@I_xc3Aq3?iWGd+ow9~F>h$aA)>X5xrg;cQ=-pB
zmtG${m$o_G!E@@U%KpbY(BhnInS#Bpyi%6}i!2VG`&qjIuUE_}8}AIbYZhjh_1yav
zeLK4HM1pKgt;nZ?-><|dxxe`C7rg=xQ{EU1{fa*kB~kpK@v?hE(z_^M`O;s%o;^Nu
z{yFkQO~;$&l-UnYE|5xcB&WyY;aW3P<Km8eY1F_Nn~q?f)aRRh)_dj{#HhKtjL*7M
zYHn4I^i<K2-IUq6RHatKm@(^1_jzX)zla>~oDBFtH%kwJv=+Ecas{P<%ze}E@-?tj
z|BkZ_3;9RU%Ll2#(r#IjGw-INnBhkpNc^PpflqIH%3RXy6k6_mm-^}nZBH~4WHXIq
zg9wuFbSLRvz>%mu7nFS*pG%i?VqO6^%nf?(eGfirY`{w|y5XbuAtTQB&q$HXIr2g8
z{mG=yeLajT`&v?c_kFQ{@@u?%=UID%Jx=O|xlVhNLc)~K5ZOLItR&~i%|$A~xvl6%
zfXr8sOZ#C}h8kH&tqKG8li@d9!k&?(3PgGyq#hdh@nV;Pt6{3{5Jp6jH{_DxAjggW
zQfo)-y~}sb)htxUR>YmZGdU@DH%#)##a^e6x)oLt+y5}T=qd2oFu<}j#5}!J<!an6
ze7?%*uh{KrGADF;3X<|H!F3#C4!9hQG(I`lBH+co+by3I_(-pBl0N30oiOuDt#wyA
z{h_knHY_?l-Q4}4_PzL<<T$wDK}&blWT)quj!A0Y$9G)~YrmKwIhQk%!jg)+jQIJH
zkZG=U{mW#phC%c|+Fkz{-fIVi2F|Hm8%#3ZuT6_OS8TH5>W_+km-;Jy#oX9;Gydh0
z(sv$r@N2$bF13w@yQk<28r_vkGbG2w+%ae|baD|Nuc&t-XHGaF`f3f`EBa#+)jZ*_
z@DGyO&trUZuW4VcOPhII6&8?iA)AWM$cedGe9e`d!g?0<DehU;B>(j=-`*Dy6Q=p4
zwdS`J`NQ*O9oC2Ktqt|1FZ<m+i|C6rG!%5;b$hBU>;J#ldkdgCwryQF!5tDLNN{%+
z?hxEvgS$g;cMa~rJ;B}Gf;++89fG_3i)82QefHV+-E+@hx9U~BU8}l#_3Y8p`WthM
zF=b3HfrK$5e=1y`l1l;P1&cDTUVPXcO+wh9HaPP$Q0dVlWJwXvhdH@4sLIk->OiPI
z>xRx$C%eV>No^!duke|q0ytPB>%I^MVHRD5Qt<_jo4mxbeDHMjh$}&g#*7lA24nn`
z4&5&p*lyg8Ndk7qK^p*Vs6X}8X+x>{Hh^P%Y!zg$Gr&lZm}|~Rs01^r?Tb+i)1o!Y
zOH}i{>;OUTj{uf~T(Jr_*JEhx%DmNE${kZ`MqYTz>J9&f(s9%;RGJ}Fedg|aObrtt
z@Y<cW(wcAgo5&dA<;NDrSU!We?_pM(5DrK!&9j*eUUhXxfh)2shYI4-@LNo1t-fOT
zu4CWw6fX}RI7F0VwvXl`#hA@*rt<Y*vd;kXKGwjeU1!~?o0jvQ5#Bu-F;1uRn;SRR
zg3*^YQPoFGbzIQo!E=ip<bpg2OcytJ|0rb^KJUk&6MTeZ1SPDec`imoYV7>rWU$w-
zo%%7AFrR8}nL3iF2m<d%Ar0hEnNI5lze2ihQ+#+hj<s`PHi@BT(F-zu`j}MJN2BjM
zhWMJ#fq<Ra$fsiLB`8HjK<<G4b-K#<tiN3l6lc8M6XAKEsDc1|b7XV`H-}-L?L8j;
zsHbjJg1O_S`^#G@go3dENMMIbiq_(TcO$xxhkfDtPA7f7P||(gp#HKi+B$i$nE+2O
zR)9CZWk6@KiY{S;F>IWZBPWPM0gBpoE=#n|w^sso7Q;=C>b}fCr*%maa&eCx^?|}z
zglNfX)<<csC&ZG*+VbEIuKcotLlz9(c0-{e`rj&pFp8`ZhlN0sDe~Hn4Ion9XHrV+
zD5S@rf_Z2kbBdi^@`#WLf+k~@&9AC9);bR23|u^ng`teMC3!1$d^o&8a(c_fe&{}0
zB}zS+=v~6>k~PTX$21Y{v~&Xd7MCQ;o6C4yBrxK--DvwQ_)%I%17R6y@fp-mzF={$
zwh5srwo|uK>!&gj$QpVu=7Jet;xIpZ*`kpWw%}$zCblwSQg7XCCH=Cpb~U3W8{$Cw
z9=qJ{CQ&v5J-r+rk1cm6#KtGAtaEfY$hKy}rKVxW5R?R#Wpjs;N=(4Wyy1}t#x>K_
zGf6unmeo`UgNGO_k1W$?vLNi%?%H%>=76eGQ_XPf_c1kj0kF<Cf-hFK?0C(u-7k;Y
zRBKt{h<Uhb6dHS?qkJ$yuzHvrwwOzU?%As{Fv!g1%p{NI2a+Z9UHAOlgdcd|xZbIl
z^#NLQ=&R&#$@VXQDx3MxbQdc09=T!dHochh8gN5Ep-Or2atx@K7`AZN8b+h2eabBT
z9!V~2Cvi`Kc6a1X#GFAvk2IB2({NAr9oul-i9;GDbM(PFqAG)AF6~m9(n<(x7SwBT
zNg?U{yso;043_`9M}$ub!bmZl?Lf6-y)mKdi@eO%E4GcS)Q@kCMkGmLHp96B(o{t{
zPggow6$EcbFi~>wx{bbr#A%UqTa}d`$i+;hK#LUeD(19S&0~qjq}3Ot;63htoq35h
zM-W_Ds|h<I*et@M%0EI*dA;^!_f-8_s*>1qA`Dl{I~dCBJ^SL5ib8}-)Z-{g_0*Q|
z;!-8AqStYZkjR^v41xg9bdM;xshRMG1MY7m)l4X)+-xoCS}7NwrfxYtunXb%V_bgX
zt0<7^J7U-?J(NV<^*-7U+q^BpgR&-@1fN7Zs7Jj4$41;|Fe`IqTb+J8*nP%uq57`3
ztlWIfWl9*g=ap<9aEnhl%9-XyNUCaqTe&W`X{4N(A#x6b!^BVIpTmqj4qz=RRPIvC
z0Fi5L7h}FMPI^0uPN+t6S}?;vFE<|U+LESbRO0TNHSGdvchl}jF#7#Coo!S(HQLi*
zj%<_E#(EpdRicNIajN)fYTKdT0~fP10`7whkiS*iG+?D_h14i}b~Rw1uDO2af@Qj;
zp2BY1{g5&qz}(}$9=tc2xs={XQa$1EvEI=*zXi-y>%G)6Xp)UzrqKqDUenaYO|I@l
z=zT1cN@NGCmeIT@eTsYW5P2lI>xWsOwQA1(MDZB~oAnwRh&ry5Z?@C+-KU(P4>nUM
zqrEt%*%`sJQv>gI4f4+RQJL$Sqc>h$g)#J;Ts6awW7zfpAO<M1%C)zvWj=W14IL#i
zXV6Hxx?6`N2IJY{2Iw~Me@V&gEdOZsRDC5hv)xZp1wV;w{#C^Y%+)fzlx93V92xw>
zHWzj{zuZXw$yB2`iUV!l00V#Ncg;NF?x|&$at5OfbkMGb^REU{+^^V1&-k&5G@N4Q
zk|-)VEDx$D;&vQOmQb0-PxUt9nbbXYEQw$mVU6oFP~Kr5H7|>4!7MD5_6#+yKb*kX
z3Ds?q6m!}jYG)@sfLe~4f>p1NLyxP2I=ZG>gPNxSgqVf#Dkx=H#-V|w7=bzCE;G-9
zi<2Rw@A%4Lc-r6Txa3*F>wf83)_xFY(A2zJH^>{1%q|-yz#8yU8>^VriG#E7t^Wf&
zb3Uq@eb96ZF|tA39ShPoRmKKfP;(qMezTtBObi2fV?vnB#ijRJDW_X|M_tG{`RJ1y
zy%0n3sm9e;E+5{Da>3kD<~M&1Pe5^U?jg`1FEC*u?ry)e7TtfS-tXVn*ImrR<$N*0
z<o}VD)?6)vx?Pm3_y{anUaqHOHOo_1XNauSROE1I@&-4(em2=G$aV#CVJ<u4u%%~o
zo$V{r5KALh$ekQlfet^od?MD_b=9IdldQvARIvmc?Qg5If|FY_sUB}r<=KJ{q0l2w
zi-KH-%_QUeGa>1(P0Kk<b69-zkd>G<Z10a62W8EKBa2j`aa{Hzi_5d{C~MNcA-i<U
z4Y09Og?Oz^#7VL6%Z1?chj%EUh}cW&jPDoT#Y;wS>wUpDO~~>!*uv7Q)4z)I`s%YM
zt5U|Vs+o9oQXkl<bz8yd_YNNZ{Pl3E6u)98b+K9bW{Q@C)QvHvnTSkVtbrgmXLFyr
zc=TRP!*h?Eb`@LKq){o4H4A66zTGZV7Oo&Uer<SBS|&li6m01<DvJ{jvkozGGUzmj
z@Tc&|3&Nw#O|AhFex;namp89iAn1vn&_Tr^9a|I3N2A7~2--a-J{byevRBUX0sB5H
z2rQbGBJx&Iu|d7n#0JcL&r)mizs_xq(RCnPh}-MfL|#QPRZeuVB^sxoav(#F8NR`=
zs<3Iz^;FmF>P565${VQEOV?U}zs3K0$&qu*VM%7jD@;N&XS221c)k{eGbbYR=5tH4
ztIapJ=H+}`l%=3>5!1o<wmY|l*HPGW8yUkl$EU&Bhjx?8g}5j)E5bAWs9{BKhq+vM
zeE5?mUQOs+Nm*&?(<vRZ?Du$<Wd?1;O(j)cmQ5GdEu7xIQmrIBjHo!6`IH8!G&CBy
zL2}Rh^e$6kRu3JWO`uz{#)kC{kF&b0pgfMTgPll*j9Foe)PISq`i7PtJabvDRc6Iu
zk&yf~^dXbfkFIzjm2iQLY+yh9uA_B2H5k*#cZNv~HpiwTs6$cD*+!uIx?U_<K0Z^k
z63T&(uuab9>pma#{AcocrY0H2mqw!b)t<)+j?N-F<Y6g<gJ*>ngu#1z9xCTQCFY5J
zc-qZ)q^+6--@F)_#%{Rfr0`W)WCba35XdWp`9^S0!&Z`(O-Onicp!X*6bJ$BEpC3V
zFMfy2qUGL8QDTC*Rpo7`#{?j}?YhWzfQ9e*$Se8SIETBq>%irk*;9TjY9>*;bmX!v
zsqSE6AwPe7DDramOVZj1uBLONxvFjv4BIPV-^|kzsJll@{+_m88df2rnnTOlJA7z1
zUe|<f=0rPDhlOO05)P%o(P&idyEC@(eS2O%KY0NipPRi097KL(+dxta0WMRqign+k
z`or?nVoKVt?dLrOpGy2VS|RXtw$SA1)yt0B{Dm{2*@!!(YWvtV?%8N|TJBmVw~$c;
z>!D`wiE&du@Q3*MEA!3vuBC&%!3iMJf1}KTklm3wF*PnDICu+mkT>7LbOsmuwJtD0
z#*qL%5O3Z|iCYvk<Iw5RLq=UmR*?&i7|ypJ+w|+!ZGT7T%(Ub1p$5Z<jHplG=2cC;
zC(-ODWszw8^%yzk_hk<0^QmnK=RT(mndu}^eky8d>6oY=?go!qhu~w0oK#Qvd$%uy
zT6}9ZoI0Hg9UEO*gG7cYi%rZiI@;m!7sq8ZqLa^$5~usHYYdU&z6L^?Y{1}EsX7zK
zk|Y%`Y`I<Z&0iN~1><8ah=@!pq8N7jbGF!+51gvr2J2?vbmDy>FPECKzySy@Vu(L+
z*{y17+lgt4+Vc-YQhpFQv={<9GZ$`da9uLVp0qnG&syjVKChhtj&Fv9jxlOhS&o>{
zw$@rFf^Syyi;2Im6W5beeb?PHN;)ll_+Aens3DaA+tf3f-$P!0SI7l%&+N@F^S*1;
zylbly#}Sl(+u)5N9O^=l2+LIb8xJYBr}6Fkcdq+v$Z?;+SfOOXpT2y=ZC#rlxdNQ4
zkT7#wgImN1nmN`xal0U=rtlN3KUOZjwh@?CLNOo}1m|vAYtp;m(<?65Z88t#uMj$*
zv=gWU4may7z!}oc*DX&Du#mB{HRd&a$;6l=_WbG)gNMP)G7<X*WQQf9G<B&~r>_XQ
zf1FRfQ|e2j7APDxSNO+NW%Ht~SZB&Z#FUFucjOE5!i=hdlHIFqF`|s*y#lc_24q4l
zo`$2nI+Gi9LU?CcO=c3Z?!a89`=GbbmWEO<`>ff!&tBH<S3|!1zV_`b2vx-CiFqA9
zMJ*XG<72&v_3Gmlm-P4LD%~XoYC-6iQd_GVCm#Cq52zcWz+vm!$k^!N3FiTpBQERR
z;mXK_oTB^a{`Y<?#hZ6n+riQIML9bwx!iA3uVz$}rN?kciF>;`So!#FIUFkD@#=a^
zB-1MO7cU7dH6uVec!)e9mY6OisjJ4V1k%-#_RJ`P&nlyN{J=SzJdPqe-xtmbB?U+O
zEEGv}j;*=p&h5)WTGG7xSZ)fzfHpVxox{5Q?u2qB^}=68Npb!~TRz4rZ#_I6%Y;(g
zt26o--A)jk<?|0qjeXr6c3DYHbuXraz!$B-U$DeS`Nv2rI5Zt8FcdPWT{gb3da50R
zHkrNY+ElE*2pfu|huoEACu3omntri$KazhUoB0@F>5?+j>U^=rCU4h05PWKlHx9TD
zj@MkT+h##J>_(n(_9N;k*u@&rs4yJhHo7u%d;saxeJxjc3M1b8H94v8-4c%$RA`ip
zrKRbM{!L<kXVrY@F`d%;BXxU@7OOMU!usypg41Ze1#>VWjBv2|F^08aBfyHp2MMGl
z0y&tr`N8q$$ta=``;O^gegbaSvGH+gyj0YsMJ2^n#-<QE#TH0=Nc&vqHo!Sm)z#G?
zx_;Ic_6E-6<#;TVOn^)Gpr;s)>ET9Ji)C#+Hlu=;ITdmpP2fD61-d;d`)=kHJsD&O
zPH)szE+s*u=-nn_Ppbv%wwr~`<f{h|pU!M<k}vxD+o&k0pW>Ajl%^-9CZ|~#nVDYR
zeaC7tH_t0AEG*71DI%k!rs*HKONolU22gPJKJ_(YeHzAbTxhY5o8<f^%1&__-Qkv!
zF$zc6DSVa8k;sBf30WFhSCo~M7L{MW*>8Wzks6+UQn%+mawVuO;-o*=<ChbAK3H_H
zKzrjaD4=U?Z4K@03rbL)hxa6I>7XR^UQDi|Cn2b8MR^2w`K)Dc)#biz*mJt1jFE+D
zTv0yu74n9+Q#V7XoB!i36R*=cdg5%|^@}>6;3+?HhAq|iPt7`K!w<sh!zrz9i+97I
z%ek~5nvnhh%^^Xd!QtT_iLC%*W3o}NzIX8XfPiXpy5FyaUsVrmkEF0RdG>5w6c#<v
zrvnUpzEt>x)*;c7VlfbYJqsG~<JpvOMn1<nB}QhzB8~70@+<PG2q<Zvz%WEp8c;5-
zo<AsaeQGBhCe;{ea8++Q*mb^`v!|UY(Q4dt-aHjVysFIA2*+is^Q`r4UVN{%--TxQ
zMIO$MDHc_qSOCoF1p_hy;B7YHD><)6(})*=P^4uqtUd5$MQ6*!3NYDk1LVI9(I>Z#
zj+@THBr6t9m)sdWKs1Jx&045DjWkpjD$i1B85-1oXqg=}k%zmeW>V<x8xRSCIelq>
z1aHHbo#6UTnk2l7u$QgQ=?2`tizsKan}UM8u)xf8cV|yJL0j9H6`Gl!-xnJB+}^&5
zaZ)iZ4rOyQhgiVh8}MUh-Kz*eM$pd-u$#lV0PJ3CCm|9LSV|5^QWiv7+*YrQjL5RG
zpu9YE^Q<g_j_0}sxpxCj@k@DoP&5ceBE*T{zks3d8QwPvoG@6X@)jY&NMB!HSC;?@
zYH;uv6afR{#EBCju#28<l+Zd9!p3vuan121X~h`6deq^YR_?D$k37(rrc(bp1^CC*
z%jfBs06Ip-e{8GwW5LRwCu#n+72&@%N%K!jW&U@kXzFSIJ<0t4-bv<czn0_tVUqa|
zcL;yN7wi9I67b*n`g;+>Z#&-pz|Aw3{(vu*zgQ##^k?)RFMIpD{rZ1*k<1U={0Uz_
z+<g4G{rX!z{=Eq6KUswJ7xMAvqRKx33_$m{g!~&}{{g~&0_V?7*k7#kWBq%b-`@cH
z4*>Q9H-Ey{k3Hf4)Pk}6Eh7KM*MESoAGrAwzJ4yj{}aFfbPRth`G2p3|DUgf{|THw
zLF|XCnm-|o?Qekn-Gu!IP1q0I{0U#Izr6eX!PNrm-}w3)U;hEVe&FU$_+tBuUNE-5
zd%^z3*MESoAGrB5zW&05Wc%BM{2O2Y3BI0j^Cx_<{82vs9Cj3RvJ;lK)3Gzaqt(;F
zqoZMZ_BQp~Kmg0L=zNaiS)BeAIp7b(0J>k@ZhsKI0J`72hY6XO+Zov4(f+~p`aij~
z3R4&ePo_gzJVQ0Y$bo(th%~-grBSt~fDN7>QUKcn2+Ms*I-`Hf|4?!hr^(4FMoDz+
zW2P5A!gZytbrM9$hbh~uYaW9V_f<JorJ3oK-#he!BvMhNF}k(Zp?WoFF5spX*a)zp
z7EuD^0^WCUCY9(8rA2KN1DI7*JuFl$JN-S;%(PTIDa4l-?IQcG%TexM?*;(}A8I+w
zXG;7HlJRC)H}EmNX+7?G)1W%dDh}wff?kP?`xLEvv4wJ@^Do#EMvM|);^HiUOGAt_
z+(Iwg);-yTtkZ0Ik0FJ5lh${g7~-&uhtH7fEUloGGa@xGULqK2ihaP(0Wgl;*U`rl
zU1ItZyGiUcNYyadU$|%p->@{4#5mzxb&=}UyD15+kx*s_vD-;Kt{G{*lO<53E>cSy
zP5P_>4e1|f{AG$tV`N?Y{dZ~mqiop|K}?%Azi_I9ewH%e(xxUp=HzLku#kiIWL6Z1
zN%<?E!FlE%<@<^oMCk|8<{Pp^Z$O*mE)_%yzb^VQBozpWZZtdCEEBoYi3KURj3GEX
zj|C5tz8`kr)0mTy_iv|Vv=5kQRd~n4xS4KesFnS$8{c%~YQciuLZZQE%kY?vF=T}p
zVM3yZaPeh<AD8F`Q~vaq3zp3uo*OYf-G3c1{|S<3oH4S||H2+{^!#7IC!=EogsF^<
zje(^d-fwE1oPn*Cy^WrMEgpdGx0aIM%F+%<@f`A7_lTr{zKIT>l@pBGvuiz|q05NJ
z!py4iPw4%{F3;$dv9Z#VH?YG~1O62d0%G65$qr8gkM{RbE4*hiep>+E&osHYfzSpf
z`y*IE0f6_zQy>g5_;+ps0G<>7#ZJFDngalS>w^C87$i<X(khu3rRj`v3(EB1*dWwh
zyx_eUqUg8rD!Iu{h^Zqbr#F=$YEK#WBQ3-be1sH}Z}0u4&$fn=XF-pwy`-gA0s--&
z!Aa||L^R8LFX{t$v}UEF@iK(BOA)N*Sz7pcuy+JP{Ec@Bq2)GQ)r~|B#ar+CFY5;B
zL*gw~mk#{_O~;WBUmFL<t=S_tVM59}q28R4S?C0qhMu2;WRt!I!}q32F(Qy<lwL>E
z&lAF1URe_9bZipB59fm=o~~1bIOrAV!x2ZoZ{L7sNiU(1aYcaNJ>@4fMYPCYUFE2_
z+SU;g&^6^2{fhC*+J0C}$@i%wp^DM`o7REAPO}UbGc@X5ABIb0Zt0^>8Vbc_wuuMp
zS@y-~l1N@eKV9bqreg)Cs%i-*m0lg9mQe^^%6jG2D9_g^<0kKdT|ed&RA27!i=_|)
z;Z+{Pow;wgMHVDRK^;3h@$S@vRLWtDd`Itn>|?OxlD}k`_)J)*U(tx^7z@E`kn2g|
zDB&-J=)^J$Es{;y>R?KVvn@f2_7xPMu$giA+AH}Gt>^b-%M8U98lPq2rb8ZGg=JzU
zo61#>=9bMDvGdafn1b=yv3w>d$x-?2#~AA~bxWjo^1fSb7#1CTBvDK-^7@-x*tAsh
zl|*m>d7tx)8*fPtTcAuF_Nx};jVc#i4kFdLS+~*r((cB@ON>R67}+C{E7@7bB!wB4
z&#x4nlghJH*4sOE-#J3&vsAM5^ckkgPem;3b?q|3&uWpN#NY9RQ|p%h1?T-h-!mkc
zSOLFt-m^yg3#UJu{r`sZ0KYkJ{GIcDU>&&e#lOLMKVJTo-2W2i{gr3}{F|cbbM&HA
zCmwphNPX~C8E{o~&HhM!$j6hSD1FFo(D4fJb#32a;-!e`&0-M@`P`7CqPK43o373{
z{Seg586I>=sCmHUSh@&deS-iyg!2lF^a`-EPJ13S+73A4$8X)GP^!JVD8z+h#UHw4
zBVx{Fu3?aedl*}I>5&_ho6&Q`+i|Uj#-c}33f{F>pvNfUlf<tlOh+8iqJ*N78B1QG
zIAhG|v01hPl$z1Gf=G+}D>ycZ1eOcmVYt8i3|SwGhJ$J)1Sdut6)kdS(b|+Ew6J`s
zhL!%YSEAeV11p<V%48Q?x2oim4ySVSM0W4H5{6sV_iy}C-<!@tE*FQ>=K66_nI+k3
zt1>)bUE=hmqSrWhp1xN}?$9dvdLRXxv+?qtd4ag<`}uaw^<N?EmrBb(_dCJ>|KqkD
z@GosU;NNfCf4uy^im-oGl%6@p_ILc_{YmlwMTtF7T(IKNiks-$0tL-a4*HFe06)bC
z!%s)B3_nZyQzFU%#n(@Z6Y!%J<$!YOk22<8d6!?uPRHEJ=vi<+XX!V&sbpYdYhq=I
zM+=}~{6hrvzc@t=?`J0PXjN3-1KR_jyab*#{?SPM5|==_-<ba|>3(JBR{{Tv*nXt-
z{Dpwg{Z_31f|Bl+2@a(Ep&|eqnZHb#<yo-)jPkb%{A)S@;Md1{j`3&J{xv1TFVw2x
z{q|-4nhvO4{JH)7p&QW3+w0mne*mg53O4ozKO0s)9b1E+55?tW1!V*%MGVXx4D3ww
zbfgUIft1hB1PpBTY)n4bS=qn<=zsGKENH1`rEg*h{Hl^VdU944I+nkO2$|T}+VLCf
z*x)g;0X^F4{B{EXRx+)!iN2jN5N|L{Ku@@TJm`Mh{W?FV@^AiN{!O|c@zMWqVoirf
zPyY;>KmC4-i3#Zc_@6NSqs+h9_h+^JbG7`eCMg{YV1@k`)o89`1cW~QPfETYsvtER
zaJLg`M&N8G02^?;4X8e{098CuAhVe0y|XkjHvs03_MNTXv$Dws+yn*a%=hOFH9ZhA
zwEQ|BL<~%fjO}1pfv(YM<?ReCl%C&^Fwpt&Vd#Oit@4usj~NIZ;D>VhQTxw@XZo2D
zpweeR4`iU9I^ZAJ_(#aEBL7kqf7BTe?mzDVc#MGOT>W>7W3`HfvD!3-$H-(ZwWr8b
zpn-Uey*+hbjsEW3v~q<Nr)mwcUQeGcsWkzU?dxd=-A_628fejB-cMCXmGCfT__H&m
z)J3gdI-r6xfL2TKXFVNUy5QM}urPqoEZ%H7^J$uG=>fCa`;Oj{(}lCNh`Y2a&hI_V
z!<(O4YosKr1WEdfHP!0{ZVl|SZdUi=2Jo{-JVK{DkH&98E*>=qY?p6fr-w1z_aOz~
zC9(D?&4kjq-z6`#d5swn8oRR4XttQ1Q+o=|JFb47yluM3-MOPFQ7`^3&9M^*jJD3Q
z$kE32mZtf9azLo{;>uW<wz)}DYb1CF_lp&$w3<;E>TT-kl8BWIs6}KVn0rw&Uc%i6
z%>Z0$6p&iwk*aVWeH!H25KHOwP56hcV@ek8#KMc2qeMkJtUb(gBZ;_0R`5eB9ghJA
z>FFFE`Bo;SUSuOhPW(vP;iYy5)qa^2m)<bqcGhO!MBfNRMV*{PkQ114nbqXvM>l`W
zv37X@oJXs)G~b=M$zFVwJW;1~^#rLw<vg9tYc#!Oa>bb=$~aE@Meph_47re*6t7@V
zna>Oy(6I5ny<fhHCV!Pgo=m_X93n?vg*}(1Hjgmm$E-BfzZJBktLxqv3lq1iVvT&Y
zE?AyI34YmiAt&mK!!YeDT;|pY22VS|lrb477g5$5oq!l8Ip)8nTiz6h7;AeY$BV-6
zf4b<edt=Fs7cZt_uvm+NcD9biJg;48|KiMne*m!K6+C{)JpC~Z33b4+wia}r^&>aI
zM^vGUmnpHO06`ekcr~)q{1hUHYcC=(f&;S6%tm~GXOW5*F+pw4Nh{gsdm}RY1FYa`
zNxG3t`MLX0G7D!+F}3tyx$TzE5wd$eLsC*E^D*RcEncJU0k+cGP6OIb`_OQWxOy{Z
zU2v{fhXGOCD*KZdmYzazcj*DE;kmkXw#(x^=m>3FQo|oUq_3)HNZh@H4XAx2)Zew$
zyY~Ftw9gP*37G>0%?^F-O@jv|;LSZ1$kK+J=fy;wM=PX36sjuA@iD*{LJveN0fP%x
z8~jo0lcciwlllex?I2aN$dfJypUQRiF7B4~8QWPQ`Wq4aZf+!xmuePO!)A2-LNH9P
z%Q$3(k3jP|?&%Qe_L_VNt@CvPWzb;-Cn^=Z5Sb0dFJ8jpmPIBaCY-!*Xa_|T$vZ^c
zz$a-Cs1>&>$Ewz%7tBw6W6ABJQFmf2am}W}0nI+`=Xin^U9giycD8r4(YR}<sFSOK
zTgA4CKSo@gKvcS>YZg;uOtP%@YUvPb*I~oVkn<q0BqD=Ss#MXKuIoZp1NW9y!wK@U
zvC%jmZnW<s1k^yx%Y)qvgbZAC&@HdmWzg!NC7>)`EZ!V#uDoaTRqwJ9-EOqWd=CN-
zq-9YZoXRcYbb~-WQqZX!DaVR3;2dE!r9-sM0J8#$gGuzNG3?POIUhnIRdkDWm|njP
zzn+6U^Nn(QUs0wt*<u!E@I?SX=_tA$(l@r|jpxe42w3=rCS@-uw5c%4!l{^)@Fq@R
za9uKd=t}@1x%bYwvQw<XA-6u$ag@Qzlqk(2dTyndH~Z(8xx@b0>N8h$WxlW+|EE(3
z#nK!NOx;{}0ZKR2r#3{+$hJE9@5F86c-PxS`2mOu2Zcw6g}Pd(cLg)bT`d%sishxj
z?urM$2NfLozNp%CXme(`IbUa5cLHFRoM{rnM-97Y=ww1`Upebr`%32Q2Am|)E(QiR
z?Q%VdtQt#HICN^MzQg|5JwY{Z8zYIa>Tzz((ygij<GF+ANALa^?md=P&)@MHxw7m0
zg9!yQfQ^pAR5*H1w?SORCRmJ>Yd-`Ie2xl@!PR|gBN_#eBXShuKll-J(fd3riDQwV
z4zZuVvhVWv+WNDRU51`HRl<(xrZX1MZM#;Ij5peiW8|w@Lv(3g(C{t;;b!|&w`#9b
zAujk(INg<QKZ(knZDu`k=^K(1E`oa0T5(;?vBJFI{&4qmM;&}E*JJ~<;m4TNf`_1o
znlEpg?aeex@y8Yeec)?EuG#P8QNLiQV)?nSaQ5yxa73vnN!)mmMM4;QA-A!uz#LN?
zLwta(gTIF}))W$XMCeF=nL|1<>G4(cNi*e~Q0n$#8T|;jJLwEq$;)YPthVGf>=iDr
zZBtN$0=(M=;~u9bqIN<SM(FGzqP+@?igXwI*$993dX7A8vFH<&3zthipWLEJw1Fff
z=o%L}@l_%pV#+dHs#%ucz^QHybwZ;EiS+*KMuw1Jr9Ctiaeazn{nn-ABl~(+MbUl%
z&LiXZAJ9J8(yFIpH8;d#QN4|T#~u;;h@bg%o>j28ABv0Q+Wi_E8#IXwC&;nwa02pi
zXr(nyj<HXvfN0uRtNUeEFONrA-s($kVm+AvNPQ>Xzd9|QdBGv};-xAh;P$!nvO0@0
z+gxExz`@50g`r67dQ7btS&WQe-WRpIV(xiE@R%J}{_CkBou7jf!X3qDi2`IIl7ex_
zo!h&kCqMCpq;*q8-P^zeUchPvXa!b9_G1}-CjG(Zrno!St&{57GHE@0%)2UfbjmP-
z2!d0th=c?5#56hf7@ZN@-S!i8{fa!e)Px{?Ti*gLwt|Zhv(>)KM+xcLx#^>@{LFmf
zOt#TC=6yNe)~VZ_L^RFMXry!Ad`oQ~?C6~!kJt`+o2KA$-?uwg>k{C)xU`g6a<m%c
zh>-s=Y1vP$_1MfbmymNdjG`SD*R%3WY%G*&rFgsLF}yg7mt`;4arJ!Z7F3gJB}C%t
z#Ngvp$9}fBHF-f!c!tF7oMPJRDH;-I<xf*n9bDm3!t&DJ1{Xw?iigVf?#*Yc=y4g7
zNl6j1jiD60wvw-1Lp>dLh@rL6Gg4Yvz`foO(x}xdqPe#(6=HD|%Dw44V)+#Bx6Q&F
zkLw=FbM!&UEu_4aw+dguNs)yDM|os`(D%(r*Gjy^b-n7-{AVlJ($soN71NLd(g^MV
z$=m8X_a^EzJ0{&xP$9RK3eYG9;Xovxd)*0$<AMICgA|?`6_wr|qiI@o)z+r^hSN>^
z`-qnhSc(zv#Q(ym{h^6Ht7r5KEdQ`-e;Fpfcb5MfTEC)#s+frK?^-{##Is8IQ#<@8
zz5h3}?RPEz|D^XnE4u&C`|0U{+Uh^_e)=CX`TwMO1NByB;I5C)&lngOeq5jb|FeDY
z(>C}+7*JpT8Qb%_KV$fLWdX*<g2w`^rRReg*va(#77H-O=lfqdcn)I)rUndyd4Bdx
z_Z$oG?H~Vsy~_&RRN-gH@40@q5q{?9SM0xCVV-0E74~dpJRi^0&)4VFe&zp}=J|Lo
z?~mud$_u1@P8k>m^Bn$s{Qv&_g^lzd#`_mB{ZDfDoa#T@R=<qje@5-^(EAC+pSIP1
z3D&=|t{8#4Ls2sTca#Az0QbfM8m`R$rFF#u+-3C-))mmW{)2VJ@@%&Lw61_%5dSc#
zn4T9bJqL^6F#&_$IT-yku9$%({N2<7Fap#5VMPBhwSe~Xvu!T-hYpXQA^&1({nokk
z%hUoe0)7~e|IH}Yp{wf$wQ1*Vwl}n|iQcUVMt=2uL3@JtVh!Hs#XBUtcfp7s5xGSB
zYN%u<I%~`)<FR>8WiVM(2ORcHQkdnZ-AOO&L<<(DpsBx9uYWONPqm(8th9He7oDCx
zs)_kp88hk7h>5(g?D!p=hKS-L!_dKFWh~A2dPvA^w}|B%&8y=zUqq`i2ZxU)D$Wo0
zA7LeKO`rkYJe7~Vf~EIV>K*Q<=l%@aaoeSUFB%-S%X+z+M(b31veUC+$hjLvmpDg+
zMq~IqXK+WpMk88o3LeZ(0M7w;#3IV{+7|D}h;*KlybA6+=CtOkbk<gH4iB5dYt)A0
zHvTuCg_-&Go7`60;SD&oy4>Dfeie1twRHA7PhP(wx^tiE$1!9Vk`A3kN9N_Y-jqXR
zNqL$M6JBClQoT<vQa+Pr++aFc<jKBU_Bf!Wndmm9-J_VJT`fn|iuI(65t`Z6lekiK
zd;C(8HCXHxI=?}}Aat$x#YkxiXSKA_vZjNAYJhLhKY}`HI?;Er{c?HYTjwQ(9@RMd
zB|AgqI=X_%ZIVA%yHvSgyrqP`!Iik)1P&I5yLd!uSeXt<h2|FtcT`Dg24QB^PmZ_z
z+b#tH$0T~M98d?LB=Gi_Y}V}=kF;&6Mgq_i45>3TVLg&uc_|^Wg=gW!nINDu9>2U(
z&V;~b809-H$caFqEF&n?)!mm0sD^Sed|g8C`vJb9a#ibPY%cGUNhrB)%a%1`fKJU$
z2Z@=6=EGHrr;SC-_xo{@!UiqhZpNPPm`nPcdlypag_^65>+gcH2oLzhkuQeT$F7Yo
zOM}gp29^eFb7@?SnvA4V8nQ0L9o@>TovDwSI}nP}I=}lCwoq;|8D-a(*C@4dzE6VG
zYCj$@OIXD*fLQoka?K2}n+3Z>nbdZ=*S{AhuDBg%V?VTe=A2vFRNmyW8CLMEwkAOK
z7UFY8!UVxL^A|(6blg@^Mr>s+pAVWkrf9Ujupt%&w@`kf(Q?p)!0kUHab1r`7`8kl
zqr{E`+wvm%!gBN3Kq4S{$5t+I2iZNtwm7(2EgKe6DfeA|1R2w#epD?Jdi#t+<TA;}
zruA(in{RiooVV{@J1hH+Ckt3Y3~3PA3_S5isXev!K3Qcqscz6Q-LsciUWaba(jVpC
zaHB;ZEpp8B#e!RN1yg#9e`WGBgHw*}9(Byw2cIHuYE$yF(p_M&*6KkuIKw0ySWDdE
z3fxAO^rv2P7Twblz5{pjOcflh#dQqX0;mWrd?X2t$ZYm=eS0Ol5D18nG#RP*-X`o8
zxJy?P%rT_VouI1za@X}5!AZ4k8vy(RXTdPF_ce7YV<4~)bQ<m>$kR@4>h6ufLh}Lq
zXW>1|TjDkyW1XFg!M69>{<}TBbH_snRT6dV*7mEq#~;x8hUZrau!|rqKYH9IAU_Tb
zaT;Ig5qG<pdwn!VqQ2;fF!Tan#ST<KFM*}k2A~;1$NTk&RKhLnLk*P6)|CLAxL%<f
z5i@5>9ow2KdW72o9l7+6w{;%Sxgtm%W4eCAx*@zb$ds-lYRc_1UK*!A%y7`W%c=Ro
zQE=DLBFK~f6wq##hk3+u-xDu0P+HYAf2+T5uQz#}aUva7%`85Tb$E8zy7=nwIwgPp
zJU7*Q*p<C?Y;q}X=QfGW^f9!{?51f`V_$avOYsP^*&XV<nnQ&9?4wqLXf}J6zt)=;
zkj4GXGl!jPFbQL~7>p10_U+<Yoq{78rTAr|>OIKsQ;nlw(=|U!r<Up@)r=>N<I4oL
z*~vjdn3aR6v%VLqdM#Qxa<I-FIB8x60pG43sa0Biwp{A|7-!XVI!IaSr0Fbp-S41S
z*Cc<3R=PSpJbXNifbWdKkq4t*TRuz8X<C+tCJPN2$DZ}tv9p?8(S?9dTEJX~C`;I+
z2u<%josw_k$$NsnZ<oNy1tF?{<gKx_+SahAd-ew!u`HcjNA9-A$YR~0cItEEGPbIy
zTTJRIA=u(~MbO$qI^VD=h`EOW%eV;6^No;OoMS~}%WJ1_MXwR@FC!L41SRx8=`l<C
zjeP~-{wBnWWW4%lK@%^wvl*10P}LGJl?yM%IX$gRL|Ytjjkup%X>zw)uSnH(J$yO5
zU8j7F)3TLShV<IZO<q=3*aV(2WXjIr{4QIVY5f|L4EpF^WE4iL3jtTx(XxWBN*W4^
z-_WCX7?;#?U*rQbe!I|V854fHIJPDRH1iJb31{R=+zSDbmBa)*gaok0A;KJa;&(Bp
z#)r(vx4L}H@~^L_*+IT#&*t;yvN6UDOC#2J0xDVdD|akrIkvWr2Ir`D8?VdnZ#okX
z_Wb!Syt{gL_8#v2AERdDI{6tsNuj~)<0dCJRN)Vt%0g{=92@B0Q0GZ@OKZeK5KN8=
zxKi3z^}irEB)ff8Ni0cYf#!T5o+&my9Zds!s1r68hrN{6mH-Bp*N)kFaE%t49ZzuC
zi-uz`WT9hCEkUq41?9|+CoSA0<r^M9!8A6?kIhBj)<8VFi`N)g6;c!_&A#b<Ao1Q;
zRPT7!oj8qhw<1^q``gl5ri26W_MWtIL5#bhmDZbW>B;d0<`u0uwIL^$j%;oK&jj`H
zQ!E?f(f-I_z*=SY*h)rmCl}oWNAwad+?(}w6?{&**JTaJ27QsXBuDo_%e+;%hIcg?
z8u0r0y5oFAYDrGV@_}0M*~qW=A``BB5qV!5mt`2lu=YE%dh;6cT0y;UkIu}IO^D@v
zrOtwrjvys~-P{=`qg%?6yzMx-6h7D0t}U(WIkrt(EFdRL5?G~`wzw{)1k&Cokd97w
zd`8G~P*!Eq+(k&3Egbw%bIm8!eT!5^!>grvoyL$%1)oCt;d5p(&dwJ|6-YT=LlAuj
zCY?n|^ZMlLD!D+#tx8b0TO#g7c<y3jK_YJFP~;ursfI&lckIJmh1$;1Dy)jc7oOD?
z^jfM=iB+jB$HvD?fw=Xwu6FdJsajf`PVLu@kL8(`wq@wpIEV?Kz~)6h+uif^qwUpl
zJB&0(gbd&|+pZzMF;qt6+7^?5bLo~}dOY`Ye8QZK1KhhHvNMipdPz2l1~yVPRIp*9
zHS^Omk0O2`)#bVFzE-|klD{x9wA*cV%rzT<QVt2!dhp$5aD7_Yd{chINCm^juqp}F
zJ91g(TKmElJ~<$$ri`Bv39h=rcx-6~#2ND%9aRzfwPlv*oWUO1!1$#X?ks97zTPRI
zqCsEbB$)^knURGHk`Vx}iWyiHa}I&1d^iH-cr9Me?USVP_UJGq4kS&YtdWIt%^?@!
zkU?wj?5fIHc&j7Ry{moIPDiY00f4EJ1SNUQ6vBgh9)@ti+5tY6ex~MBFp#`+)y0*X
z3Yyr~t8&=tSPx0C)Na!hG2aolx}aP75H4rv{B`n^>YzkX40gOZ&(li*9qpKci$Ep_
z_G(^IXMlU>dj67Ej@p&eMzP{@M$~=hTTU=f98C~z`)vrfy{CZOw@nlnp75JD<M;N3
zUqvTU1X4wA4<Cz`OOOkWXQs`1U^c%SwW<L<)z3To;qpY#a12(Sa;6t!uTMXn+->r-
zzJDwc09lh*HBopCH)?Q$MzK=Pt0g~!uNTeED3B`@02b$N2ka^%khTTvFsQgENgXZp
zSTI1ECI=p^yN|$3*C2my>eRTmb~6JvOZ%F1=%tsEO8BWrkXKygs}O{FKB|y-L_Aey
zc)&(#RYgpG)rG8Zx<oK^PL-(Eo-aii+~}@Aq3|4keM48sanamFf_sI*8#o8>sPxB<
z9q(7UMs|Rcz3s|MSu;o7<(&}4l2q2D@0HGh4R5x-jz`(G&!k5nZgX0Iha_CWe_h0$
zzk-^+eJ!8KJ8U%#W8pZW3&GLrHT;@`2gL*V<Xxm>6wgFQN<N3BmkPS^n&^dKviXa1
z!aNXCF5|u_-f~lW<uvhR#sZx)C<L9^#}(|j#_q*t|CqD#=9>&_X;<^rrCHDjD!7~o
zZti3b?l)GO9FA0mO1KnnXmPME^o<A;IgA3jN4TrM58CzwEco+h6Y+>D)AA`Vn!2qi
zuEn@iiQx-zeDmS$Xaz04@+QO-;k0%mCNd$lAlY6&Htr>B>kDqTGbK{?=?a2wM~^s;
z^E^Qjs%-WJ7^xKwP0w>EC1Ttow!Tq=mX8>VgK|<1^pvjqVzOUzPW_gZk(ISIcg+r7
z1s?o7b}Rm&J+9t5d6sO~mrmt{mc_v+8UZ4kE-&=9L!(I7`?H#9es+|Me$HM@f|uGH
zG9Qcs_!Ub~9~b8!Jo7H8o{Byc%ea=xxaRUEBtXKuXJp1v-!B*&YdWWC6>4l4nWf7r
zxnr0adUw)-28ueE#C*;WrEV$_I&C07UUG(i;{rkKE(ew_AYJi_iCi|9;?*P)*_RFx
z73Ti=sJ)zu$_%e6ExEc^#rUEEocjzRvucr)-Cp`kB18CtYq;x)K1{0I3B{V6=!n?Y
zqnY=&<05wwW;v|5bG9xOS}E+ZHlJX~L+X9c_%bgCk(Y{=<5?dU7R9A4P}Fbu{bktJ
zM6mCAm)6|xkg?PJSm}5K98gZ51ffB31)&itMpsQCN9ZfG2<1V7U?N}m`;-Yejjx`?
z2QbMUR8t@l7b$Qk^pb(dJ=~#blOkRB+9i3Ts}p$8D&J5}njV&YD85wYY)oAtHEk7i
zVuRH2czJHBqJAOsU9YsSGQBYR)fZ=|JA}b(z1egVoLL0&syXF?w;l5>kTTsVAqi)m
z+QU+pO)1}Mc;koIEMSR(4nd%6czuL=CxTv8=^(jg)Pizh!>2qXZxlc^ghkGf+{pz^
z2YVuw=C$*jt<B;>J=uMsxX-xfe<^Vvef-sd@4D*{@f-0;<wRRIu+1bBCN($a&4u6q
z<Hl8(w!kwu=w-%?mliiOOQvdwZYij%Bey2~RA8ARFb=~$bo>P@NE&w1{l3<JFZzS^
z9meQw)iGWEE3i?`N3_cdR88=DJt&mRH5l)Hc8z8jjf$LC-<il3z$c^#>SMkNvVqJR
zf;0=y6-eGh#A5DX=KD4&Rz~^as<T~3@kjNxBjU0iulnk=a8}ChUX7$sNUkqw&8`^5
z)1;G!r#icsoa8ffttIAq#A-CNmLGfjjzv|6Aa8~gVw8cUK?xhI^!m+c>&0An<6@Px
zkfim-_lgjlClGO+-(O?rTeeY`kwzBEnKL`%^=VQ(@^lO-eJp?RK4gK;mdZ?;rX<(n
zf#tPp<xw@VvY*+~SiOw3^^BZr4A0!rKu-ZfwIfkOUwjJ4;-LtS)|@_IRAPz<qG6v|
z@k<r_HGcaXQG>hF>6l6=@)#NxM@GoR*rXpGvVDRG4@`^u#H!gIQa*o9IQ1w#*{s$Z
zv}~U~5(b^9VJpI{Ha<{m1uzt9A2kk)G!$YHhzJPo8J$3UgbuW`N^h}_O(`k3CXG#Z
z-0Ke|8`xDltkW2w0sb{gsX~R05Npl%*&1sic(Er{(=A$g%_Qn-9Euta)&9c4C7Dq#
z3x~DIM<nJJvjh><UcI!mZL>%lvXFfX7AgDnlK`x1o-B*351##ieo$*@s0`TRN)Q2o
z?6~f*?}B2#(M7DTh;xz3$S_xc%a)@i<(6UKYX(_YZMWUFai<K=`|!2v@~qr7sW?b_
z*A5MK_o^l<=S)1!$I+cdhW1u*3IAd)e!{d5-A0v{g1MECiLbu5&FI?Yp_kR^Wzzr-
z7{5U#%3n41gok>!KCFCyU8Zf|IIu%3ZsdEs?*YCEk0hOj1nr_HOu?&oqX?HUm#NJ+
zmqqjfJ-BLiiW-0*|8CX-ud&r-&$~mcpz-#cVMH?kmhJdN_?GmD;*55JB<<nch{l(@
zX%$6@Hyx*13tYT$O6k6#p+=XsjJbGk!z9dj_Uy{)dwuzfWING1qFEvYFZ!Y8ghph0
zP6Ny8$Io_T@lvU3-ZgWX3DT(hrWc6Lui)4)tnXt&8;-44yApX+okX2XR!uL!S3fs9
z!oJZS;;DNeB6F3h^LijZYl3T-i+n|?e^4<NY^2mDQ(2x&{>iV6DNB(Mx`X2M>+-?f
zwBx78`+aeqYpswbu>E5^Q)17~_3Gtfce(fJhi;)-%g(4Rjr;}grp(mY8)?OvX8je!
zDhL4^M~go29G<}s5Srs4YzXRpDHKQw?ad(Hvp*3qLn5Ily-%i!7&(Q%%Z&ATkF`Z0
z)kwOePa`)GWx6MG^{K-$N(f~WewyU-t%BHI3@jyyB^|!^r;v}cc$1y11!Qv7;Px;k
zkRT~+jnJs*3DH!G`4b82v|wny-|mVY_%GW{ry6y_9UU;c4R0CRH4p0y=~|Hxq;eOV
zU;0*dPK<q&lUvdE&?Z=QiF35aU}})45w@$69e?r~)up?ZC@*K;KISc=*JrvD@2q~J
zcrR(4DM)BH=PJ3HM;r;uISblbN!-g!a5w;UH$f7@S5n209a)H7QORGzESf}QF;}Vp
z$k7OHz`CTo@Eb$6?5#`Q__nB@9k-!?+VGmTkXLEKC)~w9{`8xaC~(IYI^hj5>aG`C
zulMZaR%J{2K1y?B#jNtOt)iHZ?as&;)a9z!S#5NOZ)mvROnzLFu*u_JX}Ip6@nWcq
zl)$05>ni^|r`7q|jW+77CM#1k57Qgw3-H|x5F_h}H_M<)0&KLCc-2bOWuLCk=;N^c
zbv|O#?!*@cFB)gU2s0Vh&yi&7ZfsRm&9}EMRI7wa23SlT>${nLE?ywmx+D=7hAnwq
zd%wB^O46d42SyUl#~(uc<VIXUdI&R;+8<H$9h=(??iS1c(LDIkLvl*X-6|5n;7N2i
zylRs-0)8%wYkYBMS5VrD-?OnI5ee}2762z6hlCh*+?!0|m%mBT2uZCPctO#~KSnJ0
zLA9K%&-?At5k?7ISD|e3ibO2vYF}Qq3JQBbbmG#-Nw;)LPkpM|)vbn|@q`^(TrrY2
z^uyles2+M8)^IKiqI_)CbSXJ>NH!Spd+yA1ING?g`tK^<)cHhuLEgJ~?K6vl2yx0b
z_XRh`33(rQg<71?VA{xnKr4Q4{%TKaEh%U(_3@Q1S$R8;f1(CG2ueC^gn0a_5*+&V
z{$-{d86(c_HwR%7LOn=Hc?(~{v)3?g>xJ1@+{4avba8gBaxsqzPWaoDn-9n*EyoKk
z+@7ZRr};)fM&V)otZ!O;`-e*{+cQP2QhB4n7sfQdm?mVuLZ<khtI%1}WF^CaB3^1!
z6gxE;Znz^q2C@%o;8HdB8LcnwSg7!7#o`lF^01*$-k|v>^DL~=R<eTHLvd6|uEQD{
zVXelkiF|@5B~womB_td6O7W^#`D(JKc)ts>GE06qS>4vkK9Y=LC=<9!Y3<L9M<zRp
z-7a8URSsYiy(+nB*5{!tb_LoR2F9^=>~nthT}~L7ID|rky7W`Rfa=f-^!I-D^%ZD!
zqWccb2MA>7QOi`|-)yweiqt&Wm~C@z<|PA)Fh9X1x^I-++&_lKe1cEQjJ0*+9_@CV
zXZ8rOSnqq!XzRwj7H)`b+1gC3&c(T4zRTC#20Ofb^1a=GbyhEV5L`6rLp|PS7m2Od
z%a@zCBy=<0xh^SXly4MQa)RX~0d%;VHrPb<2&y(<uR@53#kPA>964l+z)(<(plMCh
zs1c5^L=PNQ;k(9*D7U^dRGI3OFT)eL@s|Ls4q@G%2193=jQ7LX%%0%f@T7G|ym1SZ
z(_@z@@~kur(ssBi)SHno$!7e|G)%M^Xk&9T1n`MPO&BICm4lIEd_3*~j=h<h=3Zd4
zr-<A!jgCR*aMyqndNJ5WTN@8Q3}ti*L|cqz0v)W%%v$Y*EBF;<$wI#z!=Ikns8!Xl
zL8t1ZPB;Ya_AtEae|+Y0H>zD*KVk-uka*o!dMlTunmoBfg_HbY<;|4WM+&-=WnNb-
zUsYd!Fn;~1Iimarl|xFMY%!P0uSAE1s5tdX(c)M|S>4*DXl8fI_jma$(tMShp0fqb
z{qBw)@OD6Nt}^(LFXc40w;Vq=j^@&kj<m=LB*03y$+nVm81oZcWZgfeXl7ex#^<(&
z;F-2F%ebR)MputB9%R4HETkf@P~wOk<Uf?jm%&>$$0a6*8^=M9y?U{k;e-pF3;_F<
zAf&D*J>VV2|IsS;Fhh8?wuLF@5^@y-JMfz?`PkUFqdp@CU{opellwY?o^Xhe1@vv#
zs?#Ui(KM;xn;Y#zCJ&dYgG;+0Z(ilY^kf_nsS4_{{F)5;a`3n4n`H%&gd(5Cq)DMz
zm}Y%6qUG!!kiovC)XFFJQp|%yw;zVJ$8^nOfIb`?n!gl5ReABKMSByBmr9n&jx;He
zhah0Yl!x$+37K7(U>b*0@-2Da%ppbwux639vSr@Il1=x~p6toyD_UP)NO(EshAV)i
zt&Oc+k7c=P>mFLGInlpLhnd&@PH4w+;=Q+P>fz4)`kkFJI}_H%*39XQm!}(fiVC^Y
z12MhjikS(iuT!eq$_P@ad@PNyv&}*HIxf6;iMGO~;>WECgf8&{CE<@y$!qpZQ-wYI
z?*ze6N<pV3X~#g@bIB({B%fksB9>q8O;&ZVL|g<|!d#F&4v_)g`H`Q{?j{y-b+u|P
zG>0X4F<O3N)Ev=w*rsjN_0bT`CIBenh(+QVyoiPC2Y4rSF3>zOeZPFDh4ymfxYc<1
zL6@WZ&dU05W(0O-f_&xc*ULhO?@Cy;138Ct{X-;S1(W?DDGlWnkTU!CV1u&X<%qd3
z4p7cX#rj}y$*5LyUh*#uw<2H$VD#H6JY?TG+Fpzh@A_<62yK+mRbp7}CBo17e#~((
z<S+D#C)iYTF>me`O<QUHQeQwjwj7tj!<o+Mv9VHLa}w|G)<VYRDty(Y>ncaH>X>Vz
zG5pf3&FcGk=od;zG^LO}eUWnxs+O@>9^5hlK>O;uud^IHx=gFeI^Z<s?Umogm`-tB
zR>CTvPY({^d9wT__Z;Nb@T#+K>}4VKbs|GyQ(tFOn7pBZciFv$9~OIM4x+jtZ8sjA
zWkmcruNvL~v1fZLm{bZ%sIj`aRs$)t6Z}zNuYOyu`b{y7cnDgBUgc=t)ra>jpSY-$
zqcI#Hr3^*4Bx=4ZD901VOb0ave3mK8cwM5<Gl>AsJuVb^pXw5j@6io$ao2rE9UQdD
zhwYiKVtxh20GgN>RIM_%jtgrqFT!MYdY-hHxQp+RcX^Y~bu>t|+7CyJgxF|iPeC3m
zGl@W)2Wk=aKDGYzbRe!Z<@I?r#Z&(!{ERX}V4ELL=K{8Av8A$Go%rX&jj8$M@c_d(
zF&|?D&wJB+1Y&;8JI8g}PoD3bj4xS2a6Roz6Fp7tAfB@4xMi4pTfg8X$s}()VK5$+
ze9J#LJgtYBETBnR{=5N~#gyP6@@~epmEr1*R@&31^x>k5?IrG`ckQy%elZpkd)put
z2gW19)Mp-kS%ReW;RYKx(dzJ_t>|IAF*ThRvxKSD{e6>s1>j&llb1{3nx%^qx1Z$G
z@6<O7(b7HZS_c*%i!v?{NQZpNnY*5Hx?@7vSTf*l-L5ZcGfGhvZT(x)(SuCO*`>zG
z(~@g2)=H?Z4BQ>US-!bdU$Q^x|9_o*1z1+i+U}N?knUDmz_)`&8YHDf0cns1rIGF~
zX-VOukyJuD6p$2@kP<<Z5CjzAU$5VGZ+ZF7`OkI03zj#}%slhVGixoFd+zyc(U!2<
zo-#P4RtRFUiaVm^e{#R35s}VJ7d_A0T%*8ujjGx^-o{KB-qlMaDBDn>HmN>RpMuM5
zThdPA_Pl(l^1YUjVt>_wH2UNBnWxUNzB4rw$qBh)1}ox?s)Kf;URmN@Cy)F!oj8SS
zsH_u$#@X=~CmESa0^r%Dg&Yz7qaj+M?TK!S@mUL!=`K6aA@xI=+B826_F{qUFS$x?
zHt!ci5==_hI=oG0KC(11S55g6)&FeF+SeWN9OvKq&bXztB0hePz<t}`xZ<@~%i5g=
z@}m{1`LL?@Rr!~ygElGDZm<XF=yxq#W$nsE%nh^+N^mB~i6*N(1nYBUeV24|viJL@
zXnudWO#vaCb4wE3axk0zl>U^w)vB!ipNJN}>F7w{FC+iqp8wubaCXfaSPuTb@vF5A
zHFR`T{$N^Mcf4o*4@3)0<p9a{|BYw?L;gXuI7_hpo96JFZg7q~@r#Iny>yQu9{i1A
zXb^v20rmWQ(H}!!0LTd#g2S($VyypbhlXL6w*UF_Hz5K9)P%YIO~Ls4I|li0ISe7<
zZ*R{M1^zkc|4bD4KgIf=cmjZy7V6(LY#0;)(Es7+|4*U-z!U#BQ2>k~zW*j)!!axO
ze=`Lzi~WC41pt=yA5;MhH{uLc;P=+P|KuIy_ofF-;{At}{cEqr@Bag2a`3NK{x@27
zk0FT%jZUgWW6n>%;_*1KXQFdTN%WradNLfeiq}EG3J>E=aBQyMl>*^`i6esoaW1gV
zGLk|z`GPJ9E~!ydFd5yZ)6{lKW7MW$90hh;QM)rHQ-0hK*I~UfFuc}xP_b}NFZbEO
z>{|1wxchKxqwRX)4?`)Es{x_>PjRAdNuLxoT+qn)AQ#Z1DPhSTDw-*p_AFm4^MX{B
z{cWE&`FvF`eB2LilcepxX*{NSA=X;K4Z4;=jsy!@cLnpQ?}GLkgbcq+CC8<Qo4)J(
z_Tj`w1$P%e3Wt2}fZQtK!5p>z1eH*(fC=iJ^N&`Qg5&BahAE*tV`IiS6L~&Q9-91x
zn;Jw#7l^|LdLKfyOFudH!lW`eZjXI+L&$ZnXW^kHC-Q)KVLL@@W#TV0lFIDX^_!CA
z<u6>6n_H3t+?%w)v{EvlQ?vapT(nl@o@?-9PH{ZAVv3?!{BHc%*a2U#jQN#r*d5yB
z?tzDIkMe%LeADlg6-2Ttt{6(fB*d4gM=P4CSMk>kA)Q14K64_J653<6y1eg4K2)}M
z&qJIcI+j3N-4w@#gO8+j*lE#dZKyLokjQzs-P3=uC3LT%vHK_n*>~hE_@LIQ<?Ec*
zt1V|XbrMa6mSr-q>}%15U5O>1X3%7Fl~eN5zAzi{Veuk{%?A?3hvBY2Y|*Po8<*-K
z=F7LdvPP6T{MMdMpNyBSM5~TQ#>oful&!|TJs9i|_m-K6`jH*g!av-spFm`5Rq!D1
zX~(ArYS+jTR@kiSwe8zo^S5qWrA)ZT-3-64O<^y-a8)IX`7@&HN2IHMT^Ltsoyq-Y
zE!5c;r~P_e)kUE#PqT|`IBUO3tyaSvi?-GSDVhZiIPv*PXlAL&GJLBNSwU=C1A>Y?
zBbyaB<kAOv+13O|8#XIgbRV(gUnAyOyJKAB2-mux1sRK`NEbHWo;w!vBajSKU%Pok
zGe5+;>+BQVSqS2DBaXRVq``;6FL+GzIQ*iV1nn5NYUCoR)(h}hcEU1&a^y1EmJ}sE
z{sXD-puW4JD)+dH!SeocGYie|fe2NLb;;v<lCtCWT%3n)lXcJDR|bDKsicYEnpj9Y
z^^a(X?s=;NfB9`n@VU{g`6YhG-Q-3NIR2Xl4KsmP*Pa=93tvlu7)gs1**Lgn(hwL1
zz7!L(=y;g}d6UD`JRiSl$p5_eW&@$^%O`I>m(m&zdf5hNxTrra_uER|9aIYXZisxX
zXK}Q!US?!luC-woY2>JAoK(2UuLXQ<<5BWer7Z6EEqanRl8d05?lLitlj3<tcJY<I
z;=jVPq`&JE_t+#<O(#8$48GzEGejnGjW#oL5%>{`u{;bLT{^ySpOV|-aokF$0#`s`
zM;J$E-!^ZZ)~7{uOInxQu8?7diaA3n|3ihvH{18j!GfVwEy7fEf*N>fm&xVlBYg<X
z@<?K-avmvNU*RzCU}|Z2p_`xgLH^rAGM>(#)-&uOjf*!5d3W&}jQ_P3kzfukxa=>B
zZwBrm|71eX!r`#QX|poi?|Gv!FPg0Ssut^dx0kVLso*0#^1F_?l)Oru>*gd!!C#`v
zqs1c3qWW4GUq`>W?16{q()CahhNneX2~GPkYMag{IpGL*(!!pVnhSb9^vXR6Jjr0}
zxfj7Ahqg5FSKSuOqolo-F8v{)XN9{qu0^e_h`97$pPwuMN1?vcXke_SYv?F*B30{P
zUxe&+xD!zmSTM=(BoPisnzc%5UMZ2c#jg(#k@1yVdz}jsdz#}L?aSRMJ0EAHkWS4>
zCcl^@LA&u7ze=}>@Jmo`hi#_}ax>tK=37^%*pl!7^8^-1&JErNiO&Zh9+6_|mlB>9
zrWtXhX^22q3&phQCL?}|D_0cU$@eM=(q^|WOdGrUv1^ZauQ58r#{AN<d+d;Tn#+z6
zt)$Lzk%w?1;|#-0;8&`sG<q#g>Rt*0O(VQAXP!5lmbVr?Jt$9Ty&m(r1RXB&9kZ=|
zCv6L~Lz(S(G%E@7U%uI|o$SPEAnPZOC<uPu@0YwwyGxwK^JIXmMYj5;vOv<aBw~%1
z+i!6)OK(CXnBJ<A7eLnqybM>`*V8_V@6qz4r}wyl$RW31S$;4;<ggA6n_JaH&8Tkr
zeM9}Y@PpPnMdkgJ(}?SjrkgE+Bg@FImzAy?7;!Ov0~j9e>f=!f2c4)|CaZcnwa4GS
zbuc^Owgq)n2XQ@ARC$_CHA9fsZ<sZtw`lR5lP~m1iLu55S>=z}b%`tTm8Q35P{z1v
z@u?!O(h@iKxtebecLyJ$!saYv>boDQ$_L$fGFhUdj6YICs!G|<cc2Yx4&+yr=IOa<
zkj}r8^DiDe2PJFbXQ0x%PU(+T{-S?TF3pWEI3rS6NFl^en#@I@2d1&IY#J1=eE-~n
zO)vaahGEza@1WRzrAaPJRq8VHY7^bE15(#1<=xvsBk8df0difp2KN+XiiKr-5RM40
zjwJyL9)*+;oF&*ffY#c`G)p^Q?BjNF3gKtAXfw8KBeqBMS&;h57Qx}ql_Rf+5}k)~
znx(g+$u`D+l&S2$CgOQBVY-mc_%(=6vi!}fudi;gQ<*p<(U8C<@Ykh$<82eagNg|&
za%vyDA9=nb-#n<<C2KS%C|!w^Qqhysur`c)ta2}@8y~@;2OkO<(u$jWgFj%#m&Fw<
z=<P<MiA<QSdqJ!1)$8^486AxC1E{F7j}tX0u4=I_T~hj~hU9+wz$=usw?{IwH2RT2
zhJipx!E8fV!D6nS-1w=JKCwMH`%jv#zcMZug-<kE;Y2dJ!OeKX@dpjL<_sermo*bD
zb{UIzXbvlQ_TuwvbBmz+dDMyU^wd7lUwN%Nb!|4VmaS-x^G8w5zJ6QjOAr+=#Y<+f
z%1Xz7Sxt=}q;>EIoX`l*Y?CRbj~$bjXvE{S#XV3yfim9K${ZT!Q8j)dHreleZ?%z&
z<JwWh4I?K@?GPz+kpnrW`c#<WN)1IaH;XKx%t(67%z9$y(6z2F@dN!Yf?>#BjX>hf
zlIvrndTC{Loh`z8A!TGbkxHpDudLVq8oB<Wc#=~P)H=*cv$0H&FSNgZr6zk(OH>~}
z>cONL3CZ_cFErE!iOurLqXk%W29uwax_6{lI7{c1vq>v(ONbQ-dob)bwy~*LkSj(~
zRXuY2l!hj>7*^{7mNc(6l^aB;PCRf|vR5nn+7uM_{Mpj8!Y9Im%fz16fv<BZa7x32
zox;nr0^PyeP0Qx}b8N^+ool8dIJAe}_?;F%<E~^$av-M!rEI=h1e5q*4vumlG(ENF
z6myXplO~G0p01!wM1Q(W!6r_$2$qa>8hAL%SNL!&wVx>MM3yM7l{L6;j;_-JH}TT-
zCKe0fB#O$zK29+|ip~_t*zMp8&6@q98gDN`I&~x|JE<KB7dPHr_ZWLv7(|g14N*^|
z$k~mP@z~%9w)10Iw83>Lh#%K{YXj+o`dtpT1FX{<L!9O?)|CqBpSXgp$T$SM@fUSP
zTU^3tLULz83uvO<Q1-AEXA=&-{d+X+nxQ_!>Uf^xpQYHEg!<PmDT)y7S|)o|;vKb|
zD)irS2w<5us}9*!KtK*UlN52Zq$QPh#Q0+^cBc(J0(QG>9q8R${j8<^M2j8!oCr?w
zxFESQ7gL8ioybyeh1K1O-NGR$7IhM05r5u=i+b<WN75u&k$g$T$zO3fyMvWG?0L&a
zXEq+v<K&-U9siOq<ZuRC>97alIh6ALy(ioLggl^^5#T1~G`|`}T{K<m45<3$sMu_?
zq`J|H^DezDXMLtx-oYq61M63n4<v|8-&kr7`gRueunih!n&-606xzYt`f-W9!QPcu
zP)uySL=LGcFIq{vcwaxhn~s-J%%U8t&S9d*_n?`cZdrPyu&iftaY-rEF{+Gg@h%_#
zC3=<QB=OFVi0|<Ypm#FJ1&cT%cIvyf4##C&Y!Uamhp%tyO{=%Yf9Cbu@cYPRr--bl
zzNFDtGQPs3NgZhm8x6l2^3L@!zo8t9puN?!j5%eK(nd~IjrWhjJ6(;4&4$9J3<g!d
z(~QOStE7%A=1KApoH)AJgAn8PSAOod2~yq<(^==tg*;j#jwmh9Evj1yP8_wK@Rl}M
z88f%bfJu`TjK;lT6p4E~Z?`EvO32Nvw=gsiD(~tio#(TvV&?6lDs3-aYcR)~Q*@1O
z5oXz5HDT3uN5xn+hC+jJc9YGi%aHR$9|ccroFj7dMqqaLTSFykXxj6aqpAqaOxAX8
z+iK=b&u_;bJoCdEH}darKbq;bcTl}6CiCgAwdO$NVv*gH<jSn6Q&P{DlrJ$~)@G#-
zln&lF%ztLgh4Bm6DLC#=O0+LH)sI;3%P2J!ZpATh#-L|nSYPk7ZhG?PaOEt|^*?uI
zR3RN%kBHrNh<aXbzPIKWUGA9u)moS3>YWc!X%r*)cdZ3xnpVCHI8W4O4p+p9?Pv1J
zkE~nkv+)`FISnWzNZz{zu5jPzu6@Nk)}rMxjC+IbIhl6&_DG0JcCpsY(x1&A%0u04
z6<OP}jQb?JwpI*uZ{^)C`YH92p+49&V2ZC^AYa2yr%t|L($8!Ol{3B_t?W%UO_9#W
zXA_fZ1>d_fdDWb2sf_EiHmyr3QQ^+d`N^eur<&2Ypf-W^+y!+FGKLA<);n>3RTmae
zrn*s(4`+zxHpN_-mG3kczjlY1Jx@^9<BlLbGU4)$kk%e+>!BrYJ=ZbUH%$t3kn1#=
z@FSt_jlJ*oJV^uPldRyY_+{{pI@OW)-@HOio`m34)b!sQ!)YAM^JjhQE*HyMS-9iS
z#ibPDRp#C08!C}Jyg<V3>&xxS<F7mIzhA;-rmaIg5I!4td=jCASk``x61`G5bKyba
z8wJ~FRWg#d@4gJEFs9K2=)Pq<xjjF<0^a`-E>F|b?;o+SF|g5_s>=F##M-{dquNEz
zNBp)`>+V`(PeE?h3r|WXL7RI-pLGdld2c)_$$m8Y*uLL{_@-q>DQQ7uEgxQ{(5MxS
zmH|CCm#q$yy?3w7J@2d{y>Yh2uK46^Ss^vU^g8f*bD_!DKw(wVVd3I3^v90l=A(&Q
ztP+kNWhT3nK7L(hSD0BtekVKp7%y)fJk8!~&FR@zLKoYSkSPdG?psv>e^?yn=I%Be
z*bKvUr4xtQT_1JZ)t=q%-7hf8I3{~~vivqB{BX5ENW^>fQ6sYDYkkhd$?lqpUjt9U
z9=~k_Z^b>k&%=ocOZ(J)Jr9PrxSiYWMGxN}r<~R^uTiPXr(e!eVKsz13R>h<)xfM9
zY#8qp^x7;hOw5yrk{ur2<b}(cF;um$CPc=Ta&4x?5G(AkSU6|CD!$%0GemQ-b+TYB
zlHK<7`v^&AIw|gr5?SDvV<zV#Vp!WXif_Vh<aOmL1J>jd9-Zm<t|8M1UgwW)k;ycA
zp%h(OfhwP>5l=$<vwm*=g_m7}CMmdH?xoYI7R38bMttp}mzr1GH&9O2&WvO~UGLf)
z#~g*LLDl>|xn$(s%kOcWT<IL87o8Gw!-zw|bXal~H7dlEv`;E5`ZvEdyS@|6$Pno!
zf47xmyt}Hv?rQ)!{Sva|f4X1wW?)+C^DDHg<rG1G|M2khcU!HEKP!>0R~zC^_nTeY
z+1gv14u@6=yNNgnODMm7P^~1xvn>K&`LL<B$4z613(unc;!qGC$673~M4Xahl(}(X
z($G?<F=W2`-iQ06*Fd7p6c<b9FFTe>6iR9v5REv~@Fgp^loE|-fdzDGFU~Nes><U^
z??l4Z#Y2>12pzJt<epkfmg|NY_BdHX?|LP}LOT3XZjZYxP~Gxc<Lc76<vzXD*FNgl
z_w=xqq(P9chE6YyhQ45}|N3~x;D|Xb+eJ{=a^S1c@9-}B!+7P3FrL>6pSantG&9OL
zgX3s)9F}yK14@|5VRONQm$UQem2iuwygvj>+R+*pTv|M`Vodk)B^{vhj|->pxKNV^
zDh?G~SDoWDLh$7gFHAUxQp6`YDc+IOHVv)QioedJN3XL!gSKuX5dM&qsaHz9C?@iw
z_kQn4ivU~H!^1}&WX$ptdIbe@BRNTSmL&3_oq8gqVMO4=#DQU#u<f5YnJZfcJl@W-
z0QruRzeBT#s^Fc%x2RJkmt51h_g4u6*T!Fvbrq{R=}(v7-O1Ca?bQ#tolYzv_iW7W
z29$R9DDtjFg3X0GhO`dfUia-LXA&{{*^BLPwjjI6cK&695M{=)YJSG~mG`UyW&9V#
zdIiU=+hld_8ajxS%sPr#j;(vPMry6A$`|42v#O8s(5iommRhH&yG+n01+I&Otk;X=
z&O20gaK7JM66tn8c~8*^Bl=}JbS?;!-1vy&JO%<SQIoR9;GI$hd*Xj2QM^$uhm#D7
z>c6^VmF%J9W888hA~&H+_KJ|<$FJ+{%Fh#qTXMgZ?PWS|CNRI`nsbQAvTT2`AH}q^
zEiPO7K5DW%V-tK|p)trpWx1m6nRZq56XN9|=U7>}yqTPMk73_tM5G&gW$IrsClbNW
zstTLb4Gle1k34B4l2RGQiLQ+_bGuqg5q_@iWxDA5Wp5pqa5xJs#fol}5ffmW+gX1i
zstD$vcNP}=AUNuKfXt__@;S)%usAB6d#;|q+h4r=`~f@tR<X0EQpf!XID9x0M=#DS
z_|Rc&NHYT#Iy!3O)lFUGs&8#yJIrQwF(J71ONJkKRp)kn-Eo2#U1WqVcTbRhUKNgf
zq)BqkYpYbD>rGivsR=AQjtk*^-KT|YKk;-bY${PU9j$i{ySCFd6XvT{_5-+72nX{!
zZ|;k54y{H!HPFvRbH}`|@i7!wRng#TN_>?CkGNXbI|M^PUZjb=%E_U;93jK~Nt{U{
zlKSfNpG$sKk)K$TsaFML{UarcIi>{CMF&1|$1~WKPcEtL6qzS1atTPHm6+b`GHtl7
z`L>vu-yaQJt$@;GknV7^KIvGs`f9in?hz@{!$O(%c8tx-r|F83rf%K+568<krE~4J
z4m;nM6J4qLk}JLM-amx1(6(_$W|_K|(07dvI?~he?HwWzJ(UfgDje*T%ZlYhCD(n5
zMJD5I89ylQ#MIHCFB#6)WYr&YF4rEpY(Dt#sb;}q!`(!icP48<SI#9-ZD=~QJ<Y-U
zS{v+YsHO6Fib2DZr_oabkx#<VE?M}!=^CKfoa`&hU&juJ@9XH+w3SKnrPtv^NDw7n
zkl8>Q)#w7hPgU0vT~Ep-M3w4Z<W{G$lJ3vKd#Ol5Nxwq9`&hW%_B6j%0nc=9io`wB
zDay1}mWQvKoR;M3R@>=7<SXNFQOk0=xG4H=^`4&-+AihX2Ws!OX{kexsKh-BZb^D2
zIlU2<)J>k%7M)q!j%GttevWz2?MUPwz!-|)p=?jIR^U=K4{(y}sV>**V*Fw<IHNpd
zXi4_2$e`?Yf&c6_rEA7d{jUKX3?!F$LhJ1+yy(_QtV8oqIaZ@~+lC>-#RbWA6U2S|
z6IlsJ10CIZ)u+*SdfjTXjh^gK_=eB)wY_RpZ69hGXdCdA_3!q1;rHTp{xvZDG)dOe
z*qokMCRQ%cn6K+cH?F=LtS`M4W2+?aoM&pg_B-ve=f3AMd=k0Q&NOLDYmw$dQw7W5
zd(J--9G7d}5=~mBov!~lnjnU0s5nEnCW|2Ln^ZLH3o&V3Y+`iA2Am2f=e?*07wg5(
z$eAIbHUI6~t*whC3x6T<(Mf`au=sD1)*I!C6-nayIzzZG$rRo&jOodmjhR1ile)sQ
zPC#k-zH|DX5bXIXvk1h^v~YF5Zf_xRcfrE4P5St*l-PJu+M6pUN?Ai}&COf8_+A3@
zr?MkbpHP`x;kgUPWNPWhK54QNriRm9O=+qR2d?+Zk$E|*;8;BF*nn?m33QZc-Lejw
z89>{xFFT14*L{;+vwUE2BvcIcsi&vahQuBsmvDt`%IX5^lzDiK6~vU{9UoE_e}oE`
z+H4Zp9;Mz}qPrG1|7>rehdDS)V%zEEqYT=Ex%OzAM+U0=l_YZkB8mPX`Vmg918uqO
zI++I>p<mKQQ?2BNAy?AT9|Py&@vae53((lzeKr7XisevFg;vK3G<1SG_EDZU+Ivg$
z&1}lhQ}-&gZ$xKXXTP@&x33;{$>L^*rcs@2KKlTfl@=hio6#X4NMp|orc82ob^9!0
z_#|q%Maf~_b};;A-<USlZ4+M*e~r>pEg2h@JA<X~lC2LsC?l1Ao;1<V$zJ&$G2d3s
z$Fi0GR7z!*;bcDMg2VFb#Jq&As0Rm<FGCz=#W-c<aicG<tXyXG4DsI{uD9wXv4qpc
zuHqCFPtx)jMkt8ebqysgQ7(zG%UtudmhSUSyR~((yxeQ)sHU{pc_zSfgo=!55Opj@
z<d3&NiVMy3rB!E94mMBS)pUP`V5K&L2lU#llC>ynz7W~83>vX+oH2G)U(X%8fDA-1
zS>0?9t<~urNN&84wfQinY4=HAYkV%_l@su2W682aO<H%{j6_uWZB6v|1b^bH!e^g|
zdG0$B9aL9^Rt=R#ZoCtrxkvBKVwDi4d3{Xwks{OM3&t<E@*XaFq)_Dwy!Q$2!;Q+>
zl1n5PEL>%O){tmBbE-^&lYT#9O(V+u?lv{y&Ixmsl9_QF(nd%{rq-nRVTpdJDSO9w
zcz|VD*Uz%p#E-iXn>3QV7sryM2d42g`tDM;3UDTI(<R;@R?2>+Iz*WiaMQ~f$31#*
zkWPO;xyvDW3Lc~(_Ps0r0zKTfsW0X-f54me%tYrpMNtLzId?-bJJnA<e{rxm!{|Ru
zRHTo<Ha(G9vhHs#<(`<>s5FI9=49uHrKYY;Q5^+(J+zlO`ZDd<|5_Bz*eg?r%P_{#
zz5DtF<!~tOl&c<N5&20(gT6gy{<}{OwsN<9)!+IU3#AgATEGqSLCRrqPHGJX61<G2
zI}AHVuY~yOwpm0N3M`<`n=?tUo0*SqeH~_<*~?$%x+Uf*=HtO)m~&vzCh{c3iw@lP
z6=BKax7FEE6*3^<AcBnZ4)A7NsB-O=is>s~ozVL37s{+Y)ydS5IoH8vvXFlot)QU%
zwg)6Z{nmF-4mes=)rlr5x7rz2r1dzLgEN0U&tTTc`Wy6qn;cWv&ndFNxoyim4W+k?
zr1ywZ->|bzlbaYd{52Lxr4!aP<OUg_-J(~Icp1KphJNd{do`VD<@{yUSoZtd<*lEE
zH|3}mdA)RxPkLetV!Iq6p^FmY%r2&QE6eGFipO^gsoE{miIR3+CZuazL&{dOIXv9%
zQ(6mvKP`UsNHgWmOl|d3i}m9VQXi(jg?#0j`+3sHaD|-HUg~XR9rOA^yc&nn0{R4h
zok#aIN6!@t4%#cKvbIu&;d>Ng1ceof&l66_*73#+3fnp6qW4a#g&4xAjmXG8xQ1>w
z%XrL+UivFnGPuvRSo$bL<}jbrXPu(Whe*<t$XGl$S1dRe5?saDsm|Ov!qU0iO`2#t
z6?1F5bIXKqb%ee18cXK_G}u@qcq{qv^um(l9N|B$X8)E5K!Ty@|E?<j)=1;iv$!km
z>S|$s_ns%mO(j)X4pmc64hRU0<o}QHFX1uFZe>1T|38QNO%8oPxJnod0d#vcfivRW
zyf^^C(qA%+9&Ue>`mKe=r()sh;OJ)Y$B!^8&c7;@6~QzGLV(~PFa!mK8G=B(z`y^R
z{@d`^s=JLFppONH{97&!P;E4KHv{y2!M}ykWLzvv0l_i=_*>iR+AjbQoRh^!4P!P_
z1FP)B*Hj(N{{;Tnm+j$VVF|2OgP~Aj(0@KS5O6pk=4Q$93j;&oPz2xs=7YoGZw$DE
zVwSW2!~hvsFh<JwPYiR7S!~C`Aea*>urL@#DDo@@g#Zi8XD~1bg+!ch7X}9w<<FJ{
zoH^$U6auJ)VcEf8n9!Xq3x%KnLd01N2E%A=VqtJ7wtqkbFv5C&+5vHaVPnA1!_LPF
zhQRJG#tu*)J5wKk0WzZ47#xhzeEYLq5Rm<V_QM$r@CAWU*Z<QFz@V5zkN(7fHjo(Q
z$Fmp|jgk1n#xN&DoW+1VIA;e(U<eObc94I-5a-4X3`fGS`itoYphs}FJ_G^+NW`7R
zz;G1y7=Zvgj6T5`Ul0iBxg0`);Fy_r#tsGfC7gH$L!yCCY`cHRdjtY~E-pwE5~EOm
zraqvJb8$vNpcwU!vv$A~#EJ_DAg@5NeL<o@2<-7dq9N#W^?}akJrIL)c@Ox4Ia~6q
zFAxMqCh{x>g<|I);2#`wddL|&fLwEK4g#?{R~Cr|ZcA8Yfye_yowM~JQ9uN-F*N90
zZlE9tK(pm+Sri1=9CjYV5P{D4jDmvB-NR5I5O$t|P#_2bJ13E7pfFZ_K;JOBmw&ba
z<TxCORTj|HMq<t&K5GX-VJI_yVjwj7*HZ%vLt-Ra&tNDR<eV=k*!g@$0|SEP9|(;E
z8pf&*jR2vrd<Fq!vF|UyIg#ha7hovCG32T<{-Kdj(785{sB^iCM#0aGIS_;MeFLTu
zc5a|xU_krkY`Z`foQoA24#Un#pdV1|e8Kb$U|5~44=8&sPk~rr=LRsoV9e<Of5rea
z=Gb!|6DtH(tT1KIJu84))4BNz#0q$lpJ@Zg7bNz51JgI`yaJA!f+4Wx4A3s>yw6Y=
z>|8&fz>WNDyO<n5pZ72*_B;pL1#S}9Wnoav3(nbC!GMP-HU>vvzgqyBw&?Ty0EYK`
z8|d@>fP?;_AAqR-xpvRZb3lV1g#F9|FkpbO%c79j&n+OCF=9Vh{Y4|Op8;SXgU<N^
z284yN+W;fc*!M)>)dGy2rvL`Q&KC>@NdBDl1;DVMWq=(N@<+RFE~bDMtIMyGE^gX*
zVO~)I)hsPXM>l}b2h2eXB~;15(vbt0qra|Y0nKJHB*@eh3OuhsW{|rm)Ln$Rg#`kN
qLYkUEQNY_4$U=hne>eGCkIB^yczOTz&I@=3+~$b6x#iU5iT?-o)P$G-

literal 0
HcmV?d00001

diff --git a/test/Todo.md b/test/Todo.md
index 99e246435..9e06a9e45 100644
--- a/test/Todo.md
+++ b/test/Todo.md
@@ -1,5 +1,5 @@
 This is a rough list of "tests to write". Everything here should either be
-specified in [Semantics.md](https://github.com/WebAssembly/design/blob/master/Semantics.md),
+specified in [Semantics.md](https://github.com/WebAssembly/design/blob/main/Semantics.md),
 have a link to an open issue/PR, or be obvious. Comments/corrections/additions
 welcome.
 
diff --git a/test/core/README.md b/test/core/README.md
index 319151461..6b923e4fb 100644
--- a/test/core/README.md
+++ b/test/core/README.md
@@ -1,6 +1,6 @@
-This directory contains tests for the core WebAssembly semantics, as described in [Semantics.md](https://github.com/WebAssembly/design/blob/master/Semantics.md) and specified by the [spec interpreter](https://github.com/WebAssembly/spec/blob/master/interpreter).
+This directory contains tests for the core WebAssembly semantics, as described in [Semantics.md](https://github.com/WebAssembly/design/blob/main/Semantics.md) and specified by the [spec interpreter](https://github.com/WebAssembly/spec/blob/main/interpreter).
 
-Tests are written in the [S-Expression script format](https://github.com/WebAssembly/spec/blob/master/interpreter/README.md#s-expression-syntax) defined by the interpreter.
+Tests are written in the [S-Expression script format](https://github.com/WebAssembly/spec/blob/main/interpreter/README.md#s-expression-syntax) defined by the interpreter.
 
 The test suite can be run with the spec interpreter as follows:
 ```
diff --git a/test/core/binary.wast b/test/core/binary.wast
index 8bd6c0073..6e29401cc 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -368,6 +368,62 @@
   "integer too large"
 )
 
+;; Function with missing end marker (between two functions)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section: 1 type
+    "\03\03\02\00\00"          ;; Function section: 2 functions
+    "\0a\0c\02"                ;; Code section: 2 functions
+    ;; function 0
+    "\04\00"                   ;; Function size and local type count
+    "\41\01"                   ;; i32.const 1
+    "\1a"                      ;; drop
+    ;; Missing end marker here
+    ;; function 1
+    "\05\00"                   ;; Function size and local type count
+    "\41\01"                   ;; i32.const 1
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "END opcode expected"
+)
+
+;; Function with missing end marker (at EOF)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section: 1 type
+    "\03\02\01\00"             ;; Function section: 1 function
+    "\0a\06\01"                ;; Code section: 1 function
+    ;; function 0
+    "\04\00"                   ;; Function size and local type count
+    "\41\01"                   ;; i32.const 1
+    "\1a"                      ;; drop
+    ;; Missing end marker here
+  )
+  "unexpected end of section or function"
+)
+
+;; Function with missing end marker (at end of code sections)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section: 1 type
+    "\03\02\01\00"             ;; Function section: 1 function
+    "\0a\06\01"                ;; Code section: 1 function
+    ;; function 0
+    "\04\00"                   ;; Function size and local type count
+    "\41\01"                   ;; i32.const 1
+    "\1a"                      ;; drop
+    ;; Missing end marker here
+    "\0b\03\01\01\00"          ;; Data section
+  )
+  ;; The spec interpreter consumes the `\0b` (data section start) as an
+  ;; END instruction (also happens to be `\0b`) and reports the code section as
+  ;; being larger than declared.
+  "section size mismatch"
+)
 
 ;; Unsigned LEB128 must not be overlong
 (assert_malformed
@@ -1406,7 +1462,7 @@
 (assert_malformed
   (module binary
       "\00asm" "\01\00\00\00"
-      "\05\03\01"                           ;; table section with one entry
+      "\04\03\01"                           ;; table section with one entry
       "\70"                                 ;; anyfunc
       "\02"                                 ;; malformed table limits flag
   )
@@ -1415,7 +1471,7 @@
 (assert_malformed
   (module binary
       "\00asm" "\01\00\00\00"
-      "\05\04\01"                           ;; table section with one entry
+      "\04\04\01"                           ;; table section with one entry
       "\70"                                 ;; anyfunc
       "\02"                                 ;; malformed table limits flag
       "\00"                                 ;; dummy byte
@@ -1425,12 +1481,12 @@
 (assert_malformed
   (module binary
       "\00asm" "\01\00\00\00"
-      "\05\06\01"                           ;; table section with one entry
+      "\04\06\01"                           ;; table section with one entry
       "\70"                                 ;; anyfunc
       "\81\00"                              ;; malformed table limits flag as LEB128
       "\00\00"                              ;; dummy bytes
   )
-  "integer too large"
+  "integer representation too long"
 )
 
 ;; Memory count can be zero
@@ -1760,6 +1816,6 @@
     "\02\00"
     "\0b"                      ;; end
   )
-  "junk after last section"
+  "unexpected content after last section"
 )
 
diff --git a/test/core/comments.wast b/test/core/comments.wast
index 90a64b42d9ec854f6522e940c0466eb6c1ca6de9..c291370fa72141c02e627c6edf0442bd409129cf 100644
GIT binary patch
delta 83
zcmdnX+QPQMgVDv>S|P7ACr3A_vLsa@Ek7qGzdSWXAu~5OH6=5#BsHf}A*oU!H7`Xs
lKTS6|A1ItxqL7lBlbM@Yl3K*2Va;Hz$+g*yv7C{S3joUf8<zk8

delta 12
TcmZo++snGagK={oV<{s5954g^

diff --git a/test/core/f32.wast b/test/core/f32.wast
index 36d81a05b..0f8ae0aa4 100644
--- a/test/core/f32.wast
+++ b/test/core/f32.wast
@@ -2531,3 +2531,13 @@
 (assert_invalid (module (func (result f32) (f32.nearest (i64.const 0)))) "type mismatch")
 (assert_invalid (module (func (result f32) (f32.sqrt (i64.const 0)))) "type mismatch")
 (assert_invalid (module (func (result f32) (f32.trunc (i64.const 0)))) "type mismatch")
+
+;; These float literal patterns are only allowed in scripts, not in text format.
+(assert_malformed
+  (module quote "(func (result f32) (f32.const nan:arithmetic))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (result f32) (f32.const nan:canonical))")
+  "unexpected token"
+)
diff --git a/test/core/f64.wast b/test/core/f64.wast
index 70bb477c7..afd2b2f73 100644
--- a/test/core/f64.wast
+++ b/test/core/f64.wast
@@ -2531,3 +2531,13 @@
 (assert_invalid (module (func (result f64) (f64.nearest (i64.const 0)))) "type mismatch")
 (assert_invalid (module (func (result f64) (f64.sqrt (i64.const 0)))) "type mismatch")
 (assert_invalid (module (func (result f64) (f64.trunc (i64.const 0)))) "type mismatch")
+
+;; These float literal patterns are only allowed in scripts, not in text format.
+(assert_malformed
+  (module quote "(func (result f64) (f64.const nan:arithmetic))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (result f64) (f64.const nan:canonical))")
+  "unexpected token"
+)
diff --git a/test/core/i32.wast b/test/core/i32.wast
index 32862c347..2e8ab7005 100644
--- a/test/core/i32.wast
+++ b/test/core/i32.wast
@@ -974,3 +974,12 @@
 (assert_invalid (module (func (result i32) (i32.lt_s (i64.const 0) (f32.const 0)))) "type mismatch")
 (assert_invalid (module (func (result i32) (i32.lt_u (i64.const 0) (f32.const 0)))) "type mismatch")
 (assert_invalid (module (func (result i32) (i32.ne (i64.const 0) (f32.const 0)))) "type mismatch")
+
+(assert_malformed
+  (module quote "(func (result i32) (i32.const nan:arithmetic))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (result i32) (i32.const nan:canonical))")
+  "unexpected token"
+)
diff --git a/test/core/i64.wast b/test/core/i64.wast
index baeed0ce1..b662f3d92 100644
--- a/test/core/i64.wast
+++ b/test/core/i64.wast
@@ -483,3 +483,12 @@
 (assert_invalid (module (func (result i64) (i64.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
 (assert_invalid (module (func (result i64) (i64.lt_u (i32.const 0) (f32.const 0)))) "type mismatch")
 (assert_invalid (module (func (result i64) (i64.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+
+(assert_malformed
+  (module quote "(func (result i64) (i64.const nan:arithmetic))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (result i64) (i64.const nan:canonical))")
+  "unexpected token"
+)
diff --git a/test/core/memory_trap.wast b/test/core/memory_trap.wast
index a4156fe2c..5ce8f5c31 100644
--- a/test/core/memory_trap.wast
+++ b/test/core/memory_trap.wast
@@ -20,7 +20,7 @@
 
 (assert_return (invoke "store" (i32.const -4) (i32.const 42)))
 (assert_return (invoke "load" (i32.const -4)) (i32.const 42))
-(assert_trap (invoke "store" (i32.const -3) (i32.const 13)) "out of bounds memory access")
+(assert_trap (invoke "store" (i32.const -3) (i32.const 0x12345678)) "out of bounds memory access")
 (assert_trap (invoke "load" (i32.const -3)) "out of bounds memory access")
 (assert_trap (invoke "store" (i32.const -2) (i32.const 13)) "out of bounds memory access")
 (assert_trap (invoke "load" (i32.const -2)) "out of bounds memory access")
@@ -268,3 +268,15 @@
 ;; No memory was changed
 (assert_return (invoke "i64.load" (i32.const 0xfff8)) (i64.const 0x6867666564636261))
 (assert_return (invoke "i64.load" (i32.const 0)) (i64.const 0x6867666564636261))
+
+;; Check that out of bounds store do not store partial data.
+;; Zero last 8 bytes.
+(assert_return (invoke "i64.store" (i32.const 0xfff8) (i64.const 0)))
+(assert_trap (invoke "i32.store" (i32.const 0xfffd) (i32.const 0x12345678)) "out of bounds memory access")
+(assert_return (invoke "i32.load" (i32.const 0xfffc)) (i32.const 0))
+(assert_trap (invoke "i64.store" (i32.const 0xfff9) (i64.const 0x1234567890abcdef)) "out of bounds memory access")
+(assert_return (invoke "i64.load" (i32.const 0xfff8)) (i64.const 0))
+(assert_trap (invoke "f32.store" (i32.const 0xfffd) (f32.const 0x12345678)) "out of bounds memory access")
+(assert_return (invoke "f32.load" (i32.const 0xfffc)) (f32.const 0))
+(assert_trap (invoke "f64.store" (i32.const 0xfff9) (f64.const 0x1234567890abcdef)) "out of bounds memory access")
+(assert_return (invoke "f64.load" (i32.const 0xfff8)) (f64.const 0))
diff --git a/test/core/run.py b/test/core/run.py
index ec07929c4..924b42c69 100755
--- a/test/core/run.py
+++ b/test/core/run.py
@@ -22,10 +22,14 @@
 arguments = parser.parse_args()
 sys.argv = sys.argv[:1]
 
+main_test_files = glob.glob(os.path.join(inputDir, "*.wast"))
+# SIMD test files are in a subdirectory.
+simd_test_files = glob.glob(os.path.join(inputDir, "simd", "*.wast"))
+
 wasmCommand = arguments.wasm
 jsCommand = arguments.js
 outputDir = arguments.out
-inputFiles = arguments.file if arguments.file else glob.glob(os.path.join(inputDir, "*.wast"))
+inputFiles = arguments.file if arguments.file else main_test_files + simd_test_files
 
 if not os.path.exists(wasmCommand):
   sys.stderr.write("""\
@@ -92,7 +96,6 @@ def _runTestFile(self, inputPath):
     self._runCommand(('%s -d "%s" -o "%s"') % (wasmCommand, wasm2Path, wast2Path), logPath)
     self._compareFile(wastPath, wast2Path)
 
-    # Convert to JavaScript
     jsPath = self._auxFile(outputPath.replace(".wast", ".js"))
     logPath = self._auxFile(jsPath + ".log")
     self._runCommand(('%s -d "%s" -o "%s"') % (wasmCommand, inputPath, jsPath), logPath)
diff --git a/test/core/select.wast b/test/core/select.wast
index fbe51be10..94aa86054 100644
--- a/test/core/select.wast
+++ b/test/core/select.wast
@@ -400,6 +400,9 @@
   ))
   "type mismatch"
 )
+(module (func $type-unreachable-ref-implicit
+  (drop (ref.is_null (select (unreachable) (i32.const 1))))
+))
 
 (assert_invalid
   (module (func $type-num-vs-num
diff --git a/test/core/simd/meta/README.md b/test/core/simd/meta/README.md
new file mode 100644
index 000000000..835e1bba9
--- /dev/null
+++ b/test/core/simd/meta/README.md
@@ -0,0 +1,55 @@
+# Generated SIMD Spec Tests from gen_tests.py
+
+`gen_tests.py` builds partial SIMD spec tests using templates in `simd_*.py`.
+Currently it only support following simd test files generation.
+
+- 'simd_i8x16_cmp.wast'
+- 'simd_i16x8_cmp.wast'
+- 'simd_i32x4_cmp.wast'
+- 'simd_f32x4_cmp.wast'
+- 'simd_f64x2_cmp.wast'
+- 'simd_i8x16_arith.wast'
+- 'simd_i8x16_arith2.wast'
+- 'simd_i16x8_arith.wast'
+- 'simd_i16x8_arith2.wast'
+- 'simd_i32x4_arith.wast'
+- 'simd_i32x4_arith2.wast'
+- 'simd_f32x4_arith.wast'
+- 'simd_i64x2_arith.wast'
+- 'simd_f64x2_arith.wast'
+- 'simd_bitwise.wast'
+- 'simd_i8x16_sat_arith.wast'
+- 'simd_i16x8_sat_arith.wast'
+- 'simd_f32x4.wast'
+- 'simd_f64x2.wast'
+- 'simd_f32x4_rounding.wast'
+- 'simd_f64x2_rounding.wast'
+- 'simd_f32x4_pmin_pmax.wast'
+- 'simd_f64x2_pmin_pmax.wast'
+- 'simd_i32x4_dot_i16x8.wast'
+- 'simd_load8_lane.wast'
+- 'simd_load16_lane.wast'
+- 'simd_load32_lane.wast'
+- 'simd_load64_lane.wast,
+- 'simd_store8_lane.wast'
+- 'simd_store16_lane.wast'
+- 'simd_store32_lane.wast'
+- 'simd_store64_lane.wast,
+- 'simd_i16x8_extmul_i8x16.wast'
+- 'simd_i32x4_extmul_i16x8.wast'
+- 'simd_i64x2_extmul_i32x4.wast'
+- 'simd_int_to_int_widen.wast'
+- 'simd_i32x4_trunc_sat_f32x4.wast'
+- 'simd_i32x4_trunc_sat_f64x2.wast'
+- 'simd_i16x8_q15mulr_sat_s.wast',
+- 'simd_i16x8_extadd_pairwise_i8x16.wast',
+- 'simd_i32x4_extadd_pairwise_i16x8.wast',
+
+
+Usage:
+
+```
+$ python gen_tests.py -a
+```
+
+This script requires Python 3.6+, more details are documented in `gen_tests.py`.
diff --git a/test/core/simd/meta/gen_tests.py b/test/core/simd/meta/gen_tests.py
new file mode 100644
index 000000000..5be84835c
--- /dev/null
+++ b/test/core/simd/meta/gen_tests.py
@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+
+"""
+This script is used for generating WebAssembly SIMD test cases.
+It requires Python 3.6+.
+"""
+import sys
+import argparse
+import importlib
+
+
+SUBMODULES = (
+    'simd_i8x16_cmp',
+    'simd_i16x8_cmp',
+    'simd_i32x4_cmp',
+    'simd_i64x2_cmp',
+    'simd_f32x4_cmp',
+    'simd_f64x2_cmp',
+    'simd_i8x16_arith',
+    'simd_i16x8_arith',
+    'simd_i32x4_arith',
+    'simd_f32x4_arith',
+    'simd_i64x2_arith',
+    'simd_f64x2_arith',
+    'simd_sat_arith',
+    'simd_bitwise',
+    'simd_f32x4',
+    'simd_f64x2',
+    'simd_int_arith2',
+    'simd_f32x4_rounding',
+    'simd_f64x2_rounding',
+    'simd_f32x4_pmin_pmax',
+    'simd_f64x2_pmin_pmax',
+    'simd_i32x4_dot_i16x8',
+    'simd_load_lane',
+    'simd_store_lane',
+    'simd_ext_mul',
+    'simd_int_to_int_extend',
+    'simd_int_trunc_sat_float',
+    'simd_i16x8_q15mulr_sat_s',
+    'simd_extadd_pairwise',
+)
+
+
+def gen_group_tests(mod_name):
+    """mod_name is the back-end script name without the.py extension.
+    There must be a gen_test_cases() function in each module."""
+    mod = importlib.import_module(mod_name)
+    mod.gen_test_cases()
+
+
+def main():
+    """
+    Default program entry
+    """
+
+    parser = argparse.ArgumentParser(
+        description='Front-end script to call other modules to generate SIMD tests')
+    parser.add_argument('-a', '--all', dest='gen_all', action='store_true',
+                        default=False, help='Generate all the tests')
+    parser.add_argument('-i', '--inst', dest='inst_group', choices=SUBMODULES,
+                        help='Back-end scripts that generate the SIMD tests')
+    args = parser.parse_args()
+
+    if len(sys.argv) < 2:
+        parser.print_help()
+
+    if args.inst_group:
+        gen_group_tests(args.inst_group)
+    if args.gen_all:
+        for mod_name in SUBMODULES:
+            gen_group_tests(mod_name)
+
+
+if __name__ == '__main__':
+    main()
+    print('Done.')
diff --git a/test/core/simd/meta/simd.py b/test/core/simd/meta/simd.py
new file mode 100644
index 000000000..5ff38bbe8
--- /dev/null
+++ b/test/core/simd/meta/simd.py
@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+
+"""
+This python file is a tool class for SIMD and
+currently only supports generating v128 const constant data.
+"""
+
+
+class SIMD:
+
+    # Constant template
+    CONST = '({value_type}.const {value})'
+
+    # v128 Constant template
+    V128_CONST = '(v128.const {lane_type} {value})'
+
+    @staticmethod
+    def const(value, value_type):
+        """
+        generation constant data, [e.g. i32, i64, f32, f64]
+        Params:
+            value: constant data, string or list,
+            lane_type: lane type, [i32, i64, f32, f64]
+        """
+        return SIMD.CONST.format(value_type=value_type, value=''.join(str(value)))
+
+    @staticmethod
+    def v128_const(value, lane_type):
+        """
+        generation v128 constant data, [e.g. i8x16, i16x8, i32x4, f32x4]
+        Params:
+            value: constant data, string or list,
+            lane_type: lane type, [e.g. i8x16, i16x8, i32x4, f32x4]
+        """
+        if lane_type.lower().find('x') == -1:
+            return SIMD.const(value, lane_type)
+
+        lane_cnt = int(lane_type[1:].split('x')[1])
+
+        # value is a string type, generating constant data
+        # of value according to the number of lanes
+        if isinstance(value, str):
+            data_elem = [value] * lane_cnt
+
+        # If value is type of list, generate constant data
+        # according to combination of list contents and number of lanes
+        elif isinstance(value, list):
+
+            # If it is an empty list, generate all constant data with 0x00
+            if len(value) == 0:
+                return SIMD.v128_const('0x00', lane_type)
+
+            data_elem = []
+
+            # Calculate the number of times each element in value is copied
+            times = lane_cnt // len(value)
+
+            # Calculate whether the data needs to be filled according to
+            # the number of elements in the value list and the number of lanes.
+            complement = lane_cnt % len(value)
+            complement_item = ''
+
+            # If the number of elements in the value list is greater than the number of lanes,
+            # paste data with the number of lanes from the value list.
+            if times == 0:
+                times = 1
+                complement = 0
+
+                value = value[0:lane_cnt]
+
+            # Copy data
+            for item in value:
+                data_elem.extend([item] * times)
+                complement_item = item
+
+            # Fill in the data
+            if complement > 0:
+                data_elem.extend([complement_item] * complement)
+
+        # Get string
+        data_elem = ' '.join(data_elem)
+
+        # Returns v128 constant text
+        return SIMD.V128_CONST.format(lane_type=lane_type, value=data_elem)
diff --git a/test/core/simd/meta/simd_arithmetic.py b/test/core/simd/meta/simd_arithmetic.py
new file mode 100644
index 000000000..dcdc8f973
--- /dev/null
+++ b/test/core/simd/meta/simd_arithmetic.py
@@ -0,0 +1,328 @@
+#!/usr/bin/env python3
+
+"""Base class for generating cases integer and floating-point numbers
+arithmetic and saturate arithmetic operations.
+
+Class SimdArithmeticCase is the base class of all kinds of arithmetic
+operation cases. It provides a skeleton to generate the normal, invalid and
+combined cases. Subclasses only provide the test data sets. In some special
+cases, you may need to override the methods in base class to fulfill your
+case generation.
+"""
+
+from simd import SIMD
+from test_assert import AssertReturn, AssertInvalid
+from simd_lane_value import LaneValue
+from simd_integer_op import ArithmeticOp
+
+
+i8 = LaneValue(8)
+i16 = LaneValue(16)
+i32 = LaneValue(32)
+i64 = LaneValue(64)
+
+
+class SimdArithmeticCase:
+
+    UNARY_OPS = ('neg',)
+    BINARY_OPS = ('add', 'sub', 'mul')
+    LANE_VALUE = {'i8x16': i8, 'i16x8': i16, 'i32x4': i32, 'i64x2': i64}
+
+    TEST_FUNC_TEMPLATE_HEADER = (
+            ';; Tests for {} arithmetic operations on major boundary values and all special values.\n\n')
+
+    def op_name(self, op):
+        """ Full instruction name.
+        Subclasses can overwrite to provide custom instruction names that don't
+        fit the default of {shape}.{op}.
+        """
+        return '{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op)
+
+    def __str__(self):
+        return self.get_all_cases()
+
+    @property
+    def lane(self):
+        return self.LANE_VALUE.get(self.LANE_TYPE)
+
+    @property
+    def dst_lane(self):
+        return self.lane
+
+    @property
+    def src_lane(self):
+        # Used for arithmetic that extends the lane, e.g. i16x8 lanes, which
+        # are extended multiply to i32x4.
+        if hasattr(self, 'SRC_LANE_TYPE'):
+            return self.LANE_VALUE.get(self.SRC_LANE_TYPE)
+        else:
+            return self.lane
+
+    @property
+    def normal_unary_op_test_data(self):
+        lane = self.src_lane
+        return [0, 1, -1, lane.max - 1, lane.min + 1, lane.min, lane.max, lane.mask]
+
+    @property
+    def normal_binary_op_test_data(self):
+        lane = self.src_lane
+        return [
+            (0, 0),
+            (0, 1),
+            (1, 1),
+            (0, -1),
+            (1, -1),
+            (-1, -1),
+            (lane.quarter - 1, lane.quarter),
+            (lane.quarter, lane.quarter),
+            (-lane.quarter + 1, -lane.quarter),
+            (-lane.quarter, -lane.quarter),
+            (-lane.quarter - 1, -lane.quarter),
+            (lane.max - 2, 1),
+            (lane.max - 1, 1),
+            (-lane.min, 1),
+            (lane.min + 2, -1),
+            (lane.min + 1, -1),
+            (lane.min, -1),
+            (lane.max, lane.max),
+            (lane.min, lane.min),
+            (lane.min, lane.min + 1),
+            (lane.mask, 0),
+            (lane.mask, 1),
+            (lane.mask, -1),
+            (lane.mask, lane.max),
+            (lane.mask, lane.min),
+            (lane.mask, lane.mask)
+        ]
+
+    @property
+    def bin_test_data(self):
+        return [
+            (self.normal_binary_op_test_data, [self.LANE_TYPE] * 3),
+            (self.hex_binary_op_test_data, [self.LANE_TYPE] * 3)
+        ]
+
+    @property
+    def unary_test_data(self):
+        return [
+            (self.normal_unary_op_test_data, [self.LANE_TYPE] * 2),
+            (self.hex_unary_op_test_data, [self.LANE_TYPE] * 2)
+        ]
+
+    @property
+    def combine_ternary_arith_test_data(self):
+        return {
+            'add-sub': [
+                [str(i) for i in range(self.LANE_LEN)],
+                [str(i * 2) for i in range(self.LANE_LEN)],
+                [str(i * 2) for i in range(self.LANE_LEN)],
+                [str(i) for i in range(self.LANE_LEN)]
+            ],
+            'sub-add': [
+                [str(i) for i in range(self.LANE_LEN)],
+                [str(i * 2) for i in range(self.LANE_LEN)],
+                [str(i * 2) for i in range(self.LANE_LEN)],
+                [str(i) for i in range(self.LANE_LEN)]
+            ],
+            'mul-add': [
+                [str(i) for i in range(self.LANE_LEN)],
+                [str(i) for i in range(self.LANE_LEN)],
+                ['2'] * self.LANE_LEN,
+                [str(i * 4) for i in range(self.LANE_LEN)]
+            ],
+            'mul-sub': [
+                [str(i * 2) for i in range(self.LANE_LEN)],
+                [str(i) for i in range(self.LANE_LEN)],
+                [str(i) for i in range(self.LANE_LEN)],
+                [str(pow(i, 2)) for i in range(self.LANE_LEN)]
+            ]
+        }
+
+    @property
+    def combine_binary_arith_test_data(self):
+        return {
+            'add-neg': [
+                [str(i) for i in range(self.LANE_LEN)],
+                [str(i) for i in range(self.LANE_LEN)],
+                ['0'] * self.LANE_LEN
+            ],
+            'sub-neg': [
+                [str(i) for i in range(self.LANE_LEN)],
+                [str(i) for i in range(self.LANE_LEN)],
+                [str(-i * 2) for i in range(self.LANE_LEN)]
+            ],
+            'mul-neg': [
+                [str(i) for i in range(self.LANE_LEN)],
+                ['2'] * self.LANE_LEN,
+                [str(-i * 2) for i in range(self.LANE_LEN)]
+            ]
+        }
+
+    def gen_test_func_template(self):
+        template = [
+                self.TEST_FUNC_TEMPLATE_HEADER.format(self.LANE_TYPE), '(module']
+
+        for op in self.BINARY_OPS:
+            template.append('  (func (export "{op}") (param v128 v128) (result v128) '
+                            '({op} (local.get 0) (local.get 1)))'.format(op=self.op_name(op)))
+        for op in self.UNARY_OPS:
+            template.append('  (func (export "{op}") (param v128) (result v128) '
+                            '({op} (local.get 0)))'.format(op=self.op_name(op)))
+
+        template.append(')\n')
+        return template
+
+    def gen_test_template(self):
+        template = self.gen_test_func_template()
+
+        template.append('{normal_cases}')
+        template.append('\n{invalid_cases}')
+        template.append('\n{combine_cases}')
+
+        return '\n'.join(template)
+
+    def get_case_data(self):
+        case_data = []
+
+        # i8x16.op (i8x16) (i8x16)
+        for op in self.BINARY_OPS:
+            o = ArithmeticOp(op)
+            op_name = self.LANE_TYPE + '.' + op
+            case_data.append(['#', op_name])
+            for data_group, v128_forms in self.bin_test_data:
+                for data in data_group:
+                    case_data.append([op_name, [str(data[0]), str(data[1])],
+                                      str(o.binary_op(data[0], data[1], self.src_lane, self.dst_lane)),
+                                     v128_forms])
+            for data_group in self.full_bin_test_data:
+                for data in data_group.get(op_name):
+                    case_data.append([op_name, *data])
+
+        for op in self.UNARY_OPS:
+            o = ArithmeticOp(op)
+            op_name = self.LANE_TYPE + '.' + op
+            case_data.append(['#', op_name])
+            for data_group, v128_forms in self.unary_test_data:
+                for data in data_group:
+                    case_data.append([op_name, [str(data)],
+                                      str(o.unary_op(data, self.dst_lane)),
+                                      v128_forms])
+
+        return case_data
+
+    def get_invalid_cases(self):
+        invalid_cases = [';; type check']
+
+        unary_template = '(assert_invalid (module (func (result v128) '\
+                         '({name} ({operand})))) "type mismatch")'
+        binary_template = '(assert_invalid (module (func (result v128) '\
+                          '({name} ({operand_1}) ({operand_2})))) "type mismatch")'
+
+
+        for op in self.UNARY_OPS:
+            invalid_cases.append(unary_template.format(name=self.op_name(op),
+                                                       operand='i32.const 0'))
+        for op in self.BINARY_OPS:
+            invalid_cases.append(binary_template.format(name=self.op_name(op),
+                                                        operand_1='i32.const 0',
+                                                        operand_2='f32.const 0.0'))
+
+        return '\n'.join(invalid_cases) + self.argument_empty_test()
+
+    def argument_empty_test(self):
+        """Test cases with empty argument.
+        """
+        cases = []
+
+        cases.append('\n\n;; Test operation with empty argument\n')
+
+        case_data = {
+            'op': '',
+            'extended_name': 'arg-empty',
+            'param_type': '',
+            'result_type': '(result v128)',
+            'params': '',
+        }
+
+        for op in self.UNARY_OPS:
+            case_data['op'] = self.op_name(op)
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        for op in self.BINARY_OPS:
+            case_data['op'] = self.op_name(op)
+            case_data['extended_name'] = '1st-arg-empty'
+            case_data['params'] = SIMD.v128_const('0', self.LANE_TYPE)
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        return '\n'.join(cases)
+
+    def get_combine_cases(self):
+        combine_cases = [';; combination\n(module']
+        ternary_func_template = '  (func (export "{func}") (param v128 v128 v128) (result v128)\n' \
+                              '    ({lane}.{op1} ({lane}.{op2} (local.get 0) (local.get 1))'\
+                              '(local.get 2)))'
+        for func in sorted(self.combine_ternary_arith_test_data):
+            func_parts = func.split('-')
+            combine_cases.append(ternary_func_template.format(func=func,
+                                                            lane=self.LANE_TYPE,
+                                                            op1=func_parts[0],
+                                                            op2=func_parts[1]))
+        binary_func_template = '  (func (export "{func}") (param v128 v128) (result v128)\n'\
+                             '    ({lane}.{op1} ({lane}.{op2} (local.get 0)) (local.get 1)))'
+        for func in sorted(self.combine_binary_arith_test_data):
+            func_parts = func.split('-')
+            combine_cases.append(binary_func_template.format(func=func,
+                                                           lane=self.LANE_TYPE,
+                                                           op1=func_parts[0],
+                                                           op2=func_parts[1]))
+        combine_cases.append(')\n')
+
+        for func, test in sorted(self.combine_ternary_arith_test_data.items()):
+            combine_cases.append(str(AssertReturn(func,
+                                 [SIMD.v128_const(elem, self.LANE_TYPE) for elem in test[:-1]],
+                                 SIMD.v128_const(test[-1], self.LANE_TYPE))))
+        for func, test in sorted(self.combine_binary_arith_test_data.items()):
+            combine_cases.append(str(AssertReturn(func,
+                                 [SIMD.v128_const(elem, self.LANE_TYPE) for elem in test[:-1]],
+                                 SIMD.v128_const(test[-1], self.LANE_TYPE))))
+
+        return '\n'.join(combine_cases)
+
+    def get_normal_case(self):
+        s = SIMD()
+        case_data = self.get_case_data()
+        cases = []
+
+        for item in case_data:
+            # Recognize '#' as a commentary
+            if item[0] == '#':
+                cases.append('\n;; {}'.format(item[1]))
+                continue
+
+            instruction, param, ret, lane_type = item
+            v128_result = s.v128_const(ret, lane_type[-1])
+            v128_params = []
+            for i, p in enumerate(param):
+                v128_params.append(s.v128_const(p, lane_type[i]))
+            cases.append(str(AssertReturn(instruction, v128_params, v128_result)))
+
+        return '\n'.join(cases)
+
+    def get_all_cases(self):
+        case_data = {'lane_type': self.LANE_TYPE,
+                     'normal_cases': self.get_normal_case(),
+                     'invalid_cases': self.get_invalid_cases(),
+                     'combine_cases': self.get_combine_cases()
+                     }
+        return self.gen_test_template().format(**case_data)
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_{lane_type}_arith.wast'.format(lane_type=self.LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            fp.write(self.get_all_cases())
diff --git a/test/core/simd/meta/simd_bitwise.py b/test/core/simd/meta/simd_bitwise.py
new file mode 100644
index 000000000..adba5ab6a
--- /dev/null
+++ b/test/core/simd/meta/simd_bitwise.py
@@ -0,0 +1,502 @@
+#!/usr/bin/env python3
+
+"""
+This file is used for generating bitwise test cases
+"""
+
+from simd import SIMD
+from test_assert import AssertReturn, AssertInvalid
+
+
+class SimdBitWise(SIMD):
+    """
+    Generate common tests
+    """
+
+    UNARY_OPS = ('not',)
+    BINARY_OPS = ('and', 'or', 'xor', 'andnot',)
+    TERNARY_OPS = ('bitselect',)
+
+    # Test case template
+    CASE_TXT = """;; Test all the bitwise operators on major boundary values and all special values.
+
+(module
+  (func (export "not") (param $0 v128) (result v128) (v128.not (local.get $0)))
+  (func (export "and") (param $0 v128) (param $1 v128) (result v128) (v128.and (local.get $0) (local.get $1)))
+  (func (export "or") (param $0 v128) (param $1 v128) (result v128) (v128.or (local.get $0) (local.get $1)))
+  (func (export "xor") (param $0 v128) (param $1 v128) (result v128) (v128.xor (local.get $0) (local.get $1)))
+  (func (export "bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+    (v128.bitselect (local.get $0) (local.get $1) (local.get $2))
+  )
+  (func (export "andnot") (param $0 v128) (param $1 v128) (result v128) (v128.andnot (local.get $0) (local.get $1)))
+)
+{normal_case}"""
+
+    @staticmethod
+    def init_case_data(case_data):
+        """
+        Rearrange const data into standard format
+        e.g. [0][i32x4] => (v128.const i32x4 0 0 0 0)
+             [0][i32]   => (i32.const 0)
+        """
+
+        s_i = SIMD()
+
+        lst_i_p_r = []
+
+        for item in case_data:
+            # Recognize '#' as a commentary
+            if item[0] == '#':
+                comment = '\n' if len(item[1]) == 0 else '\n;; {}'.format(item[1])
+                lst_i_p_r.append(['#', comment])
+                continue
+
+            # Params: instruction: instruction name;
+            #         params: param for instruction;
+            #         rets: excepted result;
+            #         lane_type: lane type for param and ret
+            instruction, params, rets, lane_type = item
+
+            p_const_list = []
+            for idx, param in enumerate(params):
+                p_const_list.append(s_i.v128_const(param, lane_type[idx]))
+
+            r_const_list = []
+            for idx, ret in enumerate(rets):
+                r_const_list.append(s_i.v128_const(ret, lane_type[idx + len(params)]))
+
+            lst_i_p_r.append([instruction, p_const_list, r_const_list])
+
+        return lst_i_p_r
+
+    # Generate normal case with test datas
+    def get_normal_case(self):
+        """
+        Generate normal case with test data
+        """
+
+        lst_i_p_r = self.init_case_data(self.get_case_data())
+
+        cases = []
+        for ipr in lst_i_p_r:
+
+            if ipr[0] == '#':
+                cases.append(ipr[1])
+                continue
+
+            cases.append(str(AssertReturn(ipr[0],
+                                          ipr[1],
+                                          ipr[2])))
+
+        return '\n'.join(cases)
+
+    def get_invalid_case(self):
+        """
+        Generate invalid case with test data
+        """
+
+        case_data = [
+            # i8x16
+            ['#', 'Type check'],
+            ['#', ''],
+
+            ['#', 'not'],
+            ["v128.not", ['0'], [], ['i32']],
+
+            ['#', 'and'],
+            ["v128.and", ['0', '0'], [], ['i32', 'i32x4']],
+            ["v128.and", ['0', '0'], [], ['i32x4', 'i32']],
+            ["v128.and", ['0', '0'], [], ['i32', 'i32']],
+
+            ['#', 'or'],
+            ["v128.or", ['0', '0'], [], ['i32', 'i32x4']],
+            ["v128.or", ['0', '0'], [], ['i32x4', 'i32']],
+            ["v128.or", ['0', '0'], [], ['i32', 'i32']],
+
+            ['#', 'xor'],
+            ["v128.xor", ['0', '0'], [], ['i32', 'i32x4']],
+            ["v128.xor", ['0', '0'], [], ['i32x4', 'i32']],
+            ["v128.xor", ['0', '0'], [], ['i32', 'i32']],
+
+            ['#', 'bitselect'],
+            ["v128.bitselect", ['0', '0', '0'], [], ['i32', 'i32x4', 'i32x4']],
+            ["v128.bitselect", ['0', '0', '0'], [], ['i32x4', 'i32x4', 'i32']],
+            ["v128.bitselect", ['0', '0', '0'], [], ['i32', 'i32', 'i32']],
+
+            ['#', 'andnot'],
+            ["v128.andnot", ['0', '0'], [], ['i32', 'i32x4']],
+            ["v128.andnot", ['0', '0'], [], ['i32x4', 'i32']],
+            ["v128.andnot", ['0', '0'], [], ['i32', 'i32']]
+        ]
+
+        lst_ipr = self.init_case_data(case_data)
+
+        str_invalid_case_func_tpl = '\n(assert_invalid (module (func (result v128)' \
+                                    ' ({op} {operand}))) "type mismatch")'
+
+        lst_invalid_case_func = []
+
+        for ipr in lst_ipr:
+
+            if ipr[0] == '#':
+                lst_invalid_case_func.append(ipr[1])
+                continue
+            else:
+                lst_invalid_case_func.append(
+                    str_invalid_case_func_tpl.format(op=ipr[0], operand=' '.join(ipr[1]))
+                )
+
+        return '\n{}\n'.format(''.join(lst_invalid_case_func))
+
+    def get_combination_case(self):
+        """
+        Generate combination case with test data
+        """
+
+        str_in_block_case_func_tpl = '\n  (func (export "{op}-in-block")' \
+                                     '\n    (block' \
+                                     '\n      (drop' \
+                                     '\n        (block (result v128)' \
+                                     '\n          ({op}' \
+                                     '{block_with_result}' \
+                                     '\n          )' \
+                                     '\n        )' \
+                                     '\n      )' \
+                                     '\n    )' \
+                                     '\n  )'
+        str_nested_case_func_tpl = '\n  (func (export "nested-{op}")' \
+                                   '\n    (drop' \
+                                   '\n      ({op}' \
+                                   '{block_with_result}' \
+                                   '\n      )' \
+                                   '\n    )' \
+                                   '\n  )'
+
+        case_data = [
+            ["v128.not", ['0'], [], ['i32']],
+            ["v128.and", ['0', '1'], [], ['i32', 'i32']],
+            ["v128.or", ['0', '1'], [], ['i32', 'i32']],
+            ["v128.xor", ['0', '1'], [], ['i32', 'i32']],
+            ["v128.bitselect", ['0', '1', '2'], [], ['i32', 'i32', 'i32']],
+            ["v128.andnot", ['0', '1'], [], ['i32', 'i32']],
+        ]
+        lst_ipr = self.init_case_data(case_data)
+
+        lst_in_block_case_func = []
+        lst_nested_case_func = []
+        lst_in_block_case_assert = []
+        lst_nested_case_assert = []
+        lst_argument_empty_case = []
+
+        for ipr in lst_ipr:
+
+            lst_block = ['\n            (block (result v128) (v128.load {}))'.format(x) for x in ipr[1]]
+            lst_in_block_case_func.append(
+                str_in_block_case_func_tpl.format(op=ipr[0], block_with_result=''.join(lst_block))
+            )
+
+            tpl_1 = '\n        ({op}' \
+                    '{combined_operation}' \
+                    '\n        )'
+            tpl_2 = '\n          ({op}' \
+                    '{combined_operation}' \
+                    '\n          )'
+            tpl_3 = '\n            (v128.load {value})'
+
+            lst_tpl_3 = [tpl_3.format(value=x) for x in ipr[1]]
+            lst_tpl_2 = [tpl_2.format(op=ipr[0], combined_operation=''.join(lst_tpl_3))] * len(ipr[1])
+            lst_tpl_1 = [tpl_1.format(op=ipr[0], combined_operation=''.join(lst_tpl_2))] * len(ipr[1])
+
+            lst_nested_case_func.append(
+                str_nested_case_func_tpl.format(op=ipr[0], block_with_result=''.join(lst_tpl_1))
+            )
+
+            lst_in_block_case_assert.append('\n(assert_return (invoke "{}-in-block"))'.format(ipr[0]))
+            lst_nested_case_assert.append('\n(assert_return (invoke "nested-{}"))'.format(ipr[0]))
+
+        return '\n;; Combination\n' \
+               '\n(module (memory 1)' \
+               '{in_block_cases}' \
+               '{nested_cases}' \
+               '\n  (func (export "as-param")' \
+               '\n    (drop' \
+               '\n      (v128.or' \
+               '\n        (v128.and' \
+               '\n          (v128.not' \
+               '\n            (v128.load (i32.const 0))' \
+               '\n          )' \
+               '\n          (v128.not' \
+               '\n            (v128.load (i32.const 1))' \
+               '\n          )' \
+               '\n        )' \
+               '\n        (v128.xor' \
+               '\n          (v128.bitselect' \
+               '\n            (v128.load (i32.const 0))' \
+               '\n            (v128.load (i32.const 1))' \
+               '\n            (v128.load (i32.const 2))' \
+               '\n          )' \
+               '\n          (v128.andnot' \
+               '\n            (v128.load (i32.const 0))' \
+               '\n            (v128.load (i32.const 1))' \
+               '\n          )' \
+               '\n        )' \
+               '\n      )' \
+               '\n    )' \
+               '\n  )' \
+               '\n)' \
+               '{assert_in_block_cases}' \
+               '{assert_of_nested_cases}' \
+               '\n(assert_return (invoke "as-param"))\n'.format(in_block_cases=''.join(lst_in_block_case_func),
+                                                    nested_cases=''.join(lst_nested_case_func),
+                                                    assert_in_block_cases=''.join(lst_in_block_case_assert),
+                                                    assert_of_nested_cases=''.join(lst_nested_case_assert))
+
+    def get_argument_empty_case(self):
+        """
+        Generate argument empty cases
+        """
+
+        cases = []
+
+        param_1 = SIMD.v128_const('0', 'i32x4')
+
+        cases.append('\n\n;; Test operation with empty argument\n')
+
+        case_data = {
+            'op': '',
+            'extended_name': 'arg-empty',
+            'param_type': '',
+            'result_type': '(result v128)',
+            'params': '',
+        }
+
+        for op in self.UNARY_OPS:
+            case_data['op'] = 'v128.' + op
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        for op in self.BINARY_OPS:
+            case_data['op'] = 'v128.' + op
+            case_data['extended_name'] = '1st-arg-empty'
+            case_data['params'] = param_1
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        for op in self.TERNARY_OPS:
+            case_data['op'] = 'v128.' + op
+            case_data['extended_name'] = '1st-arg-empty'
+            case_data['params'] = param_1 + ' ' + param_1
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+            case_data['extended_name'] = 'two-args-empty'
+            case_data['params'] = param_1
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        return '\n'.join(cases) + '\n'
+
+
+    def get_all_cases(self):
+        """
+        generate all test cases
+        """
+
+        case_data = {'normal_case': self.get_normal_case()}
+
+        # Add tests for unkonow operators for i32x4
+        return self.CASE_TXT.format(**case_data) + self.get_invalid_case() + self.get_combination_case() + self.get_argument_empty_case()
+
+    def get_case_data(self):
+        """
+        Overload base class method and set test data for bitwise.
+        """
+        return [
+            # i32x4
+            ['#', 'i32x4'],
+            ["not", ['0'], ['-1'], ['i32x4', 'i32x4']],
+            ["not", ['-1'], ['0'], ['i32x4', 'i32x4']],
+            ["not", [['-1', '0', '-1', '0']], [['0', '-1', '0', '-1']], ['i32x4', 'i32x4']],
+            ["not", [['0', '-1', '0', '-1']], [['-1', '0', '-1', '0']], ['i32x4', 'i32x4']],
+            ["not", ['0x55555555'], ['0xAAAAAAAA'], ['i32x4', 'i32x4']],
+            ["not", ['3435973836'], ['858993459'], ['i32x4', 'i32x4']],
+            ['not', ['01_234_567_890'], ['3060399405'], ['i32x4', 'i32x4']],
+            ['not', ['0x0_1234_5678'], ['0xedcba987'], ['i32x4', 'i32x4']],
+            ["and", [['0', '-1'], ['0', '-1', '0', '-1']], [['0', '0', '0', '-1']], ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['0', '0'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['0', '-1'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['0', '0xFFFFFFFF'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['1', '1'], ['1'], ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['255', '85'], ['85'], ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['255', '128'], ['128'], ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['2863311530', ['10', '128', '5', '165']], [['10', '128', '0', '160']],
+                    ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['0xFFFFFFFF', '0x55555555'], ['0x55555555'], ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['0xFFFFFFFF', '0xAAAAAAAA'], ['0xAAAAAAAA'], ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['0xFFFFFFFF', '0x0'], ['0x0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["and", ['0x55555555', ['0x5555', '0xFFFF', '0x55FF', '0x5FFF']], ['0x5555'],
+                    ['i32x4', 'i32x4', 'i32x4']],
+            ['and', ['01_234_567_890', '01_234_567_890'], ['1234567890'], ['i32x4', 'i32x4', 'i32x4']],
+            ['and', ['0x0_1234_5678', '0x0_90AB_cdef'], ['0x10204468'], ['i32x4', 'i32x4', 'i32x4']],
+            ["or", [['0', '0', '-1', '-1'], ['0', '-1', '0', '-1']], [['0', '-1', '-1', '-1']],
+                   ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['0', '0'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['0', '-1'], ['-1'], ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['0', '0xFFFFFFFF'], ['0xFFFFFFFF'], ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['1', '1'], ['1'], ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['255', '85'], ['255'], ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['255', '128'], ['255'], ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['2863311530', ['10', '128', '5', '165']], [['2863311530', '2863311535']],
+                   ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['0xFFFFFFFF', '0x55555555'], ['0xFFFFFFFF'], ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['0xFFFFFFFF', '0xAAAAAAAA'], ['0xFFFFFFFF'], ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['0xFFFFFFFF', '0x0'], ['0xFFFFFFFF'], ['i32x4', 'i32x4', 'i32x4']],
+            ["or", ['0x55555555', ['0x5555', '0xFFFF', '0x55FF', '0x5FFF']],
+                   [['0x55555555', '0x5555ffff', '0x555555ff', '0x55555fff']],
+                   ['i32x4', 'i32x4', 'i32x4']],
+            ['or', ['01_234_567_890', '01_234_567_890'], ['1234567890'], ['i32x4', 'i32x4', 'i32x4']],
+            ['or', ['0x0_1234_5678', '0x0_90AB_cdef'], ['0x92bfdfff'], ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", [['0', '0', '-1', '-1'], ['0', '-1', '0', '-1']], [['0', '-1', '-1', '0']],
+                    ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['0', '0'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['0', '-1'], ['-1'], ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['0', '0xFFFFFFFF'], ['0xFFFFFFFF'], ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['1', '1'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['255', '85'], ['170'], ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['255', '128'], ['127'], ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['2863311530', ['10', '128', '5', '165']],
+                    [['2863311520', '2863311402', '2863311535', '2863311375']],
+                    ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['0xFFFFFFFF', '0x55555555'], ['0xAAAAAAAA'], ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['0xFFFFFFFF', '0xAAAAAAAA'], ['0x55555555'], ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['0xFFFFFFFF', '0x0'], ['0xFFFFFFFF'], ['i32x4', 'i32x4', 'i32x4']],
+            ["xor", ['0x55555555', ['0x5555', '0xFFFF', '0x55FF', '0x5FFF']],
+                    [['0x55550000', '0x5555AAAA', '0x555500AA', '0x55550AAA']],
+                    ['i32x4', 'i32x4', 'i32x4']],
+            ['xor', ['01_234_567_890', '01_234_567_890'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ['xor', ['0x0_1234_5678', '0x0_90AB_cdef'], ['0x829f9b97'], ['i32x4', 'i32x4', 'i32x4']],
+            ["bitselect", ['0xAAAAAAAA', '0xBBBBBBBB',
+                           ['0x00112345', '0xF00FFFFF', '0x10112021', '0xBBAABBAA']],
+                          [['0xBBAABABA', '0xABBAAAAA', '0xABAABBBA', '0xAABBAABB']],
+                          ['i32x4', 'i32x4', 'i32x4', 'i32x4']],
+            ["bitselect", ['0xAAAAAAAA', '0xBBBBBBBB', '0x00000000'], ['0xBBBBBBBB'],
+                          ['i32x4', 'i32x4', 'i32x4', 'i32x4']],
+            ["bitselect", ['0xAAAAAAAA', '0xBBBBBBBB', '0x11111111'], ['0xAAAAAAAA'],
+                          ['i32x4', 'i32x4', 'i32x4', 'i32x4']],
+            ["bitselect", ['0xAAAAAAAA', '0xBBBBBBBB',
+                           ['0x01234567', '0x89ABCDEF', '0xFEDCBA98', '0x76543210']],
+                          [['0xBABABABA', '0xABABABAB']],
+                          ['i32x4', 'i32x4', 'i32x4', 'i32x4']],
+            ["bitselect", ['0xAAAAAAAA', '0x55555555',
+                           ['0x01234567', '0x89ABCDEF', '0xFEDCBA98', '0x76543210']],
+                          [['0x54761032', '0xDCFE98BA', '0xAB89EFCD', '0x23016745']],
+                          ['i32x4', 'i32x4', 'i32x4', 'i32x4']],
+            ["bitselect", ['0xAAAAAAAA', '0x55555555',
+                           ['0x55555555', '0xAAAAAAAA', '0x00000000', '0xFFFFFFFF']],
+                          [['0x00000000', '0xFFFFFFFF', '0x55555555', '0xAAAAAAAA']],
+                          ['i32x4', 'i32x4', 'i32x4', 'i32x4']],
+            ['bitselect', ['01_234_567_890', '03_060_399_406', '0xcdefcdef'], ['2072391874'],
+                          ['i32x4', 'i32x4', 'i32x4', 'i32x4']],
+            ['bitselect', ['0x0_1234_5678', '0x0_90AB_cdef', '0xcdefcdef'], ['0x10244468'],
+                          ['i32x4', 'i32x4', 'i32x4', 'i32x4']],
+            ["andnot", [['0', '-1'], ['0', '-1', '0', '-1']], [['0', '0', '-1', '0']], ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['0', '0'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['0', '-1'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['0', '0xFFFFFFFF'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['1', '1'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['255', '85'], ['170'], ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['255', '128'], ['127'], ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['2863311530', ['10', '128', '5', '165']], [['2863311520', '2863311402', '2863311530', '2863311370']],
+                       ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['0xFFFFFFFF', '0x55555555'], ['0xAAAAAAAA'], ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['0xFFFFFFFF', '0xAAAAAAAA'], ['0x55555555'], ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['0xFFFFFFFF', '0x0'], ['0xFFFFFFFF'], ['i32x4', 'i32x4', 'i32x4']],
+            ["andnot", ['0x55555555', ['0x5555', '0xFFFF', '0x55FF', '0x5FFF']], ['0x55550000'],
+                       ['i32x4', 'i32x4', 'i32x4']],
+            ['andnot', ['01_234_567_890', '01_234_567_890'], ['0'], ['i32x4', 'i32x4', 'i32x4']],
+            ['andnot', ['0x0_1234_5678', '0x0_90AB_cdef'], ['0x02141210'], ['i32x4', 'i32x4', 'i32x4']],
+
+            ['#', 'for float special data [e.g. -nan nan -inf inf]'],
+            ["not", ['-nan'], ['5.87747e-39'], ['f32x4', 'f32x4']],
+            ["not", ['nan'], ['-5.87747e-39'], ['f32x4', 'f32x4']],
+            ["not", ['-inf'], ['0x007fffff'], ['f32x4', 'i32x4']],
+            ["not", ['inf'], ['0x807fffff'], ['f32x4', 'i32x4']],
+
+            ["and", ['-nan', '-nan'], ['0xffc00000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["and", ['-nan', 'nan'], ['nan'], ['f32x4', 'f32x4', 'f32x4']],
+            ["and", ['-nan', '-inf'], ['-inf'], ['f32x4', 'f32x4', 'f32x4']],
+            ["and", ['-nan', 'inf'], ['inf'], ['f32x4', 'f32x4', 'f32x4']],
+            ["and", ['nan', 'nan'], ['nan'], ['f32x4', 'f32x4', 'f32x4']],
+            ["and", ['nan', '-inf'], ['inf'], ['f32x4', 'f32x4', 'f32x4']],
+            ["and", ['nan', 'inf'], ['inf'], ['f32x4', 'f32x4', 'f32x4']],
+            ["and", ['-inf', '-inf'], ['-inf'], ['f32x4', 'f32x4', 'f32x4']],
+            ["and", ['-inf', 'inf'], ['inf'], ['f32x4', 'f32x4', 'f32x4']],
+            ["and", ['inf', 'inf'], ['inf'], ['f32x4', 'f32x4', 'f32x4']],
+
+            ["or", ['-nan', '-nan'], ['0xffc00000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["or", ['-nan', 'nan'], ['0xffc00000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["or", ['-nan', '-inf'], ['0xffc00000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["or", ['-nan', 'inf'], ['0xffc00000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["or", ['nan', 'nan'], ['nan'], ['f32x4', 'f32x4', 'f32x4']],
+            ["or", ['nan', '-inf'], ['0xffc00000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["or", ['nan', 'inf'], ['nan'], ['f32x4', 'f32x4', 'f32x4']],
+            ["or", ['-inf', '-inf'], ['-inf'], ['f32x4', 'f32x4', 'f32x4']],
+            ["or", ['-inf', 'inf'], ['-inf'], ['f32x4', 'f32x4', 'f32x4']],
+            ["or", ['inf', 'inf'], ['inf'], ['f32x4', 'f32x4', 'f32x4']],
+
+            ["xor", ['-nan', '-nan'], ['0'], ['f32x4', 'f32x4', 'f32x4']],
+            ["xor", ['-nan', 'nan'], ['-0'], ['f32x4', 'f32x4', 'f32x4']],
+            ["xor", ['-nan', '-inf'], ['0x00400000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["xor", ['-nan', 'inf'], ['0x80400000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["xor", ['nan', 'nan'], ['0'], ['f32x4', 'f32x4', 'f32x4']],
+            ["xor", ['nan', '-inf'], ['0x80400000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["xor", ['nan', 'inf'], ['0x00400000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["xor", ['-inf', '-inf'], ['0'], ['f32x4', 'f32x4', 'f32x4']],
+            ["xor", ['-inf', 'inf'], ['0x80000000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["xor", ['inf', 'inf'], ['0'], ['f32x4', 'f32x4', 'f32x4']],
+
+            ["bitselect", ['-nan', '-nan','0xA5A5A5A5'], ['0xffc00000'], ['f32x4', 'f32x4', 'f32x4', 'i32x4']],
+            ["bitselect", ['-nan', 'nan','0xA5A5A5A5'], ['nan'], ['f32x4', 'f32x4', 'f32x4', 'f32x4']],
+            ["bitselect", ['-nan', '-inf','0xA5A5A5A5'], ['-inf'], ['f32x4', 'f32x4', 'f32x4', 'f32x4']],
+            ["bitselect", ['-nan', 'inf','0xA5A5A5A5'], ['inf'], ['f32x4', 'f32x4', 'f32x4', 'f32x4']],
+            ["bitselect", ['nan', 'nan','0xA5A5A5A5'], ['nan'], ['f32x4', 'f32x4', 'f32x4', 'f32x4']],
+            ["bitselect", ['nan', '-inf','0xA5A5A5A5'], ['-inf'], ['f32x4', 'f32x4', 'f32x4', 'f32x4']],
+            ["bitselect", ['nan', 'inf','0xA5A5A5A5'], ['inf'], ['f32x4', 'f32x4', 'f32x4', 'f32x4']],
+            ["bitselect", ['-inf', '-inf','0xA5A5A5A5'], ['-inf'], ['f32x4', 'f32x4', 'f32x4', 'f32x4']],
+            ["bitselect", ['-inf', 'inf','0xA5A5A5A5'], ['inf'], ['f32x4', 'f32x4', 'f32x4', 'f32x4']],
+            ["bitselect", ['inf', 'inf','0xA5A5A5A5'], ['inf'], ['f32x4', 'f32x4', 'f32x4', 'f32x4']],
+
+            ["andnot", ['-nan', '-nan'], ['0x00000000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["andnot", ['-nan', 'nan'], ['-0'], ['f32x4', 'f32x4', 'f32x4']],
+            ["andnot", ['-nan', '-inf'], ['0x00400000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["andnot", ['-nan', 'inf'], ['0x80400000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["andnot", ['nan', 'nan'], ['0x00000000'], ['f32x4', 'f32x4', 'f32x4']],
+            ["andnot", ['nan', '-inf'], ['0x00400000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["andnot", ['nan', 'inf'], ['0x00400000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["andnot", ['-inf', '-inf'], ['0x00000000'], ['f32x4', 'f32x4', 'f32x4']],
+            ["andnot", ['-inf', 'inf'], ['0x80000000'], ['f32x4', 'f32x4', 'i32x4']],
+            ["andnot", ['inf', 'inf'], ['0x00000000'], ['f32x4', 'f32x4', 'i32x4']]
+        ]
+
+    def gen_test_cases(self):
+        """
+        Generate test case file
+        """
+        with open('../simd_bitwise.wast', 'w+') as f_out:
+            f_out.write(self.get_all_cases())
+
+
+def gen_test_cases():
+    """
+    Generate test case file
+    """
+    bit_wise = SimdBitWise()
+    bit_wise.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_compare.py b/test/core/simd/meta/simd_compare.py
new file mode 100644
index 000000000..584985082
--- /dev/null
+++ b/test/core/simd/meta/simd_compare.py
@@ -0,0 +1,412 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+This class is used to generate common tests for SIMD comparison instructions.
+Defines the test template to generate corresponding test file(simd_*_cmp.wast)
+via using variable test data set and subclass from sub test template
+"""
+
+import abc
+from simd import SIMD
+from test_assert import AssertReturn, AssertInvalid
+
+
+# Generate common comparison tests
+class SimdCmpCase(object):
+
+    __metaclass__ = abc.ABCMeta
+
+    # Test case template
+    CASE_TXT = """
+;; Test all the {lane_type} comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) ({lane_type}.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) ({lane_type}.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x v128) (param $y v128) (result v128) ({lane_type}.lt_s (local.get $x) (local.get $y)))
+  (func (export "lt_u") (param $x v128) (param $y v128) (result v128) ({lane_type}.lt_u (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x v128) (param $y v128) (result v128) ({lane_type}.le_s (local.get $x) (local.get $y)))
+  (func (export "le_u") (param $x v128) (param $y v128) (result v128) ({lane_type}.le_u (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x v128) (param $y v128) (result v128) ({lane_type}.gt_s (local.get $x) (local.get $y)))
+  (func (export "gt_u") (param $x v128) (param $y v128) (result v128) ({lane_type}.gt_u (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x v128) (param $y v128) (result v128) ({lane_type}.ge_s (local.get $x) (local.get $y)))
+  (func (export "ge_u") (param $x v128) (param $y v128) (result v128) ({lane_type}.ge_u (local.get $x) (local.get $y)))
+)
+
+{normal_case}
+
+
+;; Type check
+
+(assert_invalid (module (func (result v128) ({lane_type}.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.ge_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.gt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.le_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.lt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+
+
+;; combination
+
+(module (memory 1)
+  (func (export "eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          ({lane_type}.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          ({lane_type}.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "lt_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          ({lane_type}.lt_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "le_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          ({lane_type}.le_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "gt_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          ({lane_type}.gt_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ge_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          ({lane_type}.ge_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-eq")
+    (drop
+      ({lane_type}.eq
+        ({lane_type}.eq
+          ({lane_type}.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        ({lane_type}.eq
+          ({lane_type}.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ne")
+    (drop
+      ({lane_type}.ne
+        ({lane_type}.ne
+          ({lane_type}.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        ({lane_type}.ne
+          ({lane_type}.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-lt_s")
+    (drop
+      ({lane_type}.lt_s
+        ({lane_type}.lt_s
+          ({lane_type}.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        ({lane_type}.lt_s
+          ({lane_type}.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-le_u")
+    (drop
+      ({lane_type}.le_u
+        ({lane_type}.le_u
+          ({lane_type}.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        ({lane_type}.le_u
+          ({lane_type}.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-gt_u")
+    (drop
+      ({lane_type}.gt_u
+        ({lane_type}.gt_u
+          ({lane_type}.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        ({lane_type}.gt_u
+          ({lane_type}.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ge_s")
+    (drop
+      ({lane_type}.ge_s
+        ({lane_type}.ge_s
+          ({lane_type}.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        ({lane_type}.ge_s
+          ({lane_type}.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      ({lane_type}.ge_u
+        ({lane_type}.eq
+          ({lane_type}.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        ({lane_type}.ne
+          ({lane_type}.gt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          ({lane_type}.lt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "eq-in-block"))
+(assert_return (invoke "ne-in-block"))
+(assert_return (invoke "lt_s-in-block"))
+(assert_return (invoke "le_u-in-block"))
+(assert_return (invoke "gt_u-in-block"))
+(assert_return (invoke "ge_s-in-block"))
+(assert_return (invoke "nested-eq"))
+(assert_return (invoke "nested-ne"))
+(assert_return (invoke "nested-lt_s"))
+(assert_return (invoke "nested-le_u"))
+(assert_return (invoke "nested-gt_u"))
+(assert_return (invoke "nested-ge_s"))
+(assert_return (invoke "as-param"))
+
+"""
+
+    # lane type [e.g. i8x16, i16x8, i32x4, f32x4]
+    LANE_TYPE = 'i8x16'
+
+    def __init__(self):
+        super(SimdCmpCase, self).__init__()
+
+    def __str__(self):
+        return self.get_all_cases()
+
+    # This method requires subclass overloading with its own type of test data.
+    @abc.abstractmethod
+    def get_case_data(self):
+        pass
+
+    # Generate normal case with test datas
+    def get_normal_case(self):
+
+        s = SIMD()
+
+        case_data = self.get_case_data()
+
+        cases = []
+
+        for item in case_data:
+            # Recognize '#' as a commentary
+            if item[0] == '#':
+                cases.append('\n;; {}'.format(item[1]))
+                continue
+
+            """
+            Generate assert_return
+            Params: instruction: instruction name;
+                    param: param for instruction;
+                    ret: excepted result;
+                    lane_type: lane type
+            """
+            instruction, param, ret, lane_type = item
+            cases.append(str(AssertReturn(instruction,
+                                          [s.v128_const(param[0], lane_type[0]),
+                                           s.v128_const(param[1], lane_type[1])],
+                                          s.v128_const(ret, lane_type[2]))))
+
+        return '\n'.join(cases)
+
+    def argument_empty_test(self):
+        """Test cases with empty argument.
+        """
+        cases = []
+
+        cases.append('\n;; Test operation with empty argument\n')
+
+        case_data = {
+            'op': '',
+            'extended_name': 'arg-empty',
+            'param_type': '',
+            'result_type': '(result v128)',
+            'params': '',
+        }
+
+        for op in self.BINARY_OPS:
+            case_data['op'] = '{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op)
+            case_data['extended_name'] = '1st-arg-empty'
+            case_data['params'] = SIMD.v128_const('0', self.LANE_TYPE)
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        return '\n'.join(cases)
+
+    # Generate all test cases
+    def get_all_cases(self):
+
+        case_data = {'normal_case': self.get_normal_case(),
+                     'lane_type': self.LANE_TYPE}
+
+        # Generate tests using the test template
+        return self.CASE_TXT.format(**case_data) + self.argument_empty_test()
+
+    # Generate test case file
+    def gen_test_cases(self):
+        with open('../simd_{}_cmp.wast'.format(self.LANE_TYPE), 'w+') as f_out:
+            f_out.write(self.get_all_cases())
+            f_out.close()
diff --git a/test/core/simd/meta/simd_ext_mul.py b/test/core/simd/meta/simd_ext_mul.py
new file mode 100644
index 000000000..30a4082f2
--- /dev/null
+++ b/test/core/simd/meta/simd_ext_mul.py
@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+
+""" Base class for generating extended multiply instructions.  These
+instructions 2 inputs of the same (narrower) lane shape, multiplies
+corresponding lanes with extension (no overflow/wraparound), producing 1 output
+of a (wider) shape. These instructions can choose to work on the low or high
+halves of the inputs, and perform signed or unsigned multiply.
+
+Subclasses need to define 3 attributes:
+  - LANE_TYPE (this is the output shape)
+  - SRC_LANE_TYPE (this is the input (narrower) shape)
+  - BINARY_OPS (list of operations)
+"""
+
+from simd_arithmetic import SimdArithmeticCase
+
+
+class SimdExtMulCase(SimdArithmeticCase):
+    UNARY_OPS = ()
+
+    @property
+    def full_bin_test_data(self):
+        return []
+
+    def get_combine_cases(self):
+        return ''
+
+    @property
+    def bin_test_data(self):
+        lane_forms = [self.SRC_LANE_TYPE, self.SRC_LANE_TYPE, self.LANE_TYPE]
+        return [(self.normal_binary_op_test_data, lane_forms)]
+
+    @property
+    def hex_binary_op_test_data(self):
+        return []
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_{wide}_extmul_{narrow}.wast'.format(
+                wide=self.LANE_TYPE, narrow=self.SRC_LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            fp.write(self.get_all_cases())
+
+
+class SimdI16x8ExtMulCase(SimdExtMulCase):
+    LANE_TYPE = 'i16x8'
+    SRC_LANE_TYPE = 'i8x16'
+    BINARY_OPS = ('extmul_low_i8x16_s', 'extmul_high_i8x16_s',
+                  'extmul_low_i8x16_u', 'extmul_high_i8x16_u')
+
+
+class SimdI32x4ExtMulCase(SimdExtMulCase):
+    LANE_TYPE = 'i32x4'
+    SRC_LANE_TYPE = 'i16x8'
+    BINARY_OPS = ('extmul_low_i16x8_s', 'extmul_high_i16x8_s',
+                  'extmul_low_i16x8_u', 'extmul_high_i16x8_u')
+
+
+class SimdI64x2ExtMulCase(SimdExtMulCase):
+    LANE_TYPE = 'i64x2'
+    SRC_LANE_TYPE = 'i32x4'
+    BINARY_OPS = ('extmul_low_i32x4_s', 'extmul_high_i32x4_s',
+                  'extmul_low_i32x4_u', 'extmul_high_i32x4_u')
+
+
+def gen_test_cases():
+    simd_i16x8_ext_mul_case = SimdI16x8ExtMulCase()
+    simd_i16x8_ext_mul_case.gen_test_cases()
+    simd_i32x4_ext_mul_case = SimdI32x4ExtMulCase()
+    simd_i32x4_ext_mul_case.gen_test_cases()
+    simd_i64x2_ext_mul_case = SimdI64x2ExtMulCase()
+    simd_i64x2_ext_mul_case.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_extadd_pairwise.py b/test/core/simd/meta/simd_extadd_pairwise.py
new file mode 100644
index 000000000..8a398414d
--- /dev/null
+++ b/test/core/simd/meta/simd_extadd_pairwise.py
@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+
+from simd_arithmetic import SimdArithmeticCase, i16
+from simd_integer_op import ArithmeticOp
+
+
+class SimdExtAddPairwise(SimdArithmeticCase):
+    BINARY_OPS = ()
+
+    def unary_op(self, x, signed):
+        # For test data we always splat a single value to the
+        # entire v128, so doubling the input works.
+        return ArithmeticOp.get_valid_value(x, self.src_lane, signed=signed) * 2
+
+    @property
+    def hex_unary_op_test_data(self):
+        return []
+
+    @property
+    def unary_test_data(self):
+        return [
+            (self.normal_unary_op_test_data, [self.SRC_LANE_TYPE,self.LANE_TYPE]),
+        ]
+
+    def get_case_data(self):
+        case_data = []
+        for op in self.UNARY_OPS:
+            op_name = self.op_name(op)
+            case_data.append(['#', op_name])
+            for data_group, v128_forms in self.unary_test_data:
+                for data in data_group:
+                    case_data.append([op_name, [str(data)],
+                        str(self.unary_op(data, op.endswith('s'))),
+                        v128_forms])
+        return case_data
+
+    def get_combine_cases(self):
+        return ''
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_{}_extadd_pairwise_{}.wast'.format(self.LANE_TYPE, self.SRC_LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            fp.write(self.get_all_cases())
+
+class SimdI16x8ExtAddPairwise(SimdExtAddPairwise):
+    UNARY_OPS = ('extadd_pairwise_i8x16_s','extadd_pairwise_i8x16_u')
+    LANE_TYPE = 'i16x8'
+    SRC_LANE_TYPE = 'i8x16'
+
+class SimdI32x4ExtAddPairwise(SimdExtAddPairwise):
+    UNARY_OPS = ('extadd_pairwise_i16x8_s','extadd_pairwise_i16x8_u')
+    LANE_TYPE = 'i32x4'
+    SRC_LANE_TYPE = 'i16x8'
+
+def gen_test_cases():
+    simd_i16x8_arith = SimdI16x8ExtAddPairwise()
+    simd_i32x4_arith = SimdI32x4ExtAddPairwise()
+    simd_i16x8_arith.gen_test_cases()
+    simd_i32x4_arith.gen_test_cases()
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_f32x4.py b/test/core/simd/meta/simd_f32x4.py
new file mode 100644
index 000000000..b9b6b0f9f
--- /dev/null
+++ b/test/core/simd/meta/simd_f32x4.py
@@ -0,0 +1,376 @@
+#!/usr/bin/env python3
+
+"""
+Generate f32x4 [abs, min, max] cases.
+"""
+
+from simd_f32x4_arith import Simdf32x4ArithmeticCase
+from simd_float_op import FloatingPointSimpleOp
+from simd import SIMD
+from test_assert import AssertReturn
+
+
+class Simdf32x4Case(Simdf32x4ArithmeticCase):
+    UNARY_OPS = ('abs',)
+    BINARY_OPS = ('min', 'max',)
+    floatOp = FloatingPointSimpleOp()
+
+    FLOAT_NUMBERS = (
+        '0x0p+0', '-0x0p+0', '0x1p-149', '-0x1p-149', '0x1p-126', '-0x1p-126', '0x1p-1', '-0x1p-1', '0x1p+0', '-0x1p+0',
+        '0x1.921fb6p+2', '-0x1.921fb6p+2', '0x1.fffffep+127', '-0x1.fffffep+127', 'inf', '-inf'
+    )
+
+    LITERAL_NUMBERS = (
+        '0123456789e019', '0123456789e-019',
+        '0123456789.e019', '0123456789.e+019',
+        '-0123456789.0123456789'
+    )
+    NAN_NUMBERS = ('nan', '-nan', 'nan:0x200000', '-nan:0x200000')
+    binary_params_template = ('({assert_type} (invoke "{func}" ', '{operand_1}', '{operand_2})', '{expected_result})')
+    unary_param_template = ('({assert_type} (invoke "{func}" ', '{operand})', '{expected_result})')
+    binary_nan_template = ('({assert_type} (invoke "{func}" ', '{operand_1}', '{operand_2}))')
+    unary_nan_template = ('({assert_type} (invoke "{func}" ', '{operand}))')
+
+    def full_op_name(self, op_name):
+        return self.LANE_TYPE + '.' + op_name
+
+    @staticmethod
+    def v128_const(lane, value):
+
+        return SIMD().v128_const(value, lane)
+
+    def gen_test_func_template(self):
+
+        # Get function code
+        template = Simdf32x4ArithmeticCase.gen_test_func_template(self)
+
+        # Function template
+        tpl_func = '  (func (export "{func}"){params} (result v128) ({op} {operand_1}{operand_2}))'
+
+        # Const data for min and max
+        lst_instr_with_const = [
+            [
+                [['0', '1', '2', '-3'], ['0', '2', '1', '3']],
+                [['0', '1', '1', '-3'], ['0', '2', '2', '3']]
+            ],
+            [
+                [['0', '1', '2', '3'], ['0', '1', '2', '3']],
+                [['0', '1', '2', '3'], ['0', '1', '2', '3']]
+            ],
+            [
+                [['0x00', '0x01', '0x02', '0x80000000'], ['0x00', '0x02', '0x01', '2147483648']],
+                [['0x00', '0x01', '0x01', '0x80000000'], ['0x00', '0x02', '0x02', '2147483648']]
+            ],
+            [
+                [['0x00', '0x01', '0x02', '0x80000000'], ['0x00', '0x01', '0x02', '0x80000000']],
+                [['0x00', '0x01', '0x02', '0x80000000'], ['0x00', '0x01', '0x02', '0x80000000']]
+            ]
+        ]
+
+        # Assert data
+        lst_oprt_with_const_assert = {}
+
+        # Generate func and assert
+        for op in self.BINARY_OPS:
+
+            op_name = self.full_op_name(op)
+
+            # Add comment for the case script "  ;; [f32x4.min, f32x4.max] const vs const"
+            template.insert(len(template)-1, '  ;; {} const vs const'.format(op_name))
+
+            # Add const vs const cases
+            for case_data in lst_instr_with_const:
+
+                func = "{op}_with_const_{index}".format(op=op_name, index=len(template)-7)
+                template.insert(len(template)-1,
+                                tpl_func.format(func=func, params='', op=op_name,
+                                                operand_1=self.v128_const('f32x4', case_data[0][0]),
+                                                operand_2=' ' + self.v128_const('f32x4', case_data[0][1])))
+
+                ret_idx = 0 if op == 'min' else 1
+
+                if op not in lst_oprt_with_const_assert:
+                    lst_oprt_with_const_assert[op] = []
+
+                lst_oprt_with_const_assert[op].append([func, case_data[1][ret_idx]])
+
+            # Add comment for the case script "  ;; [f32x4.min, f32x4.max] param vs const"
+            template.insert(len(template)-1, '  ;; {} param vs const'.format(op_name))
+
+            case_cnt = 0
+
+            # Add param vs const cases
+            for case_data in lst_instr_with_const:
+
+                func = "{}_with_const_{}".format(op_name, len(template)-7)
+
+                # Cross parameters and constants
+                if case_cnt in (0, 3):
+                    operand_1 = '(local.get 0)'
+                    operand_2 = self.v128_const('f32x4', case_data[0][0])
+                else:
+                    operand_1 = self.v128_const('f32x4', case_data[0][0])
+                    operand_2 = '(local.get 0)'
+
+                template.insert(len(template)-1,
+                                tpl_func.format(func=func, params='(param v128)', op=op_name,
+                                                operand_1=operand_1, operand_2=' ' + operand_2))
+
+                ret_idx = 0 if op == 'min' else 1
+
+                if op not in lst_oprt_with_const_assert:
+                    lst_oprt_with_const_assert[op] = []
+
+                lst_oprt_with_const_assert[op].append([func, case_data[0][1], case_data[1][ret_idx]])
+
+                case_cnt += 1
+
+        # Generate func for abs
+        op_name = self.full_op_name('abs')
+        func = "{}_with_const".format(op_name)
+        template.insert(len(template)-1, '')
+        template.insert(len(template)-1,
+                        tpl_func.format(func=func, params='', op=op_name,
+                                        operand_1=self.v128_const('f32x4', ['-0', '-1', '-2', '-3']), operand_2=''))
+
+        # Test different lanes go through different if-then clauses
+        lst_diff_lane_vs_clause = [
+            [
+                'f32x4.min',
+                [['nan', '0', '0', '1'], ['0', '-nan', '1', '0']],
+                [['nan:canonical', 'nan:canonical', '0', '0']],
+                ['f32x4', 'f32x4', 'f32x4']
+            ],
+            [
+                'f32x4.min',
+                [['nan', '0', '0', '0'], ['0', '-nan', '1', '0']],
+                [['nan:canonical', 'nan:canonical', '0', '0']],
+                ['f32x4', 'f32x4', 'f32x4']
+            ],
+            [
+                'f32x4.max',
+                [['nan', '0', '0', '1'], ['0', '-nan', '1', '0']],
+                [['nan:canonical', 'nan:canonical', '1', '1']],
+                ['f32x4', 'f32x4', 'f32x4']
+            ],
+            [
+                'f32x4.max',
+                [['nan', '0', '0', '0'], ['0', '-nan', '1', '0']],
+                [['nan:canonical', 'nan:canonical', '1', '0']],
+                ['f32x4', 'f32x4', 'f32x4']
+            ]
+        ]
+
+        # Template for assert
+        tpl_assert = '(assert_return\n' \
+                     '  (invoke "{func}"\n' \
+                     '    {operand_1}\n' \
+                     '    {operand_2}\n' \
+                     '  )\n' \
+                     '  {expected_result}\n' \
+                     ')'
+
+        lst_diff_lane_vs_clause_assert = []
+
+        # Add comment in wast script
+        lst_diff_lane_vs_clause_assert.append('')
+        lst_diff_lane_vs_clause_assert.append(';; Test different lanes go through different if-then clauses')
+
+        for case_data in lst_diff_lane_vs_clause:
+
+            lst_diff_lane_vs_clause_assert.append(';; {lane_type}'.format(lane_type=case_data[0]))
+
+            lst_diff_lane_vs_clause_assert.append(tpl_assert.format(
+                func=case_data[0],
+                operand_1=self.v128_const(case_data[3][0], case_data[1][0]),
+                operand_2=self.v128_const(case_data[3][1], case_data[1][1]),
+                expected_result=self.v128_const(case_data[3][2], case_data[2][0])
+            ))
+
+        lst_diff_lane_vs_clause_assert.append('')
+
+        # Add test for operations with constant operands
+        for key in lst_oprt_with_const_assert:
+            op_name = self.full_op_name(key)
+            case_cnt = 0
+            for case_data in lst_oprt_with_const_assert[key]:
+
+                # Add comment for the param combination
+                if case_cnt == 0:
+                    template.append(';; {} const vs const'.format(op_name))
+                if case_cnt == 4:
+                    template.append(';; {} param vs const'.format(op_name))
+
+                # Cross parameters and constants
+                if case_cnt < 4:
+                    template.append(str(AssertReturn(case_data[0], [], self.v128_const('f32x4', case_data[1]))))
+                else:
+                    template.append(str(AssertReturn(case_data[0], [self.v128_const('f32x4', case_data[1])], self.v128_const('f32x4', case_data[2]))))
+                case_cnt += 1
+
+        # Generate and append f32x4.abs assert
+        op_name = self.full_op_name('abs')
+        func = "{}_with_const".format(op_name)
+        template.append('')
+        template.append(str(AssertReturn(func, [], self.v128_const('f32x4', ['0', '1', '2', '3']))))
+
+        template.extend(lst_diff_lane_vs_clause_assert)
+
+        return template
+
+    @property
+    def combine_ternary_arith_test_data(self):
+        return {
+            'min-max': [
+                ['1.125'] * 4, ['0.25'] * 4, ['0.125'] * 4, ['0.125'] * 4
+            ],
+            'max-min': [
+                ['1.125'] * 4, ['0.25'] * 4, ['0.125'] * 4, ['0.25'] * 4
+            ]
+        }
+
+    @property
+    def combine_binary_arith_test_data(self):
+        return {
+            'min-abs': [
+                ['-1.125'] * 4, ['0.125'] * 4, ['0.125'] * 4
+            ],
+            'max-abs': [
+                ['-1.125'] * 4, ['0.125'] * 4, ['1.125'] * 4
+            ]
+        }
+
+    def get_normal_case(self):
+        """Normal test cases from WebAssembly core tests.
+        """
+        cases = []
+        binary_test_data = []
+        unary_test_data = []
+
+        for op in self.BINARY_OPS:
+            op_name = self.full_op_name(op)
+            for operand1 in self.FLOAT_NUMBERS:
+                for operand2 in self.FLOAT_NUMBERS:
+                    result = self.floatOp.binary_op(op, operand1, operand2)
+                    if 'nan' not in result:
+                        # Normal floating point numbers as the results
+                        binary_test_data.append([op_name, operand1, operand2, result])
+                    else:
+                        # Since the results contain the 'nan' string, the result literals would be
+                        # nan:canonical
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:canonical'])
+
+            for operand1 in self.LITERAL_NUMBERS:
+                for operand2 in self.LITERAL_NUMBERS:
+                    result = self.floatOp.binary_op(op, operand1, operand2, hex_form=False)
+                    binary_test_data.append([op_name, operand1, operand2, result])
+
+            for operand1 in self.NAN_NUMBERS:
+                for operand2 in self.FLOAT_NUMBERS:
+                    if 'nan:' in operand1 or 'nan:' in operand2:
+                        # When the arguments contain 'nan:', the result literal is nan:arithmetic
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:arithmetic'])
+                    else:
+                        # No 'nan' string found, then the result literal is nan:canonical
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:canonical'])
+                for operand2 in self.NAN_NUMBERS:
+                    if 'nan:' in operand1 or 'nan:' in operand2:
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:arithmetic'])
+                    else:
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:canonical'])
+
+        for case in binary_test_data:
+            cases.append(str(AssertReturn(case[0],
+                        [SIMD.v128_const(c, self.LANE_TYPE) for c in case[1:-1]],
+                        SIMD.v128_const(case[-1], self.LANE_TYPE))))
+
+        # Test opposite signs of zero
+        lst_oppo_signs_0 = [
+            '\n;; Test opposite signs of zero',
+            [
+                'f32x4.min',
+                [['0', '0', '-0', '+0'], ['+0', '-0', '+0', '-0']],
+                [['0', '-0', '-0', '-0']],
+                ['f32x4', 'f32x4', 'f32x4']
+            ],
+            [
+                'f32x4.min',
+                [['-0', '-0', '-0', '-0'], ['+0', '+0', '+0', '+0']],
+                [['-0', '-0', '-0', '-0']],
+                ['f32x4', 'f32x4', 'f32x4']
+            ],
+            [
+                'f32x4.max',
+                [['0', '0', '-0', '+0'], ['+0', '-0', '+0', '-0']],
+                [['0', '0', '0', '0']],
+                ['f32x4', 'f32x4', 'f32x4']
+            ],
+            [
+                'f32x4.max',
+                [['-0', '-0', '-0', '-0'], ['+0', '+0', '+0', '+0']],
+                [['+0', '+0', '+0', '+0']],
+                ['f32x4', 'f32x4', 'f32x4']
+            ],
+            '\n'
+        ]
+
+        # Generate test case for opposite signs of zero
+        for case_data in lst_oppo_signs_0:
+
+            if isinstance(case_data, str):
+                cases.append(case_data)
+                continue
+
+            cases.append(str(AssertReturn(case_data[0],
+                                          [self.v128_const(case_data[3][0], case_data[1][0]),
+                                           self.v128_const(case_data[3][1], case_data[1][1])],
+                                          self.v128_const(case_data[3][2], case_data[2][0]))))
+
+        for operand in self.FLOAT_NUMBERS + self.LITERAL_NUMBERS:
+            op_name = self.full_op_name('abs')
+            hex_literal = True
+            if operand in self.LITERAL_NUMBERS:
+                hex_literal = False
+            result = self.floatOp.unary_op('abs', operand, hex_form=hex_literal)
+            # Abs operation is valid for all the floating point numbers
+            unary_test_data.append([op_name, operand, result])
+
+        for case in unary_test_data:
+            cases.append(str(AssertReturn(case[0],
+                        [SIMD.v128_const(elem, self.LANE_TYPE) for elem in case[1:-1]],
+                        SIMD.v128_const(case[-1], self.LANE_TYPE))))
+
+        self.get_unknown_operator_case(cases)
+
+        return '\n'.join(cases)
+
+    def get_unknown_operator_case(self, cases):
+        """Unknown operator cases.
+        """
+
+        tpl_assert = "(assert_malformed (module quote \"(memory 1) (func (result v128) " \
+                     "({lane_type}.{op} {value}))\") \"unknown operator\")"
+
+        unknown_op_cases = ['\n\n;; Unknown operators\n']
+        cases.extend(unknown_op_cases)
+
+        for lane_type in ['i8x16', 'i16x8', 'i32x4', 'i64x2']:
+
+            for op in self.BINARY_OPS:
+                cases.append(tpl_assert.format(lane_type=lane_type, op=op, value=' '.join([self.v128_const('i32x4', '0')]*2)))
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_{lane_type}.wast'.format(lane_type=self.LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            txt_test_case = self.get_all_cases()
+            txt_test_case = txt_test_case.replace('f32x4 arithmetic', 'f32x4 [abs, min, max]')
+            fp.write(txt_test_case)
+
+
+def gen_test_cases():
+    simd_f32x4_case = Simdf32x4Case()
+    simd_f32x4_case.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_f32x4_arith.py b/test/core/simd/meta/simd_f32x4_arith.py
new file mode 100644
index 000000000..1a56c05c4
--- /dev/null
+++ b/test/core/simd/meta/simd_f32x4_arith.py
@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+
+"""
+Generate f32x4 floating-point arithmetic operation cases.
+"""
+
+from simd_arithmetic import SimdArithmeticCase
+from simd_float_op import FloatingPointArithOp
+from test_assert import AssertReturn
+from simd import SIMD
+
+
+class F32ArithOp(FloatingPointArithOp):
+    maximum = '0x1.fffffep+127'
+
+
+class Simdf32x4ArithmeticCase(SimdArithmeticCase):
+    LANE_LEN = 4
+    LANE_TYPE = 'f32x4'
+
+    floatOp = F32ArithOp()
+    UNARY_OPS = ('neg', 'sqrt')
+    BINARY_OPS = ('add', 'sub', 'mul', 'div')
+
+    FLOAT_NUMBERS = (
+        '0x0p+0', '-0x0p+0', '0x1p-149', '-0x1p-149', '0x1p-126', '-0x1p-126', '0x1p-1', '-0x1p-1', '0x1p+0', '-0x1p+0',
+        '0x1.921fb6p+2', '-0x1.921fb6p+2', '0x1.fffffep+127', '-0x1.fffffep+127', 'inf', '-inf'
+    )
+    LITERAL_NUMBERS = ('0123456789', '0123456789e019', '0123456789e+019', '0123456789e-019',
+                       '0123456789.', '0123456789.e019', '0123456789.e+019', '0123456789.e-019',
+                       '0123456789.0123456789', '0123456789.0123456789e019',
+                       '0123456789.0123456789e+019', '0123456789.0123456789e-019',
+                       '0x0123456789ABCDEF', '0x0123456789ABCDEFp019',
+                       '0x0123456789ABCDEFp+019', '0x0123456789ABCDEFp-019',
+                       '0x0123456789ABCDEF.', '0x0123456789ABCDEF.p019',
+                       '0x0123456789ABCDEF.p+019', '0x0123456789ABCDEF.p-019',
+                       '0x0123456789ABCDEF.019aF', '0x0123456789ABCDEF.019aFp019',
+                       '0x0123456789ABCDEF.019aFp+019', '0x0123456789ABCDEF.019aFp-019'
+    )
+    NAN_NUMBERS = ('nan', '-nan', 'nan:0x200000', '-nan:0x200000')
+
+    def full_op_name(self, op_name):
+        return self.LANE_TYPE + '.' + op_name
+
+    @staticmethod
+    def v128_const(lane, value):
+        return '(v128.const {lane_type} {value})'.format(lane_type=lane, value=' '.join([str(value)] * 4))
+
+    @property
+    def combine_ternary_arith_test_data(self):
+        return {
+            'add-sub': [
+                ['1.125'] * 4, ['0.25'] * 4, ['0.125'] * 4, ['1.0'] * 4
+            ],
+            'sub-add': [
+                ['1.125'] * 4, ['0.25'] * 4, ['0.125'] * 4, ['1.25'] * 4
+            ],
+            'mul-add': [
+                ['1.25'] * 4, ['0.25'] * 4, ['0.25'] * 4, ['0.375'] * 4
+            ],
+            'mul-sub': [
+                ['1.125'] * 4, ['0.125'] * 4, ['0.25'] * 4, ['0.25'] * 4
+            ],
+            'div-add': [
+                ['1.125'] * 4, ['0.125'] * 4, ['0.25'] * 4, ['5.0'] * 4
+            ],
+            'div-sub': [
+                ['1.125'] * 4, ['0.125'] * 4, ['0.25'] * 4, ['4.0'] * 4
+            ],
+            'mul-div': [
+                ['1.125'] * 4, ['0.125'] * 4, ['0.25'] * 4, ['2.25'] * 4
+            ],
+            'div-mul': [
+                ['1.125'] * 4, ['4'] * 4, ['0.25'] * 4, ['18.0'] * 4
+            ]
+        }
+
+    @property
+    def combine_binary_arith_test_data(self):
+        return {
+            'add-neg': [
+                ['1.125'] * 4, ['0.125'] * 4, ['-1.0'] * 4
+            ],
+            'sub-neg': [
+                ['1.125'] * 4, ['0.125'] * 4, ['-1.25'] * 4
+            ],
+            'mul-neg': [
+                ['1.5'] * 4, ['0.25'] * 4, ['-0.375'] * 4
+            ],
+            'div-neg': [
+                ['1.5'] * 4, ['0.25'] * 4, ['-6'] * 4
+            ],
+            'add-sqrt': [
+                ['2.25'] * 4, ['0.25'] * 4, ['1.75'] * 4
+            ],
+            'sub-sqrt': [
+                ['2.25'] * 4, ['0.25'] * 4, ['1.25'] * 4
+            ],
+            'mul-sqrt': [
+                ['2.25'] * 4, ['0.25'] * 4, ['0.375'] * 4
+            ],
+            'div-sqrt': [
+                ['2.25'] * 4, ['0.25'] * 4, ['6'] * 4
+            ]
+        }
+
+    def get_normal_case(self):
+        """Normal test cases from WebAssembly core tests
+        """
+        cases = []
+        binary_test_data = []
+        unary_test_data = []
+
+        for op in self.BINARY_OPS:
+            op_name = self.full_op_name(op)
+            for operand1 in self.FLOAT_NUMBERS:
+                for operand2 in self.FLOAT_NUMBERS:
+                    result = self.floatOp.binary_op(op, operand1, operand2)
+                    if 'nan' not in result:
+                        # Normal floating point numbers as the results
+                        binary_test_data.append([op_name, operand1, operand2, result])
+                    else:
+                        # Since the results contain the 'nan' string, the result literals would be
+                        # nan:canonical
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:canonical'])
+
+            for operand1 in self.NAN_NUMBERS:
+                for operand2 in self.FLOAT_NUMBERS:
+                    if 'nan:' in operand1 or 'nan:' in operand2:
+                        # When the arguments contain 'nan:', the result literal is nan:arithmetic
+                        # Consider the different order of arguments as different cases.
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:arithmetic'])
+                        binary_test_data.append([op_name, operand2, operand1, 'nan:arithmetic'])
+                    else:
+                        # No 'nan' string found, then the result literal is nan:canonical.
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:canonical'])
+                        binary_test_data.append([op_name, operand2, operand1, 'nan:canonical'])
+                for operand2 in self.NAN_NUMBERS:
+                    if 'nan:' in operand1 or 'nan:' in operand2:
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:arithmetic'])
+                    else:
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:canonical'])
+
+            for operand in self.LITERAL_NUMBERS:
+                if self.LANE_TYPE == 'f32x4':
+                    single_precision = True
+                else:
+                    single_precision = False
+                result = self.floatOp.binary_op(op, operand, operand, single_prec=single_precision)
+                binary_test_data.append([op_name, operand, operand, result])
+
+        for case in binary_test_data:
+            cases.append(str(AssertReturn(case[0],
+                        [SIMD.v128_const(elem, self.LANE_TYPE) for elem in case[1:-1]],
+                        SIMD.v128_const(case[-1], self.LANE_TYPE))))
+
+        for operand in self.FLOAT_NUMBERS + self.NAN_NUMBERS + self.LITERAL_NUMBERS:
+            if 'nan:' in operand:
+                unary_test_data.append([op_name, operand, 'nan:arithmetic'])
+            elif 'nan' in operand:
+                unary_test_data.append([op_name, operand, 'nan:canonical'])
+            else:
+                # Normal floating point numbers for sqrt operation
+                op_name = self.full_op_name('sqrt')
+                result = self.floatOp.float_sqrt(operand)
+                if 'nan' not in result:
+                    # Get the sqrt value correctly
+                    unary_test_data.append([op_name, operand, result])
+                else:
+                    #
+                    unary_test_data.append([op_name, operand, 'nan:canonical'])
+
+        for operand in self.FLOAT_NUMBERS + self.NAN_NUMBERS + self.LITERAL_NUMBERS:
+            op_name = self.full_op_name('neg')
+            result = self.floatOp.float_neg(operand)
+            # Neg operation is valid for all the floating point numbers
+            unary_test_data.append([op_name, operand, result])
+
+        for case in unary_test_data:
+            cases.append(str(AssertReturn(case[0],
+                        [SIMD.v128_const(elem, self.LANE_TYPE) for elem in case[1:-1]],
+                        SIMD.v128_const(case[-1], self.LANE_TYPE))))
+
+        self.mixed_nan_test(cases)
+
+        return '\n'.join(cases)
+
+    @property
+    def mixed_sqrt_nan_test_data(self):
+        return {
+            "sqrt_canon": [
+                ('-1.0', 'nan', '4.0', '9.0'),
+                ('nan:canonical', 'nan:canonical', '2.0', '3.0')
+            ],
+            'sqrt_arith': [
+                ('nan:0x200000', '-nan:0x200000', '16.0', '25.0'),
+                ('nan:arithmetic', 'nan:arithmetic', '4.0', '5.0')
+            ],
+            'sqrt_mixed': [
+                ('-inf', 'nan:0x200000', '36.0', '49.0'),
+                ('nan:canonical', 'nan:arithmetic', '6.0', '7.0')
+            ]
+        }
+
+    def mixed_nan_test(self, cases):
+        """Mixed f32x4 tests when only expects NaNs in a subset of lanes.
+        """
+        mixed_cases = ['\n\n;; Mixed f32x4 tests when some lanes are NaNs', '(module\n']
+        cases.extend(mixed_cases)
+        for test_type, test_data in sorted(self.mixed_sqrt_nan_test_data.items()):
+            func = ['  (func (export "{lane}_{t}") (result v128)'.format(
+                lane=self.LANE_TYPE, t=test_type),
+                    '    ({lane}.{op} (v128.const {lane} {value})))'.format(
+                lane=self.LANE_TYPE, op=test_type.split('_')[0], value=' '.join(test_data[0]))]
+            cases.extend(func)
+        cases.append(')\n')
+
+        for test_type, test_data in sorted(self.mixed_sqrt_nan_test_data.items()):
+            cases.append('(assert_return (invoke "{lane}_{t}") (v128.const {lane} {result}))'.format(
+                lane=self.LANE_TYPE, t=test_type, result=' '.join(test_data[1])))
+
+
+def gen_test_cases():
+    simd_f32x4_arith = Simdf32x4ArithmeticCase()
+    simd_f32x4_arith.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
\ No newline at end of file
diff --git a/test/core/simd/meta/simd_f32x4_cmp.py b/test/core/simd/meta/simd_f32x4_cmp.py
new file mode 100644
index 000000000..8b3b30b6b
--- /dev/null
+++ b/test/core/simd/meta/simd_f32x4_cmp.py
@@ -0,0 +1,507 @@
+#!/usr/bin/env python3
+
+"""
+This file is used for generating simd_f32x4_cmp.wast file.
+Which inherites from `SimdCmpCase` class, overloads
+the `get_test_cases` method, and reset the Test Case template.
+The reason why this is different from other cmp files is that
+f32x4 only has 6 comparison instructions but with amounts of
+test datas.
+"""
+import struct
+from simd_compare import SimdCmpCase
+
+
+# Generate f32x4 test case
+class Simdf32x4CmpCase(SimdCmpCase):
+
+    LANE_TYPE = 'f32x4'
+
+    BINARY_OPS = ['eq', 'ne', 'lt', 'le', 'gt', 'ge']
+
+    # Test template, using this template to generate tests with variable test datas.
+    CASE_TXT = """;; Test all the {lane_type} comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (f32x4.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (f32x4.ne (local.get $x) (local.get $y)))
+  (func (export "lt") (param $x v128) (param $y v128) (result v128) (f32x4.lt (local.get $x) (local.get $y)))
+  (func (export "le") (param $x v128) (param $y v128) (result v128) (f32x4.le (local.get $x) (local.get $y)))
+  (func (export "gt") (param $x v128) (param $y v128) (result v128) (f32x4.gt (local.get $x) (local.get $y)))
+  (func (export "ge") (param $x v128) (param $y v128) (result v128) (f32x4.ge (local.get $x) (local.get $y)))
+)
+{normal_case}
+
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (f32x4.eq (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.ge (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.gt (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.le (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.lt (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.ne (i64.const 0) (f64.const 0)))) "type mismatch")
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.eq (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.ge (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.gt (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.le (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.lt (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.ne (local.get $x) (local.get $y)))") "unknown operator")
+
+
+;; Combination
+
+(module (memory 1)
+  (func (export "eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "lt-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.lt
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "le-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.le
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "gt-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.gt
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ge-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.ge
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-eq")
+    (drop
+      (f32x4.eq
+        (f32x4.eq
+          (f32x4.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.eq
+          (f32x4.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ne")
+    (drop
+      (f32x4.ne
+        (f32x4.ne
+          (f32x4.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.ne
+          (f32x4.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-lt")
+    (drop
+      (f32x4.lt
+        (f32x4.lt
+          (f32x4.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.lt
+          (f32x4.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-le")
+    (drop
+      (f32x4.le
+        (f32x4.le
+          (f32x4.le
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.le
+          (f32x4.le
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-gt")
+    (drop
+      (f32x4.gt
+        (f32x4.gt
+          (f32x4.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.gt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.gt
+          (f32x4.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.gt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ge")
+    (drop
+      (f32x4.ge
+        (f32x4.ge
+          (f32x4.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ge
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.ge
+          (f32x4.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ge
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (f32x4.ge
+        (f32x4.eq
+          (f32x4.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.ne
+          (f32x4.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+
+(assert_return (invoke "eq-in-block"))
+(assert_return (invoke "ne-in-block"))
+(assert_return (invoke "lt-in-block"))
+(assert_return (invoke "le-in-block"))
+(assert_return (invoke "gt-in-block"))
+(assert_return (invoke "ge-in-block"))
+(assert_return (invoke "nested-eq"))
+(assert_return (invoke "nested-ne"))
+(assert_return (invoke "nested-lt"))
+(assert_return (invoke "nested-le"))
+(assert_return (invoke "nested-gt"))
+(assert_return (invoke "nested-ge"))
+(assert_return (invoke "as-param"))
+"""
+
+    # Overloads base class method and sets test data for f32x4.
+    def get_case_data(self):
+
+        case_data = []
+
+        operand1 = ('nan', '0x1p-149', '-nan:0x200000', '-inf', '0x1.921fb6p+2',
+                    '0x1p+0', '-0x1.fffffep+127', '-0x0p+0', '-0x1p-1', '0x1.fffffep+127',
+                    '-nan', '-0x1p-149', '-0x1p-126', '0x1p-1', '-0x1.921fb6p+2',
+                    'nan:0x200000', '0x0p+0', 'inf', '-0x1p+0', '0x1p-126')
+        operand2 = ('nan', '0x1p-149', '-nan:0x200000', '-inf', '0x1.921fb6p+2',
+                    '0x1p+0', '-0x1.fffffep+127', '-0x0p+0', '-0x1p-1', '0x1.fffffep+127',
+                    '-nan', '-0x1p-149', '-0x1p-126', '0x1p-1', '-0x1.921fb6p+2',
+                    'nan:0x200000', '0x0p+0', 'inf', '-0x1p+0', '0x1p-126')
+        LITERAL_NUMBERS = (
+            '0123456789e019', '0123456789e-019',
+            '0123456789.e019', '0123456789.e+019',
+            '0123456789.0123456789')
+        Ops = ('eq', 'ne', 'lt', 'le', 'gt', 'ge')
+
+        # Combinations between operand1 and operand2
+        for op in Ops:
+            case_data.append(['#', op])
+            for param1 in operand1:
+                for param2 in operand2:
+                    case_data.append([op, [param1, param2], self.operate(op, param1, param2), ['f32x4', 'f32x4', 'i32x4']])
+
+            for param1 in LITERAL_NUMBERS:
+                for param2 in LITERAL_NUMBERS:
+                    case_data.append([op, [param1, param2], self.operate(op, param1, param2), ['f32x4', 'f32x4', 'i32x4']])
+        # eq
+        case_data.append(['#', 'eq'])
+
+        # f32x4.eq  (f32x4) (i8x16)
+        case_data.append(['#', 'f32x4.eq  (f32x4) (i8x16)'])
+        case_data.append(['eq', [['-1', '0', '1', '2.0'], ['-1', '-1', '-1', '-1', '0', '0', '0', '0', '1', '1', '1', '1', '2', '2', '2']], ['0', '-1', '0', '0'], ['f32x4', 'i8x16', 'i32x4']])
+
+        # f32x4.eq  (f32x4) (i16x8)
+        case_data.append(['#', 'f32x4.eq  (f32x4) (i16x8)'])
+        case_data.append(['eq', [['-1', '0', '1', '2.0'], ['-1', '-1', '0', '0', '1', '1', '2']], ['0', '-1', '0', '0'], ['f32x4', 'i16x8', 'i32x4']])
+
+        # f32x4.eq  (f32x4) (i32x4)
+        case_data.append(['#', 'f32x4.eq  (f32x4) (i32x4)'])
+        case_data.append(['eq', [['-1', '0', '1', '2.0'], ['3212836864', '0', '1', '2']], ['-1 -1', '0', '0', ''], ['f32x4', 'i32x4', 'i32x4']])
+
+        # ne
+        case_data.append(['#', 'ne'])
+
+        # f32x4.ne  (f32x4) (i8x16)
+        case_data.append(['#', 'f32x4.ne  (f32x4) (i8x16)'])
+        case_data.append(['ne', [['-1', '0', '1', '2.0'], ['-1', '-1', '-1', '-1', '0', '0', '0', '0', '1', '1', '1', '1', '2', '2', '2']], ['-1', '0', '-1', '-1'], ['f32x4', 'i8x16', 'i32x4']])
+
+        # f32x4.ne  (f32x4) (i16x8)
+        case_data.append(['#', 'f32x4.ne  (f32x4) (i16x8)'])
+        case_data.append(['ne', [['-1', '0', '1', '2.0'], ['-1', '-1', '0', '0', '1', '1', '2']], ['-1', '0', '-1', '-1'], ['f32x4', 'i16x8', 'i32x4']])
+
+        # f32x4.ne  (f32x4) (i32x4)
+        case_data.append(['#', 'f32x4.ne  (f32x4) (i32x4)'])
+        case_data.append(['ne', [['-1', '0', '1', '2.0'], ['3212836864', '0', '1', '2']], ['0', '0', '-1', '-1'], ['f32x4', 'i32x4', 'i32x4']])
+
+        # lt
+        case_data.append(['#', 'lt'])
+
+        # f32x4.lt  (f32x4) (i8x16)
+        case_data.append(['#', 'f32x4.lt  (f32x4) (i8x16)'])
+        case_data.append(['lt', [['-1', '0', '1', '2.0'], ['-1', '-1', '-1', '-1', '0', '0', '0', '0', '1', '1', '1', '1', '2', '2', '2']], ['0', '0', '0', '0'], ['f32x4', 'i8x16', 'i32x4']])
+
+        # f32x4.lt  (f32x4) (i16x8)
+        case_data.append(['#', 'f32x4.lt  (f32x4) (i16x8)'])
+        case_data.append(['lt', [['-1', '0', '1', '2.0'], ['-1', '-1', '0', '0', '1', '1', '2']], ['0', '0', '0', '0'], ['f32x4', 'i16x8', 'i32x4']])
+
+        # f32x4.lt  (f32x4) (i32x4)
+        case_data.append(['#', 'f32x4.lt  (f32x4) (i32x4)'])
+        case_data.append(['lt', [['-1', '0', '1', '2.0'], ['3212836864', '0', '1', '2']], ['0', '0', '0', '0'], ['f32x4', 'i32x4', 'i32x4']])
+
+        # le
+        case_data.append(['#', 'le'])
+
+        # f32x4.le  (f32x4) (i8x16)
+        case_data.append(['#', 'f32x4.le  (f32x4) (i8x16)'])
+        case_data.append(['le', [['-1', '0', '1', '2.0'], ['-1', '-1', '-1', '-1', '0', '0', '0', '0', '1', '1', '1', '1', '2', '2', '2']], ['0', '-1', '0', '0'], ['f32x4', 'i8x16', 'i32x4']])
+
+        # f32x4.le  (f32x4) (i16x8)
+        case_data.append(['#', 'f32x4.le  (f32x4) (i16x8)'])
+        case_data.append(['le', [['-1', '0', '1', '2.0'], ['-1', '-1', '0', '0', '1', '1', '2']], ['0', '-1', '0', '0'], ['f32x4', 'i16x8', 'i32x4']])
+
+        # f32x4.le  (f32x4) (i32x4)
+        case_data.append(['#', 'f32x4.le  (f32x4) (i32x4)'])
+        case_data.append(['le', [['-1', '0', '1', '2.0'], ['3212836864', '0', '1', '2']], ['-1', '-1', '0', '0'], ['f32x4', 'i32x4', 'i32x4']])
+
+        # gt
+        case_data.append(['#', 'gt'])
+
+        # f32x4.gt  (f32x4) (i8x16)
+        case_data.append(['#', 'f32x4.gt  (f32x4) (i8x16)'])
+        case_data.append(['gt', [['-1', '0', '1', '2.0'], ['-1', '-1', '-1', '-1', '0', '0', '0', '0', '1', '1', '1', '1', '2', '2', '2']], ['0', '0', '-1', '-1'], ['f32x4', 'i8x16', 'i32x4']])
+
+        # f32x4.gt  (f32x4) (i16x8)
+        case_data.append(['#', 'f32x4.gt  (f32x4) (i16x8)'])
+        case_data.append(['gt', [['-1', '0', '1', '2.0'], ['-1', '-1', '0', '0', '1', '1', '2']], ['0', '0', '-1', '-1'], ['f32x4', 'i16x8', 'i32x4']])
+
+        # f32x4.gt  (f32x4) (i32x4)
+        case_data.append(['#', 'f32x4.gt  (f32x4) (i32x4)'])
+        case_data.append(['gt', [['-1', '0', '1', '2.0'], ['3212836864', '0', '1', '2']], ['0', '0', '-1', '-1'], ['f32x4', 'i32x4', 'i32x4']])
+
+        # ge
+        case_data.append(['#', 'ge'])
+
+        # f32x4.ge  (f32x4) (i8x16)
+        case_data.append(['#', 'f32x4.ge  (f32x4) (i8x16)'])
+        case_data.append(['ge', [['-1', '0', '1', '2.0'], ['-1', '-1', '-1', '-1', '0', '0', '0', '0', '1', '1', '1', '1', '2', '2', '2']], ['0', '-1', '-1', '-1'], ['f32x4', 'i8x16', 'i32x4']])
+
+        # f32x4.ge  (f32x4) (i16x8)
+        case_data.append(['#', 'f32x4.ge  (f32x4) (i16x8)'])
+        case_data.append(['ge', [['-1', '0', '1', '2.0'], ['-1', '-1', '0', '0', '1', '1', '2']], ['0', '-1', '-1', '-1'], ['f32x4', 'i16x8', 'i32x4']])
+
+        # f32x4.ge  (f32x4) (i32x4)
+        case_data.append(['#', 'f32x4.ge  (f32x4) (i32x4)'])
+        case_data.append(['ge', [['-1', '0', '1', '2.0'], ['3212836864', '0', '1', '2']], ['-1', '-1', '-1', '-1'], ['f32x4', 'i32x4', 'i32x4']])
+
+        return case_data
+
+    def special_float2dec(self, p):
+        if p in ('0x0p+0', '-0x0p+0'):
+            return 0.0
+        if p == 'inf':
+            return float(340282366920938463463374607431768211456)
+        if p == '-inf':
+            return -float(340282366920938463463374607431768211456)
+
+        if '0x' in p:
+            f = float.fromhex(p)
+        else:
+            f = float(p)
+
+        return struct.unpack('f', struct.pack('f', f))[0]
+
+    def operate(self, op, p1, p2):
+        for p in (p1, p2):
+            if 'nan' in p:
+                if op == 'ne':
+                    return '-1'
+                else:
+                    return '0'
+
+        num1 = self.special_float2dec(p1)
+        num2 = self.special_float2dec(p2)
+
+        if op == 'eq':
+            if num1 == num2:
+                return '-1'
+
+        if op == 'ne':
+            if num1 != num2:
+                return '-1'
+        if op == 'lt':
+            if num1 < num2:
+                return '-1'
+        if op == 'le':
+            if num1 <= num2:
+                return '-1'
+        if op == 'gt':
+            if num1 > num2:
+                return '-1'
+        if op == 'ge':
+            if num1 >= num2:
+                return '-1'
+
+        return '0'
+
+
+def gen_test_cases():
+    f32x4 = Simdf32x4CmpCase()
+    f32x4.gen_test_cases()
+
+
+if __name__ == '__main__':
+    f32x4 = Simdf32x4CmpCase()
+    f32x4.gen_test_cases()
diff --git a/test/core/simd/meta/simd_f32x4_pmin_pmax.py b/test/core/simd/meta/simd_f32x4_pmin_pmax.py
new file mode 100644
index 000000000..42fa6229b
--- /dev/null
+++ b/test/core/simd/meta/simd_f32x4_pmin_pmax.py
@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+
+"""
+Generate f32x4 [pmin, pmax] cases.
+"""
+
+from simd_f32x4_arith import Simdf32x4ArithmeticCase
+from simd_float_op import FloatingPointSimpleOp
+from simd import SIMD
+from test_assert import AssertReturn
+
+
+class Simdf32x4PminPmaxCase(Simdf32x4ArithmeticCase):
+    UNARY_OPS = ()
+    BINARY_OPS = ('pmin', 'pmax',)
+    floatOp = FloatingPointSimpleOp()
+
+    def get_combine_cases(self):
+        return ''
+
+    def get_normal_case(self):
+        """Normal test cases from WebAssembly core tests.
+        """
+        cases = []
+        binary_test_data = []
+        unary_test_data = []
+
+        for op in self.BINARY_OPS:
+            op_name = self.full_op_name(op)
+            for operand1 in self.FLOAT_NUMBERS + self.LITERAL_NUMBERS:
+                for operand2 in self.FLOAT_NUMBERS + self.LITERAL_NUMBERS:
+                    result = self.floatOp.binary_op(op, operand1, operand2)
+                    binary_test_data.append([op_name, operand1, operand2, result])
+
+            # pmin and pmax always return operand1 if either operand is a nan
+            for operand1 in self.NAN_NUMBERS:
+                for operand2 in self.FLOAT_NUMBERS + self.LITERAL_NUMBERS + self.NAN_NUMBERS:
+                    binary_test_data.append([op_name, operand1, operand2, operand1])
+            for operand2 in self.NAN_NUMBERS:
+                for operand1 in self.FLOAT_NUMBERS + self.LITERAL_NUMBERS:
+                    binary_test_data.append([op_name, operand1, operand2, operand1])
+
+        for case in binary_test_data:
+            cases.append(str(AssertReturn(case[0],
+                        [SIMD.v128_const(c, self.LANE_TYPE) for c in case[1:-1]],
+                        SIMD.v128_const(case[-1], self.LANE_TYPE))))
+
+        self.get_unknown_operator_case(cases)
+
+        return '\n'.join(cases)
+
+    def get_unknown_operator_case(self, cases):
+        """Unknown operator cases.
+        """
+
+        tpl_assert = "(assert_malformed (module quote \"(memory 1) (func (result v128) " \
+                     "({lane_type}.{op} {value}))\") \"unknown operator\")"
+
+        unknown_op_cases = ['\n\n;; Unknown operators\n']
+        cases.extend(unknown_op_cases)
+
+        for lane_type in ['i8x16', 'i16x8', 'i32x4', 'i64x2']:
+
+            for op in self.BINARY_OPS:
+                cases.append(tpl_assert.format(lane_type=lane_type, op=op, value=' '.join([self.v128_const('i32x4', '0')]*2)))
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_{lane_type}_pmin_pmax.wast'.format(lane_type=self.LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            txt_test_case = self.get_all_cases()
+            txt_test_case = txt_test_case.replace(
+                    self.LANE_TYPE + ' arithmetic',
+                    self.LANE_TYPE + ' [pmin, pmax]')
+            fp.write(txt_test_case)
+
+
+def gen_test_cases():
+    simd_f32x4_pmin_pmax_case = Simdf32x4PminPmaxCase()
+    simd_f32x4_pmin_pmax_case.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_f32x4_rounding.py b/test/core/simd/meta/simd_f32x4_rounding.py
new file mode 100644
index 000000000..2512326d6
--- /dev/null
+++ b/test/core/simd/meta/simd_f32x4_rounding.py
@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+
+"""
+Generate f32x4 [ceil, floor, trunc, nearest] cases.
+"""
+
+from simd_f32x4_arith import Simdf32x4ArithmeticCase
+from simd_float_op import FloatingPointRoundingOp
+from simd import SIMD
+from test_assert import AssertReturn
+
+
+class Simdf32x4RoundingCase(Simdf32x4ArithmeticCase):
+    UNARY_OPS = ('ceil', 'floor', 'trunc', 'nearest')
+    BINARY_OPS = ()
+    floatOp = FloatingPointRoundingOp()
+
+    def get_combine_cases(self):
+        return ''
+
+    def get_normal_case(self):
+        """Normal test cases from WebAssembly core tests.
+        """
+        cases = []
+        unary_test_data = []
+
+        for op in self.UNARY_OPS:
+            op_name = self.full_op_name(op)
+            for operand in self.FLOAT_NUMBERS:
+                result = self.floatOp.unary_op(op, operand)
+                if 'nan' in result:
+                    unary_test_data.append([op_name, operand, 'nan:canonical'])
+                else:
+                    unary_test_data.append([op_name, operand, result])
+
+            for operand in self.LITERAL_NUMBERS:
+                result = self.floatOp.unary_op(op, operand, hex_form=False)
+                unary_test_data.append([op_name, operand, result])
+
+            for operand in self.NAN_NUMBERS:
+                if 'nan:' in operand:
+                    unary_test_data.append([op_name, operand, 'nan:arithmetic'])
+                else:
+                    unary_test_data.append([op_name, operand, 'nan:canonical'])
+
+        for case in unary_test_data:
+            cases.append(str(AssertReturn(case[0],
+                        [SIMD.v128_const(elem, self.LANE_TYPE) for elem in case[1:-1]],
+                        SIMD.v128_const(case[-1], self.LANE_TYPE))))
+
+        self.get_unknown_operator_case(cases)
+
+        return '\n'.join(cases)
+
+    def get_unknown_operator_case(self, cases):
+        """Unknown operator cases.
+        """
+
+        tpl_assert = "(assert_malformed (module quote \"(memory 1) (func (result v128) " \
+                     "({lane_type}.{op} {value}))\") \"unknown operator\")"
+
+        unknown_op_cases = ['\n\n;; Unknown operators\n']
+        cases.extend(unknown_op_cases)
+
+        for lane_type in ['i8x16', 'i16x8', 'i32x4', 'i64x2']:
+            for op in self.UNARY_OPS:
+                cases.append(tpl_assert.format(lane_type=lane_type, op=op, value=self.v128_const('i32x4', '0')))
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_{lane_type}_rounding.wast'.format(lane_type=self.LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            txt_test_case = self.get_all_cases()
+            txt_test_case = txt_test_case.replace(
+                    self.LANE_TYPE + ' arithmetic',
+                    self.LANE_TYPE + ' [ceil, floor, trunc, nearest]')
+            fp.write(txt_test_case)
+
+
+def gen_test_cases():
+    simd_f32x4_case = Simdf32x4RoundingCase()
+    simd_f32x4_case.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_f64x2.py b/test/core/simd/meta/simd_f64x2.py
new file mode 100644
index 000000000..e6b80ee2c
--- /dev/null
+++ b/test/core/simd/meta/simd_f64x2.py
@@ -0,0 +1,395 @@
+#!/usr/bin/env python3
+
+"""
+Generate f64x2 [abs, min, max] cases.
+"""
+
+from simd_f32x4 import Simdf32x4Case
+from simd_f32x4_arith import Simdf32x4ArithmeticCase
+from test_assert import AssertReturn
+from simd import SIMD
+
+
+class Simdf64x2Case(Simdf32x4Case):
+
+    LANE_TYPE = 'f64x2'
+
+    FLOAT_NUMBERS = (
+        '0x0p+0', '-0x0p+0', '0x1p-1074', '-0x1p-1074', '0x1p-1022', '-0x1p-1022', '0x1p-1', '-0x1p-1', '0x1p+0', '-0x1p+0',
+        '0x1.921fb54442d18p+2', '-0x1.921fb54442d18p+2', '0x1.fffffffffffffp+1023', '-0x1.fffffffffffffp+1023', 'inf', '-inf'
+    )
+    LITERAL_NUMBERS = ('01234567890123456789e038', '01234567890123456789e-038',
+                       '0123456789.e038', '0123456789.e+038',
+                       '-01234567890123456789.01234567890123456789'
+    )
+    NAN_NUMBERS = ('nan', '-nan', 'nan:0x4000000000000', '-nan:0x4000000000000')
+
+    def gen_test_func_template(self):
+
+        # Get function code
+        template = Simdf32x4ArithmeticCase.gen_test_func_template(self)
+
+        # Function template
+        tpl_func = '  (func (export "{func}"){params} (result v128) ({op} {operand_1}{operand_2}))'
+
+        # Raw data list specific for "const vs const" and "param vs const" tests"
+        const_test_raw_data = [
+            [
+                [['0', '1'], ['0', '2']],
+                [['0', '1'], ['0', '2']]
+            ],
+            [
+                [['2', '-3'], ['1', '3']],
+                [['1', '-3'], ['2', '3']]
+            ],
+            [
+                [['0', '1'], ['0', '1']],
+                [['0', '1'], ['0', '1']]
+            ],
+            [
+                [['2', '3'], ['2', '3']],
+                [['2', '3'], ['2', '3']]
+            ],
+            [
+                [['0x00', '0x01'], ['0x00', '0x02']],
+                [['0x00', '0x01'], ['0x00', '0x02']]
+            ],
+            [
+                [['0x02', '0x80000000'], ['0x01', '2147483648']],
+                [['0x01', '0x80000000'], ['0x02', '2147483648']]
+            ],
+            [
+                [['0x00', '0x01'], ['0x00', '0x01']],
+                [['0x00', '0x01'], ['0x00', '0x01']]
+            ],
+            [
+                [['0x02', '0x80000000'], ['0x02', '0x80000000']],
+                [['0x02', '0x80000000'], ['0x02', '0x80000000']]
+            ]
+        ]
+
+        # Test data list combined with `const_test_raw_data` and corresponding ops and function names
+        # specific for "const vs const" and "param vs const" tests
+        const_test_data = {}
+
+        # Generate func and assert
+        for op in self.BINARY_OPS:
+
+            op_name = self.full_op_name(op)
+
+            # Add comment for the case script "  ;; [f64x2.min, f64x2.max] const vs const"
+            template.insert(len(template)-1, '  ;; {} const vs const'.format(op_name))
+
+            # Add const vs const cases
+            for case_data in const_test_raw_data:
+
+                func = "{op}_with_const_{index}".format(op=op_name, index=len(template)-7)
+                template.insert(len(template)-1,
+                                tpl_func.format(func=func, params='', op=op_name,
+                                                operand_1=self.v128_const('f64x2', case_data[0][0]),
+                                                operand_2=' ' + self.v128_const('f64x2', case_data[0][1])))
+
+                ret_idx = 0 if op == 'min' else 1
+
+                if op not in const_test_data:
+                    const_test_data[op] = []
+
+                const_test_data[op].append([func, case_data[1][ret_idx]])
+
+            # Add comment for the case script "  ;; [f64x2.min, f64x2.max] param vs const"
+            template.insert(len(template)-1, '  ;; {} param vs const'.format(op_name))
+
+            case_cnt = 0
+
+            # Add param vs const cases
+            for case_data in const_test_raw_data:
+
+                func = "{op}_with_const_{index}".format(op=op_name, index=len(template)-7)
+
+                # Cross parameters and constants
+                if case_cnt in (0, 3):
+                    operand_1 = '(local.get 0)'
+                    operand_2 = self.v128_const('f64x2', case_data[0][0])
+                else:
+                    operand_1 = self.v128_const('f64x2', case_data[0][0])
+                    operand_2 = '(local.get 0)'
+
+                template.insert(len(template)-1,
+                                tpl_func.format(func=func, params=' (param v128)', op=op_name,
+                                                operand_1=operand_1, operand_2=' ' + operand_2))
+
+                ret_idx = 0 if op == 'min' else 1
+
+                if op not in const_test_data:
+                    const_test_data[op] = []
+
+                const_test_data[op].append([func, case_data[0][1], case_data[1][ret_idx]])
+
+                case_cnt += 1
+
+        # Generate func for abs
+        op_name = self.full_op_name('abs')
+        template.insert(len(template)-1, '')
+        func = "{op}_with_const_{index}".format(op=op_name, index=35)
+        template.insert(len(template)-1,
+                        tpl_func.format(func=func, params='', op=op_name,
+                                        operand_1=self.v128_const('f64x2', ['-0', '-1']), operand_2=''))
+        func = "{op}_with_const_{index}".format(op=op_name, index=36)
+        template.insert(len(template)-1,
+                        tpl_func.format(func=func, params='', op=op_name,
+                                        operand_1=self.v128_const('f64x2', ['-2', '-3']), operand_2=''))
+
+        # Test different lanes go through different if-then clauses
+        lst_diff_lane_vs_clause = [
+            [
+                'f64x2.min',
+                [['nan', '0'], ['0', '1']],
+                [['nan:canonical', '0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.min',
+                [['0', '1'], ['-nan', '0']],
+                [['nan:canonical', '0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.min',
+                [['0', '1'], ['-nan', '1']],
+                [['nan:canonical', '1']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.max',
+                [['nan', '0'], ['0', '1']],
+                [['nan:canonical', '1']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.max',
+                [['0', '1'], ['-nan', '0']],
+                [['nan:canonical', '1']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.max',
+                [['0', '1'], ['-nan', '1']],
+                [['nan:canonical', '1']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ]
+        ]
+
+        # Template for assert
+        tpl_assert = '(assert_return\n' \
+                     '  (invoke "{func}"\n' \
+                     '    {operand_1}\n' \
+                     '    {operand_2}\n' \
+                     '  )\n' \
+                     '  {expected_result}\n' \
+                     ')'
+
+        lst_diff_lane_vs_clause_assert = []
+
+        # Add comment in wast script
+        lst_diff_lane_vs_clause_assert.append('')
+        lst_diff_lane_vs_clause_assert.append(';; Test different lanes go through different if-then clauses')
+
+        for case_data in lst_diff_lane_vs_clause:
+
+            lst_diff_lane_vs_clause_assert.append(';; {lane_type}'.format(lane_type=case_data[0]))
+
+            lst_diff_lane_vs_clause_assert.append(tpl_assert.format(
+                func=case_data[0],
+                operand_1=self.v128_const(case_data[3][0], case_data[1][0]),
+                operand_2=self.v128_const(case_data[3][1], case_data[1][1]),
+                expected_result=self.v128_const(case_data[3][2], case_data[2][0])
+            ))
+
+        lst_diff_lane_vs_clause_assert.append('')
+
+        # Add test for operations with constant operands
+        for key in const_test_data:
+            op_name = self.full_op_name(key)
+            case_cnt = 0
+            for case_data in const_test_data[key]:
+
+                # Add comment for the param combination
+                if case_cnt == 0:
+                    template.append(';; {} const vs const'.format(op_name))
+                if case_cnt == 4:
+                    template.append(';; {} param vs const'.format(op_name))
+
+                # Cross parameters and constants
+                if case_cnt < 8:
+                    template.append(str(AssertReturn(case_data[0], [], self.v128_const('f64x2', case_data[1]))))
+                else:
+                    template.append(str(AssertReturn(case_data[0], [self.v128_const('f64x2', case_data[1])], self.v128_const('f64x2', case_data[2]))))
+                case_cnt += 1
+
+        # Generate and append f64x2.abs assert
+        op_name = self.full_op_name('abs')
+        template.append('')
+        func = "{op}_with_const_{index}".format(op=op_name, index=35)
+        template.append(str(AssertReturn(func, [], self.v128_const('f64x2', ['0', '1']))))
+        func = "{op}_with_const_{index}".format(op=op_name, index=36)
+        template.append(str(AssertReturn(func, [], self.v128_const('f64x2', ['2', '3']))))
+
+        template.extend(lst_diff_lane_vs_clause_assert)
+
+        return template
+
+    @property
+    def combine_ternary_arith_test_data(self):
+        # This method overrides the base class method from SimdArithmeticCase
+        # used for generating test data for min and max combination tests.
+        return {
+            'min-max': [
+                ['1.125'] * 2, ['0.25'] * 2, ['0.125'] * 2, ['0.125'] * 2
+            ],
+            'max-min': [
+                ['1.125'] * 2, ['0.25'] * 2, ['0.125'] * 2, ['0.25'] * 2
+            ]
+        }
+
+    @property
+    def combine_binary_arith_test_data(self):
+        # This method overrides the base class method from SimdArithmeticCase
+        # used for generating test data for min, max and abs combination tests.
+        return {
+            'min-abs': [
+                ['-1.125'] * 2, ['0.125'] * 2, ['0.125'] * 2
+            ],
+            'max-abs': [
+                ['-1.125'] * 2, ['0.125'] * 2, ['1.125'] * 2
+            ]
+        }
+
+    def get_normal_case(self):
+        """Normal test cases from WebAssembly core tests
+        """
+        cases = []
+        binary_test_data = []
+        unary_test_data = []
+
+        for op in self.BINARY_OPS:
+            op_name = self.full_op_name(op)
+            for operand1 in self.FLOAT_NUMBERS:
+                for operand2 in self.FLOAT_NUMBERS:
+                    result = self.floatOp.binary_op(op, operand1, operand2)
+                    if 'nan' not in result:
+                        # Normal floating point numbers as the results
+                        binary_test_data.append([op_name, operand1, operand2, result])
+                    else:
+                        # Since the results contain the 'nan' string, the result literals would be
+                        # nan:canonical
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:canonical'])
+
+            for operand1 in self.NAN_NUMBERS:
+                for operand2 in self.FLOAT_NUMBERS:
+                    if 'nan:' in operand1 or 'nan:' in operand2:
+                        # When the arguments contain 'nan:', the result literal is nan:arithmetic
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:arithmetic'])
+                    else:
+                        # No 'nan' string found, then the result literal is nan:canonical
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:canonical'])
+                for operand2 in self.NAN_NUMBERS:
+                    if 'nan:' in operand1 or 'nan:' in operand2:
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:arithmetic'])
+                    else:
+                        binary_test_data.append([op_name, operand1, operand2, 'nan:canonical'])
+
+            for operand1 in self.LITERAL_NUMBERS:
+                for operand2 in self.LITERAL_NUMBERS:
+                    result = self.floatOp.binary_op(op, operand1, operand2, hex_form=False)
+                    binary_test_data.append([op_name, operand1, operand2, result])
+
+        for case in binary_test_data:
+            cases.append(str(AssertReturn(case[0],
+                        [SIMD.v128_const(elem, self.LANE_TYPE) for elem in case[1:-1]],
+                        SIMD.v128_const(case[-1], self.LANE_TYPE))))
+
+        # Test opposite signs of zero
+        lst_oppo_signs_0 = [
+            '\n;; Test opposite signs of zero',
+            [
+                'f64x2.min',
+                [['0', '0'], ['+0', '-0']],
+                [['0', '-0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.min',
+                [['-0', '+0'], ['+0', '-0']],
+                [['-0', '-0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.min',
+                [['-0', '-0'], ['+0', '+0']],
+                [['-0', '-0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.max',
+                [['0', '0'], ['+0', '-0']],
+                [['0', '0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.max',
+                [['-0', '+0'], ['+0', '-0']],
+                [['0', '0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.max',
+                [['-0', '-0'], ['+0', '+0']],
+                [['+0', '+0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            '\n'
+        ]
+
+        # Generate test case for opposite signs of zero
+        for case_data in lst_oppo_signs_0:
+
+            if isinstance(case_data, str):
+                cases.append(case_data)
+                continue
+
+            cases.append(str(AssertReturn(case_data[0],
+                                          [self.v128_const(case_data[3][0], case_data[1][0]),
+                                           self.v128_const(case_data[3][1], case_data[1][1])],
+                                          self.v128_const(case_data[3][2], case_data[2][0]))))
+
+        for p in self.FLOAT_NUMBERS + self.LITERAL_NUMBERS:
+            op_name = self.full_op_name('abs')
+            hex_literal = True
+            if p in self.LITERAL_NUMBERS:
+                hex_literal = False
+            result = self.floatOp.unary_op('abs', p, hex_form=hex_literal)
+            # Abs operation is valid for all the floating point numbers
+            unary_test_data.append([ op_name, p, result])
+
+        for case in unary_test_data:
+            cases.append(str(AssertReturn(case[0],
+                        [SIMD.v128_const(c, self.LANE_TYPE) for c in case[1:-1]],
+                        SIMD.v128_const(case[-1], self.LANE_TYPE))))
+
+        return '\n'.join(cases)
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_{lane_type}.wast'.format(lane_type=self.LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            txt_test_case = self.get_all_cases()
+            txt_test_case = txt_test_case.replace('f64x2 arithmetic', 'f64x2 [abs, min, max]')
+            fp.write(txt_test_case)
+
+
+def gen_test_cases():
+    simd_f64x2_case = Simdf64x2Case()
+    simd_f64x2_case.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
\ No newline at end of file
diff --git a/test/core/simd/meta/simd_f64x2_arith.py b/test/core/simd/meta/simd_f64x2_arith.py
new file mode 100644
index 000000000..df29d7b2d
--- /dev/null
+++ b/test/core/simd/meta/simd_f64x2_arith.py
@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+
+"""
+Generate f32x4 floating-point arithmetic operation cases.
+"""
+
+from simd_f32x4_arith import Simdf32x4ArithmeticCase
+from simd_float_op import FloatingPointArithOp
+
+
+class F64ArithOp(FloatingPointArithOp):
+    maximum = '0x1.fffffffffffffp+1023'
+
+
+class Simdf64x2ArithmeticCase(Simdf32x4ArithmeticCase):
+
+    LANE_LEN = 2
+    LANE_TYPE = 'f64x2'
+
+    floatOp = F64ArithOp()
+
+    FLOAT_NUMBERS = (
+        '0x0p+0', '-0x0p+0', '0x1p-1022', '-0x1p-1022', '0x1p-1', '-0x1p-1', '0x1p+0', '-0x1p+0',
+        '0x1.921fb54442d18p+2', '-0x1.921fb54442d18p+2', '0x1.fffffffffffffp+1023', '-0x1.fffffffffffffp+1023',
+        '0x0.0000000000001p-1022', '0x0.0000000000001p-1022', 'inf', '-inf'
+    )
+    LITERAL_NUMBERS = ('0123456789', '0123456789e019', '0123456789e+019', '0123456789e-019',
+                       '0123456789.', '0123456789.e019', '0123456789.e+019', '0123456789.e-019',
+                       '0123456789.0123456789', '0123456789.0123456789e019',
+                       '0123456789.0123456789e+019', '0123456789.0123456789e-019',
+                       '0x0123456789ABCDEFabcdef', '0x0123456789ABCDEFabcdefp019',
+                       '0x0123456789ABCDEFabcdefp+019', '0x0123456789ABCDEFabcdefp-019',
+                       '0x0123456789ABCDEFabcdef.', '0x0123456789ABCDEFabcdef.p019',
+                       '0x0123456789ABCDEFabcdef.p+019', '0x0123456789ABCDEFabcdef.p-019',
+                       '0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef',
+                       '0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019',
+                       '0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019',
+                       '0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019'
+    )
+    NAN_NUMBERS = ('nan', '-nan', 'nan:0x4000000000000', '-nan:0x4000000000000')
+
+    @staticmethod
+    def v128_const(lane, value):
+        return '(v128.const {lane_type} {value})'.format(lane_type=lane, value=' '.join([str(value)] * 2))
+
+    @property
+    def combine_ternary_arith_test_data(self):
+        return {
+            'add-sub': [
+                ['1.125'] * 2, ['0.25'] * 2, ['0.125'] * 2, ['1.0'] * 2
+            ],
+            'sub-add': [
+                ['1.125'] * 2, ['0.25'] * 2, ['0.125'] * 2, ['1.25'] * 2
+            ],
+            'mul-add': [
+                ['1.25'] * 2, ['0.25'] * 2, ['0.25'] * 2, ['0.375'] * 2
+            ],
+            'mul-sub': [
+                ['1.125'] * 2, ['0.125'] * 2, ['0.25'] * 2, ['0.25'] * 2
+            ],
+            'div-add': [
+                ['1.125'] * 2, ['0.125'] * 2, ['0.25'] * 2, ['5.0'] * 2
+            ],
+            'div-sub': [
+                ['1.125'] * 2, ['0.125'] * 2, ['0.25'] * 2, ['4.0'] * 2
+            ],
+            'mul-div': [
+                ['1.125'] * 2, ['0.125'] * 2, ['0.25'] * 2, ['2.25'] * 2
+            ],
+            'div-mul': [
+                ['1.125'] * 2, ['4'] * 2, ['0.25'] * 2, ['18.0'] * 2
+            ]
+        }
+
+    @property
+    def combine_binary_arith_test_data(self):
+        return {
+            'add-neg': [
+                ['1.125'] * 2, ['0.125'] * 2, ['-1.0'] * 2
+            ],
+            'sub-neg': [
+                ['1.125'] * 2, ['0.125'] * 2, ['-1.25'] * 2
+            ],
+            'mul-neg': [
+                ['1.5'] * 2, ['0.25'] * 2, ['-0.375'] * 2
+            ],
+            'div-neg': [
+                ['1.5'] * 2, ['0.25'] * 2, ['-6'] * 2
+            ],
+            'add-sqrt': [
+                ['2.25'] * 2, ['0.25'] * 2, ['1.75'] * 2
+            ],
+            'sub-sqrt': [
+                ['2.25'] * 2, ['0.25'] * 2, ['1.25'] * 2
+            ],
+            'mul-sqrt': [
+                ['2.25'] * 2, ['0.25'] * 2, ['0.375'] * 2
+            ],
+            'div-sqrt': [
+                ['2.25'] * 2, ['0.25'] * 2, ['6'] * 2
+            ]
+        }
+
+    def get_invalid_cases(self):
+        return super().get_invalid_cases().replace('32', '64')
+
+    @property
+    def mixed_nan_test_data(self):
+        return {
+            'neg_canon': [
+                ('nan', '1.0'), ('nan:canonical', '-1.0'),
+            ],
+            'sqrt_canon': [
+                ('4.0', '-nan'), ('2.0', 'nan:canonical'),
+            ],
+            'add_arith': [
+                ('nan:0x8000000000000', '1.0'), ('nan', '1.0'),
+                ('nan:arithmetic', '2.0'),
+            ],
+            'sub_arith': [
+                ('1.0', '-1.0'), ('-nan', '1.0'), ('nan:canonical', '-2.0'),
+            ],
+            'mul_mixed': [
+                ('nan:0x8000000000000', '1.0'), ('2.0', 'nan'),
+                ('nan:arithmetic', 'nan:canonical')
+            ],
+            'div_mixed': [
+                ('nan', '1.0'), ('2.0', '-nan:0x8000000000000'),
+                ('nan:canonical', 'nan:arithmetic')
+            ]
+        }
+
+    def mixed_nan_test(self, cases):
+        """Mixed f64x2 tests when only expects NaNs in a subset of lanes."""
+        mixed_cases = [
+            '\n;; Mixed f64x2 tests when some lanes are NaNs', '(module']
+        for test_type, test_data in sorted(self.mixed_nan_test_data.items()):
+            op = test_type.split('_')[0]
+            if op in self.UNARY_OPS:
+                mixed_cases.extend([
+                    '  (func (export "{lane}_{t}") (result v128)'.format(lane=self.LANE_TYPE, t=test_type),
+                    '    ({lane}.{op} (v128.const {lane} {param})))'.format(
+                        lane=self.LANE_TYPE, op=op, param=' '.join(test_data[0]))])
+            if op in self.BINARY_OPS:
+                mixed_cases.extend([
+                    '  (func (export "{lane}_{t}") (result v128)'.format(lane=self.LANE_TYPE, t=test_type),
+                    '    ({lane}.{op} (v128.const {lane} {param1}) (v128.const {lane} {param2})))'.format(
+                        lane=self.LANE_TYPE, op=op,
+                        param1=' '.join(test_data[0]),
+                        param2=' '.join(test_data[1]))])
+        mixed_cases.append(')\n')
+        for test_type, test_data in sorted(self.mixed_nan_test_data.items()):
+            mixed_cases.append('(assert_return (invoke "{lane}_{t}") (v128.const {lane} {result}))'.format(
+                lane=self.LANE_TYPE, t=test_type, result=' '.join(test_data[-1])
+            ))
+        cases.extend(mixed_cases)
+
+
+def gen_test_cases():
+    simd_f64x2_arith = Simdf64x2ArithmeticCase()
+    simd_f64x2_arith.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
\ No newline at end of file
diff --git a/test/core/simd/meta/simd_f64x2_cmp.py b/test/core/simd/meta/simd_f64x2_cmp.py
new file mode 100644
index 000000000..10ae36484
--- /dev/null
+++ b/test/core/simd/meta/simd_f64x2_cmp.py
@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+
+"""
+This file is used for generating simd_f64x2_cmp.wast file.
+Which inherites from `SimdArithmeticCase` class, overloads
+the `get_test_cases` method, and reset the Test Case template.
+The reason why this is different from other cmp files is that
+f64x2 only has 6 comparison instructions but with amounts of
+test datas.
+"""
+
+from simd_arithmetic import SimdArithmeticCase
+from simd_float_op import FloatingPointCmpOp
+from test_assert import AssertReturn
+from simd import SIMD
+
+
+class Simdf64x2CmpCase(SimdArithmeticCase):
+    LANE_LEN = 4
+    LANE_TYPE = 'f64x2'
+
+    UNARY_OPS = ()
+    BINARY_OPS = ('eq', 'ne', 'lt', 'le', 'gt', 'ge',)
+    floatOp = FloatingPointCmpOp()
+
+    FLOAT_NUMBERS_SPECIAL = ('0x1p-1074', '-inf', '0x1.921fb54442d18p+2',
+                             '0x1p+0', '-0x1.fffffffffffffp+1023', '-0x0p+0', '-0x1p-1', '0x1.fffffffffffffp+1023',
+                             '-0x1p-1074', '-0x1p-1022', '0x1p-1', '-0x1.921fb54442d18p+2',
+                             '0x0p+0', 'inf', '-0x1p+0', '0x1p-1022'
+                            )
+    LITERAL_NUMBERS = ('01234567890123456789e038', '01234567890123456789e-038',
+                       '0123456789.e038', '0123456789.e+038',
+                       '01234567890123456789.01234567890123456789'
+
+    )
+    FLOAT_NUMBERS_NORMAL = ('-1', '0', '1', '2.0')
+    NAN_NUMBERS = ('nan', '-nan', 'nan:0x4000000000000', '-nan:0x4000000000000')
+
+    def full_op_name(self, op_name):
+        return self.LANE_TYPE + '.' + op_name
+
+    @staticmethod
+    def v128_const(lane, value):
+        lane_cnt = 2 if lane in ['f64x2', 'i64x2'] else 4
+        return '(v128.const {lane_type} {value})'.format(lane_type=lane, value=' '.join([str(value)] * lane_cnt))
+
+    @property
+    def combine_ternary_arith_test_data(self):
+        return {}
+
+    @property
+    def combine_binary_arith_test_data(self):
+        return ['f64x2.eq', 'f64x2.ne', 'f64x2.lt', 'f64x2.le', 'f64x2.gt', 'f64x2.ge']
+
+    def get_combine_cases(self):
+        combine_cases = [';; combination\n(module (memory 1)']
+
+        # append funcs
+        binary_func_template = '  (func (export "{op}-in-block")\n' \
+                             '    (block\n' \
+                             '      (drop\n' \
+                             '        (block (result v128)\n' \
+                             '          ({op}\n' \
+                             '            (block (result v128) (v128.load (i32.const 0)))\n' \
+                             '            (block (result v128) (v128.load (i32.const 1)))\n' \
+                             '          )\n' \
+                             '        )\n' \
+                             '      )\n' \
+                             '    )\n' \
+                             '  )'
+        for func in self.combine_binary_arith_test_data:
+            combine_cases.append(binary_func_template.format(op=func))
+
+        binary_func_template = '  (func (export "nested-{func}")\n' \
+                             '    (drop\n' \
+                             '      ({func}\n' \
+                             '        ({func}\n' \
+                             '          ({func}\n' \
+                             '            (v128.load (i32.const 0))\n' \
+                             '            (v128.load (i32.const 1))\n' \
+                             '          )\n' \
+                             '          ({func}\n' \
+                             '            (v128.load (i32.const 2))\n' \
+                             '            (v128.load (i32.const 3))\n' \
+                             '          )\n' \
+                             '        )\n' \
+                             '        ({func}\n' \
+                             '          ({func}\n' \
+                             '            (v128.load (i32.const 0))\n' \
+                             '            (v128.load (i32.const 1))\n' \
+                             '          )\n' \
+                             '          ({func}\n' \
+                             '            (v128.load (i32.const 2))\n' \
+                             '            (v128.load (i32.const 3))\n' \
+                             '          )\n' \
+                             '        )\n' \
+                             '      )\n' \
+                             '    )\n' \
+                             '  )' \
+
+        for func in self.combine_binary_arith_test_data:
+            combine_cases.append(binary_func_template.format(func=func))
+
+        combine_cases.append('  (func (export "as-param")\n'
+                             '    (drop\n'
+                             '      (f64x2.eq\n'
+                             '        (f64x2.ne\n'
+                             '          (f64x2.lt\n'
+                             '            (v128.load (i32.const 0))\n'
+                             '            (v128.load (i32.const 1))\n'
+                             '          )\n'
+                             '          (f64x2.le\n'
+                             '            (v128.load (i32.const 2))\n'
+                             '            (v128.load (i32.const 3))\n'
+                             '          )\n'
+                             '        )\n'
+                             '        (f64x2.gt\n'
+                             '          (f64x2.ge\n'
+                             '            (v128.load (i32.const 0))\n'
+                             '            (v128.load (i32.const 1))\n'
+                             '          )\n'
+                             '          (f64x2.eq\n'
+                             '            (v128.load (i32.const 2))\n'
+                             '            (v128.load (i32.const 3))\n'
+                             '          )\n'
+                             '        )\n'
+                             '      )\n'
+                             '    )\n'
+                             '  )')
+
+        combine_cases.append(')')
+
+        # append assert
+        binary_case_template = ('(assert_return (invoke "{func}-in-block"))')
+        for func in self.combine_binary_arith_test_data:
+            combine_cases.append(binary_case_template.format(func=func))
+
+        binary_case_template = ('(assert_return (invoke "nested-{func}"))')
+        for func in self.combine_binary_arith_test_data:
+            combine_cases.append(binary_case_template.format(func=func))
+
+        combine_cases.append('(assert_return (invoke "as-param"))\n')
+
+        return '\n'.join(combine_cases)
+
+    def get_normal_case(self):
+        """Normal test cases from WebAssembly core tests
+        """
+        cases = []
+        binary_test_data = []
+        unary_test_data = []
+
+        for op in self.BINARY_OPS:
+            op_name = self.full_op_name(op)
+            for operand1 in self.FLOAT_NUMBERS_SPECIAL:
+                for operand2 in self.FLOAT_NUMBERS_SPECIAL + self.NAN_NUMBERS:
+                    result = self.floatOp.binary_op(op, operand1, operand2)
+                    binary_test_data.append([op_name, operand1, operand2, result])
+
+            for operand1 in self.LITERAL_NUMBERS:
+                for operand2 in self.LITERAL_NUMBERS:
+                    result = self.floatOp.binary_op(op, operand1, operand2)
+                    binary_test_data.append([op_name, operand1, operand2, result])
+
+            for operand1 in self.NAN_NUMBERS:
+                for operand2 in self.FLOAT_NUMBERS_SPECIAL + self.NAN_NUMBERS:
+                    result = self.floatOp.binary_op(op, operand1, operand2)
+                    binary_test_data.append([op_name, operand1, operand2, result])
+
+        for op in self.BINARY_OPS:
+            op_name = self.full_op_name(op)
+            for operand1 in self.FLOAT_NUMBERS_NORMAL:
+                for operand2 in self.FLOAT_NUMBERS_NORMAL:
+                    result = self.floatOp.binary_op(op, operand1, operand2)
+                    binary_test_data.append([op_name, operand1, operand2, result])
+
+        for case in binary_test_data:
+            cases.append(str(AssertReturn(case[0],
+                        [SIMD.v128_const(elem, self.LANE_TYPE) for elem in case[1:-1]],
+                        SIMD.v128_const(case[-1], 'i64x2'))))
+
+        for case in unary_test_data:
+            cases.append(str(AssertReturn(case[0],
+                        [SIMD.v128_const(elem, self.LANE_TYPE) for elem in case[1:-1]],
+                        SIMD.v128_const(case[-1], 'i64x2'))))
+
+        self.get_unknown_operator_case(cases)
+
+        return '\n'.join(cases)
+
+    def get_unknown_operator_case(self, cases):
+        """Unknown operator cases.
+        """
+
+        tpl_assert = "(assert_malformed (module quote \"(memory 1) (func " \
+                     " (param $x v128) (param $y v128) (result v128) " \
+                     "({lane_type}.{op} (local.get $x) (local.get $y)))\") \"unknown operator\")"
+
+        cases.append('\n\n;; unknown operators')
+
+        for lane_type in ['f2x64']:
+            for op in self.BINARY_OPS:
+                cases.append(tpl_assert.format(lane_type=lane_type,
+                                               op=op))
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_{lane_type}_cmp.wast'.format(lane_type=self.LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            txt_test_case = self.get_all_cases()
+            txt_test_case = txt_test_case.replace('f64x2 arithmetic', 'f64x2 comparison')
+            fp.write(txt_test_case)
+
+
+def gen_test_cases():
+    simd_f64x2_cmp = Simdf64x2CmpCase()
+    simd_f64x2_cmp.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
\ No newline at end of file
diff --git a/test/core/simd/meta/simd_f64x2_pmin_pmax.py b/test/core/simd/meta/simd_f64x2_pmin_pmax.py
new file mode 100644
index 000000000..c97badd48
--- /dev/null
+++ b/test/core/simd/meta/simd_f64x2_pmin_pmax.py
@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+
+"""
+Generate f64x2 [pmin, pmax] cases.
+"""
+
+from simd_f32x4_pmin_pmax import Simdf32x4PminPmaxCase
+from simd_f64x2_arith import Simdf64x2ArithmeticCase
+from simd_float_op import FloatingPointSimpleOp
+from simd import SIMD
+from test_assert import AssertReturn
+
+
+class Simdf64x2PminPmaxCase(Simdf32x4PminPmaxCase):
+    LANE_TYPE = 'f64x2'
+    FLOAT_NUMBERS = Simdf64x2ArithmeticCase.FLOAT_NUMBERS
+    LITERAL_NUMBERS = Simdf64x2ArithmeticCase.LITERAL_NUMBERS
+    NAN_NUMBERS = Simdf64x2ArithmeticCase.NAN_NUMBERS
+
+
+def gen_test_cases():
+    simd_f64x2_pmin_pmax_case = Simdf64x2PminPmaxCase()
+    simd_f64x2_pmin_pmax_case.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_f64x2_rounding.py b/test/core/simd/meta/simd_f64x2_rounding.py
new file mode 100644
index 000000000..a0a389e2f
--- /dev/null
+++ b/test/core/simd/meta/simd_f64x2_rounding.py
@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+
+"""
+Generate f64x2 [ceil, floor, trunc, nearest] cases.
+"""
+
+from simd_f32x4_rounding import Simdf32x4RoundingCase
+from simd_f64x2 import Simdf64x2Case
+from simd_f64x2_arith import Simdf64x2ArithmeticCase
+from simd_float_op import FloatingPointRoundingOp
+from simd import SIMD
+from test_assert import AssertReturn
+
+
+class Simdf64x2RoundingCase(Simdf32x4RoundingCase):
+
+    LANE_TYPE = 'f64x2'
+    FLOAT_NUMBERS = Simdf64x2ArithmeticCase.FLOAT_NUMBERS
+    LITERAL_NUMBERS = Simdf64x2ArithmeticCase.LITERAL_NUMBERS
+    NAN_NUMBERS = Simdf64x2ArithmeticCase.NAN_NUMBERS
+
+
+def gen_test_cases():
+    simd_f64x2_case = Simdf64x2RoundingCase()
+    simd_f64x2_case.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_float_op.py b/test/core/simd/meta/simd_float_op.py
new file mode 100644
index 000000000..4e65443a6
--- /dev/null
+++ b/test/core/simd/meta/simd_float_op.py
@@ -0,0 +1,303 @@
+#!/usr/bin/env python3
+
+"""Common floating-point number operations for f32x4 and f64x2"""
+
+from abc import abstractmethod
+import math
+import struct
+
+
+class FloatingPointOp:
+
+    maximum = None
+
+    @abstractmethod
+    def binary_op(self, op: str, p1: str, p2: str) -> str:
+        pass
+
+    def of_string(self, value: str) -> float:
+        if '0x' in value:
+            return float.fromhex(value)
+        else:
+            return float(value)
+
+    def is_hex(self, value:str) -> bool:
+        return '0x' in value
+
+    def to_single_precision(self, value: float) -> str:
+        # Python only has doubles, when reading in float, we need to convert to
+        # single-precision first.
+        return struct.unpack('f', struct.pack('f', value))[0]
+
+
+class FloatingPointArithOp(FloatingPointOp):
+    """Common arithmetic ops for both f32x4 and f64x2:
+        neg, sqrt, add, sub, mul, div
+    """
+
+    def binary_op(self, op: str, p1: str, p2: str, single_prec=False) -> str:
+        """Binary operation on p1 and p2 with the operation specified by op
+
+        :param op: add, sub, mul, div
+        :param p1: float number in hex
+        :param p2: float number in hex
+        :return:
+        """
+        hex_form = self.is_hex(p1) or self.is_hex(p2)
+        f1 = self.of_string(p1)
+        f2 = self.of_string(p2)
+
+        if op == 'add':
+            if 'inf' in p1 and 'inf' in p2 and p1 != p2:
+                return '-nan'
+            result = f1 + f2
+
+        elif op == 'sub':
+            if 'inf' in p1 and 'inf' in p2 and p1 == p2:
+                return '-nan'
+            result = f1 - f2
+
+        elif op == 'mul':
+            if '0x0p+0' in p1 and 'inf' in p2 or 'inf' in p1 and '0x0p+0' in p2:
+                return '-nan'
+            if single_prec:
+                # For some literals, f32x4.mul operation may cause precision lost.
+                # Use struct.unpack('f', struct.pack('f', literal)) to compensate
+                # single precision lost of f32
+                f1 = struct.unpack('f', struct.pack('f', f1))[0]
+                f2 = struct.unpack('f', struct.pack('f', f2))[0]
+                result = struct.unpack('f', struct.pack('f', f1 * f2))[0]
+            else:
+                result = f1 * f2
+
+        elif op == 'div':
+            if '0x0p+0' in p1 and '0x0p+0' in p2:
+                return '-nan'
+            if 'inf' in p1 and 'inf' in p2:
+                return '-nan'
+
+            try:
+                result = f1 / f2
+                return self.get_valid_float(result, self.maximum, hex_form)
+            except ZeroDivisionError:
+                if p1[0] == p2[0]:
+                    return 'inf'
+                elif p1 == 'inf' and p2 == '0x0p+0':
+                    return 'inf'
+                else:
+                    return '-inf'
+
+        else:
+            raise Exception('Unknown binary operation')
+
+        return self.get_valid_float(result, self.maximum, hex_form)
+
+    def get_valid_float(self, value, maximum_literals, hex_form=False):
+        if value > float.fromhex(maximum_literals):
+            return 'inf'
+        if value < float.fromhex('-' + maximum_literals):
+            return '-inf'
+
+        if hex_form:
+            return value.hex()
+        else:
+            return str(value)
+
+    def float_sqrt(self, p):
+        if p == '-0x0p+0':
+            return '-0x0p+0'
+
+        try:
+            if '0x' in p:
+                f = float.fromhex(p)
+                result = float.hex(math.sqrt(f))
+            else:
+                f = float(p)
+                result = str(math.sqrt(f))
+        except ValueError:
+            result = '-nan'
+
+        return result
+
+    def float_neg(self, p):
+        if p == 'nan':
+            return '-nan'
+        try:
+            if '0x' in p:
+                f = float.fromhex(p)
+                result = float.hex(-f)
+            else:
+                f = float(p)
+                result = str(-f)
+        except ValueError:
+            if p.startswith('nan:'):
+                return '-' + p
+            if p.startswith('-nan:'):
+                return p[1:]
+
+        return result
+
+
+class FloatingPointSimpleOp(FloatingPointOp):
+    """Common simple ops for both f32x4 and f64x2: abs, min, max, pmin, pmax"""
+
+    def binary_op(self, op: str, p1: str, p2: str, hex_form=True) -> str:
+        """Binary operation on p1 and p2 with the operation specified by op
+
+        :param op: min, max,
+        :param p1: float number in hex
+        :param p2: float number in hex
+        :return:
+        """
+        f1 = self.of_string(p1)
+        f2 = self.of_string(p2)
+
+        if '-nan' in [p1, p2] and 'nan' in [p1, p2]:
+            return p1
+
+        if 'nan' in [p1, p2]:
+            return 'nan'
+
+        if '-nan' in [p1, p2]:
+            return '-nan'
+
+        # pmin and pmax semantics follow C++'s std::min std::max
+        if op == 'pmin':
+            r = f2 if f2 < f1 else f1
+            if hex_form:
+                return r.hex()
+            else:
+                return str(r)
+
+        if op == 'pmax':
+            r = f2 if f1 < f2 else f1
+            if hex_form:
+                return r.hex()
+            else:
+                return str(r)
+
+        if op == 'min':
+            if '-0x0p+0' in [p1, p2] and '0x0p+0' in [p1, p2]:
+                return '-0x0p+0'
+            if hex_form:
+                return min(f1, f2).hex()
+            else:
+                return p1 if f1 <= f2 else p2
+
+        elif op == 'max':
+            if '-0x0p+0' in [p1, p2] and '0x0p+0' in [p1, p2]:
+                return '0x0p+0'
+            if hex_form:
+                return max(f1, f2).hex()
+            else:
+                return p1 if f1 > f2 else p2
+
+        else:
+            raise Exception('Unknown binary operation: {}'.format(op))
+
+    def unary_op(self, op: str, p1: str, hex_form=True) -> str:
+        """Unnary operation on p1 with the operation specified by op
+
+        :param op: abs,
+        :param p1: float number in hex
+        :return:
+        """
+        f1 = self.of_string(p1)
+        if op == 'abs':
+            if hex_form:
+                return abs(f1).hex()
+            else:
+                return p1 if not p1.startswith('-') else p1[1:]
+
+        raise Exception('Unknown unary operation: {}'.format(op))
+
+
+class FloatingPointCmpOp(FloatingPointOp):
+
+    def binary_op(self, op: str, p1: str, p2: str) -> str:
+        """Binary operation on p1 and p2 with the operation specified by op
+
+        :param op: eq, ne, lt, le, gt, ge
+        :param p1: float number in hex
+        :param p2: float number in hex
+        :return:
+        """
+
+        # ne
+        # if either p1 or p2 is a NaN, then return True
+        if op == 'ne' and ('nan' in p1.lower() or 'nan' in p2.lower()):
+            return '-1'
+
+        # other instructions
+        # if either p1 or p2 is a NaN, then return False
+        if 'nan' in p1.lower() or 'nan' in p2.lower():
+            return '0'
+
+        f1 = self.of_string(p1)
+        f2 = self.of_string(p2)
+
+        if op == 'eq':
+            return '-1' if f1 == f2 else '0'
+
+        elif op == 'ne':
+            return '-1' if f1 != f2 else '0'
+
+        elif op == 'lt':
+            return '-1' if f1 < f2 else '0'
+
+        elif op == 'le':
+            return '-1' if f1 <= f2 else '0'
+
+        elif op == 'gt':
+            return '-1' if f1 > f2 else '0'
+
+        elif op == 'ge':
+            return '-1' if f1 >= f2 else '0'
+        else:
+            raise Exception('Unknown binary operation')
+
+
+class FloatingPointRoundingOp(FloatingPointOp):
+    def unary_op(self, op: str, p1: str, hex_form=True) -> str:
+        """Unnary operation on p1 with the operation specified by op
+
+        :param op: ceil, floor, trunc, nearest
+        :param p1: float number in hex
+        :return:
+        """
+        f1 = self.of_string(p1)
+
+        if 'nan' in p1:
+            return 'nan'
+
+        if 'inf' in p1:
+            return p1
+
+        # The rounding ops don't treat -0.0 correctly, e.g.:
+        # math.ceil(-0.4) returns +0.0, so copy the sign.
+        elif op == 'ceil':
+            r = math.copysign(math.ceil(f1), f1)
+            if hex_form:
+                return r.hex()
+            else:
+                return str(r)
+        elif op == 'floor':
+            r = math.copysign(math.floor(f1), f1)
+            if hex_form:
+                return r.hex()
+            else:
+                return str(r)
+        elif op == 'trunc':
+            r = math.copysign(math.trunc(f1), f1)
+            if hex_form:
+                return r.hex()
+            else:
+                return str(r)
+        elif op == 'nearest':
+            r = math.copysign(round(f1), f1)
+            if hex_form:
+                return r.hex()
+            else:
+                return str(r)
+        else:
+            raise Exception('Unknown binary operation')
diff --git a/test/core/simd/meta/simd_i16x8_arith.py b/test/core/simd/meta/simd_i16x8_arith.py
new file mode 100644
index 000000000..110907104
--- /dev/null
+++ b/test/core/simd/meta/simd_i16x8_arith.py
@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+
+"""
+Generate i16x8 integer arithmetic operation cases.
+"""
+
+from simd_arithmetic import SimdArithmeticCase
+
+
+class SimdI16x8ArithmeticCase(SimdArithmeticCase):
+
+    LANE_LEN = 8
+    LANE_TYPE = 'i16x8'
+
+    @property
+    def hex_binary_op_test_data(self):
+        return [
+            ('0x3fff', '0x4000'),
+            ('0x4000', '0x4000'),
+            ('-0x3fff', '-0x4000'),
+            ('-0x4000', '-0x4000'),
+            ('-0x4000', '-0x4001'),
+            ('0x7fff', '0x7fff'),
+            ('0x7fff', '0x01'),
+            ('0x8000', '-0x01'),
+            ('0x7fff', '0x8000'),
+            ('0x8000', '0x8000'),
+            ('0xffff', '0x01'),
+            ('0xffff', '0xffff')
+        ]
+
+    @property
+    def hex_unary_op_test_data(self):
+        return ['0x01', '-0x01', '-0x8000', '-0x7fff', '0x7fff', '0x8000', '0xffff']
+
+    @property
+    def underscore_literal_test_data(self):
+        return {
+            'i16x8.add': [
+                [['012_345', '056_789'], '03_598', ['i16x8'] * 3],
+                [['0x0_1234', '0x0_5678'], '0x0_68ac', ['i16x8'] * 3]
+            ],
+            'i16x8.sub': [
+                [['056_789', '012_345'], '044_444', ['i16x8'] * 3],
+                [['0x0_5678', '0x0_1234'], '0x0_4444', ['i16x8'] * 3]
+            ],
+            'i16x8.mul': [
+                [['012_345', '056_789'], '021_613', ['i16x8'] * 3],
+                [['0x0_1234', '0x0_cdef'], '0x0_a28c', ['i16x8'] * 3]
+            ]
+        }
+
+    @property
+    def i16x8_i8x16_test_data(self):
+        return {
+            'i16x8.add': [
+                [['0x7fff', ['0', '0x80'] * 8], '-1', ['i16x8', 'i8x16', 'i16x8']],
+                [['1', '255'], '0', ['i16x8', 'i8x16', 'i16x8']]
+            ],
+            'i16x8.sub': [
+                [['0x7fff', ['0', '0x80'] * 8], '-1', ['i16x8', 'i8x16', 'i16x8']],
+                [['1', '255'], '0x02', ['i16x8', 'i8x16', 'i16x8']]
+            ],
+            'i16x8.mul': [
+                [['0x1000', '0x10'], '0', ['i16x8', 'i8x16', 'i16x8']],
+                [['65535', '255'], '0x01', ['i16x8', 'i8x16', 'i16x8']]
+            ]
+        }
+
+    @property
+    def i16x8_i32x4_test_data(self):
+        return {
+            'i16x8.add': [
+                [['0x7fff', '0x80008000'], '-1', ['i16x8', 'i32x4', 'i16x8']],
+                [['1', '0xffffffff'], '0', ['i16x8', 'i32x4', 'i16x8']]
+            ],
+            'i16x8.sub': [
+                [['0x7fff', '0x80008000'], '-1', ['i16x8', 'i32x4', 'i16x8']],
+                [['1', '0xffffffff'], '0x02', ['i16x8', 'i32x4', 'i16x8']]
+            ],
+            'i16x8.mul': [
+                [['0x8000', '0x00020002'], '0', ['i16x8', 'i32x4', 'i16x8']],
+                [['65535', '0xffffffff'], '0x01', ['i16x8', 'i32x4', 'i16x8']]
+            ]
+        }
+
+    @property
+    def i16x8_f32x4_test_data(self):
+        return {
+            'i16x8.add': [
+                [['0x8000', '+0.0'], '0x8000', ['i16x8', 'f32x4', 'i16x8']],
+                [['0x8000', '-0.0'], ['0x8000', '0'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['0x8000', '1.0'], ['0x8000', '0xbf80'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['0x8000', '-1.0'], ['0x8000', '0x3f80'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '+inf'], ['0x01', '0x7f81'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '-inf'], ['0x01', '0xff81'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', 'nan'], ['0x01', '0x7fc1'] * 4, ['i16x8', 'f32x4', 'i16x8']]
+            ],
+            'i16x8.sub': [
+                [['0x8000', '+0.0'], '0x8000', ['i16x8', 'f32x4', 'i16x8']],
+                [['0x8000', '-0.0'], ['0x8000', '0'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['0x8000', '1.0'], ['0x8000', '0x4080'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['0x8000', '-1.0'], ['0x8000', '0xc080'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '+inf'], ['0x01', '0x8081'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '-inf'], ['0x01', '0x81'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', 'nan'], ['0x01', '0x8041'] * 4, ['i16x8', 'f32x4', 'i16x8']]
+            ],
+            'i16x8.mul': [
+                [['0x8000', '+0.0'], '0', ['i16x8', 'f32x4', 'i16x8']],
+                [['0x8000', '-0.0'], '0', ['i16x8', 'f32x4', 'i16x8']],
+                [['0x8000', '1.0'], '0', ['i16x8', 'f32x4', 'i16x8']],
+                [['0x8000', '-1.0'], '0', ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '+inf'], ['0', '0x7f80'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '-inf'], ['0', '0xff80'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', 'nan'], ['0', '0x7fc0'] * 4, ['i16x8', 'f32x4', 'i16x8']]
+            ]
+        }
+
+    @property
+    def combine_dec_hex_test_data(self):
+        return {
+            'i16x8.add': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7'],
+                  ['0', '0xffff', '0xfffe', '0xfffd', '0xfffc', '0xfffb', '0xfffa', '0xfff9']],
+                 ['0'] * 8, ['i16x8'] * 3]
+            ],
+            'i16x8.sub': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7'],
+                  ['0', '0xffff', '0xfffe', '0xfffd', '0xfffc', '0xfffb', '0xfffa', '0xfff9']],
+                 ['0', '0x02', '0x04', '0x06', '0x08', '0x0a', '0x0c', '0x0e'], ['i16x8'] * 3]
+            ],
+            'i16x8.mul': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7'],
+                  ['0', '0xffff', '0xfffe', '0xfffd', '0xfffc', '0xfffb', '0xfffa', '0xfff9']],
+                 ['0', '0xffff', '0xfffc', '0xfff7', '0xfff0', '0xffe7', '0xffdc', '0xffcf'],
+                 ['i16x8'] * 3]
+            ]
+        }
+
+    @property
+    def range_test_data(self):
+        return {
+            'i16x8.add': [
+                [[[str(i) for i in range(8)], [str(i * 2) for i in range(8)]],
+                 [str(i * 3) for i in range(8)], ['i16x8'] * 3]
+            ],
+            'i16x8.sub': [
+                [[[str(i) for i in range(8)], [str(i * 2) for i in range(8)]],
+                 [str(-i) for i in range(8)], ['i16x8'] * 3]
+            ],
+            'i16x8.mul': [
+                [[[str(i) for i in range(8)], [str(i * 2) for i in range(8)]],
+                 ['0', '0x02', '0x08', '0x12', '0x20', '0x32', '0x48', '0x62'],
+                 ['i16x8'] * 3]
+            ]
+        }
+
+    @property
+    def full_bin_test_data(self):
+        return [
+            self.i16x8_i8x16_test_data,
+            self.i16x8_i32x4_test_data,
+            self.i16x8_f32x4_test_data,
+            self.combine_dec_hex_test_data,
+            self.range_test_data,
+            self.underscore_literal_test_data
+        ]
+
+
+def gen_test_cases():
+    simd_i16x8_arith = SimdI16x8ArithmeticCase()
+    simd_i16x8_arith.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
\ No newline at end of file
diff --git a/test/core/simd/meta/simd_i16x8_cmp.py b/test/core/simd/meta/simd_i16x8_cmp.py
new file mode 100644
index 000000000..c575cdd0e
--- /dev/null
+++ b/test/core/simd/meta/simd_i16x8_cmp.py
@@ -0,0 +1,825 @@
+#!/usr/bin/env python3
+
+"""
+This file is used for generating i16x8 related test cases
+which inherites from the 'SimdCmpCase' class and overloads
+with the 'get_test_cases' method.
+"""
+
+from simd_compare import SimdCmpCase
+
+
+# Generate i16x8 test case
+class Simdi16x8CmpCase(SimdCmpCase):
+
+    LANE_TYPE = 'i16x8'
+
+    BINARY_OPS = ['eq', 'ne', 'lt_s', 'lt_u', 'le_s', 'le_u', 'gt_s', 'gt_u', 'ge_s', 'ge_u']
+
+    # Overloads base class method and sets test data for i16x8.
+    def get_case_data(self):
+
+        case_data = []
+
+        # eq
+        # i16x8.eq  (i16x8) (i16x8)
+        case_data.append(['#', 'eq'])
+        case_data.append(['#', 'i16x8.eq  (i16x8) (i16x8)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['eq', ['0xFFFF', '0xFFFF'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['0x0000', '0x0000'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['0xF0F0', '0xF0F0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['0x0F0F', '0x0F0F'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['0xFFFF', '0x0000'], ['0xFFFF', '0x0000']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['0x0000', '0xFFFF'], ['0x0000', '0xFFFF']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB'],
+                          ['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['eq', ['0xFFFF', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['0xFFFF', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['0x8080', '32896'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['0x8080', '-32640'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['0x8180', '0x8382', '0xFEFD', '0x00FF', '0x0100', '0x7F02', '0xFD80', '0xFFFE'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['eq', ['-1', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['0', '0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['65535', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['65535', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['65535', '0'], ['65535', '0']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['0', '65535'], ['0', '65535']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['-32768', '65534', '-1', '-0', '0', '1', '2', '65535'],
+                          ['32768', '-2', '-1', '-0', '0', '1', '2', '-1']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['eq', [['0x0000', '0xc300', '0x0000', '0xc2fe', '0x0000', '0xbf80', '0x0000', '0x0000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i16x8', 'f32x4', 'i16x8']])
+        case_data.append(['eq', [['0x0000', '0x3f80', '0x0000', '0x42fe', '0x0000', '0x4300', '0x0000', '0x437f'],
+                          ['1.0', '127.0', '128.0', '255.0']], '-1', ['i16x8', 'f32x4', 'i16x8']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['eq', ['0x0F0F', '0xF0F0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['0x0000', '0xFFFF'], ['0xFFFF', '0x0000']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['0x0001', '0x0203', '0x0409', '0x1011', '0x120A', '0x0B1A', '0x1BAA', '0xABFF'],
+                          ['0xFFAB', '0xAA1B', '0x1A0B', '0x0A12', '0x1110', '0x0904', '0x0302', '0x0100']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['0x8000', '0x8001', '0x8002', '0x8003', '0x8004', '0x8005', '0x8006', '0x8007'],
+                          ['32775', '32774', '32773', '32772', '32771', '32770', '32769', '32768']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['32768', '32769', '65534', '65535', '0', '-1', '-32767', '-32768'],
+                          ['-32768', '-32767', '-1', '0', '65535', '65534', '32769', '32768']], ['-1', '-1', '0', '0', '0', '0', '-1', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+
+        # i16x8.eq  (i16x8) (i8x16)
+        case_data.append(['#', 'i16x8.eq  (i16x8) (i8x16)'])
+        case_data.append(['eq', ['0xFFFF', '0xFF'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['eq', ['65535', '255'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['eq', ['0', '0'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['eq', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['eq', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['eq', [['-128', '-128', '0', '0', '1', '1', '255', '255'],
+                          ['-128', '0', '1', '255']], ['0', '0', '-1', '-1', '0', '0', '0', '0'], ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['eq', ['0x5555', '0xAA'], '0', ['i16x8', 'i8x16', 'i16x8']])
+
+        # i16x8.eq  (i16x8) (i32x4)
+        case_data.append(['#', 'i16x8.eq  (i16x8) (i32x4)'])
+        case_data.append(['eq', ['0xFFFF', '0xFFFFFFFF'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['eq', ['65535', '4294967295'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['eq', ['0', '0'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['eq', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['eq', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['eq', [['65535', '0', '1', '32768'], ['65535', '0', '1', '32768']], ['-1', '0', '-1', '-1', '-1', '0', '-1', '0'], ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['eq', ['0x5555', '0xAAAAAAAA'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['eq', ['012_345', '12345'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['0x0_1234', '0x1234'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # ne
+        # i16x8.ne  (i16x8) (i16x8)
+        case_data.append(['#', 'ne'])
+        case_data.append(['#', 'i16x8.ne  (i16x8) (i16x8)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ne', ['0xFFFF', '0xFFFF'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', ['0x0000', '0x0000'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', ['0xF0F0', '0xF0F0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', ['0x0F0F', '0x0F0F'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['0xFFFF', '0x0000'], ['0xFFFF', '0x0000']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['0x0000', '0xFFFF'], ['0x0000', '0xFFFF']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB'],
+                          ['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['ne', ['0xFFFF', '65535'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', ['0xFFFF', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', ['0x8080', '32896'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', ['0x8080', '-32640'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['0x8180', '0x8382', '0xFEFD', '0x00FF', '0x0100', '0x7F02', '0xFD80', '0xFFFE'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['ne', ['-1', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', ['0', '0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', ['255', '255'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', ['65535', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['255', '0'], ['255', '0']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['0', '255'], ['0', '255']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['255', '32767', '-0', '0', '1', '2', '65534', '65535'],
+                          ['255', '32767', '0', '0', '1', '2', '-2', '-1']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['ne', [['0x0000', '0xc300', '0x0000', '0xc2fe', '0x0000', '0xbf80', '0x0000', '0x0000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i16x8', 'f32x4', 'i16x8']])
+        case_data.append(['ne', [['0x0000', '0x3f80', '0x0000', '0x42fe', '0x0000', '0x4300', '0x0000', '0x437f'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i16x8', 'f32x4', 'i16x8']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['ne', ['0x0F0F', '0xF0F0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['0x0000', '0xFFFF'], ['0xFFFF', '0x0000']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['0x0001', '0x0203', '0x0409', '0x1011', '0x120A', '0x0B1A', '0x1BAA', '0xABFF'],
+                          ['0xFFAB', '0xAA1B', '0x1A0B', '0x0A12', '0x1110', '0x0904', '0x0302', '0x0100']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['0x8081', '0x8283', '0xFDFE', '0xFF00', '0x0001', '0x027F', '0x80FD', '0xFEFF'],
+                          ['65279', '33021', '639', '1', '65280', '65022', '33411', '32897']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', [['128', '129', '130', '131', '-0', '255', '32766', '32767'],
+                          ['32767', '32766', '255', '-0', '131', '130', '129', '28']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # i16x8.ne  (i16x8) (i8x16)
+        case_data.append(['#', 'i16x8.ne  (i16x8) (i8x16)'])
+        case_data.append(['ne', ['0xFFFF', '0xFF'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ne', ['65535', '255'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ne', ['0', '0'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ne', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ne', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ne', [['-128', '-128', '0', '0', '1', '1', '255', '255'], ['-128', '0', '1', '255']],
+                          ['-1', '-1', '0', '0', '-1', '-1', '-1', '-1'], ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ne', ['0x5555', '0xAA'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+
+        # i16x8.ne  (i16x8) (i32x4)
+        case_data.append(['#', 'i16x8.ne  (i16x8) (i32x4)'])
+        case_data.append(['ne', ['0xFFFF', '0xFFFFFFFF'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ne', ['65535', '4294967295'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ne', ['0', '0'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ne', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ne', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ne', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['0', '-1', '0', '0', '0', '-1', '0', '-1'], ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ne', ['0x5555', '0xAAAAAAAA'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ne', ['012_345', '12345'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ne', ['0x0_1234', '0x1234'], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # lt_s
+        # i16x8.lt_s  (i16x8) (i16x8)
+        case_data.append(['#', 'lt_s'])
+        case_data.append(['#', 'i16x8.lt_s  (i16x8) (i16x8)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['lt_s', ['0xFFFF', '0xFFFF'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['0x0000', '0x0000'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['0xF0F0', '0xF0F0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['0x0F0F', '0x0F0F'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['0xFFFF', '0x0000'], ['0xFFFF', '0x0000']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['0x0000', '0xFFFF'], ['0x0000', '0xFFFF']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB'],
+                          ['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['0xFFFF', '65535'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['0xFFFF', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['0x8080', '32896'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['0x8080', '-32640'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['0x8180', '0x8382', '0xFEFD', '0x00FF', '0x0100', '0x7F02', '0xFD80', '0xFFFE'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['-1', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['0', '0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['255', '255'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['65535', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['255', '0'], ['255', '0']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['0', '255'], ['0', '255']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['255', '32767', '-0', '0', '1', '2', '65534', '65535'], ['255', '32767', '0', '0', '1', '2', '-2', '-1']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['0x0000', '0xc300', '0x0000', '0xc2fe', '0x0000', '0xbf80', '0x0000', '0x0000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i16x8', 'f32x4', 'i16x8']])
+        case_data.append(['lt_s', [['0x0000', '0x3f80', '0x0000', '0x42fe', '0x0000', '0x4300', '0x0000', '0x437f'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i16x8', 'f32x4', 'i16x8']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['lt_s', ['0x0F0F', '0xF0F0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['0x0000', '0xFFFF'], ['0xFFFF', '0x0000']], ['0', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['0x0001', '0x0203', '0x0409', '0x1011', '0x120A', '0x0B1A', '0x1BAA', '0xABFF'],
+                          ['0xFFAB', '0xAA1B', '0x1A0B', '0x0A12', '0x1110', '0x0904', '0x0302', '0x0100']], ['0', '0', '-1', '0', '0', '0', '0', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['0x8081', '0x8283', '0xFDFE', '0xFF00', '0x0001', '0x027F', '0x80FD', '0xFEFF'],
+                          ['65279', '33021', '639', '1', '65280', '65022', '33411', '32897']], ['-1', '0', '-1', '-1', '0', '0', '-1', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', [['128', '129', '130', '131', '-0', '255', '32766', '32767'],
+                          ['32767', '32766', '255', '-0', '131', '130', '129', '28']], ['-1', '-1', '-1', '0', '-1', '0', '0', '0'], ['i16x8', 'i16x8', 'i16x8']])
+
+        # i16x8.lt_s  (i16x8) (i8x16)
+        case_data.append(['#', 'i16x8.lt_s  (i16x8) (i8x16)'])
+        case_data.append(['lt_s', ['0xFFFF', '0xFF'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_s', ['65535', '255'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_s', ['0', '0'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_s', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_s', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_s', [['-128', '-128', '0', '0', '1', '1', '255', '255'], ['-128', '0', '1', '255']],
+                          ['0', '0', '0', '0', '-1', '-1', '0', '0'], ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_s', ['0x5555', '0xAA'], '0', ['i16x8', 'i8x16', 'i16x8']])
+
+        # i16x8.lt_s  (i16x8) (i32x4)
+        case_data.append(['#', 'i16x8.lt_s  (i16x8) (i32x4)'])
+        case_data.append(['lt_s', ['0xFFFF', '0xFFFFFFFF'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_s', ['65535', '4294967295'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_s', ['0', '0'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_s', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_s', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_s', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['0', '-1', '0', '0', '0', '0', '0', '0'], ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_s', ['0x5555', '0xAAAAAAAA'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_s', ['012_345', '12345'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_s', ['0x0_1234', '0x1234'], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # lt_u
+        # i16x8.lt_u  (i16x8) (i16x8)
+        case_data.append(['#', 'lt_u'])
+        case_data.append(['#', 'i16x8.lt_u  (i16x8) (i16x8)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['lt_u', ['0xFFFF', '0xFFFF'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', ['0x0000', '0x0000'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', ['0xF0F0', '0xF0F0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', ['0x0F0F', '0x0F0F'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['0xFFFF', '0x0000'], ['0xFFFF', '0x0000']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['0x0000', '0xFFFF'], ['0x0000', '0xFFFF']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB'],
+                          ['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['lt_u', ['0xFFFF', '65535'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', ['0xFFFF', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', ['0x8080', '32896'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', ['0x8080', '-32640'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['0x8180', '0x8382', '0xFEFD', '0x00FF', '0x0100', '0x7F02', '0xFD80', '0xFFFE'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['lt_u', ['-1', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', ['0', '0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', ['255', '255'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', ['65535', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['255', '0'], ['255', '0']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['0', '255'], ['0', '255']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['255', '32767', '-0', '0', '1', '2', '65534', '65535'],
+                          ['255', '32767', '0', '0', '1', '2', '-2', '-1']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['lt_u', [['0x0000', '0xc300', '0x0000', '0xc2fe', '0x0000', '0xbf80', '0x0000', '0x0000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i16x8', 'f32x4', 'i16x8']])
+        case_data.append(['lt_u', [['0x0000', '0x3f80', '0x0000', '0x42fe', '0x0000', '0x4300', '0x0000', '0x437f'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i16x8', 'f32x4', 'i16x8']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['lt_u', ['0x0F0F', '0xF0F0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['0x0000', '0xFFFF'], ['0xFFFF', '0x0000']], ['-1', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['0x0001', '0x0203', '0x0409', '0x1011', '0x120A', '0x0B1A', '0x1BAA', '0xABFF'],
+                          ['0xFFAB', '0xAA1B', '0x1A0B', '0x0A12', '0x1110', '0x0904', '0x0302', '0x0100']], ['-1', '-1', '-1', '0', '0', '0', '0', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['0x8081', '0x8283', '0xFDFE', '0xFF00', '0x0001', '0x027F', '0x80FD', '0xFEFF'],
+                          ['65279', '33021', '639', '1', '65280', '65022', '33411', '32897']], ['-1', '0', '0', '0', '-1', '-1', '-1', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', [['128', '129', '130', '131', '-0', '255', '32766', '32767'],
+                          ['32767', '32766', '255', '-0', '131', '130', '129', '28']], ['-1', '-1', '-1', '0', '-1', '0', '0', '0'], ['i16x8', 'i16x8', 'i16x8']])
+
+        # i16x8.lt_u  (i16x8) (i8x16)
+        case_data.append(['#', 'i16x8.lt_u  (i16x8) (i8x16)'])
+        case_data.append(['lt_u', ['0xFFFF', '0xFF'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_u', ['65535', '255'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_u', ['0', '0'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_u', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_u', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_u', [['-128', '-128', '0', '0', '1', '1', '255', '255'], ['-128', '0', '1', '255']], ['0', '-1'], ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['lt_u', ['0x5555', '0xAA'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+
+        # i16x8.lt_u  (i16x8) (i32x4)
+        case_data.append(['#', 'i16x8.lt_u  (i16x8) (i32x4)'])
+        case_data.append(['lt_u', ['0xFFFF', '0xFFFFFFFF'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_u', ['65535', '4294967295'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_u', ['0', '0'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_u', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_u', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_u', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']],
+                          ['0', '-1', '0', '0', '0', '0', '0', '0'], ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_u', ['0x5555', '0xAAAAAAAA'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['lt_u', ['012_345', '12345'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['lt_u', ['0x0_1234', '0x1234'], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # le_s
+        # i16x8.le_s  (i16x8) (i16x8)
+        case_data.append(['#', 'le_s'])
+        case_data.append(['#', 'i16x8.le_s  (i16x8) (i16x8)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['le_s', ['0xFFFF', '0xFFFF'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', ['0x0000', '0x0000'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', ['0xF0F0', '0xF0F0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', ['0x0F0F', '0x0F0F'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['0xFFFF', '0x0000'], ['0xFFFF', '0x0000']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['0x0000', '0xFFFF'], ['0x0000', '0xFFFF']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB'],
+                          ['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['le_s', ['0xFFFF', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', ['0xFFFF', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', ['0x8080', '32896'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', ['0x8080', '-32640'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['0x8180', '0x8382', '0xFEFD', '0x00FF', '0x0100', '0x7F02', '0xFD80', '0xFFFE'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['le_s', ['-1', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', ['0', '0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', ['65535', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', ['65535', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['65535', '0'], ['65535', '0']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['0', '65535'], ['0', '65535']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['-32768', '65534', '-1', '-0', '0', '1', '2', '65535'],
+                          ['32768', '-2', '-1', '-0', '0', '1', '2', '-1']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['le_s', [['0x0000', '0xc300', '0x0000', '0xc2fe', '0x0000', '0xbf80', '0x0000', '0x0000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i16x8', 'f32x4', 'i16x8']])
+        case_data.append(['le_s', [['0x0000', '0x3f80', '0x0000', '0x42fe', '0x0000', '0x4300', '0x0000', '0x437f'],
+                          ['1.0', '127.0', '128.0', '255.0']], '-1', ['i16x8', 'f32x4', 'i16x8']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['le_s', ['0x0F0F', '0xF0F0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['0x0000', '0xFFFF'], ['0xFFFF', '0x0000']], ['0', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['0x0001', '0x0203', '0x0409', '0x1011', '0x120A', '0x0B1A', '0x1BAA', '0xABFF'],
+                          ['0xFFAB', '0xAA1B', '0x1A0B', '0x0A12', '0x1110', '0x0904', '0x0302', '0x0100']], ['0', '0', '-1', '0', '0', '0', '0', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['0x8000', '0x8001', '0x8002', '0x8003', '0x8004', '0x8005', '0x8006', '0x8007'],
+                          ['32775', '32774', '32773', '32772', '32771', '32770', '32769', '32768']], ['-1', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', [['32768', '32769', '65534', '65535', '0', '-1', '-32767', '-32768'],
+                          ['-32768', '-32767', '-1', '0', '65535', '65534', '32769', '32768']], ['-1', '-1', '-1', '-1', '0', '0', '-1', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+
+        # i16x8.le_s  (i16x8) (i8x16)
+        case_data.append(['#', 'i16x8.le_s  (i16x8) (i8x16)'])
+        case_data.append(['le_s', ['0xFFFF', '0xFF'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_s', ['65535', '255'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_s', ['0', '0'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_s', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_s', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_s', [['-128', '-128', '0', '0', '1', '1', '255', '255'], ['-128', '0', '1', '255']],
+                          ['0', '0', '-1', '-1', '-1', '-1', '0', '0'], ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_s', ['0x5555', '0xAA'], '0', ['i16x8', 'i8x16', 'i16x8']])
+
+        # i16x8.le_s  (i16x8) (i32x4)
+        case_data.append(['#', 'i16x8.le_s  (i16x8) (i32x4)'])
+        case_data.append(['le_s', ['0xFFFF', '0xFFFFFFFF'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_s', ['65535', '4294967295'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_s', ['0', '0'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_s', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_s', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_s', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['-1', '-1', '-1', '-1', '-1', '0', '-1', '0'], ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_s', ['0x5555', '0xAAAAAAAA'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_s', ['012_345', '12345'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_s', ['0x0_1234', '0x1234'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # le_u
+        # i16x8.le_u  (i16x8) (i16x8)
+        case_data.append(['#', 'le_u'])
+        case_data.append(['#', 'i16x8.le_u  (i16x8) (i16x8)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['le_u', ['0xFFFF', '0xFFFF'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', ['0x0000', '0x0000'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', ['0xF0F0', '0xF0F0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', ['0x0F0F', '0x0F0F'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['0xFFFF', '0x0000'], ['0xFFFF', '0x0000']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['0x0000', '0xFFFF'], ['0x0000', '0xFFFF']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB'],
+                          ['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['le_u', ['0xFFFF', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', ['0xFFFF', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', ['0x8080', '32896'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', ['0x8080', '-32640'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['0x8180', '0x8382', '0xFEFD', '0x00FF', '0x0100', '0x7F02', '0xFD80', '0xFFFE'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['le_u', ['-1', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', ['0', '0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', ['65535', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', ['65535', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['65535', '0'], ['65535', '0']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['0', '65535'], ['0', '65535']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['-32768', '65534', '-1', '-0', '0', '1', '2', '65535'], ['32768', '-2', '-1', '-0', '0', '1', '2', '-1']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['le_u', [['0x0000', '0xc300', '0x0000', '0xc2fe', '0x0000', '0xbf80', '0x0000', '0x0000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i16x8', 'f32x4', 'i16x8']])
+        case_data.append(['le_u', [['0x0000', '0x3f80', '0x0000', '0x42fe', '0x0000', '0x4300', '0x0000', '0x437f'],
+                          ['1.0', '127.0', '128.0', '255.0']], '-1', ['i16x8', 'f32x4', 'i16x8']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['le_u', ['0x0F0F', '0xF0F0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['0x0000', '0xFFFF'], ['0xFFFF', '0x0000']], ['-1', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['0x0001', '0x0203', '0x0409', '0x1011', '0x120A', '0x0B1A', '0x1BAA', '0xABFF'],
+                          ['0xFFAB', '0xAA1B', '0x1A0B', '0x0A12', '0x1110', '0x0904', '0x0302', '0x0100']], ['-1', '-1', '-1', '0', '0', '0', '0', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['0x8000', '0x8001', '0x8002', '0x8003', '0x8004', '0x8005', '0x8006', '0x8007'],
+                          ['32775', '32774', '32773', '32772', '32771', '32770', '32769', '32768']], ['-1', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', [['32768', '32769', '65534', '65535', '0', '-1', '-32767', '-32768'],
+                          ['-32768', '-32767', '-1', '0', '65535', '65534', '32769', '32768']], ['-1', '-1', '-1', '0', '-1', '0', '-1', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+
+        # i16x8.le_u  (i16x8) (i8x16)
+        case_data.append(['#', 'i16x8.le_u  (i16x8) (i8x16)'])
+        case_data.append(['le_u', ['0xFFFF', '0xFF'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_u', ['65535', '255'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_u', ['0', '0'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_u', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_u', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_u', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['0', '0', '-1', '-1', '-1', '-1', '-1', '-1'], ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['le_u', ['0x5555', '0xAA'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+
+        # i16x8.le_u  (i16x8) (i32x4)
+        case_data.append(['#', 'i16x8.le_u  (i16x8) (i32x4)'])
+        case_data.append(['le_u', ['0xFFFF', '0xFFFFFFFF'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_u', ['65535', '4294967295'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_u', ['0', '0'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_u', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_u', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_u', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['-1', '-1', '-1', '-1', '-1', '0', '-1', '0'], ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_u', ['0x5555', '0xAAAAAAAA'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['le_u', ['012_345', '12345'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['le_u', ['0x0_edcb', '-0x1234'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # gt_s
+        # i16x8.gt_s  (i16x8) (i16x8)
+        case_data.append(['#', 'gt_s'])
+        case_data.append(['#', 'i16x8.gt_s  (i16x8) (i16x8)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['gt_s', ['0xFFFF', '0xFFFF'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', ['0x0000', '0x0000'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', ['0xF0F0', '0xF0F0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', ['0x0F0F', '0x0F0F'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['0xFFFF', '0x0000'], ['0xFFFF', '0x0000']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['0x0000', '0xFFFF'], ['0x0000', '0xFFFF']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB'],
+                          ['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['gt_s', ['0xFFFF', '65535'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', ['0xFFFF', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', ['0x8080', '32896'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', ['0x8080', '-32640'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['0x8180', '0x8382', '0xFEFD', '0x00FF', '0x0100', '0x7F02', '0xFD80', '0xFFFE'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['gt_s', ['-1', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', ['0', '0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', ['65535', '65535'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', ['65535', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['65535', '0'], ['65535', '0']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['0', '65535'], ['0', '65535']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['-32768', '65534', '-1', '-0', '0', '1', '2', '65535'], ['32768', '-2', '-1', '-0', '0', '1', '2', '-1']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['gt_s', [['0x0000', '0xc300', '0x0000', '0xc2fe', '0x0000', '0xbf80', '0x0000', '0x0000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i16x8', 'f32x4', 'i16x8']])
+        case_data.append(['gt_s', [['0x0000', '0x3f80', '0x0000', '0x42fe', '0x0000', '0x4300', '0x0000', '0x437f'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i16x8', 'f32x4', 'i16x8']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['gt_s', ['0x0F0F', '0xF0F0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['0x0000', '0xFFFF'], ['0xFFFF', '0x0000']], ['-1', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['0x0001', '0x0203', '0x0409', '0x1011', '0x120A', '0x0B1A', '0x1BAA', '0xABFF'],
+                          ['0xFFAB', '0xAA1B', '0x1A0B', '0x0A12', '0x1110', '0x0904', '0x0302', '0x0100']], ['-1', '-1', '0', '-1', '-1', '-1', '-1', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['0x8000', '0x8001', '0x8002', '0x8003', '0x8004', '0x8005', '0x8006', '0x8007'],
+                          ['32775', '32774', '32773', '32772', '32771', '32770', '32769', '32768']], ['0', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', [['32768', '32769', '65534', '65535', '0', '-1', '-32767', '-32768'],
+                          ['-32768', '-32767', '-1', '0', '65535', '65534', '32769', '32768']], ['0', '0', '0', '0', '-1', '-1', '0', '0'], ['i16x8', 'i16x8', 'i16x8']])
+
+        # i16x8.gt_s  (i16x8) (i8x16)
+        case_data.append(['#', 'i16x8.gt_s  (i16x8) (i8x16)'])
+        case_data.append(['gt_s', ['0xFFFF', '0xFF'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_s', ['65535', '255'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_s', ['0', '0'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_s', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_s', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_s', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['-1', '0', '0', '-1'], ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_s', ['0x5555', '0xAA'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+
+        # i16x8.gt_s  (i16x8) (i32x4)
+        case_data.append(['#', 'i16x8.gt_s  (i16x8) (i32x4)'])
+        case_data.append(['gt_s', ['0xFFFF', '0xFFFFFFFF'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_s', ['65535', '4294967295'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_s', ['0', '0'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_s', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_s', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_s', [['65535', '0', '1', '32768'], ['65535', '0', '1', '32768']], ['0', '0', '0', '0', '0', '-1', '0', '0'], ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_s', ['0x5555', '0xAAAAAAAA'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_s', ['012_345', '12345'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_s', ['0x0_1234', '0x1234'], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # gt_u
+        # i16x8.gt_u  (i16x8) (i16x8)
+        case_data.append(['#', 'gt_u'])
+        case_data.append(['#', 'i16x8.gt_u  (i16x8) (i16x8)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['gt_u', ['0xFFFF', '0xFFFF'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', ['0x0000', '0x0000'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', ['0xF0F0', '0xF0F0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', ['0x0F0F', '0x0F0F'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', [['0xFFFF', '0x0000'], ['0xFFFF', '0x0000']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', [['0x0000', '0xFFFF'], ['0x0000', '0xFFFF']], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', [['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB'],
+                          ['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['gt_u', ['0xFFFF', '65535'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', ['0xFFFF', '-1'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', ['0x8080', '32896'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', ['0x8080', '-32640'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', [['0x8180', '0x8382', '0xFEFD', '0x00FF', '0x0100', '0x7F02', '0xFD80', '0xFFFE'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['eq', ['-1', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['0', '0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['65535', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', ['65535', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['65535', '0'], ['65535', '0']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['0', '65535'], ['0', '65535']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['eq', [['-32768', '65534', '-1', '-0', '0', '1', '2', '65535'],
+                          ['32768', '-2', '-1', '-0', '0', '1', '2', '-1']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['gt_u', [['0x0000', '0xc300', '0x0000', '0xc2fe', '0x0000', '0xbf80', '0x0000', '0x0000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i16x8', 'f32x4', 'i16x8']])
+        case_data.append(['gt_u', [['0x0000', '0x3f80', '0x0000', '0x42fe', '0x0000', '0x4300', '0x0000', '0x437f'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i16x8', 'f32x4', 'i16x8']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['gt_u', ['0x0F0F', '0xF0F0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', [['0x0000', '0xFFFF'], ['0xFFFF', '0x0000']], ['0', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', [['0x0001', '0x0203', '0x0409', '0x1011', '0x120A', '0x0B1A', '0x1BAA', '0xABFF'],
+                          ['0xFFAB', '0xAA1B', '0x1A0B', '0x0A12', '0x1110', '0x0904', '0x0302', '0x0100']], ['0', '0', '0', '-1', '-1', '-1', '-1', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', [['0x8000', '0x8001', '0x8002', '0x8003', '0x8004', '0x8005', '0x8006', '0x8007'],
+                          ['32775', '32774', '32773', '32772', '32771', '32770', '32769', '32768']], ['0', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', [['32768', '32769', '65534', '65535', '0', '-1', '-32767', '-32768'],
+                          ['-32768', '-32767', '-1', '0', '65535', '65534', '32769', '32768']], ['0', '0', '0', '-1', '0', '-1', '0', '0'], ['i16x8', 'i16x8', 'i16x8']])
+
+        # i16x8.gt_u  (i16x8) (i8x16)
+        case_data.append(['#', 'i16x8.gt_u  (i16x8) (i8x16)'])
+        case_data.append(['gt_u', ['0xFFFF', '0xFF'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_u', ['65535', '255'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_u', ['0', '0'], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_u', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_u', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_u', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['-1', '0', '0', '0'], ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['gt_u', ['0x5555', '0xAA'], '0', ['i16x8', 'i8x16', 'i16x8']])
+
+        # i16x8.gt_u  (i16x8) (i32x4)
+        case_data.append(['#', 'i16x8.gt_u  (i16x8) (i32x4)'])
+        case_data.append(['gt_u', ['0xFFFF', '0xFFFFFFFF'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_u', ['65535', '4294967295'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_u', ['0', '0'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_u', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_u', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_u', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['0', '0', '0', '0', '0', '-1', '0', '-1'], ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_u', ['0x5555', '0xAAAAAAAA'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['gt_u', ['012_345', '12345'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['gt_u', ['0x0_1234', '0x1234'], '0', ['i16x8', 'i16x8', 'i16x8']])
+
+        # ge_s
+        # i16x8.ge_s  (i16x8) (i16x8)
+        case_data.append(['#', 'ge_s'])
+        case_data.append(['#', 'i16x8.ge_s  (i16x8) (i16x8)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ge_s', ['0xFFFF', '0xFFFF'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', ['0x0000', '0x0000'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', ['0xF0F0', '0xF0F0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', ['0x0F0F', '0x0F0F'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['0xFFFF', '0x0000'], ['0xFFFF', '0x0000']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['0x0000', '0xFFFF'], ['0x0000', '0xFFFF']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB'],
+                          ['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['ge_s', ['0xFFFF', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', ['0xFFFF', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', ['0x8080', '32896'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', ['0x8080', '-32640'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['0x8180', '0x8382', '0xFEFD', '0x00FF', '0x0100', '0x7F02', '0xFD80', '0xFFFE'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['ge_s', ['-1', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', ['0', '0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', ['65535', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', ['65535', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['65535', '0'], ['65535', '0']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['0', '65535'], ['0', '65535']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['-32768', '65534', '-1', '-0', '0', '1', '2', '65535'], ['32768', '-2', '-1', '-0', '0', '1', '2', '-1']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['ge_s', [['0x0000', '0xc300', '0x0000', '0xc2fe', '0x0000', '0xbf80', '0x0000', '0x0000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i16x8', 'f32x4', 'i16x8']])
+        case_data.append(['ge_s', [['0x0000', '0x3f80', '0x0000', '0x42fe', '0x0000', '0x4300', '0x0000', '0x437f'],
+                          ['1.0', '127.0', '128.0', '255.0']], '-1', ['i16x8', 'f32x4', 'i16x8']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['ge_s', ['0x0F0F', '0xF0F0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['0x0000', '0xFFFF'], ['0xFFFF', '0x0000']], ['-1', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['0x0001', '0x0203', '0x0409', '0x1011', '0x120A', '0x0B1A', '0x1BAA', '0xABFF'],
+                          ['0xFFAB', '0xAA1B', '0x1A0B', '0x0A12', '0x1110', '0x0904', '0x0302', '0x0100']], ['-1', '-1', '0', '-1', '-1', '-1', '-1', '0'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['0x8000', '0x8001', '0x8002', '0x8003', '0x8004', '0x8005', '0x8006', '0x8007'],
+                          ['32775', '32774', '32773', '32772', '32771', '32770', '32769', '32768']], ['0', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', [['32768', '32769', '65534', '65535', '0', '-1', '-32767', '-32768'],
+                          ['-32768', '-32767', '-1', '0', '65535', '65534', '32769', '32768']], ['-1', '-1', '0', '0', '-1', '-1', '-1', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+
+        # i16x8.ge_s  (i16x8) (i8x16)
+        case_data.append(['#', 'i16x8.ge_s  (i16x8) (i8x16)'])
+        case_data.append(['ge_s', ['0xFFFF', '0xFF'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_s', ['65535', '255'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_s', ['0', '0'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_s', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_s', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_s', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['-1', '-1', '-1', '-1', '0', '0', '-1', '-1'], ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_s', ['0xAAAA', '0x55'], '0', ['i16x8', 'i8x16', 'i16x8']])
+
+        # i16x8.ge_s  (i16x8) (i32x4)
+        case_data.append(['#', 'i16x8.ge_s  (i16x8) (i32x4)'])
+        case_data.append(['ge_s', ['0xFFFF', '0xFFFFFFFF'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_s', ['65535', '4294967295'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_s', ['0', '0'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_s', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_s', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_s', [['65535', '0', '1', '32768'], ['65535', '0', '1', '32768']], ['-1', '0', '-1', '-1', '-1', '-1', '-1', '0'], ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_s', ['0x5555', '0xAAAAAAAA'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_s', ['012_345', '12345'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_s', ['0x0_1234', '0x1234'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # ge_u
+        # i16x8.ge_u  (i16x8) (i16x8)
+        case_data.append(['#', 'ge_u'])
+        case_data.append(['#', 'i16x8.ge_u  (i16x8) (i16x8)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ge_u', ['0xFFFF', '0xFFFF'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', ['0x0000', '0x0000'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', ['0xF0F0', '0xF0F0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', ['0x0F0F', '0x0F0F'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['0xFFFF', '0x0000'], ['0xFFFF', '0x0000']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['0x0000', '0xFFFF'], ['0x0000', '0xFFFF']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB'],
+                          ['0x0100', '0x0302', '0x0904', '0x1110', '0x0A12', '0x1A0B', '0xAA1B', '0xFFAB']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['ge_u', ['0xFFFF', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', ['0xFFFF', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', ['0x8080', '32896'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', ['0x8080', '-32640'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['0x8180', '0x8382', '0xFEFD', '0x00FF', '0x0100', '0x7F02', '0xFD80', '0xFFFE'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['ge_u', ['-1', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', ['0', '0'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', ['65535', '65535'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', ['65535', '-1'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['65535', '0'], ['65535', '0']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['0', '65535'], ['0', '65535']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['-32768', '65534', '-1', '-0', '0', '1', '2', '65535'], ['32768', '-2', '-1', '-0', '0', '1', '2', '-1']], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['ge_u', [['0x0000', '0xc300', '0x0000', '0xc2fe', '0x0000', '0xbf80', '0x0000', '0x0000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i16x8', 'f32x4', 'i16x8']])
+        case_data.append(['ge_u', [['0x0000', '0x3f80', '0x0000', '0x42fe', '0x0000', '0x4300', '0x0000', '0x437f'],
+                          ['1.0', '127.0', '128.0', '255.0']], '-1', ['i16x8', 'f32x4', 'i16x8']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['ge_u', ['0x0F0F', '0xF0F0'], '0', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['0x0000', '0xFFFF'], ['0xFFFF', '0x0000']], ['0', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['0x0001', '0x0203', '0x0409', '0x1011', '0x120A', '0x0B1A', '0x1BAA', '0xABFF'],
+                          ['0xFFAB', '0xAA1B', '0x1A0B', '0x0A12', '0x1110', '0x0904', '0x0302', '0x0100']], ['0', '0', '0', '-1', '-1', '-1', '-1', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['0x8000', '0x8001', '0x8002', '0x8003', '0x8004', '0x8005', '0x8006', '0x8007'],
+                          ['32775', '32774', '32773', '32772', '32771', '32770', '32769', '32768']], ['0', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', [['32768', '32769', '65534', '65535', '0', '-1', '-32767', '-32768'],
+                          ['-32768', '-32767', '-1', '0', '65535', '65534', '32769', '32768']], ['-1', '-1', '0', '-1', '0', '-1', '-1', '-1'], ['i16x8', 'i16x8', 'i16x8']])
+
+        # i16x8.ge_u  (i16x8) (i8x16)
+        case_data.append(['#', 'i16x8.ge_u  (i16x8) (i8x16)'])
+        case_data.append(['ge_u', ['0xFFFF', '0xFF'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_u', ['65535', '255'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_u', ['0', '0'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_u', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_u', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_u', [['-128', '-128', '0', '0', '1', '1', '255', '255'], ['-128', '0', '1', '255']], ['-1', '0'], ['i16x8', 'i8x16', 'i16x8']])
+        case_data.append(['ge_u', ['0xAAAA', '0x55'], '-1', ['i16x8', 'i8x16', 'i16x8']])
+
+        # i16x8.ge_u  (i16x8) (i32x4)
+        case_data.append(['#', 'i16x8.ge_u  (i16x8) (i32x4)'])
+        case_data.append(['ge_u', ['0xFFFF', '0xFFFFFFFF'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_u', ['65535', '4294967295'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_u', ['0', '0'], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_u', [['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_u', [['33152', '33666', '65277', '255', '256', '32514', '64896', '65534'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_u', [['65535', '0', '1', '32768'], ['-128', '0', '1', '255']], '-1', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_u', ['0x5555', '0xAAAAAAAA'], '0', ['i16x8', 'i32x4', 'i16x8']])
+        case_data.append(['ge_u', ['012_345', '12345'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+        case_data.append(['ge_u', ['0x0_1234', '0x1234'], '-1', ['i16x8', 'i16x8', 'i16x8']])
+
+        return case_data
+
+
+def gen_test_cases():
+    i16x8 = Simdi16x8CmpCase()
+    i16x8.gen_test_cases()
+
+
+if __name__ == '__main__':
+    i16x8 = Simdi16x8CmpCase()
+    i16x8.gen_test_cases()
diff --git a/test/core/simd/meta/simd_i16x8_q15mulr_sat_s.py b/test/core/simd/meta/simd_i16x8_q15mulr_sat_s.py
new file mode 100644
index 000000000..bf59331f2
--- /dev/null
+++ b/test/core/simd/meta/simd_i16x8_q15mulr_sat_s.py
@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+
+from simd_arithmetic import SimdArithmeticCase
+
+
+"""Generate test cases for i16x8.mulr_sat_s
+"""
+class SimdI16x8Q15MulRSatS(SimdArithmeticCase):
+    LANE_TYPE = 'i16x8'
+    UNARY_OPS = ()
+    BINARY_OPS = ('q15mulr_sat_s',)
+
+    @property
+    def full_bin_test_data(self):
+        return []
+
+    @property
+    def hex_binary_op_test_data(self):
+        return []
+
+    def get_combine_cases(self):
+        return ''
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_i16x8_q15mulr_sat_s.wast'
+        with open(wast_filename, 'w') as fp:
+            fp.write(self.get_all_cases())
+
+
+def gen_test_cases():
+    simd_i16x8_q16mulr_sat_s = SimdI16x8Q15MulRSatS()
+    simd_i16x8_q16mulr_sat_s.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_i32x4_arith.py b/test/core/simd/meta/simd_i32x4_arith.py
new file mode 100644
index 000000000..b402b02cb
--- /dev/null
+++ b/test/core/simd/meta/simd_i32x4_arith.py
@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+
+"""
+Generate i32x4 integer arithmetic operation cases.
+"""
+
+from simd_arithmetic import SimdArithmeticCase
+
+
+class SimdI32x4ArithmeticCase(SimdArithmeticCase):
+
+    LANE_LEN = 4
+    LANE_TYPE = 'i32x4'
+
+    @property
+    def hex_binary_op_test_data(self):
+        return [
+            ('0x3fffffff', '0x40000000'),
+            ('0x40000000', '0x40000000'),
+            ('-0x3fffffff', '-0x40000000'),
+            ('-0x40000000', '-0x40000000'),
+            ('-0x40000000', '-0x40000001'),
+            ('0x7fffffff', '0x7fffffff'),
+            ('0x7fffffff', '0x01'),
+            ('0x80000000', '-0x01'),
+            ('0x7fffffff', '0x80000000'),
+            ('0x80000000', '0x80000000'),
+            ('0xffffffff', '0x01'),
+            ('0xffffffff', '0xffffffff')
+        ]
+
+    @property
+    def hex_unary_op_test_data(self):
+        return ['0x01', '-0x01', '-0x80000000', '-0x7fffffff', '0x7fffffff', '0x80000000', '0xffffffff']
+
+    @property
+    def underscore_literal_test_data(self):
+        return {
+            'i32x4.add': [
+                [['01_234_567_890', '01_234_567_890'], '02_469_135_780', ['i32x4'] * 3],
+                [['0x0_1234_5678', '0x0_90AB_cdef'], '0x0_a2e0_2467', ['i32x4'] * 3]
+            ],
+            'i32x4.sub': [
+                [['03_214_567_890 ', '01_234_567_890 '], '01_980_000_000', ['i32x4'] * 3],
+                [['0x0_90AB_cdef', '0x0_1234_5678'], '0x0_7e77_7777', ['i32x4'] * 3]
+            ],
+            'i32x4.mul': [
+                [['0_123_456_789', '0_987_654_321'], '04_227_814_277', ['i32x4'] * 3],
+                [['0x0_1234_5678', '0x0_90AB_cdef'], '0x0_2a42_d208', ['i32x4'] * 3]
+            ]
+        }
+
+    @property
+    def i32x4_i8x16_test_data(self):
+        return {
+            'i32x4.add': [
+                [['0x7fffffff', ['0', '0', '0', '0x80'] * 4], '-1', ['i32x4', 'i8x16', 'i32x4']],
+                [['1', '255'], '0', ['i32x4', 'i8x16', 'i32x4']]
+            ],
+            'i32x4.sub': [
+                [['0x7fffffff', ['0', '0', '0', '0x80'] * 4], '-1', ['i32x4', 'i8x16', 'i32x4']],
+                [['1', '255'], '2', ['i32x4', 'i8x16', 'i32x4']]
+            ],
+            'i32x4.mul': [
+                [['0x10000000', '0x10'], '0', ['i32x4', 'i8x16', 'i32x4']],
+                [['0xffffffff', '255'], '1', ['i32x4', 'i8x16', 'i32x4']]
+            ]
+        }
+
+    @property
+    def i32x4_i16x8_test_data(self):
+        return {
+            'i32x4.add': [
+                [['0x7fffffff', ['0', '0x8000'] * 4], '-1', ['i32x4', 'i16x8', 'i32x4']],
+                [['1', '0xffff'], '0', ['i32x4', 'i16x8', 'i32x4']]
+            ],
+            'i32x4.sub': [
+                [['0x7fffffff', ['0', '0x8000'] * 4], '-1', ['i32x4', 'i16x8', 'i32x4']],
+                [['1', '0xffff'], '0x02', ['i32x4', 'i16x8', 'i32x4']]
+            ],
+            'i32x4.mul': [
+                [['0x80000000', ['0', '0x02'] * 4], '0', ['i32x4', 'i16x8', 'i32x4']],
+                [['0xffffffff', '0xffff'], '1', ['i32x4', 'i16x8', 'i32x4']]
+            ]
+        }
+
+    @property
+    def i32x4_f32x4_test_data(self):
+        return {
+            'i32x4.add': [
+                [['0x80000000', '+0.0'], '0x80000000', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x80000000', '-0.0'], '0', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x80000000', '1.0'], '0xbf800000', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x80000000', '-1.0'], '0x3f800000', ['i32x4', 'f32x4', 'i32x4']],
+                [['1', '+inf'], '0x7f800001', ['i32x4', 'f32x4', 'i32x4']],
+                [['1', '-inf'], '0xff800001', ['i32x4', 'f32x4', 'i32x4']],
+                [['1', 'nan'], '0x7fc00001', ['i32x4', 'f32x4', 'i32x4']]
+            ],
+            'i32x4.sub': [
+                [['0x80000000', '+0.0'], '0x80000000', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x80000000', '-0.0'], '0', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x80000000', '1.0'], '0x40800000', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x80000000', '-1.0'], '0xc0800000', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x1', '+inf'], '0x80800001', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x1', '-inf'], '0x00800001', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x1', 'nan'], '0x80400001', ['i32x4', 'f32x4', 'i32x4']]
+            ],
+            'i32x4.mul': [
+                [['0x8000', '+0.0'], '0', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x8000', '-0.0'], '0', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x8000', '1.0'], '0', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x8000', '-1.0'], '0', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x1', '+inf'], '0x7f800000', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x1', '-inf'], '0xff800000', ['i32x4', 'f32x4', 'i32x4']],
+                [['0x1', 'nan'], '0x7fc00000', ['i32x4', 'f32x4', 'i32x4']]
+            ]
+        }
+
+    @property
+    def combine_dec_hex_test_data(self):
+        return {
+            'i32x4.add': [
+                [[['0', '1', '2', '3'],
+                  ['0', '0xffffffff', '0xfffffffe', '0xfffffffd']],
+                 ['0'] * 16, ['i32x4'] * 3]
+            ],
+            'i32x4.sub': [
+                [[['0', '1', '2', '3'],
+                  ['0', '0xffffffff', '0xfffffffe', '0xfffffffd']],
+                 ['0', '0x02', '0x04', '0x06'], ['i32x4'] * 3]
+            ],
+            'i32x4.mul': [
+                [[['0', '1', '2', '3'],
+                  ['0', '0xffffffff', '0xfffffffe', '0xfffffffd']],
+                 ['0', '0xffffffff', '0xfffffffc', '0xfffffff7'],
+                 ['i32x4'] * 3]
+            ]
+        }
+
+    @property
+    def range_test_data(self):
+        return {
+            'i32x4.add': [
+                [[[str(i) for i in range(4)], [str(i * 2) for i in range(4)]],
+                 [str(i * 3) for i in range(4)], ['i32x4'] * 3]
+            ],
+            'i32x4.sub': [
+                [[[str(i) for i in range(4)], [str(i * 2) for i in range(4)]],
+                 [str(-i) for i in range(4)], ['i32x4'] * 3]
+            ],
+            'i32x4.mul': [
+                [[[str(i) for i in range(4)], [str(i * 2) for i in range(4)]],
+                 ['0', '0x02', '0x08', '0x12'],
+                 ['i32x4'] * 3]
+            ]
+        }
+
+    @property
+    def full_bin_test_data(self):
+        return [
+            self.i32x4_i8x16_test_data,
+            self.i32x4_i16x8_test_data,
+            self.i32x4_f32x4_test_data,
+            self.combine_dec_hex_test_data,
+            self.range_test_data,
+            self.underscore_literal_test_data
+        ]
+
+
+def gen_test_cases():
+    simd_i32x4_arith = SimdI32x4ArithmeticCase()
+    simd_i32x4_arith.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
\ No newline at end of file
diff --git a/test/core/simd/meta/simd_i32x4_cmp.py b/test/core/simd/meta/simd_i32x4_cmp.py
new file mode 100644
index 000000000..41a093ee6
--- /dev/null
+++ b/test/core/simd/meta/simd_i32x4_cmp.py
@@ -0,0 +1,837 @@
+#!/usr/bin/env python3
+
+"""
+This file is used for generating i32x4 related test cases
+which inherites from the 'SimdCmpCase' class and overloads
+with the 'get_test_cases' method.
+"""
+
+from simd_compare import SimdCmpCase
+
+
+# Generate i32x4 test case
+class Simdi32x4CmpCase(SimdCmpCase):
+
+    LANE_TYPE = 'i32x4'
+
+    BINARY_OPS = ['eq', 'ne', 'lt_s', 'lt_u', 'le_s', 'le_u', 'gt_s', 'gt_u', 'ge_s', 'ge_u']
+
+    # Overload base class method and set test data for i32x4.
+    def get_case_data(self):
+
+        case_data = []
+
+        # eq
+        # i32x4.eq  (i32x4) (i32x4)
+        case_data.append(['#', 'eq'])
+        case_data.append(['#', 'i32x4.eq  (i32x4) (i32x4)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['eq', ['0xFFFFFFFF', '0xFFFFFFFF'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', ['0x00000000', '0x00000000'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', ['0xF0F0F0F0', '0xF0F0F0F0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', ['0x0F0F0F0F', '0x0F0F0F0F'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['0xFFFFFFFF', '0x00000000'], ['0xFFFFFFFF', '0x00000000']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['0x00000000', '0xFFFFFFFF'], ['0x00000000', '0xFFFFFFFF']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['eq', ['0xFFFFFFFF', '4294967295'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', ['0xFFFFFFFF', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', ['0x80808080', '2155905152'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', ['0x80808080', '-2139062144'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['0x83828180', '0x00FFFEFD', '0x7F020100', '0xFFFEFD80'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['eq', ['-1', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', ['0', '0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', ['4294967295', '4294967295'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', ['4294967295', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['4294967295', '0'], ['4294967295', '0']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['0', '4294967295'], ['0', '4294967295']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['-2147483647', '4294967295', '0', '-1'], ['2147483649', '-1', '0', '-1']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['eq', [['0xc3000000', '0xc2fe0000', '0xbf800000', '0x00000000'], ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i32x4', 'f32x4', 'i32x4']])
+        case_data.append(['eq', [['0x3f800000', '0x42fe0000', '0x43000000', '0x437f0000'], ['1.0', '127.0', '128.0', '255.0']], '-1', ['i32x4', 'f32x4', 'i32x4']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['eq', ['0x0F0F0F0F', '0xF0F0F0F0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['0x00000000', '0xFFFFFFFF'], ['0xFFFFFFFF', '0x00000000']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['0x02030001', '0x10110409', '0x0B1A120A', '0xABFF1BAA'],
+                          ['0xAA1BFFAB', '0x0A121A0B', '0x09041110', '0x01000302']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['0x80018000', '0x80038002', '0x80058004', '0x80078006'],
+                          ['2147975174', '2147844100', '2147713026', '2147581952']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', [['2147483648', '2147483647', '0', '-1'], ['-2147483648', '-2147483647', '-1', '0']], ['-1', '0', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+
+        # i32x4.eq  (i32x4) (i8x16)
+        case_data.append(['#', 'i32x4.eq  (i32x4) (i8x16)'])
+        case_data.append(['eq', ['0xFFFFFFFF', '0xFF'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['eq', ['4294967295', '255'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['eq', ['0', '0'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['eq', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['eq', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['eq', [['-8323200', '0', '1', '4294967295'], ['-128', '0', '1', '255']], ['0', '-1', '0', '-1'], ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['eq', ['0x55555555', '0xAA'], '0', ['i32x4', 'i8x16', 'i32x4']])
+
+        # i32x4.eq  (i32x4) (i16x8)
+        case_data.append(['#', 'i32x4.eq  (i32x4) (i16x8)'])
+        case_data.append(['eq', ['0xFFFFFFFF', '0xFFFF'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['eq', ['4294967295', '65535'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['eq', ['0', '0'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['eq', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['eq', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['eq', [['4294967295', '0', '1', '65535'], ['65535', '65535', '0', '0', '1', '0', '65535', '65535']], ['-1', '-1', '-1', '0'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['eq', ['0x55555555', '0xAAAA'], '0', ['i32x4', 'i16x8', 'i32x4']])
+
+        case_data.append(['eq', ['0_123_456_789', '123456789'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['eq', ['0x0_1234_5678', '0x12345678'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # ne
+        # i32x4.ne  (i32x4) (i32x4)
+        case_data.append(['#', 'ne'])
+        case_data.append(['#', 'i32x4.ne  (i32x4) (i32x4)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ne', ['0xFFFFFFFF', '0xFFFFFFFF'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', ['0x00000000', '0x00000000'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', ['0xF0F0F0F0', '0xF0F0F0F0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', ['0x0F0F0F0F', '0x0F0F0F0F'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['0xFFFFFFFF', '0x00000000'], ['0xFFFFFFFF', '0x00000000']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['0x00000000', '0xFFFFFFFF'], ['0x00000000', '0xFFFFFFFF']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['ne', ['0xFFFFFFFF', '4294967295'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', ['0xFFFFFFFF', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', ['0x80808080', '2155905152'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', ['0x80808080', '-2139062144'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['0x83828180', '0x00FFFEFD', '0x7F020100', '0xFFFEFD80'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['ne', ['-1', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', ['0', '0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', ['4294967295', '4294967295'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', ['4294967295', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['4294967295', '0'], ['4294967295', '0']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['0', '4294967295'], ['0', '4294967295']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['-2147483647', '4294967295', '0', '-1'], ['2147483649', '-1', '0', '-1']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['ne', [['0xc3000000', '0xc2fe0000', '0xbf800000', '0x00000000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i32x4', 'f32x4', 'i32x4']])
+        case_data.append(['ne', [['0x3f800000', '0x42fe0000', '0x43000000', '0x437f0000'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i32x4', 'f32x4', 'i32x4']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['ne', ['0x0F0F0F0F', '0xF0F0F0F0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['0x00000000', '0xFFFFFFFF'], ['0xFFFFFFFF', '0x00000000']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['0x02030001', '0x10110409', '0x0B1A120A', '0xABFF1BAA'],
+                          ['0xAA1BFFAB', '0x0A121A0B', '0x09041110', '0x01000302']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['0x80018000', '0x80038002', '0x80058004', '0x80078006'],
+                          ['2147975174', '2147844100', '2147713026', '2147581952']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', [['2147483648', '2147483647', '0', '-1'], ['-2147483648', '-2147483647', '-1', '0']], ['0', '-1', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+
+        # i32x4.ne  (i32x4) (i8x16)
+        case_data.append(['#', 'i32x4.ne  (i32x4) (i8x16)'])
+        case_data.append(['ne', ['0xFFFFFFFF', '0xFF'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ne', ['4294967295', '255'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ne', ['0', '0'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ne', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ne', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ne', [['-8323200', '0', '1', '4294967295'], ['-128', '0', '1', '255']], ['-1', '0', '-1', '0'], ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ne', ['0x55555555', '0xAA'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+
+        # i32x4.ne  (i32x4) (i16x8)
+        case_data.append(['#', 'i32x4.ne  (i32x4) (i16x8)'])
+        case_data.append(['ne', ['0xFFFFFFFF', '0xFFFF'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ne', ['4294967295', '65535'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ne', ['0', '0'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ne', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ne', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ne', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['-1', '0', '-1', '-1'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ne', ['0xAAAAAAAA', '0x5555'], ['-1', '-1', '-1', '-1'], ['i32x4', 'i16x8', 'i32x4']])
+
+        case_data.append(['ne', ['0_123_456_789', '123456789'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ne', ['0x0_1234_5678', '0x12345678'], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # lt_s
+        # i32x4.lt_s  (i32x4) (i32x4)
+        case_data.append(['#', 'lt_s'])
+        case_data.append(['#', 'i32x4.lt_s  (i32x4) (i32x4)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['lt_s', ['0xFFFFFFFF', '0xFFFFFFFF'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', ['0x00000000', '0x00000000'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', ['0xF0F0F0F0', '0xF0F0F0F0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', ['0x0F0F0F0F', '0x0F0F0F0F'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['0xFFFFFFFF', '0x00000000'], ['0xFFFFFFFF', '0x00000000']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['0x00000000', '0xFFFFFFFF'], ['0x00000000', '0xFFFFFFFF']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['lt_s', ['0xFFFFFFFF', '4294967295'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', ['0xFFFFFFFF', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', ['0x80808080', '2155905152'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', ['0x80808080', '-2139062144'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['0x83828180', '0x00FFFEFD', '0x7F020100', '0xFFFEFD80'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['lt_s', ['-1', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', ['0', '0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', ['4294967295', '4294967295'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', ['4294967295', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['4294967295', '0'], ['4294967295', '0']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['0', '4294967295'], ['0', '4294967295']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['-2147483647', '4294967295', '0', '-1'],
+                          ['2147483649', '-1', '0', '-1']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['lt_s', [['0xc3000000', '0xc2fe0000', '0xbf800000', '0x00000000'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i32x4', 'f32x4', 'i32x4']])
+        case_data.append(['lt_s', [['0x3f800000', '0x42fe0000', '0x43000000', '0x437f0000'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i32x4', 'f32x4', 'i32x4']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['lt_s', ['0x0F0F0F0F', '0xF0F0F0F0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['0x00000000', '0xFFFFFFFF'], ['0xFFFFFFFF', '0x00000000']], ['0', '0', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['0x02030001', '0x10110409', '0x0B1A120A', '0xABFF1BAA'],
+                          ['0xAA1BFFAB', '0x0A121A0B', '0x09041110', '0x01000302']], ['0', '0', '0', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['0x80018000', '0x80038002', '0x80058004', '0x80078006'],
+                          ['2147975174', '2147844100', '2147713026', '2147581952']], ['-1', '-1', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', [['2147483648', '2147483647', '0', '-1'], ['-2147483648', '-2147483647', '-1', '0']], ['0', '0', '0', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+
+        # i32x4.lt_s  (i32x4) (i8x16)
+        case_data.append(['#', 'i32x4.lt_s  (i32x4) (i8x16)'])
+        case_data.append(['lt_s', ['0xFFFFFFFF', '0xFF'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_s', ['4294967295', '255'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_s', ['0', '0'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_s', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_s', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_s', [['-8323200', '0', '1', '4294967295'], ['-128', '0', '1', '255']], ['0', '0', '-1', '0'], ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_s', ['0x55555555', '0xAA'], '0', ['i32x4', 'i8x16', 'i32x4']])
+
+        # i32x4.lt_s  (i32x4) (i16x8)
+        case_data.append(['#', 'i32x4.lt_s  (i32x4) (i16x8)'])
+        case_data.append(['lt_s', ['0xFFFFFFFF', '0xFFFF'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_s', ['4294967295', '65535'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_s', ['0', '0'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_s', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_s', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_s', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['0', '0', '-1', '-1'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_s', ['0xAAAAAAAA', '0x5555'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+
+        case_data.append(['lt_s', ['0_123_456_789', '123456789'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_s', ['0x0_90AB_cdef', '-0x6f543210'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # lt_u
+        # i32x4.lt_u  (i32x4) (i32x4)
+        case_data.append(['#', 'lt_u'])
+        case_data.append(['#', 'i32x4.lt_u  (i32x4) (i32x4)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['lt_u', ['0xFFFFFFFF', '0xFFFFFFFF'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', ['0x00000000', '0x00000000'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', ['0xF0F0F0F0', '0xF0F0F0F0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', ['0x0F0F0F0F', '0x0F0F0F0F'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['0xFFFFFFFF', '0x00000000'], ['0xFFFFFFFF', '0x00000000']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['0x00000000', '0xFFFFFFFF'], ['0x00000000', '0xFFFFFFFF']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['lt_u', ['0xFFFFFFFF', '4294967295'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', ['0xFFFFFFFF', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', ['0x80808080', '2155905152'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', ['0x80808080', '-2139062144'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['0x83828180', '0x00FFFEFD', '0x7F020100', '0xFFFEFD80'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['lt_u', ['-1', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', ['0', '0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', ['4294967295', '4294967295'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', ['4294967295', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['4294967295', '0'], ['4294967295', '0']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['0', '4294967295'], ['0', '4294967295']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['-2147483647', '4294967295', '0', '-1'], ['2147483649', '-1', '0', '-1']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['lt_u', [['0xc3000000', '0xc2fe0000', '0xbf800000', '0x00000000'], ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i32x4', 'f32x4', 'i32x4']])
+        case_data.append(['lt_u', [['0x3f800000', '0x42fe0000', '0x43000000', '0x437f0000'], ['1.0', '127.0', '128.0', '255.0']], '0', ['i32x4', 'f32x4', 'i32x4']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['lt_u', ['0x0F0F0F0F', '0xF0F0F0F0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['0x00000000', '0xFFFFFFFF'], ['0xFFFFFFFF', '0x00000000']], ['-1', '-1', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['0x02030001', '0x10110409', '0x0B1A120A', '0xABFF1BAA'],
+                          ['0xAA1BFFAB', '0x0A121A0B', '0x09041110', '0x01000302']], ['-1', '0', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['0x80018000', '0x80038002', '0x80058004', '0x80078006'],
+                          ['2147975174', '2147844100', '2147713026', '2147581952']], ['-1', '-1', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', [['2147483648', '2147483647', '0', '-1'], ['-2147483648', '-2147483647', '-1', '0']], ['0', '-1', '-1', '0'], ['i32x4', 'i32x4', 'i32x4']])
+
+        # i32x4.lt_u  (i32x4) (i8x16)
+        case_data.append(['#', 'i32x4.lt_u  (i32x4) (i8x16)'])
+        case_data.append(['lt_u', ['0xFFFFFFFF', '0xFF'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_u', ['4294967295', '255'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_u', ['0', '0'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_u', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_u', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_u', [['-8323200', '0', '1', '4294967295'], ['-128', '0', '1', '255']], ['0', '0', '-1', '0'], ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['lt_u', ['0x55555555', '0xAA'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+
+        # i32x4.lt_u  (i32x4) (i16x8)
+        case_data.append(['#', 'i32x4.lt_u  (i32x4) (i16x8)'])
+        case_data.append(['lt_u', ['0xFFFFFFFF', '0xFFFF'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_u', ['4294967295', '65535'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_u', ['0', '0'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_u', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_u', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_u', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['0', '0', '-1', '-1'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['lt_u', ['0xAAAAAAAA', '0x5555'], '0', ['i32x4', 'i16x8', 'i32x4']])
+
+        case_data.append(['lt_u', ['0_123_456_789', '123456789'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['lt_u', ['0x0_90AB_cdef', '-0x6f543210'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # le_s
+        # i32x4.le_s  (i32x4) (i32x4)
+        case_data.append(['#', 'le_s'])
+
+        case_data.append(['#', 'i32x4.le_s  (i32x4) (i32x4)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['le_s', ['0xFFFFFFFF', '0xFFFFFFFF'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', ['0x00000000', '0x00000000'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', ['0xF0F0F0F0', '0xF0F0F0F0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', ['0x0F0F0F0F', '0x0F0F0F0F'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['0xFFFFFFFF', '0x00000000'], ['0xFFFFFFFF', '0x00000000']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['0x00000000', '0xFFFFFFFF'], ['0x00000000', '0xFFFFFFFF']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['le_s', ['0xFFFFFFFF', '4294967295'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', ['0xFFFFFFFF', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', ['0x80808080', '2155905152'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', ['0x80808080', '-2139062144'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['0x83828180', '0x00FFFEFD', '0x7F020100', '0xFFFEFD80'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['le_s', ['-1', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', ['0', '0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', ['4294967295', '4294967295'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', ['4294967295', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['4294967295', '0'], ['4294967295', '0']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['0', '4294967295'], ['0', '4294967295']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['-2147483647', '4294967295', '0', '-1'],
+                          ['2147483649', '-1', '0', '-1']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['le_s', [['0xc3000000', '0xc2fe0000', '0xbf800000', '0x00000000'], ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i32x4', 'f32x4', 'i32x4']])
+        case_data.append(['le_s', [['0x3f800000', '0x42fe0000', '0x43000000', '0x437f0000'], ['1.0', '127.0', '128.0', '255.0']], '-1', ['i32x4', 'f32x4', 'i32x4']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['le_s', ['0x0F0F0F0F', '0xF0F0F0F0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['0x00000000', '0xFFFFFFFF'], ['0xFFFFFFFF', '0x00000000']], ['0', '0', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['0x02030001', '0x10110409', '0x0B1A120A', '0xABFF1BAA'],
+                          ['0xAA1BFFAB', '0x0A121A0B', '0x09041110', '0x01000302']], ['0', '0', '0', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['0x80018000', '0x80038002', '0x80058004', '0x80078006'],
+                          ['2147975174', '2147844100', '2147713026', '2147581952']], ['-1', '-1', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', [['2147483648', '2147483647', '0', '-1'], ['-2147483648', '-2147483647', '-1', '0']], ['-1', '0', '0', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+
+        # i32x4.le_s  (i32x4)(i8x16)
+        case_data.append(['#', 'i32x4.le_s  (i32x4)(i8x16)'])
+        case_data.append(['le_s', ['0xFFFFFFFF', '0xFF'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_s', ['4294967295', '255'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_s', ['0', '0'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_s', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_s', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_s', [['-8323200', '0', '1', '4294967295'], ['-128', '0', '1', '255']], ['0', '-1', '-1', '-1'], ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_s', ['0x55555555', '0xAA'], '0', ['i32x4', 'i8x16', 'i32x4']])
+
+        # i32x4.le_s  (i32x4) (i16x8)
+        case_data.append(['#', 'i32x4.le_s  (i32x4) (i16x8)'])
+        case_data.append(['le_s', ['0xFFFFFFFF', '0xFFFF'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_s', ['4294967295', '65535'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_s', ['0', '0'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_s', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_s', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_s', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['0', '-1', '-1', '-1'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_s', ['0xAAAAAAAA', '0x5555'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+
+        case_data.append(['le_s', ['0_123_456_789', '123456789'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_s', ['0x0_1234_5678', '0x12345678'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # le_u
+        # i32x4.le_u  (i32x4) (i32x4)
+        case_data.append(['#', 'le_u'])
+
+        case_data.append(['#', 'i32x4.le_u  (i32x4) (i32x4)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['le_u', ['0xFFFFFFFF', '0xFFFFFFFF'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', ['0x00000000', '0x00000000'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', ['0xF0F0F0F0', '0xF0F0F0F0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', ['0x0F0F0F0F', '0x0F0F0F0F'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['0xFFFFFFFF', '0x00000000'], ['0xFFFFFFFF', '0x00000000']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['0x00000000', '0xFFFFFFFF'], ['0x00000000', '0xFFFFFFFF']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['le_u', ['0xFFFFFFFF', '4294967295'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', ['0xFFFFFFFF', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', ['0x80808080', '2155905152'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', ['0x80808080', '-2139062144'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['0x83828180', '0x00FFFEFD', '0x7F020100', '0xFFFEFD80'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['le_u', ['-1', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', ['0', '0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', ['4294967295', '4294967295'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', ['4294967295', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['4294967295', '0'], ['4294967295', '0']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['0', '4294967295'], ['0', '4294967295']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['-2147483647', '4294967295', '0', '-1'], ['2147483649', '-1', '0', '-1']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['le_u', [['0xc3000000', '0xc2fe0000', '0xbf800000', '0x00000000'], ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i32x4', 'f32x4', 'i32x4']])
+        case_data.append(['le_u', [['0x3f800000', '0x42fe0000', '0x43000000', '0x437f0000'], ['1.0', '127.0', '128.0', '255.0']], '-1', ['i32x4', 'f32x4', 'i32x4']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['le_u', ['0x0F0F0F0F', '0xF0F0F0F0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['0x00000000', '0xFFFFFFFF'], ['0xFFFFFFFF', '0x00000000']], ['-1', '-1', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['0x02030001', '0x10110409', '0x0B1A120A', '0xABFF1BAA'],
+                          ['0xAA1BFFAB', '0x0A121A0B', '0x09041110', '0x01000302']], ['-1', '0', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['0x80018000', '0x80038002', '0x80058004', '0x80078006'],
+                          ['2147975174', '2147844100', '2147713026', '2147581952']], ['-1', '-1', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', [['2147483648', '2147483647', '0', '-1'], ['-2147483648', '-2147483647', '-1', '0']], ['-1', '-1', '-1', '0'], ['i32x4', 'i32x4', 'i32x4']])
+
+        # i32x4.le_u  (i32x4) (i8x16)
+        case_data.append(['#', 'i32x4.le_u  (i32x4) (i8x16)'])
+        case_data.append(['le_u', ['0xFFFFFFFF', '0xFF'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_u', ['4294967295', '255'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_u', ['0', '0'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_u', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_u', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_u', [['-8323200', '0', '1', '4294967295'], ['-128', '0', '1', '255']], ['0', '-1', '-1', '-1'], ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['le_u', ['0x55555555', '0xAA'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+
+        # i32x4.le_u  (i32x4) (i16x8)
+        case_data.append(['#', 'i32x4.le_u  (i32x4) (i16x8)'])
+        case_data.append(['le_u', ['0xFFFFFFFF', '0xFFFF'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_u', ['4294967295', '65535'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_u', ['0', '0'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_u', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_u', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_u', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['0', '-1', '-1', '-1'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['le_u', ['0xAAAAAAAA', '0x5555'], '0', ['i32x4', 'i16x8', 'i32x4']])
+
+        case_data.append(['le_u', ['0_123_456_789', '123456789'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['le_u', ['0x0_90AB_cdef', '0x90ABcdef'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # gt_s
+        # i32x4.gt_s  (i32x4) (i32x4)
+        case_data.append(['#', 'gt_s'])
+
+        case_data.append(['#', 'i32x4.gt_s  (i32x4) (i32x4)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['gt_s', ['0xFFFFFFFF', '0xFFFFFFFF'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', ['0x00000000', '0x00000000'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', ['0xF0F0F0F0', '0xF0F0F0F0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', ['0x0F0F0F0F', '0x0F0F0F0F'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['0xFFFFFFFF', '0x00000000'], ['0xFFFFFFFF', '0x00000000']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['0x00000000', '0xFFFFFFFF'], ['0x00000000', '0xFFFFFFFF']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['gt_s', ['0xFFFFFFFF', '4294967295'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', ['0xFFFFFFFF', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', ['0x80808080', '2155905152'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', ['0x80808080', '-2139062144'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['0x83828180', '0x00FFFEFD', '0x7F020100', '0xFFFEFD80'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['gt_s', ['-1', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', ['0', '0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', ['4294967295', '4294967295'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', ['4294967295', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['4294967295', '0'], ['4294967295', '0']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['0', '4294967295'], ['0', '4294967295']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['-2147483647', '4294967295', '0', '-1'], ['2147483649', '-1', '0', '-1']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['gt_s', [['0xc3000000', '0xc2fe0000', '0xbf800000', '0x00000000'], ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i32x4', 'f32x4', 'i32x4']])
+        case_data.append(['gt_s', [['0x3f800000', '0x42fe0000', '0x43000000', '0x437f0000'], ['1.0', '127.0', '128.0', '255.0']], '0', ['i32x4', 'f32x4', 'i32x4']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['gt_s', ['0x0F0F0F0F', '0xF0F0F0F0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['0x00000000', '0xFFFFFFFF'], ['0xFFFFFFFF', '0x00000000']], ['-1', '-1', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['0x02030001', '0x10110409', '0x0B1A120A', '0xABFF1BAA'],
+                          ['0xAA1BFFAB', '0x0A121A0B', '0x09041110', '0x01000302']], ['-1', '-1', '-1', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['0x80018000', '0x80038002', '0x80058004', '0x80078006'],
+                          ['2147975174', '2147844100', '2147713026', '2147581952']], ['0', '0', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', [['2147483648', '2147483647', '0', '-1'], ['-2147483648', '-2147483647', '-1', '0']], ['0', '-1', '-1', '0'], ['i32x4', 'i32x4', 'i32x4']])
+
+        # i32x4.gt_s  (i32x4) (i8x16)
+        case_data.append(['#', 'i32x4.gt_s  (i32x4) (i8x16)'])
+        case_data.append(['gt_s', ['0xFFFFFFFF', '0xFF'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_s', ['4294967295', '255'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_s', ['0', '0'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_s', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_s', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_s', [['-8323200', '0', '1', '4294967295'], ['-128', '0', '1', '255']], ['-1', '0', '0', '0'], ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_s', ['0x55555555', '0xAA'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+
+        # i32x4.gt_s  (i32x4) (i16x8)
+        case_data.append(['#', 'i32x4.gt_s  (i32x4) (i16x8)'])
+        case_data.append(['gt_s', ['0xFFFFFFFF', '0xFFFF'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_s', ['4294967295', '65535'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_s', ['0', '0'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_s', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_s', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_s', [['65535', '0', '1', '32768'], ['65535', '65535', '0', '0', '1', '1', '32768', '32768']], ['-1', '0', '0', '-1'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_s', ['0xAAAAAAAA', '0x5555'], '0', ['i32x4', 'i16x8', 'i32x4']])
+
+        case_data.append(['gt_s', ['0_123_456_789', '123456789'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_s', ['0x0_90AB_cdef', '-0x6f543211'], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # gt_u
+        # i32x4.gt_u  (i32x4) (i32x4)
+        case_data.append(['#', 'gt_u'])
+
+        case_data.append(['#', 'i32x4.gt_u  (i32x4) (i32x4)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['gt_u', ['0xFFFFFFFF', '0xFFFFFFFF'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', ['0x00000000', '0x00000000'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', ['0xF0F0F0F0', '0xF0F0F0F0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', ['0x0F0F0F0F', '0x0F0F0F0F'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['0xFFFFFFFF', '0x00000000'], ['0xFFFFFFFF', '0x00000000']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['0x00000000', '0xFFFFFFFF'], ['0x00000000', '0xFFFFFFFF']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['gt_u', ['0xFFFFFFFF', '4294967295'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', ['0xFFFFFFFF', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', ['0x80808080', '2155905152'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', ['0x80808080', '-2139062144'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['0x83828180', '0x00FFFEFD', '0x7F020100', '0xFFFEFD80'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['gt_u', ['-1', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', ['0', '0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', ['4294967295', '4294967295'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', ['4294967295', '-1'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['4294967295', '0'], ['4294967295', '0']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['0', '4294967295'], ['0', '4294967295']], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['-2147483647', '4294967295', '0', '-1'], ['2147483649', '-1', '0', '-1']], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['gt_u', [['0xc3000000', '0xc2fe0000', '0xbf800000', '0x00000000'], ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i32x4', 'f32x4', 'i32x4']])
+        case_data.append(['gt_u', [['0x3f800000', '0x42fe0000', '0x43000000', '0x437f0000'], ['1.0', '127.0', '128.0', '255.0']], '0', ['i32x4', 'f32x4', 'i32x4']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['gt_u', ['0x0F0F0F0F', '0xF0F0F0F0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['0x00000000', '0xFFFFFFFF'], ['0xFFFFFFFF', '0x00000000']], ['0', '0', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['0x02030001', '0x10110409', '0x0B1A120A', '0xABFF1BAA'],
+                          ['0xAA1BFFAB', '0x0A121A0B', '0x09041110', '0x01000302']], ['0', '-1', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['0x80018000', '0x80038002', '0x80058004', '0x80078006'],
+                          ['2147975174', '2147844100', '2147713026', '2147581952']], ['0', '0', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', [['2147483648', '2147483647', '0', '-1'], ['-2147483648', '-2147483647', '-1', '0']], ['0', '0', '0', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+
+        # i32x4.gt_u  (i32x4) (i8x16)
+        case_data.append(['#', 'i32x4.gt_u  (i32x4) (i8x16)'])
+        case_data.append(['gt_u', ['0xFFFFFFFF', '0xFF'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_u', ['4294967295', '255'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_u', ['0', '0'], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_u', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_u', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_u', [['-8323200', '0', '1', '4294967295'], ['-128', '0', '1', '255']], ['-1', '0', '0', '0'], ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['gt_u', ['0x55555555', '0xAA'], '0', ['i32x4', 'i8x16', 'i32x4']])
+
+        # i32x4.gt_u  (i32x4) (i16x8)
+        case_data.append(['#', 'i32x4.gt_u  (i32x4) (i16x8)'])
+        case_data.append(['gt_u', ['0xFFFFFFFF', '0xFFFF'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_u', ['4294967295', '65535'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_u', ['0', '0'], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_u', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '0', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_u', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], ['0', '0', '0', '0'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_u', [['-128', '0', '1', '255'], ['-128', '0', '1', '255']], ['-1', '0', '0', '0'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['gt_u', ['0xAAAAAAAA', '0x5555'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+
+        case_data.append(['gt_u', ['0_123_456_789', '123456789'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['gt_u', ['0x0_1234_5678', '0x12345678'], '0', ['i32x4', 'i32x4', 'i32x4']])
+
+        # ge_s
+        # i32x4.ge_s  (i32x4) (i32x4)
+        case_data.append(['#', 'ge_s'])
+
+        case_data.append(['#', 'i32x4.ge_s  (i32x4) (i32x4)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ge_s', ['0xFFFFFFFF', '0xFFFFFFFF'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', ['0x00000000', '0x00000000'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', ['0xF0F0F0F0', '0xF0F0F0F0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', ['0x0F0F0F0F', '0x0F0F0F0F'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['0xFFFFFFFF', '0x00000000'], ['0xFFFFFFFF', '0x00000000']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['0x00000000', '0xFFFFFFFF'], ['0x00000000', '0xFFFFFFFF']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['ge_s', ['0xFFFFFFFF', '4294967295'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', ['0xFFFFFFFF', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', ['0x80808080', '2155905152'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', ['0x80808080', '-2139062144'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['0x83828180', '0x00FFFEFD', '0x7F020100', '0xFFFEFD80'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['ge_s', ['-1', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', ['0', '0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', ['4294967295', '4294967295'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', ['4294967295', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['4294967295', '0'], ['4294967295', '0']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['0', '4294967295'], ['0', '4294967295']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['-2147483647', '4294967295', '0', '-1'], ['2147483649', '-1', '0', '-1']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['ge_s', [['0xc3000000', '0xc2fe0000', '0xbf800000', '0x00000000'], ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i32x4', 'f32x4', 'i32x4']])
+        case_data.append(['ge_s', [['0x3f800000', '0x42fe0000', '0x43000000', '0x437f0000'], ['1.0', '127.0', '128.0', '255.0']], '-1', ['i32x4', 'f32x4', 'i32x4']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['ge_s', ['0x0F0F0F0F', '0xF0F0F0F0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['0x00000000', '0xFFFFFFFF'], ['0xFFFFFFFF', '0x00000000']], ['-1', '-1', '0', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['0x02030001', '0x10110409', '0x0B1A120A', '0xABFF1BAA'],
+                          ['0xAA1BFFAB', '0x0A121A0B', '0x09041110', '0x01000302']], ['-1', '-1', '-1', '0'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['0x80018000', '0x80038002', '0x80058004', '0x80078006'],
+                          ['2147975174', '2147844100', '2147713026', '2147581952']], ['0', '0', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', [['2147483648', '2147483647', '0', '-1'], ['-2147483648', '-2147483647', '-1', '0']], ['-1', '-1', '-1', '0'], ['i32x4', 'i32x4', 'i32x4']])
+
+        # i32x4.ge_s  (i32x4) (i8x16)
+        case_data.append(['#', 'i32x4.ge_s  (i32x4) (i8x16)'])
+        case_data.append(['ge_s', ['0xFFFFFFFF', '0xFF'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_s', ['4294967295', '255'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_s', ['0', '0'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_s', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_s', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_s', [['-8323200', '0', '1', '4294967295'], ['-128', '0', '1', '255']], ['-1', '-1', '0', '-1'], ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_s', ['0x55555555', '0x55'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+
+        # i32x4.ge_s  (i32x4) (i16x8)
+        case_data.append(['#', 'i32x4.ge_s  (i32x4) (i16x8)'])
+        case_data.append(['ge_s', ['0xFFFFFFFF', '0xFFFF'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_s', ['4294967295', '65535'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_s', ['0', '0'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_s', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_s', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_s', [['65535', '0', '1', '32768'], ['65535', '65535', '0', '0', '1', '1', '32768', '32768']], ['-1', '-1', '0', '-1'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_s', ['0xAAAAAAAA', '0x5555'], '0', ['i32x4', 'i16x8', 'i32x4']])
+
+        case_data.append(['ge_s', ['0_123_456_789', '123456789'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_s', ['0x0_1234_5678', '0x12345678'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # ge_u
+        # i32x4.ge_u  (i32x4) (i32x4)
+        case_data.append(['#', 'ge_u'])
+
+        case_data.append(['#', 'i32x4.ge_u  (i32x4) (i32x4)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ge_u', ['0xFFFFFFFF', '0xFFFFFFFF'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', ['0x00000000', '0x00000000'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', ['0xF0F0F0F0', '0xF0F0F0F0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', ['0x0F0F0F0F', '0x0F0F0F0F'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['0xFFFFFFFF', '0x00000000'], ['0xFFFFFFFF', '0x00000000']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['0x00000000', '0xFFFFFFFF'], ['0x00000000', '0xFFFFFFFF']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['ge_u', ['0xFFFFFFFF', '4294967295'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', ['0xFFFFFFFF', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', ['0x80808080', '2155905152'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', ['0x80808080', '-2139062144'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['0x83828180', '0x00FFFEFD', '0x7F020100', '0xFFFEFD80'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['ge_u', ['-1', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', ['0', '0'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', ['4294967295', '4294967295'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', ['4294967295', '-1'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['4294967295', '0'], ['4294967295', '0']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['0', '4294967295'], ['0', '4294967295']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['-2147483647', '4294967295', '0', '-1'], ['2147483649', '-1', '0', '-1']], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['ge_u', [['0xc3000000', '0xc2fe0000', '0xbf800000', '0x00000000'], ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i32x4', 'f32x4', 'i32x4']])
+        case_data.append(['ge_u', [['0x3f800000', '0x42fe0000', '0x43000000', '0x437f0000'], ['1.0', '127.0', '128.0', '255.0']], '-1', ['i32x4', 'f32x4', 'i32x4']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['ge_u', ['0x0F0F0F0F', '0xF0F0F0F0'], '0', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['0x00000000', '0xFFFFFFFF'], ['0xFFFFFFFF', '0x00000000']], ['0', '0', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['0x02030001', '0x10110409', '0x0B1A120A', '0xABFF1BAA'],
+                          ['0xAA1BFFAB', '0x0A121A0B', '0x09041110', '0x01000302']], ['0', '-1', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['0x80018000', '0x80038002', '0x80058004', '0x80078006'],
+                          ['2147975174', '2147844100', '2147713026', '2147581952']], ['0', '0', '-1', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', [['2147483648', '2147483647', '0', '-1'], ['-2147483648', '-2147483647', '-1', '0']], ['-1', '0', '0', '-1'], ['i32x4', 'i32x4', 'i32x4']])
+
+        # i32x4.ge_u  (i32x4) (i8x16)
+        case_data.append(['#', 'i32x4.ge_u  (i32x4) (i8x16)'])
+        case_data.append(['ge_u', ['0xFFFFFFFF', '0xFF'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_u', ['4294967295', '255'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_u', ['0', '0'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_u', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F']], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_u', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_u', [['-8323200', '0', '1', '4294967295'], ['-128', '0', '1', '255']],
+                          ['-1', '-1', '0', '-1'], ['i32x4', 'i8x16', 'i32x4']])
+        case_data.append(['ge_u', ['0xAAAAAAAA', '0x55'], '-1', ['i32x4', 'i8x16', 'i32x4']])
+
+        # i32x4.ge_u  (i32x4) (i16x8)
+        case_data.append(['#', 'i32x4.ge_u  (i32x4) (i16x8)'])
+        case_data.append(['ge_u', ['0xFFFFFFFF', '0xFFFF'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_u', ['4294967295', '65535'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_u', ['0', '0'], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_u', [['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_u', [['2206368128', '16776957', '2130837760', '4294901120'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_u', [['-128', '0', '1', '255'], ['65535', '65535', '0', '0', '1', '1', '32768', '32768']], ['0', '-1', '0', '0'], ['i32x4', 'i16x8', 'i32x4']])
+        case_data.append(['ge_u', ['0xAAAAAAAA', '0x5555'], ['-1', '-1', '-1', '-1'], ['i32x4', 'i16x8', 'i32x4']])
+
+        case_data.append(['ge_u', ['0_123_456_789', '123456789'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+        case_data.append(['ge_u', ['0x0_1234_5678', '0x12345678'], '-1', ['i32x4', 'i32x4', 'i32x4']])
+
+        return case_data
+
+    # generate all test cases
+    def get_all_cases(self):
+
+        # Add tests for unkonow operators for i32x4
+        return SimdCmpCase.get_all_cases(self) + """
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.eq (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ne (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.lt_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.lt_u (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.le_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.le_u (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.gt_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.gt_u (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ge_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ge_u (local.get $x) (local.get $y)))") "unknown operator")
+
+"""
+
+
+def gen_test_cases():
+    i32x4 = Simdi32x4CmpCase()
+    i32x4.gen_test_cases()
+
+
+if __name__ == '__main__':
+    i32x4 = Simdi32x4CmpCase()
+    i32x4.gen_test_cases()
diff --git a/test/core/simd/meta/simd_i32x4_dot_i16x8.py b/test/core/simd/meta/simd_i32x4_dot_i16x8.py
new file mode 100644
index 000000000..1d62fc102
--- /dev/null
+++ b/test/core/simd/meta/simd_i32x4_dot_i16x8.py
@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+
+from simd_arithmetic import SimdArithmeticCase, i16
+from simd_integer_op import ArithmeticOp
+
+
+class SimdI32x4DotI16x8TestCase(SimdArithmeticCase):
+    LANE_TYPE = 'i32x4'
+    UNARY_OPS = ()
+    BINARY_OPS = ('dot_i16x8_s',)
+
+    @property
+    def lane(self):
+        return i16
+
+    def binary_op(self, x, y, lane):
+        # For test data we always splat a single value to the
+        # entire v128, so '* 2' will work here.
+        return ArithmeticOp.get_valid_value(x, i16) * ArithmeticOp.get_valid_value(y, i16) * 2
+
+    @property
+    def hex_binary_op_test_data(self):
+        return []
+
+    @property
+    def bin_test_data(self):
+        return [
+            (self.normal_binary_op_test_data, ['i16x8', 'i16x8', 'i32x4']),
+            (self.hex_binary_op_test_data, ['i16x8', 'i16x8', 'i32x4'])
+        ]
+
+    def get_case_data(self):
+        case_data = []
+        op_name = 'i32x4.dot_i16x8_s'
+        case_data.append(['#', op_name])
+        for data_group, v128_forms in self.bin_test_data:
+            for data in data_group:
+                case_data.append([op_name, [str(data[0]), str(data[1])],
+                    str(self.binary_op(data[0], data[1], self.lane)),
+                    v128_forms])
+        return case_data
+
+    def get_combine_cases(self):
+        return ''
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_i32x4_dot_i16x8.wast'
+        with open(wast_filename, 'w') as fp:
+            fp.write(self.get_all_cases())
+
+def gen_test_cases():
+    simd_i16x8_arith = SimdI32x4DotI16x8TestCase()
+    simd_i16x8_arith.gen_test_cases()
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_i64x2_arith.py b/test/core/simd/meta/simd_i64x2_arith.py
new file mode 100644
index 000000000..a65bcc389
--- /dev/null
+++ b/test/core/simd/meta/simd_i64x2_arith.py
@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+
+"""
+Generate i64x2 integer arithmetic operation cases.
+"""
+
+from simd_arithmetic import SimdArithmeticCase
+
+
+class SimdI64x2ArithmeticCase(SimdArithmeticCase):
+
+    LANE_LEN = 2
+    LANE_TYPE = 'i64x2'
+
+    @property
+    def hex_binary_op_test_data(self):
+        return [
+            ('0x3fffffffffffffff', '0x4000000000000000'),
+            ('0x4000000000000000', '0x4000000000000000'),
+            ('-0x3fffffffffffffff', '-0x40000000fffffff'),
+            ('-0x4000000000000000', '-0x400000000000000'),
+            ('-0x4000000000000000', '-0x400000000000001'),
+            ('0x7fffffffffffffff', '0x7ffffffffffffff'),
+            ('0x7fffffffffffffff', '0x01'),
+            ('0x8000000000000000', '-0x01'),
+            ('0x7fffffffffffffff', '0x8000000000000000'),
+            ('0x8000000000000000', '0x8000000000000000'),
+            ('0xffffffffffffffff', '0x01'),
+            ('0xffffffffffffffff', '0xffffffffffffffff')
+        ]
+
+    @property
+    def hex_unary_op_test_data(self):
+        return ['0x01', '-0x01', '-0x8000000000000000', '-0x7fffffffffffffff',
+                '0x7fffffffffffffff', '0x8000000000000000', '0xffffffffffffffff']
+
+    @property
+    def underscore_literal_test_data(self):
+        return {
+            'i64x2.add': [
+                [['01_234_567_890_123_456_789', '01_234_567_890_123_456_789'],
+                 '02_469_135_780_246_913_578', ['i64x2'] * 3],
+                [['0x0_1234_5678_90AB_cdef', '0x0_90AB_cdef_1234_5678'],
+                 '0x0_a2e0_2467_a2e0_2467', ['i64x2'] * 3]
+            ],
+            'i64x2.sub': [
+                [['03_214_567_890_123_456_789', '01_234_567_890_123_456_789'],
+                 '01_980_000_000_000_000_000', ['i64x2'] * 3],
+                [['0x0_90AB_cdef_8765_4321', '0x0_1234_5678_90AB_cdef'],
+                 '0x0_7e77_7776_f6b9_7532', ['i64x2'] * 3]
+            ],
+            'i64x2.mul': [
+                [['01_234_567_890_123_456_789', '01_234_567_890_123_456_789'],
+                 '09_710_478_858_155_731_897', ['i64x2'] * 3],
+                [['0x0_1234_5678_90AB_cdef', '0x0_90AB_cdef_8765_4321'],
+                 '0x0_602f_05e9_e556_18cf', ['i64x2'] * 3]
+            ]
+        }
+
+    @property
+    def i64x2_i8x16_test_data(self):
+        """This test data will be intepreted by the SIMD.v128_const() method in simd.py."""
+        return {
+            'i64x2.add': [
+                [['0x7fffffffffffffff', ['0', '0', '0', '0', '0', '0', '0', '0x80'] * 2], '-1',
+                 ['i64x2', 'i8x16', 'i64x2']],
+                [['1', '255'], '0', ['i64x2', 'i8x16', 'i64x2']]
+            ],
+            'i64x2.sub': [
+                [['0x7fffffffffffffff', ['0', '0', '0', '0', '0', '0', '0', '0x80'] * 2], '-1',
+                 ['i64x2', 'i8x16', 'i64x2']],
+                [['1', '255'], '2', ['i64x2', 'i8x16', 'i64x2']]
+            ],
+            'i64x2.mul': [
+                [['0x8000000000000000', '0x2'], '0', ['i64x2', 'i8x16', 'i64x2']],
+                [['0xffffffffffffffff', '255'], '1', ['i64x2', 'i8x16', 'i64x2']]
+            ]
+        }
+
+    @property
+    def i64x2_i16x8_test_data(self):
+        """This test data will be intepreted by the SIMD.v128_const() method in simd.py."""
+        return {
+            'i64x2.add': [
+                [['0x7fffffffffffffff', ['0', '0', '0', '0x8000'] * 2], '-1', ['i64x2', 'i16x8', 'i64x2']],
+                [['1', '0xffff'], '0', ['i64x2', 'i16x8', 'i64x2']]
+            ],
+            'i64x2.sub': [
+                [['0x7fffffffffffffff', ['0', '0', '0', '0x8000'] * 2], '-1', ['i64x2', 'i16x8', 'i64x2']],
+                [['1', '0xffff'], '2', ['i64x2', 'i16x8', 'i64x2']]
+            ],
+            'i64x2.mul': [
+                [['0x8000000000000000', ['0', '0', '0', '0x02'] * 4], '0', ['i64x2', 'i16x8', 'i64x2']],
+                [['0xffffffffffffffff', '0xffff'], '1', ['i64x2', 'i16x8', 'i64x2']]
+            ]
+        }
+
+    @property
+    def i64x2_i32x4_test_data(self):
+        """This test data will be intepreted by the SIMD.v128_const() method in simd.py."""
+        return {
+            'i64x2.add': [
+                [['0x7fffffffffffffff', ['0', '0x80000000'] * 2], '-1', ['i64x2', 'i32x4', 'i64x2']],
+                [['1', '0xffffffff'], '0', ['i64x2', 'i32x4', 'i64x2']]
+            ],
+            'i64x2.sub': [
+                [['0x7fffffffffffffff', ['0', '0x80000000'] * 2], '-1', ['i64x2', 'i32x4', 'i64x2']],
+                [['1', '0xffffffff'], '2', ['i64x2', 'i32x4', 'i64x2']]
+            ],
+            'i64x2.mul': [
+                [['0x8000000000000000', ['0', '0x02'] * 2], '0', ['i64x2', 'i32x4', 'i64x2']],
+                [['0xffffffffffffffff', '0xffffffff'], '1', ['i64x2', 'i32x4', 'i64x2']]
+            ]
+        }
+
+    @property
+    def i64x2_f64x2_test_data(self):
+        """This test data will be intepreted by the SIMD.v128_const() method in simd.py."""
+        return {
+            'i64x2.add': [
+                [['0x8000000000000000', '+0.0'], '0x8000000000000000', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x8000000000000000', '-0.0'], '0', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x8000000000000000', '1.0'], '0xbff0000000000000', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x8000000000000000', '-1.0'], '0x3ff0000000000000', ['i64x2', 'f64x2', 'i64x2']],
+                [['1', '+inf'], '0x7ff0000000000001', ['i64x2', 'f64x2', 'i64x2']],
+                [['1', '-inf'], '0xfff0000000000001', ['i64x2', 'f64x2', 'i64x2']],
+                [['1', 'nan'], '0x7ff8000000000001', ['i64x2', 'f64x2', 'i64x2']]
+            ],
+            'i64x2.sub': [
+                [['0x8000000000000000', '+0.0'], '0x8000000000000000', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x8000000000000000', '-0.0'], '0', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x8000000000000000', '1.0'], '0x4010000000000000', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x8000000000000000', '-1.0'], '0xc010000000000000', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x1', '+inf'], '0x8010000000000001', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x1', '-inf'], '0x0010000000000001', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x1', 'nan'], '0x8008000000000001', ['i64x2', 'f64x2', 'i64x2']]
+            ],
+            'i64x2.mul': [
+                [['0x80000000', '+0.0'], '0', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x80000000', '-0.0'], '0', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x80000000', '1.0'], '0', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x80000000', '-1.0'], '0', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x1', '+inf'], '0x7ff0000000000000', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x1', '-inf'], '0xfff0000000000000', ['i64x2', 'f64x2', 'i64x2']],
+                [['0x1', 'nan'], '0x7ff8000000000000', ['i64x2', 'f64x2', 'i64x2']]
+            ]
+        }
+
+    @property
+    def combine_dec_hex_test_data(self):
+        """This test data will be intepreted by the SIMD.v128_const() method in simd.py."""
+        return {
+            'i64x2.add': [
+                [[['0', '1'], ['0', '0xffffffffffffffff']], ['0'] * 2, ['i64x2'] * 3]
+            ],
+            'i64x2.sub': [
+                [[['0', '1'], ['0', '0xffffffffffffffff']], ['0', '0x02'], ['i64x2'] * 3]
+            ],
+            'i64x2.mul': [
+                [[['0', '1'], ['0', '0xffffffffffffffff']], ['0', '0xffffffffffffffff'], ['i64x2'] * 3]
+            ]
+        }
+
+    @property
+    def range_test_data(self):
+        """This test data will be intepreted by the SIMD.v128_const() method in simd.py."""
+        return {
+            'i64x2.add': [
+                [[[str(i) for i in range(2)], [str(i * 2) for i in range(2)]],
+                 [str(i * 3) for i in range(2)], ['i64x2'] * 3]
+            ],
+            'i64x2.sub': [
+                [[[str(i) for i in range(2)], [str(i * 2) for i in range(2)]],
+                 [str(-i) for i in range(2)], ['i64x2'] * 3]
+            ],
+            'i64x2.mul': [
+                [[[str(i) for i in range(2)], [str(i * 2) for i in range(4)]],
+                 ['0', '0x02'], ['i64x2'] * 3]
+            ]
+        }
+
+    @property
+    def full_bin_test_data(self):
+        return [
+            self.i64x2_i8x16_test_data,
+            self.i64x2_i16x8_test_data,
+            self.i64x2_i32x4_test_data,
+            self.i64x2_f64x2_test_data,
+            self.combine_dec_hex_test_data,
+            self.range_test_data,
+            self.underscore_literal_test_data
+        ]
+
+
+def gen_test_cases():
+    simd_i64x2_arith = SimdI64x2ArithmeticCase()
+    simd_i64x2_arith.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
\ No newline at end of file
diff --git a/test/core/simd/meta/simd_i64x2_cmp.py b/test/core/simd/meta/simd_i64x2_cmp.py
new file mode 100644
index 000000000..35089efe1
--- /dev/null
+++ b/test/core/simd/meta/simd_i64x2_cmp.py
@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+
+from simd_compare import SimdCmpCase
+
+
+# Generate i64x2 test case
+class Simdi64x2CmpCase(SimdCmpCase):
+    LANE_TYPE = 'i64x2'
+
+    BINARY_OPS = ['eq', 'ne']
+
+    # Override this since i64x2 does not support as many comparison instructions.
+    CASE_TXT = """
+;; Test all the {lane_type} comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) ({lane_type}.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) ({lane_type}.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x v128) (param $y v128) (result v128) ({lane_type}.lt_s (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x v128) (param $y v128) (result v128) ({lane_type}.le_s (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x v128) (param $y v128) (result v128) ({lane_type}.gt_s (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x v128) (param $y v128) (result v128) ({lane_type}.ge_s (local.get $x) (local.get $y)))
+)
+
+{normal_case}
+
+;; Type check
+
+(assert_invalid (module (func (result v128) ({lane_type}.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) ({lane_type}.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+"""
+
+    def get_case_data(self):
+        forms = ['i64x2'] * 3
+        case_data = []
+
+        case_data.append(['#', 'eq'])
+        case_data.append(['#', 'i64x2.eq  (i64x2) (i64x2)'])
+        case_data.append(['eq', ['0xFFFFFFFFFFFFFFFF', '0xFFFFFFFFFFFFFFFF'], '-1', forms])
+        case_data.append(['eq', ['0x0000000000000000', '0x0000000000000000'], '-1', forms])
+        case_data.append(['eq', ['0xF0F0F0F0F0F0F0F0', '0xF0F0F0F0F0F0F0F0'], '-1', forms])
+        case_data.append(['eq', ['0x0F0F0F0F0F0F0F0F', '0x0F0F0F0F0F0F0F0F'], '-1', forms])
+        case_data.append(['eq', [['0xFFFFFFFFFFFFFFFF', '0x0000000000000000'], ['0xFFFFFFFFFFFFFFFF', '0x0000000000000000']], '-1', forms])
+        case_data.append(['eq', [['0x0000000000000000', '0xFFFFFFFFFFFFFFFF'], ['0x0000000000000000', '0xFFFFFFFFFFFFFFFF']], '-1', forms])
+        case_data.append(['eq', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '-1', forms])
+        case_data.append(['eq', ['0xFFFFFFFFFFFFFFFF', '0x0FFFFFFFFFFFFFFF'], '0', forms])
+        case_data.append(['eq', ['0x1', '0x2'], '0', forms])
+
+        case_data.append(['#', 'ne'])
+        case_data.append(['#', 'i64x2.ne  (i64x2) (i64x2)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ne', ['0xFFFFFFFFFFFFFFFF', '0xFFFFFFFFFFFFFFFF'], '0', forms])
+        case_data.append(['ne', ['0x0000000000000000', '0x0000000000000000'], '0', forms])
+        case_data.append(['ne', ['0xF0F0F0F0F0F0F0F0', '0xF0F0F0F0F0F0F0F0'], '0', forms])
+        case_data.append(['ne', ['0x0F0F0F0F0F0F0F0F', '0x0F0F0F0F0F0F0F0F'], '0', forms])
+        case_data.append(['ne', [['0xFFFFFFFFFFFFFFFF', '0x0000000000000000'], ['0xFFFFFFFFFFFFFFFF', '0x0000000000000000']], '0', forms])
+        case_data.append(['ne', [['0x0000000000000000', '0xFFFFFFFFFFFFFFFF'], ['0x0000000000000000', '0xFFFFFFFFFFFFFFFF']], '0', forms])
+        case_data.append(['ne', [['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B'],
+                          ['0x03020100', '0x11100904', '0x1A0B0A12', '0xFFABAA1B']], '0', forms])
+
+        # lt_s
+        # i64x2.lt_s  (i64x2) (i64x2)
+        case_data.append(['#', 'lt_s'])
+        case_data.append(['#', 'i64x2.lt_s  (i64x2) (i64x2)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['lt_s', ['0xFFFFFFFFFFFFFFFF', '0xFFFFFFFFFFFFFFFF'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', ['0x0000000000000000', '0x0000000000000000'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', ['0xF0F0F0F0F0F0F0F0', '0xF0F0F0F0F0F0F0F0'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', ['0x0F0F0F0F0F0F0F0F', '0x0F0F0F0F0F0F0F0F'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', [['0xFFFFFFFFFFFFFFFF', '0x0000000000000000'], ['0xFFFFFFFFFFFFFFFF', '0x0000000000000000']], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', [['0x0000000000000000', '0xFFFFFFFFFFFFFFFF'], ['0x0000000000000000', '0xFFFFFFFFFFFFFFFF']], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', [['0x0302010011100904', '0x1A0B0A12FFABAA1B'],
+                          ['0x0302010011100904', '0x1A0B0A12FFABAA1B']], '0', ['i64x2', 'i64x2', 'i64x2']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['lt_s', ['0xFFFFFFFFFFFFFFFF', '18446744073709551615'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', ['0xFFFFFFFFFFFFFFFF', '-1'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', ['0x8080808080808080', '9259542123273814144'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', ['0x8080808080808080', '-9187201950435737472'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', [['0x8382818000FFFEFD', '0x7F020100FFFEFD80'],
+                          ['-8970465120996032771', '9151878496576798080']], '0', ['i64x2', 'i64x2', 'i64x2']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['lt_s', ['-1', '-1'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', ['0', '0'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', ['18446744073709551615', '18446744073709551615'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', ['18446744073709551615', '-1'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', [['18446744073709551615', '0'], ['18446744073709551615', '0']], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', [['0', '18446744073709551615'], ['0', '18446744073709551615']], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['lt_s', [['-9223372036854775807', '18446744073709551615'],
+                          ['9223372036854775809', '-1']], '0', ['i64x2', 'i64x2', 'i64x2']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['lt_s', [['0xc060000000000000', '0xc05fc00000000000'],
+                          ['-128.0', '-127.0']], '0', ['i64x2', 'f64x2', 'i64x2']])
+        case_data.append(['lt_s', [['0x3ff0000000000000', '0x405fc00000000000'],
+                          ['1.0', '127.0']], '0', ['i64x2', 'f64x2', 'i64x2']])
+
+        # le_s
+        # i64x2.le_s  (i64x2) (i64x2)
+        case_data.append(['#', 'le_s'])
+        case_data.append(['#', 'i64x2.le_s  (i64x2) (i64x2)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['le_s', ['0xFFFFFFFFFFFFFFFF', '0xFFFFFFFFFFFFFFFF'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', ['0x0000000000000000', '0x0000000000000000'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', ['0xF0F0F0F0F0F0F0F0', '0xF0F0F0F0F0F0F0F0'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', ['0x0F0F0F0F0F0F0F0F', '0x0F0F0F0F0F0F0F0F'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', [['0xFFFFFFFFFFFFFFFF', '0x0000000000000000'], ['0xFFFFFFFFFFFFFFFF', '0x0000000000000000']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', [['0x0000000000000000', '0xFFFFFFFFFFFFFFFF'], ['0x0000000000000000', '0xFFFFFFFFFFFFFFFF']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', [['0x0302010011100904', '0x1A0B0A12FFABAA1B'],
+                          ['0x0302010011100904', '0x1A0B0A12FFABAA1B']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['le_s', ['0xFFFFFFFFFFFFFFFF', '18446744073709551615'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', ['0xFFFFFFFFFFFFFFFF', '-1'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', ['0x8080808080808080', '9259542123273814144'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', ['0x8080808080808080', '-9187201950435737472'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', [['0x8382818000FFFEFD', '0x7F020100FFFEFD80'],
+                          ['-8970465120996032771', '9151878496576798080']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['le_s', ['-1', '-1'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', [['0', '0'], ['0', '-1']], ['-1', '0'], ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', ['0', '0'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', ['18446744073709551615', '18446744073709551615'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', ['18446744073709551615', '-1'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', [['18446744073709551615', '0'], ['18446744073709551615', '0']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', [['0', '18446744073709551615'], ['0', '18446744073709551615']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['le_s', [['-9223372036854775807', '18446744073709551615'],
+                          ['9223372036854775809', '-1']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['le_s', [['0xc060000000000000', '0xc05fc00000000000'],
+                          ['-128.0', '-127.0']], '-1', ['i64x2', 'f64x2', 'i64x2']])
+        case_data.append(['le_s', [['0x3ff0000000000000', '0x405fc00000000000'],
+                          ['1.0', '127.0']], '-1', ['i64x2', 'f64x2', 'i64x2']])
+
+        # gt_s
+        # i64x2.gt_s  (i64x2) (i64x2)
+        case_data.append(['#', 'gt_s'])
+        case_data.append(['#', 'i64x2.gt_s  (i64x2) (i64x2)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['gt_s', ['0xFFFFFFFFFFFFFFFF', '0xFFFFFFFFFFFFFFFF'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', ['0x0000000000000000', '0x0000000000000000'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', ['0xF0F0F0F0F0F0F0F0', '0xF0F0F0F0F0F0F0F0'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', ['0x0F0F0F0F0F0F0F0F', '0x0F0F0F0F0F0F0F0F'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', [['0xFFFFFFFFFFFFFFFF', '0x0000000000000000'], ['0xFFFFFFFFFFFFFFFF', '0x0000000000000000']], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', [['0x0000000000000000', '0xFFFFFFFFFFFFFFFF'], ['0x0000000000000000', '0xFFFFFFFFFFFFFFFF']], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', [['0x0302010011100904', '0x1A0B0A12FFABAA1B'],
+                          ['0x0302010011100904', '0x1A0B0A12FFABAA1B']], '0', ['i64x2', 'i64x2', 'i64x2']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['gt_s', ['0xFFFFFFFFFFFFFFFF', '18446744073709551615'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', ['0xFFFFFFFFFFFFFFFF', '-1'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', ['0x8080808080808080', '9259542123273814144'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', ['0x8080808080808080', '-9187201950435737472'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', [['0x8382818000FFFEFD', '0x7F020100FFFEFD80'],
+                          ['-8970465120996032771', '9151878496576798080']], '0', ['i64x2', 'i64x2', 'i64x2']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['gt_s', ['-1', '-1'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', ['0', '0'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', ['18446744073709551615', '18446744073709551615'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', ['18446744073709551615', '-1'], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', [['18446744073709551615', '0'], ['18446744073709551615', '0']], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', [['0', '18446744073709551615'], ['0', '18446744073709551615']], '0', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['gt_s', [['-9223372036854775807', '18446744073709551615'],
+                          ['9223372036854775809', '-1']], '0', ['i64x2', 'i64x2', 'i64x2']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['gt_s', [['0xc060000000000000', '0xc05fc00000000000'],
+                          ['-128.0', '-127.0']], '0', ['i64x2', 'f64x2', 'i64x2']])
+        case_data.append(['gt_s', [['0x3ff0000000000000', '0x405fc00000000000'],
+                          ['1.0', '127.0']], '0', ['i64x2', 'f64x2', 'i64x2']])
+
+        # ge_s
+        # i64x2.ge_s  (i64x2) (i64x2)
+        case_data.append(['#', 'ge_s'])
+        case_data.append(['#', 'i64x2.ge_s  (i64x2) (i64x2)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ge_s', ['0xFFFFFFFFFFFFFFFF', '0xFFFFFFFFFFFFFFFF'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', ['0x0000000000000000', '0x0000000000000000'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', ['0xF0F0F0F0F0F0F0F0', '0xF0F0F0F0F0F0F0F0'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', ['0x0F0F0F0F0F0F0F0F', '0x0F0F0F0F0F0F0F0F'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', [['0xFFFFFFFFFFFFFFFF', '0x0000000000000000'], ['0xFFFFFFFFFFFFFFFF', '0x0000000000000000']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', [['0x0000000000000000', '0xFFFFFFFFFFFFFFFF'], ['0x0000000000000000', '0xFFFFFFFFFFFFFFFF']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', [['0x0302010011100904', '0x1A0B0A12FFABAA1B'],
+                          ['0x0302010011100904', '0x1A0B0A12FFABAA1B']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['ge_s', ['0xFFFFFFFFFFFFFFFF', '18446744073709551615'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', ['0xFFFFFFFFFFFFFFFF', '-1'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', ['0x8080808080808080', '9259542123273814144'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', ['0x8080808080808080', '-9187201950435737472'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', [['0x8382818000FFFEFD', '0x7F020100FFFEFD80'],
+                          ['-8970465120996032771', '9151878496576798080']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['ge_s', ['-1', '-1'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', [['-1', '-1'], ['0', '-1']], ['0', '-1'], ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', ['0', '0'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', ['18446744073709551615', '18446744073709551615'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', ['18446744073709551615', '-1'], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', [['18446744073709551615', '0'], ['18446744073709551615', '0']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', [['0', '18446744073709551615'], ['0', '18446744073709551615']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+        case_data.append(['ge_s', [['-9223372036854775807', '18446744073709551615'],
+                          ['9223372036854775809', '-1']], '-1', ['i64x2', 'i64x2', 'i64x2']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['ge_s', [['0xc060000000000000', '0xc05fc00000000000'],
+                          ['-128.0', '-127.0']], '-1', ['i64x2', 'f64x2', 'i64x2']])
+        case_data.append(['ge_s', [['0x3ff0000000000000', '0x405fc00000000000'],
+                          ['1.0', '127.0']], '-1', ['i64x2', 'f64x2', 'i64x2']])
+
+        return case_data
+
+
+def gen_test_cases():
+    i64x2 = Simdi64x2CmpCase()
+    i64x2.gen_test_cases()
+
+
+if __name__ == '__main__':
+    i64x2 = Simdi64x2CmpCase()
+    i64x2.gen_test_cases()
diff --git a/test/core/simd/meta/simd_i8x16_arith.py b/test/core/simd/meta/simd_i8x16_arith.py
new file mode 100644
index 000000000..9639d04a8
--- /dev/null
+++ b/test/core/simd/meta/simd_i8x16_arith.py
@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+
+"""
+Generate i8x16 integer arithmetic operation cases.
+"""
+
+from simd_arithmetic import SimdArithmeticCase
+
+
+class SimdI8x16ArithmeticCase(SimdArithmeticCase):
+
+    LANE_LEN = 16
+    LANE_TYPE = 'i8x16'
+    BINARY_OPS = ('add', 'sub')
+
+    @property
+    def hex_binary_op_test_data(self):
+        return [
+            ('0x3f', '0x40'),
+            ('0x40', '0x40'),
+            ('-0x3f', '-0x40'),
+            ('-0x40', '-0x40'),
+            ('-0x40', '-0x41'),
+            ('0x7f', '0x7f'),
+            ('0x7f', '0x01'),
+            ('0x80', '-0x01'),
+            ('0x7f', '0x80'),
+            ('0x80', '0x80'),
+            ('0xff', '0x01'),
+            ('0xff', '0xff')
+        ]
+
+    @property
+    def hex_unary_op_test_data(self):
+        return ['0x01', '-0x01', '-0x80', '-0x7f', '0x7f', '0x80', '0xff']
+
+    @property
+    def i8x16_i16x8_test_data(self):
+        return {
+            'i8x16.add': [
+                [['0x7f', '0x8080'], '-1', ['i8x16', 'i16x8', 'i8x16']],
+                [['1', '65535'], '0', ['i8x16', 'i16x8', 'i8x16']]
+            ],
+            'i8x16.sub': [
+                [['0x7f', '0x8080'], '-1', ['i8x16', 'i16x8', 'i8x16']],
+                [['1', '65535'], '2', ['i8x16', 'i16x8', 'i8x16']]
+            ]
+        }
+
+    @property
+    def i8x16_i32x4_test_data(self):
+        return {
+            'i8x16.add': [
+                [['0x7f', '0x80808080'], '-1', ['i8x16', 'i32x4', 'i8x16']],
+                [['1', '0xffffffff'], '0', ['i8x16', 'i32x4', 'i8x16']]
+            ],
+            'i8x16.sub': [
+                [['0x7f', '0x80808080'], '-1', ['i8x16', 'i32x4', 'i8x16']],
+                [['1', '0xffffffff'], '2', ['i8x16', 'i32x4', 'i8x16']]
+            ]
+        }
+
+    @property
+    def i8x16_f32x4_test_data(self):
+        return {
+            'i8x16.add': [
+                [['0x80', '+0.0'], '0x80', ['i8x16', 'f32x4', 'i8x16']],
+                [['0x80', '-0.0'], ['0x80', '0x80', '0x80', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['0x80', '1.0'], ['0x80', '0x80', '0', '0xbf'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['0x80', '-1.0'], ['0x80', '0x80', '0', '0x3f'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '+inf'], ['0x01', '0x01', '0x81', '0x80'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '-inf'], ['0x01', '0x01', '0x81', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', 'nan'], ['0x01', '0x01', '0xc1', '0x80'] * 4, ['i8x16', 'f32x4', 'i8x16']]
+            ],
+            'i8x16.sub': [
+                [['0x80', '+0.0'], '0x80', ['i8x16', 'f32x4', 'i8x16']],
+                [['0x80', '-0.0'], ['0x80', '0x80', '0x80', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['0x80', '1.0'], ['0x80', '0x80', '0', '0x41'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['0x80', '-1.0'], ['0x80', '0x80', '0', '0xc1'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '+inf'], ['0x01', '0x01', '0x81', '0x82'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '-inf'], ['0x01', '0x01', '0x81', '0x02'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', 'nan'], ['0x01', '0x01', '0x41', '0x82'] * 4, ['i8x16', 'f32x4', 'i8x16']]
+            ]
+        }
+
+    @property
+    def combine_dec_hex_test_data(self):
+        return {
+            'i8x16.add': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15'],
+                  ['0', '0xff', '0xfe', '0xfd', '0xfc', '0xfb', '0xfa', '0xf9', '0xf8', '0xf7', '0xf6', '0xf5',
+                   '0xf4', '0xf3', '0xf2', '0xf1']],
+                 ['0'] * 16, ['i8x16', 'i8x16', 'i8x16']]
+            ],
+            'i8x16.sub': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15'],
+                  ['0', '0xff', '0xfe', '0xfd', '0xfc', '0xfb', '0xfa', '0xf9', '0xf8', '0xf7', '0xf6', '0xf5',
+                   '0xf4', '0xf3', '0xf2', '0xf1']],
+                 ['0', '0x02', '0x04', '0x06', '0x08', '0x0a', '0x0c', '0x0e', '0x10', '0x12', '0x14', '0x16',
+                  '0x18', '0x1a', '0x1c', '0x1e'],
+                 ['i8x16', 'i8x16', 'i8x16']]
+            ]
+        }
+
+    @property
+    def range_test_data(self):
+        return {
+            'i8x16.add': [
+                [[[str(i) for i in range(16)], [str(i * 2) for i in range(16)]],
+                 [str(i * 3) for i in range(16)], ['i8x16', 'i8x16', 'i8x16']]
+            ],
+            'i8x16.sub': [
+                [[[str(i) for i in range(16)], [str(i * 2) for i in range(16)]],
+                 [str(-i) for i in range(16)], ['i8x16', 'i8x16', 'i8x16']]
+            ]
+        }
+
+    @property
+    def combine_ternary_arith_test_data(self):
+        test_data = super().combine_ternary_arith_test_data
+        test_data.pop('mul-add')
+        test_data.pop('mul-sub')
+        return test_data
+
+    @property
+    def combine_binary_arith_test_data(self):
+        test_data = super().combine_binary_arith_test_data
+        test_data.pop('mul-neg')
+        return test_data
+
+    @property
+    def full_bin_test_data(self):
+        return [
+            self.i8x16_i16x8_test_data,
+            self.i8x16_i32x4_test_data,
+            self.i8x16_f32x4_test_data,
+            self.combine_dec_hex_test_data,
+            self.range_test_data
+        ]
+
+
+def gen_test_cases():
+    simd_i8x16_arith = SimdI8x16ArithmeticCase()
+    simd_i8x16_arith.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
\ No newline at end of file
diff --git a/test/core/simd/meta/simd_i8x16_cmp.py b/test/core/simd/meta/simd_i8x16_cmp.py
new file mode 100644
index 000000000..440d6087b
--- /dev/null
+++ b/test/core/simd/meta/simd_i8x16_cmp.py
@@ -0,0 +1,825 @@
+#!/usr/bin/env python3
+
+"""
+This file is used for generating i8x16 related test cases
+which inherites from the 'SimdCmpCase' class and overloads
+with the 'get_test_cases' method.
+"""
+
+from simd_compare import SimdCmpCase
+
+
+# Generate i8x16 test case
+class Simdi8x16CmpCase(SimdCmpCase):
+
+    # set lane type
+    LANE_TYPE = 'i8x16'
+
+    BINARY_OPS = ['eq', 'ne', 'lt_s', 'lt_u', 'le_s', 'le_u', 'gt_s', 'gt_u', 'ge_s', 'ge_u']
+
+    # Overload base class method and set test data for i32x4.
+    def get_case_data(self):
+
+        case_data = []
+
+        # i8x16.eq  (i8x16) (i8x16)
+        # hex vs hex
+        case_data.append(['#', 'eq'])
+        case_data.append(['#', 'i8x16.eq  (i8x16) (i8x16)'])
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['eq', ['0xFF', '0xFF'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', ['0x00', '0x00'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', ['0xF0', '0xF0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', ['0x0F', '0x0F'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['0xFF', '0x00'], ['0xFF', '0x00']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['0x00', '0xFF'], ['0x00', '0xFF']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['eq', ['0xFF', '255'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', ['0xFF', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', ['0x80', '128'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', ['0x80', '-128'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['eq', ['-1', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', ['0', '0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', ['255', '255'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', ['255', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['255', '0'], ['255', '0']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['0', '255'], ['0', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '-0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['eq', [['0x00', '0x00', '0x00', '0xc3', '0x00', '0x00', '0xfe', '0xc2', '0x00', '0x00', '0x80', '0xbf', '0x00', '0x00', '0x00', '0x00'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i8x16', 'f32x4', 'i8x16']])
+        case_data.append(['eq', [['0x00', '0x00', '0x80', '0x3f', '0x00', '0x00', '0xfe', '0x42', '0x00', '0x00', '0x00', '0x43', '0x00', '0x00', '0x7f', '0x43'],
+                          ['1.0', '127.0', '128.0', '255.0']], '-1', ['i8x16', 'f32x4', 'i8x16']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['eq', ['0x0F', '0xF0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['0x00', '0xFF'], ['0xFF', '0x00']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0xFF', '0xAB', '0xAA', '0x1B', '0x1A', '0x0B', '0x0A', '0x12', '0x11', '0x10', '0x09', '0x04', '0x03', '0x02', '0x01', '0x00']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['0', '0', '0', '0', '0', '0', '0', '-1', '-1', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['eq', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '-0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['0', '0', '0', '0', '0', '0', '0', '-1', '-1', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+
+        # i8x16.eq  (i8x16) (i16x8)
+        case_data.append(['#', 'i8x16.eq  (i8x16) (i16x8)'])
+        case_data.append(['eq', ['0xFF', '0xFFFF'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['eq', ['255', '65535'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['eq', ['0', '0'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['eq', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['eq', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['eq', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'],
+                          ['-128', '-128', '0', '0', '1', '1', '255', '255']], ['-1', '0', '-1', '0', '-1', '-1', '-1', '-1', '-1', '0', '-1', '0', '-1', '0', '-1', '0'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['eq', ['0x55', '0xAAAA'], '0', ['i8x16', 'i16x8', 'i8x16']])
+
+        # i8x16.eq  (i8x16) (i32x4)
+        case_data.append(['#', 'i8x16.eq  (i8x16) (i32x4)'])
+        case_data.append(['eq', ['0xFF', '0xFFFFFFFF'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['eq', ['255', '4294967295'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['eq', ['0', '0'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['eq', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['eq', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['eq', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'],
+                          ['-128', '0', '1', '255']], ['-1', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '-1', '0', '0', '0'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['eq', ['0x55', '0xAAAAAAAA'], '0', ['i8x16', 'i32x4', 'i8x16']])
+
+        # ne
+        # i8x16.ne  (i8x16) (i8x16)
+        case_data.append(['#', 'ne'])
+        case_data.append(['#', 'i8x16.ne  (i8x16) (i8x16)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ne', ['0xFF', '0xFF'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', ['0x00', '0x00'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', ['0xF0', '0xF0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', ['0x0F', '0x0F'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['0xFF', '0x00'], ['0xFF', '0x00']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['0x00', '0xFF'], ['0x00', '0xFF']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['ne', ['0xFF', '255'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', ['0xFF', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', ['0x80', '128'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', ['0x80', '-128'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['ne', ['-1', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', ['0', '0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', ['255', '255'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', ['255', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['255', '0'], ['255', '0']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['0', '255'], ['0', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '-0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['ne', [['0x00', '0x00', '0x00', '0xc3', '0x00', '0x00', '0xfe', '0xc2', '0x00', '0x00', '0x80', '0xbf', '0x00', '0x00', '0x00', '0x00'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i8x16', 'f32x4', 'i8x16']])
+        case_data.append(['ne', [['0x00', '0x00', '0x80', '0x3f', '0x00', '0x00', '0xfe', '0x42', '0x00', '0x00', '0x00', '0x43', '0x00', '0x00', '0x7f', '0x43'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i8x16', 'f32x4', 'i8x16']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['ne', ['0x0F', '0xF0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['0x00', '0xFF'], ['0xFF', '0x00']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0xFF', '0xAB', '0xAA', '0x1B', '0x1A', '0x0B', '0x0A', '0x12', '0x11', '0x10', '0x09', '0x04', '0x03', '0x02', '0x01', '0x00']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ne', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '-0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+
+        # i8x16.ne  (i8x16) (i16x8)
+        case_data.append(['#', 'i8x16.ne (i8x16) (i16x8)'])
+        case_data.append(['ne', ['0xFF', '0xFFFF'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ne', ['255', '65535'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ne', ['0', '0'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ne', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ne', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ne', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'],
+                          ['-128', '-128', '0', '0', '1', '1', '255', '255']], ['0', '-1', '0', '-1', '0', '0', '0', '0', '0', '-1', '0', '-1', '0', '-1', '0', '-1'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ne', ['0x55', '0xAAAA'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+
+        # i8x16.ne  (i8x16) (i32x4)
+        case_data.append(['#', 'i8x16.ne  (i8x16) (i32x4)'])
+        case_data.append(['ne', ['0xFF', '0xFFFFFFFF'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ne', ['255', '4294967295'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ne', ['0', '0'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ne', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ne', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ne', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '0', '1', '255']],
+                          ['0', '-1', '-1', '-1', '0', '0', '0', '0', '0', '-1', '-1', '-1', '0', '-1', '-1', '-1'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ne', ['0x55', '0xAAAAAAAA'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+
+        # lt_s
+        case_data.append(['#', 'lt_s'])
+        case_data.append(['#', 'i8x16.lt_s  (i8x16) (i8x16)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['lt_s', ['0xFF', '0xFF'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', ['0x00', '0x00'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', ['0xF0', '0xF0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', ['0x0F', '0x0F'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['0xFF', '0x00'], ['0xFF', '0x00']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['0x00', '0xFF'], ['0x00', '0xFF']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['lt_s', ['0xFF', '255'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', ['0xFF', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', ['0x80', '128'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', ['0x80', '-128'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['lt_s', ['-1', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', ['0', '0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', ['255', '255'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', ['255', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['255', '0'], ['255', '0']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['0', '255'], ['0', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '-0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['lt_s', [['0x00', '0x00', '0x00', '0xc3', '0x00', '0x00', '0xfe', '0xc2', '0x00', '0x00', '0x80', '0xbf', '0x00', '0x00', '0x00', '0x00'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i8x16', 'f32x4', 'i8x16']])
+        case_data.append(['lt_s', [['0x00', '0x00', '0x80', '0x3f', '0x00', '0x00', '0xfe', '0x42', '0x00', '0x00', '0x00', '0x43', '0x00', '0x00', '0x7f', '0x43'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i8x16', 'f32x4', 'i8x16']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['lt_s', ['0x0F', '0xF0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['0x00', '0xFF'], ['0xFF', '0x00']], ['0', '0', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0xFF', '0xAB', '0xAA', '0x1B', '0x1A', '0x0B', '0x0A', '0x12', '0x11', '0x10', '0x09', '0x04', '0x03', '0x02', '0x01', '0x00']],
+                          ['0', '0', '0', '-1', '-1', '-1', '0', '-1', '0', '-1', '0', '0', '0', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['-1', '-1', '-1', '0', '-1', '-1', '-1', '0', '0', '0', '0', '0', '-1', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_s', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '-0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['-1', '-1', '-1', '0', '-1', '-1', '-1', '0', '0', '0', '0', '0', '-1', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['#', 'i8x16.lt_s  (i8x16) (i16x8)'])
+        case_data.append(['lt_s', ['0xFF', '0xFFFF'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_s', ['255', '65535'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_s', ['0', '0'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_s', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_s', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '-128', '0', '0', '1', '1', '255', '255']],
+                          ['0', '-1', '0', '-1', '0', '0', '0', '0', '0', '0', '0', '0', '0', '-1', '0', '-1'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_s', ['0x55', '0xAAAA'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['#', 'i8x16.lt_s  (i8x16) (i32x4)'])
+        case_data.append(['lt_s', ['0xFF', '0xFFFFFFFF'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_s', ['255', '4294967295'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_s', ['0', '0'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_s', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_s', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '0', '1', '255']],
+                          ['0', '-1', '-1', '-1', '0', '0', '0', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_s', ['0x55', '0xAAAAAAAA'], '0', ['i8x16', 'i32x4', 'i8x16']])
+
+        # lt_u
+        case_data.append(['#', 'lt_u'])
+        case_data.append(['#', 'i8x16.lt_u  (i8x16) (i8x16)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['lt_u', ['0xFF', '0xFF'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', ['0x00', '0x00'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', ['0xF0', '0xF0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', ['0x0F', '0x0F'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['0xFF', '0x00'], ['0xFF', '0x00']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['0x00', '0xFF'], ['0x00', '0xFF']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['lt_u', ['0xFF', '255'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', ['0xFF', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', ['0x80', '128'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', ['0x80', '-128'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['lt_u', ['-1', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', ['0', '0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', ['255', '255'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', ['255', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['255', '0'], ['255', '0']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['0', '255'], ['0', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '-0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['lt_u', [['0x00', '0x00', '0x00', '0xc3', '0x00', '0x00', '0xfe', '0xc2', '0x00', '0x00', '0x80', '0xbf', '0x00', '0x00', '0x00', '0x00'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i8x16', 'f32x4', 'i8x16']])
+        case_data.append(['lt_u', [['0x00', '0x00', '0x80', '0x3f', '0x00', '0x00', '0xfe', '0x42', '0x00', '0x00', '0x00', '0x43', '0x00', '0x00', '0x7f', '0x43'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i8x16', 'f32x4', 'i8x16']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['lt_u', ['0x0F', '0xF0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['0x00', '0xFF'], ['0xFF', '0x00']], ['-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0xFF', '0xAB', '0xAA', '0x1B', '0x1A', '0x0B', '0x0A', '0x12', '0x11', '0x10', '0x09', '0x04', '0x03', '0x02', '0x01', '0x00']],
+                          ['-1', '-1', '-1', '-1', '-1', '-1', '0', '-1', '0', '-1', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['-1', '-1', '-1', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1', '-1', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['lt_u', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '-0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['-1', '-1', '-1', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1', '-1', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['#', 'i8x16.lt_u  (i8x16) (i16x8)'])
+        case_data.append(['lt_u', ['0xFF', '0xFFFF'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_u', ['255', '65535'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_u', ['0', '0'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_u', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_u', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'],
+                          ['-128', '-128', '0', '0', '1', '1', '255', '255']], ['0', '-1', '0', '-1', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['lt_u', ['0x55', '0xAAAA'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['#', 'i8x16.lt_u  (i8x16) (i32x4)'])
+        case_data.append(['lt_u', ['0xFF', '0xFFFFFFFF'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_u', ['255', '4294967295'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_u', ['0', '0'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_u', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_u', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'],
+                          ['-128', '0', '1', '255']], ['0', '-1', '-1', '-1', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['lt_u', ['0x55', '0xAAAAAAAA'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+
+        # le_s
+        case_data.append(['#', 'le_s'])
+        case_data.append(['#', 'i8x16.le_s  (i8x16) (i8x16)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['le_s', ['0xFF', '0xFF'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', ['0x00', '0x00'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', ['0xF0', '0xF0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', ['0x0F', '0x0F'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['0xFF', '0x00'], ['0xFF', '0x00']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['0x00', '0xFF'], ['0x00', '0xFF']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['le_s', ['0xFF', '255'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', ['0xFF', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', ['0x80', '128'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', ['0x80', '-128'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['le_s', ['-1', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', ['0', '0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', ['255', '255'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', ['255', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['255', '0'], ['255', '0']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['0', '255'], ['0', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '-0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['le_s', [['0x00', '0x00', '0x00', '0xc3', '0x00', '0x00', '0xfe', '0xc2', '0x00', '0x00', '0x80', '0xbf', '0x00', '0x00', '0x00', '0x00'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i8x16', 'f32x4', 'i8x16']])
+        case_data.append(['le_s', [['0x00', '0x00', '0x80', '0x3f', '0x00', '0x00', '0xfe', '0x42', '0x00', '0x00', '0x00', '0x43', '0x00', '0x00', '0x7f', '0x43'],
+                          ['1.0', '127.0', '128.0', '255.0']], '-1', ['i8x16', 'f32x4', 'i8x16']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['le_s', ['0x0F', '0xF0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['0x00', '0xFF'], ['0xFF', '0x00']], ['0', '0', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0xFF', '0xAB', '0xAA', '0x1B', '0x1A', '0x0B', '0x0A', '0x12', '0x11', '0x10', '0x09', '0x04', '0x03', '0x02', '0x01', '0x00']],
+                          ['0', '0', '0', '-1', '-1', '-1', '0', '-1', '0', '-1', '0', '0', '0', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['-1', '-1', '-1', '0', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '-1', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_s', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '-0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['-1', '-1', '-1', '0', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '-1', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['#', 'i8x16.le_s  (i8x16) (i16x8)'])
+        case_data.append(['le_s', ['0xFF', '0xFFFF'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_s', ['255', '65535'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_s', ['0', '0'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_s', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_s', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'],
+                          ['-128', '-128', '0', '0', '1', '1', '255', '255']],
+                          ['-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '-1', '0', '-1', '-1', '-1', '-1'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_s', ['0x55', '0xAAAA'], ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['#', 'i8x16.le_s  (i8x16) (i32x4)'])
+        case_data.append(['le_s', ['0xFF', '0xFFFFFFFF'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_s', ['255', '4294967295'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_s', ['0', '0'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_s', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_s', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '0', '1', '255']],
+                          ['-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '-1', '-1', '-1', '-1'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_s', ['0x55', '0xAAAAAAAA'], '0', ['i8x16', 'i32x4', 'i8x16']])
+
+        # le_u
+        case_data.append(['#', 'le_u'])
+        case_data.append(['#', 'i8x16.le_u  (i8x16) (i8x16)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['le_u', ['0xFF', '0xFF'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', ['0x00', '0x00'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', ['0xF0', '0xF0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', ['0x0F', '0x0F'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['0xFF', '0x00'], ['0xFF', '0x00']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['0x00', '0xFF'], ['0x00', '0xFF']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['le_u', ['0xFF', '255'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', ['0xFF', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', ['0x80', '128'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', ['0x80', '-128'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['le_u', ['-1', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', ['0', '0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', ['255', '255'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', ['255', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['255', '0'], ['255', '0']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['0', '255'], ['0', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '-0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['le_u', [['0x00', '0x00', '0x00', '0xc3', '0x00', '0x00', '0xfe', '0xc2', '0x00', '0x00', '0x80', '0xbf', '0x00', '0x00', '0x00', '0x00'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i8x16', 'f32x4', 'i8x16']])
+        case_data.append(['le_u', [['0x00', '0x00', '0x80', '0x3f', '0x00', '0x00', '0xfe', '0x42', '0x00', '0x00', '0x00', '0x43', '0x00', '0x00', '0x7f', '0x43'],
+                          ['1.0', '127.0', '128.0', '255.0']], '-1', ['i8x16', 'f32x4', 'i8x16']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['le_u', ['0x0F', '0xF0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['0x00', '0xFF'], ['0xFF', '0x00']], ['-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0xFF', '0xAB', '0xAA', '0x1B', '0x1A', '0x0B', '0x0A', '0x12', '0x11', '0x10', '0x09', '0x04', '0x03', '0x02', '0x01', '0x00']],
+                          ['-1', '-1', '-1', '-1', '-1', '-1', '0', '-1', '0', '-1', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['-1', '-1', '-1', '0', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['le_u', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '-0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['-1', '-1', '-1', '0', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['#', 'i8x16.le_u  (i8x16) (i16x8)'])
+        case_data.append(['le_u', ['0xFF', '0xFFFF'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_u', ['255', '65535'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_u', ['0', '0'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_u', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_u', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'],
+                          ['-128', '-128', '0', '0', '1', '1', '255', '255']], ['-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '-1', '0', '-1', '0', '-1', '0'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['le_u', ['0x55', '0xAAAA'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['#', 'i8x16.le_u  (i8x16) (i32x4)'])
+        case_data.append(['le_u', ['0xFF', '0xFFFFFFFF'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_u', ['255', '4294967295'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_u', ['0', '0'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_u', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_u', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '0', '1', '255']],
+                          ['-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '-1', '0', '0', '0'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['le_u', ['0x55', '0xAAAAAAAA'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+
+        # gt_s
+        case_data.append(['#', 'gt_s'])
+        case_data.append(['#', 'i8x16.gt_s  (i8x16) (i8x16)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['gt_s', ['0xFF', '0xFF'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', ['0x00', '0x00'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', ['0xF0', '0xF0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', ['0x0F', '0x0F'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['0xFF', '0x00'], ['0xFF', '0x00']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['0x00', '0xFF'], ['0x00', '0xFF']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['gt_s', ['0xFF', '255'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', ['0xFF', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', ['0x80', '128'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', ['0x80', '-128'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['gt_s', ['-1', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', ['0', '0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', ['255', '255'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', ['255', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['255', '0'], ['255', '0']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['0', '255'], ['0', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '-0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['gt_s', [['0x00', '0x00', '0x00', '0xc3', '0x00', '0x00', '0xfe', '0xc2', '0x00', '0x00', '0x80', '0xbf', '0x00', '0x00', '0x00', '0x00'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i8x16', 'f32x4', 'i8x16']])
+        case_data.append(['gt_s', [['0x00', '0x00', '0x80', '0x3f', '0x00', '0x00', '0xfe', '0x42', '0x00', '0x00', '0x00', '0x43', '0x00', '0x00', '0x7f', '0x43'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i8x16', 'f32x4', 'i8x16']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['gt_s', ['0x0F', '0xF0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['0x00', '0xFF'], ['0xFF', '0x00']], ['-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0xFF', '0xAB', '0xAA', '0x1B', '0x1A', '0x0B', '0x0A', '0x12', '0x11', '0x10', '0x09', '0x04', '0x03', '0x02', '0x01', '0x00']],
+                          ['-1', '-1', '-1', '0', '0', '0', '-1', '0', '-1', '0', '-1', '-1', '-1', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['0', '0', '0', '-1', '0', '0', '0', '0', '0', '-1', '-1', '-1', '0', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_s', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '-0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['0', '0', '0', '-1', '0', '0', '0', '0', '0', '-1', '-1', '-1', '0', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['#', 'i8x16.gt_s  (i8x16) (i16x8)'])
+        case_data.append(['gt_s', ['0xFF', '0xFFFF'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_s', ['255', '65535'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_s', ['0', '0'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_s', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_s', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '-128', '0', '0', '1', '1', '255', '255']],
+                          ['0', '0', '0', '0', '0', '0', '0', '0', '0', '-1', '0', '-1', '0', '0', '0', '0'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_s', ['0x55', '0xAAAA'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['#', 'i8x16.gt_s  (i8x16) (i32x4)'])
+        case_data.append(['gt_s', ['0xFF', '0xFFFFFFFF'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_s', ['255', '4294967295'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_s', ['0', '0'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_s', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'], ['2206368128', '16776957', '2130837760', '4294901120']],
+                          ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_s', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '0', '1', '255']],
+                          ['0', '0', '0', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1', '0', '0', '0', '0'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_s', ['0x55', '0xAAAAAAAA'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+
+        # gt_u
+        case_data.append(['#', 'gt_u'])
+        case_data.append(['#', 'i8x16.gt_u  (i8x16) (i8x16)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['gt_u', ['0xFF', '0xFF'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', ['0x00', '0x00'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', ['0xF0', '0xF0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', ['0x0F', '0x0F'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['0xFF', '0x00'], ['0xFF', '0x00']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['0x00', '0xFF'], ['0x00', '0xFF']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['gt_u', ['0xFF', '255'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', ['0xFF', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', ['0x80', '128'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', ['0x80', '-128'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['gt_u', ['-1', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', ['0', '0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', ['255', '255'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', ['255', '-1'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['255', '0'], ['255', '0']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['0', '255'], ['0', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '-0', '0', '1', '2', '127', '128', '253', '254', '255']], '0', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['gt_u', [['0x00', '0x00', '0x00', '0xc3', '0x00', '0x00', '0xfe', '0xc2', '0x00', '0x00', '0x80', '0xbf', '0x00', '0x00', '0x00', '0x00'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '0', ['i8x16', 'f32x4', 'i8x16']])
+        case_data.append(['gt_u', [['0x00', '0x00', '0x80', '0x3f', '0x00', '0x00', '0xfe', '0x42', '0x00', '0x00', '0x00', '0x43', '0x00', '0x00', '0x7f', '0x43'],
+                          ['1.0', '127.0', '128.0', '255.0']], '0', ['i8x16', 'f32x4', 'i8x16']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['gt_u', ['0x0F', '0xF0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['0x00', '0xFF'], ['0xFF', '0x00']], ['0', '0', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0xFF', '0xAB', '0xAA', '0x1B', '0x1A', '0x0B', '0x0A', '0x12', '0x11', '0x10', '0x09', '0x04', '0x03', '0x02', '0x01', '0x00']],
+                          ['0', '0', '0', '0', '0', '0', '-1', '0', '-1', '0', '-1', '-1', '-1', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['0', '0', '0', '-1', '-1', '-1', '-1', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['gt_u', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '-0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['0', '0', '0', '-1', '-1', '-1', '-1', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['#', 'i8x16.gt_u  (i8x16) (i16x8)'])
+        case_data.append(['gt_u', ['0xFF', '0xFFFF'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_u', ['255', '65535'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_u', ['0', '0'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_u', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_u', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '-128', '0', '0', '1', '1', '255', '255']],
+                          ['0', '0', '0', '0', '0', '0', '0', '0', '0', '-1', '0', '-1', '0', '-1', '0', '-1'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['gt_u', ['0x55', '0xAAAA'], '0', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['#', 'i8x16.gt_u  (i8x16) (i32x4)'])
+        case_data.append(['gt_u', ['0xFF', '0xFFFFFFFF'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_u', ['255', '4294967295'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_u', ['0', '0'], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '0', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_u', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'], ['2206368128', '16776957', '2130837760', '4294901120']],
+                          ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_u', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '0', '1', '255']],
+                          ['0', '0', '0', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1', '0', '-1', '-1', '-1'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['gt_u', ['0x55', '0xAAAAAAAA'], ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i32x4', 'i8x16']])
+
+        # ge_s
+        case_data.append(['#', 'ge_s'])
+        case_data.append(['#', 'i8x16.ge_s  (i8x16) (i8x16)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ge_s', ['0xFF', '0xFF'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', ['0x00', '0x00'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', ['0xF0', '0xF0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', ['0x0F', '0x0F'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['0xFF', '0x00'], ['0xFF', '0x00']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['0x00', '0xFF'], ['0x00', '0xFF']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['ge_s', ['0xFF', '255'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', ['0xFF', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', ['0x80', '128'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', ['0x80', '-128'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['ge_s', ['-1', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', ['0', '0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', ['255', '255'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', ['255', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['255', '0'], ['255', '0']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['0', '255'], ['0', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '-0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['ge_s', [['0x00', '0x00', '0x00', '0xc3', '0x00', '0x00', '0xfe', '0xc2', '0x00', '0x00', '0x80', '0xbf', '0x00', '0x00', '0x00', '0x00'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i8x16', 'f32x4', 'i8x16']])
+        case_data.append(['ge_s', [['0x00', '0x00', '0x80', '0x3f', '0x00', '0x00', '0xfe', '0x42', '0x00', '0x00', '0x00', '0x43', '0x00', '0x00', '0x7f', '0x43'],
+                          ['1.0', '127.0', '128.0', '255.0']], '-1', ['i8x16', 'f32x4', 'i8x16']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['ge_s', ['0x0F', '0xF0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['0x00', '0xFF'], ['0xFF', '0x00']], ['-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0xFF', '0xAB', '0xAA', '0x1B', '0x1A', '0x0B', '0x0A', '0x12', '0x11', '0x10', '0x09', '0x04', '0x03', '0x02', '0x01', '0x00']],
+                          ['-1', '-1', '-1', '0', '0', '0', '-1', '0', '-1', '0', '-1', '-1', '-1', '0', '0', '0'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['0', '0', '0', '-1', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '0', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_s', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '-0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['0', '0', '0', '-1', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '0', '-1', '-1', '-1'],
+                          ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['#', 'i8x16.ge_s  (i8x16) (i16x8)'])
+        case_data.append(['ge_s', ['0xFF', '0xFFFF'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_s', ['255', '65535'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_s', ['0', '0'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_s', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_s', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '-128', '0', '0', '1', '1', '255', '255']],
+                          ['-1', '0', '-1', '0', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '-1', '0'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_s', ['0x55', '0xAAAA'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['#', 'i8x16.ge_s  (i8x16) (i32x4)'])
+        case_data.append(['ge_s', ['0xFF', '0xFFFFFFFF'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_s', ['255', '4294967295'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_s', ['0', '0'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_s', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_s', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_s', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'], ['-128', '0', '1', '255']],
+                          ['-1', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_s', ['0x55', '0xAAAAAAAA'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+
+        # ge_u
+        # i8x16.ge_u  (i8x16) (i8x16)
+        case_data.append(['#', 'ge_u'])
+        case_data.append(['#', 'i8x16.ge_u  (i8x16) (i8x16)'])
+
+        # hex vs hex
+        case_data.append(['#', 'hex vs hex'])
+        case_data.append(['ge_u', ['0xFF', '0xFF'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', ['0x00', '0x00'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', ['0xF0', '0xF0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', ['0x0F', '0x0F'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['0xFF', '0x00'], ['0xFF', '0x00']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['0x00', '0xFF'], ['0x00', '0xFF']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs dec
+        case_data.append(['#', 'hex vs dec'])
+        case_data.append(['ge_u', ['0xFF', '255'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', ['0xFF', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', ['0x80', '128'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', ['0x80', '-128'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # dec vs dec
+        case_data.append(['#', 'dec vs dec'])
+        case_data.append(['ge_u', ['-1', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', ['0', '0'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', ['255', '255'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', ['255', '-1'], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['255', '0'], ['255', '0']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['0', '255'], ['0', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['-128', '-127', '-126', '-125', '-3', '-2', '-1', '-0', '0', '1', '2', '127', '128', '253', '254', '255']], '-1', ['i8x16', 'i8x16', 'i8x16']])
+
+        # hex vs float
+        case_data.append(['#', 'hex vs float'])
+        case_data.append(['ge_u', [['0x00', '0x00', '0x00', '0xc3', '0x00', '0x00', '0xfe', '0xc2', '0x00', '0x00', '0x80', '0xbf', '0x00', '0x00', '0x00', '0x00'],
+                          ['-128.0', '-127.0', '-1.0', '0.0']], '-1', ['i8x16', 'f32x4', 'i8x16']])
+        case_data.append(['ge_u', [['0x00', '0x00', '0x80', '0x3f', '0x00', '0x00', '0xfe', '0x42', '0x00', '0x00', '0x00', '0x43', '0x00', '0x00', '0x7f', '0x43'],
+                          ['1.0', '127.0', '128.0', '255.0']], '-1', ['i8x16', 'f32x4', 'i8x16']])
+
+        # not equal
+        case_data.append(['#', 'not equal'])
+        case_data.append(['ge_u', ['0x0F', '0xF0'], '0', ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['0x00', '0xFF'], ['0xFF', '0x00']], ['0', '0', '0', '0', '0', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x09', '0x10', '0x11', '0x12', '0x0A', '0x0B', '0x1A', '0x1B', '0xAA', '0xAB', '0xFF'],
+                          ['0xFF', '0xAB', '0xAA', '0x1B', '0x1A', '0x0B', '0x0A', '0x12', '0x11', '0x10', '0x09', '0x04', '0x03', '0x02', '0x01', '0x00']],
+                          ['0', '0', '0', '0', '0', '0', '-1', '0', '-1', '0', '-1', '-1', '-1', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['0x80', '0x81', '0x82', '0x83', '0xFD', '0xFE', '0xFF', '0x00', '0x00', '0x01', '0x02', '0x7F', '0x80', '0xFD', '0xFE', '0xFF'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['0', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '0', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+        case_data.append(['ge_u', [['128', '129', '130', '131', '253', '254', '255', '-0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['255', '254', '253', '128', '127', '2', '1', '0', '-0', '-1', '-2', '-3', '-125', '-126', '-127', '-128']],
+                          ['0', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '0', '0', '0', '0', '-1', '-1', '-1'], ['i8x16', 'i8x16', 'i8x16']])
+
+        # i8x16.ge_u (i8x16) (i16x8)
+        case_data.append(['#', 'i8x16.ge_u (i8x16) (i16x8)'])
+        case_data.append(['ge_u', ['0xFF', '0xFFFF'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_u', ['255', '65535'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_u', ['0', '0'], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x0100', '0x0302', '0x0504', '0x0706', '0x0908', '0x0B0A', '0x0D0C', '0x0F0E']], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_u', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['33152', '33666', '65277', '255', '256', '32514', '64896', '65534']], '-1', ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_u', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'],
+                          ['-128', '-128', '0', '0', '1', '1', '255', '255']], ['-1', '0', '-1', '0', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1'], ['i8x16', 'i16x8', 'i8x16']])
+        case_data.append(['ge_u', ['0x55', '0xAAAA'], ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i16x8', 'i8x16']])
+
+        # i8x16.ge_u (i8x16) (i32x4)
+        case_data.append(['#', 'i8x16.ge_u (i8x16) (i32x4)'])
+        case_data.append(['ge_u', ['0xFF', '0xFFFFFFFF'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_u', ['255', '4294967295'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_u', ['0', '0'], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_u', [['0x00', '0x01', '0x02', '0x03', '0x04', '0x05', '0x06', '0x07', '0x08', '0x09', '0x0A', '0x0B', '0x0C', '0x0D', '0x0E', '0x0F'],
+                          ['0x03020100', '0x07060504', '0x0B0A0908', '0x0F0E0D0C']], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_u', [['-128', '-127', '-126', '-125', '-3', '-2', '-1', '0', '0', '1', '2', '127', '128', '253', '254', '255'],
+                          ['2206368128', '16776957', '2130837760', '4294901120']], '-1', ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_u', [['-128', '-128', '-128', '-128', '0', '0', '0', '0', '1', '1', '1', '1', '255', '255', '255', '255'],
+                          ['-128', '0', '1', '255']], ['-1', '0', '0', '0', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1', '-1'], ['i8x16', 'i32x4', 'i8x16']])
+        case_data.append(['ge_u', ['0x55', '0xAAAAAAAA'], ['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0'], ['i8x16', 'i32x4', 'i8x16']])
+
+        return case_data
+
+
+def gen_test_cases():
+    i8x16 = Simdi8x16CmpCase()
+    i8x16.gen_test_cases()
+
+
+if __name__ == '__main__':
+    i8x16 = Simdi8x16CmpCase()
+    i8x16.gen_test_cases()
diff --git a/test/core/simd/meta/simd_int_arith2.py b/test/core/simd/meta/simd_int_arith2.py
new file mode 100644
index 000000000..342aea854
--- /dev/null
+++ b/test/core/simd/meta/simd_int_arith2.py
@@ -0,0 +1,575 @@
+#!/usr/bin/env python3
+
+"""
+Generate [min_s, min_u, max_s, max_u] cases for i32x4, i16x8 and i8x16.
+"""
+
+from simd import SIMD
+from test_assert import AssertReturn, AssertInvalid, AssertMalformed
+from simd_lane_value import LaneValue
+from simd_integer_op import ArithmeticOp
+
+
+class SimdLaneWiseInteger:
+    LANE_TYPE = None
+
+    LANE_VALUE = None
+
+    BINARY_OPS = ('min_s', 'min_u', 'max_s', 'max_u',)
+
+    UNARY_OPS = ('abs',)
+
+    class_summary = """;; Tests for {lane_type} [min_s, min_u, max_s, max_u, avgr_u, abs] operations."""
+
+    def __init__(self):
+
+        self.LANE_VALUE = LaneValue(self.lane_width)
+
+    @property
+    def lane_count(self):
+        """count of lanes"""
+        return int(self.LANE_TYPE.split('x')[1])
+
+    @property
+    def lane_width(self):
+        """width of a single lane"""
+        return int(self.LANE_TYPE.replace('i', '').split('x')[0])
+
+    @property
+    def get_unary_complex_test_data(self):
+        """test const vs const and different lanes go through different if-then clauses for unary ops"""
+        case_data = [
+            [self.LANE_VALUE.min, self.LANE_VALUE.max, self.LANE_VALUE.quarter, self.LANE_VALUE.mask]
+        ]
+        case_data = [list(map(str, param)) for param in case_data]
+
+        return case_data
+
+    @property
+    def get_binary_test_data_with_const(self):
+        """test const vs const and param vs const for binary ops"""
+        case_data = [
+            [
+                [self.LANE_VALUE.min, self.LANE_VALUE.max, self.LANE_VALUE.quarter, self.LANE_VALUE.mask],
+                [self.LANE_VALUE.mask, self.LANE_VALUE.quarter, self.LANE_VALUE.max, self.LANE_VALUE.min]
+            ],
+            [
+                [0, 1, 2, 3],
+                [3, 2, 1, 0],
+            ]
+        ]
+        case_data = [[list(map(str, param_1)), list(map(str, param_2))] for param_1, param_2 in case_data]
+
+        return case_data
+
+    @property
+    def get_binary_test_data_go_through_if(self):
+        """test different lanes go through different if-then clauses"""
+        case_data = [
+            [
+                [self.LANE_VALUE.min, self.LANE_VALUE.max, self.LANE_VALUE.quarter, self.LANE_VALUE.mask],
+                [self.LANE_VALUE.mask, self.LANE_VALUE.quarter, self.LANE_VALUE.max, self.LANE_VALUE.min]
+            ],
+            [
+                [0, 1, 2, 128],
+                [0, 2, 1, 0x80],
+            ]
+        ]
+        case_data = [[list(map(str, param_1)), list(map(str, param_2))] for param_1, param_2 in case_data]
+
+        return case_data
+
+    @property
+    def get_unary_test_data_opposite_sign_zero(self):
+        """test opposite signs of zero for unary ops"""
+        case_data = [
+            ['-0', '-0', '+0', '+0'],
+            ['+0', '0', '-0', '0'],
+            ['-0', '-0', '-0', '-0'],
+            ['+0', '+0', '+0', '+0'],
+        ]
+
+        return case_data
+
+    @property
+    def get_binary_test_data_opposite_sign_zero(self):
+        """test opposite signs of zero for binary ops"""
+        case_data = [
+            [
+                ['-0', '-0', '+0', '+0'],
+                ['+0', '0', '-0', '0'],
+            ],
+            [
+                ['-0', '-0', '-0', '-0'],
+                ['+0', '+0', '+0', '+0'],
+            ]
+        ]
+
+        return case_data
+
+    @property
+    def get_unary_test_data(self):
+        """general unary case data"""
+
+        case_data = [
+
+            ['1'] * self.lane_count,
+            ['-1'] * self.lane_count,
+            [str(self.LANE_VALUE.mask)] * self.lane_count,
+            [hex(self.LANE_VALUE.mask)] * self.lane_count,
+            [str(-self.LANE_VALUE.min)] * self.lane_count,
+            [str(self.LANE_VALUE.min)] * self.lane_count,
+            [hex(self.LANE_VALUE.min)] * self.lane_count,
+            [hex(-self.LANE_VALUE.min)] * self.lane_count,
+            ['01_2_3'] * self.lane_count,
+            ['-01_2_3'] * self.lane_count,
+            ['0x80'] * self.lane_count,
+            ['-0x80'] * self.lane_count,
+            ['0x0_8_0'] * self.lane_count,
+            ['-0x0_8_0'] * self.lane_count
+
+        ]
+
+        return case_data
+
+    @property
+    def get_binary_test_data(self):
+        """general binary case data"""
+
+        case_data = [
+
+            [
+                ['0'] * self.lane_count,
+                ['0'] * self.lane_count,
+            ],
+            [
+                ['0'] * self.lane_count,
+                ['-1'] * self.lane_count,
+            ],
+            [
+                ['0', '0', '-1', '-1'],
+                ['0', '-1', '0', '-1'],
+            ],
+            [
+                ['0'] * self.lane_count,
+                [hex(self.LANE_VALUE.mask)] * self.lane_count,
+            ],
+
+            [
+                ['1'] * self.lane_count,
+                ['1'] * self.lane_count,
+            ],
+            [
+                [str(self.LANE_VALUE.mask)] * self.lane_count,
+                ['1'] * self.lane_count,
+            ],
+            [
+                [str(self.LANE_VALUE.mask)] * self.lane_count,
+                ['128'] * self.lane_count,
+            ],
+            [
+                [str(-self.LANE_VALUE.min)] * self.lane_count,
+                [str(self.LANE_VALUE.min)] * self.lane_count,
+            ],
+            [
+                [hex(-self.LANE_VALUE.min)] * self.lane_count,
+                [str(self.LANE_VALUE.min)] * self.lane_count,
+            ],
+            [
+                ['123'] * self.lane_count,
+                ['01_2_3'] * self.lane_count,
+            ],
+            [
+                ['0x80'] * self.lane_count,
+                ['0x0_8_0'] * self.lane_count,
+            ],
+
+        ]
+
+        return case_data
+
+    @property
+    def gen_funcs_normal(self):
+        """generate normal functions"""
+        binary_func_template = '\n  (func (export "{lane_type}.{op}") (param v128 v128) (result v128) ({lane_type}.{op} (local.get 0) (local.get 1)))'
+        unary_func_template = '\n  (func (export "{lane_type}.{op}") (param v128) (result v128) ({lane_type}.{op} (local.get 0)))'
+        funcs = ''
+        for op in self.BINARY_OPS:
+            funcs += binary_func_template.format(lane_type=self.LANE_TYPE, op=op)
+        for op in self.UNARY_OPS:
+            funcs += unary_func_template.format(lane_type=self.LANE_TYPE, op=op)
+        return funcs
+
+    @property
+    def gen_funcs_with_const(self):
+        """generate functions with const arguments"""
+        binary_func_with_const = '\n  (func (export "{lane_type}.{op}_with_const_{cnt}") (result v128) ({lane_type}.{op} {param_1} {param_2}))'
+        unary_func_with_const = '\n  (func (export "{lane_type}.{op}_with_const_{cnt}") (result v128) ({lane_type}.{op} {param}))'
+        binary_func_with_param_and_const = '\n  (func (export "{lane_type}.{op}_with_const_{cnt}") (param v128) (result v128) ({lane_type}.{op} (local.get 0) {param_1}))'
+        funcs = ''
+        cnt = 0
+        for op in self.BINARY_OPS:
+            for param_1, param_2 in self.get_binary_test_data_with_const:
+                funcs += binary_func_with_const.format(lane_type=self.LANE_TYPE,
+                                                op=op,
+                                                param_1=SIMD.v128_const(param_1, self.LANE_TYPE),
+                                                param_2=SIMD.v128_const(param_2, self.LANE_TYPE),
+                                                cnt=cnt)
+                cnt += 1
+        for op in self.UNARY_OPS:
+            for param in self.get_unary_complex_test_data:
+                funcs += unary_func_with_const.format(lane_type=self.LANE_TYPE,
+                                               op=op,
+                                               param=SIMD.v128_const(param, self.LANE_TYPE),
+                                               cnt=cnt)
+                cnt += 1
+        for op in self.BINARY_OPS:
+            for param_1, param_2 in self.get_binary_test_data_with_const:
+                funcs += binary_func_with_param_and_const.format(lane_type=self.LANE_TYPE,
+                                                          op=op,
+                                                          param_1=SIMD.v128_const(param_1, self.LANE_TYPE),
+                                                          cnt=cnt)
+                cnt += 1
+
+        return funcs
+
+    @property
+    def gen_test_case_with_const(self):
+        """generate tests calling function with const"""
+        cnt = 0
+        cases = '\n\n;; Const vs const'
+        for op in self.BINARY_OPS:
+            o = ArithmeticOp(op)
+            for param_1, param_2 in self.get_binary_test_data_with_const:
+                result = []
+                for idx in range(0, len(param_1)):
+                    result.append(o.binary_op(param_1[idx], param_2[idx], self.LANE_VALUE))
+                cases += '\n' + str(AssertReturn('{lane_type}.{op}_with_const_{cnt}'.format(lane_type=self.LANE_TYPE, op=op, cnt=cnt),
+                                                 [],
+                                                 SIMD.v128_const(result, self.LANE_TYPE)))
+                cnt += 1
+
+        for op in self.UNARY_OPS:
+            o = ArithmeticOp(op)
+            for param in self.get_unary_complex_test_data:
+                result = []
+                for idx in range(0, len(param)):
+                    result.append(o.unary_op(param[idx], self.LANE_VALUE))
+                cases += '\n' + str(AssertReturn('{lane_type}.{op}_with_const_{cnt}'.format(lane_type=self.LANE_TYPE, op=op, cnt=cnt),
+                                                 [],
+                                                 SIMD.v128_const(result, self.LANE_TYPE)))
+                cnt += 1
+
+        cases += '\n\n;; Param vs const'
+        for op in self.BINARY_OPS:
+            o = ArithmeticOp(op)
+            for param_1, param_2 in self.get_binary_test_data_with_const:
+                result = []
+                for idx in range(0, len(param_1)):
+                    result.append(o.binary_op(param_1[idx], param_2[idx], self.LANE_VALUE))
+                cases += '\n' + str(AssertReturn('{lane_type}.{op}_with_const_{cnt}'.format(lane_type=self.LANE_TYPE, op=op, cnt=cnt),
+                                                 [SIMD.v128_const(param_2, self.LANE_TYPE)],
+                                                 SIMD.v128_const(result, self.LANE_TYPE)))
+                cnt += 1
+
+        return cases
+
+    @property
+    def gen_test_case(self):
+        """generate binary test cases"""
+        cases = ''
+
+        def gen_binary(case_data):
+            cases = ''
+            for op in self.BINARY_OPS:
+                o = ArithmeticOp(op)
+                for param_1, param_2 in case_data:
+                    result = []
+                    for idx in range(0, len(param_1)):
+                        result.append(o.binary_op(param_1[idx], param_2[idx], self.LANE_VALUE))
+                    cases += '\n' + str(AssertReturn('{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op),
+                                                     [SIMD.v128_const(param_1, self.LANE_TYPE), SIMD.v128_const(param_2, self.LANE_TYPE)],
+                                                     SIMD.v128_const(result, self.LANE_TYPE)))
+            return cases
+
+        def gen_unary(case_data):
+            cases = ''
+            for op in self.UNARY_OPS:
+                o = ArithmeticOp(op)
+                for param in case_data:
+                    result = []
+                    for idx in range(0, len(param)):
+                        result.append(o.unary_op(param[idx], self.LANE_VALUE))
+                    cases += '\n' + str(AssertReturn('{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op),
+                                                     [SIMD.v128_const(param, self.LANE_TYPE)],
+                                                     SIMD.v128_const(result, self.LANE_TYPE)))
+            return cases
+
+        cases += gen_binary(self.get_binary_test_data)
+        cases += gen_unary(self.get_unary_test_data)
+
+        cases += self.gen_test_case_with_const
+
+        # test different lanes go through different if-then clauses
+        cases += '\n\n;; Test different lanes go through different if-then clauses'
+        cases += gen_binary(self.get_binary_test_data_go_through_if)
+        cases += gen_unary(self.get_unary_complex_test_data)
+
+        # test opposite signs of zero
+        cases += '\n\n;; Test opposite signs of zero'
+        cases += gen_binary(self.get_binary_test_data_opposite_sign_zero)
+        cases += gen_unary(self.get_unary_test_data_opposite_sign_zero)
+
+        # unknown operators test cases
+        cases += self.gen_test_case_unknown_operators
+
+        # type check test cases
+        cases += self.gen_test_case_type_check
+
+        # empty argument test cases
+        cases += self.gen_test_case_empty_argument
+
+        return cases
+
+    @property
+    def gen_test_case_unknown_operators(self):
+        """generate unknown operators test cases"""
+        cases = ['\n\n;; Unknown operators']
+
+        for op in self.UNKNOWN_BINARY_OPS:
+            cases.append(AssertMalformed.get_unknown_op_test(
+                op, 'v128',
+                SIMD.v128_const('0', self.LANE_TYPE),
+                SIMD.v128_const('1', self.LANE_TYPE)
+            ))
+        if hasattr(self, 'UNKNOWN_UNARY_OPS'):
+            for op in self.UNKNOWN_UNARY_OPS:
+                cases.append(AssertMalformed.get_unknown_op_test(
+                    op, 'v128',
+                    SIMD.v128_const('-1', self.LANE_TYPE)
+                ))
+        return '\n'.join(cases)
+
+    @property
+    def gen_test_case_type_check(self):
+        """generate type check test cases"""
+        cases = '\n\n;; Type check'
+        binary_assert_template = '(assert_invalid (module (func (result v128) ({lane_type}.{op} (i32.const 0) (f32.const 0.0)))) "type mismatch")'
+        unary_assert_template = '(assert_invalid (module (func (result v128) ({lane_type}.{op} (f32.const 0.0)))) "type mismatch")'
+        for op in self.BINARY_OPS:
+            cases += '\n' + binary_assert_template.format(lane_type=self.LANE_TYPE, op=op)
+        for op in self.UNARY_OPS:
+            cases += '\n' + unary_assert_template.format(lane_type=self.LANE_TYPE, op=op)
+
+        return cases
+
+    @property
+    def gen_funcs_combination(self):
+        """generate functions for combination test cases"""
+        funcs = '\n\n;; Combination'
+        funcs += '\n(module'
+
+        binary_vs_binary_assert_template = '  (func (export "{lane_type}.{op1}-{lane_type}.{op2}") (param v128 v128 v128) (result v128) ' \
+                          '({lane_type}.{op1} ({lane_type}.{op2} (local.get 0) (local.get 1))(local.get 2))' \
+                          ')'
+        binary_vs_unary_assert_template = '  (func (export "{lane_type}.{op1}-{lane_type}.{op2}") (param v128 v128) (result v128) ' \
+                          '({lane_type}.{op1} ({lane_type}.{op2} (local.get 0))(local.get 1))' \
+                          ')'
+        unary_vs_binary_assert_template = '  (func (export "{lane_type}.{op1}-{lane_type}.{op2}") (param v128 v128) (result v128) ' \
+                          '({lane_type}.{op1} ({lane_type}.{op2} (local.get 0) (local.get 1)))' \
+                          ')'
+        unary_vs_unary_assert_template = '  (func (export "{lane_type}.{op1}-{lane_type}.{op2}") (param v128) (result v128) ' \
+                          '({lane_type}.{op1} ({lane_type}.{op2} (local.get 0)))' \
+                          ')'
+
+        binary_ops = list(self.BINARY_OPS)
+        binary_ops.reverse()
+        unary_ops = list(self.UNARY_OPS)
+        unary_ops.reverse()
+        for op1 in self.BINARY_OPS:
+            for op2 in binary_ops:
+                funcs += '\n' + binary_vs_binary_assert_template.format(lane_type=self.LANE_TYPE, op1=op1, op2=op2)
+            for op2 in self.UNARY_OPS:
+                funcs += '\n' + binary_vs_unary_assert_template.format(lane_type=self.LANE_TYPE, op1=op1, op2=op2)
+                funcs += '\n' + unary_vs_binary_assert_template.format(lane_type=self.LANE_TYPE, op1=op2, op2=op1)
+        for op1 in self.UNARY_OPS:
+            for op2 in unary_ops:
+                funcs += '\n' + unary_vs_unary_assert_template.format(lane_type=self.LANE_TYPE, op1=op1, op2=op2)
+
+        funcs += '\n)'
+        return funcs
+
+    @property
+    def gen_test_case_combination(self):
+        """generate combination test cases"""
+
+        cases = '\n'
+
+        binary_ops = list(self.BINARY_OPS)
+        binary_ops.reverse()
+        unary_ops = list(self.UNARY_OPS)
+        unary_ops.reverse()
+        for op1 in self.BINARY_OPS:
+            """binary vs binary"""
+            o1 = ArithmeticOp(op1)
+            for op2 in binary_ops:
+                o2 = ArithmeticOp(op2)
+                result = []
+                ret = o2.binary_op('0', '1', self.LANE_VALUE)
+                ret = o1.binary_op(ret, '2', self.LANE_VALUE)
+                result.append(ret)
+
+                cases += '\n' + str(AssertReturn('{lane_type}.{op1}-{lane_type}.{op2}'.format(lane_type=self.LANE_TYPE, op1=op1, op2=op2),
+                                                 [SIMD.v128_const('0', self.LANE_TYPE),
+                                                  SIMD.v128_const('1', self.LANE_TYPE),
+                                                  SIMD.v128_const('2', self.LANE_TYPE)],
+                                                 SIMD.v128_const(result, self.LANE_TYPE)))
+            for op2 in self.UNARY_OPS:
+                """binary vs unary"""
+                o2 = ArithmeticOp(op2)
+                result1 = []
+                ret1 = o2.unary_op('-1', self.LANE_VALUE)
+                ret1 = o1.binary_op(ret1, '0', self.LANE_VALUE)
+                result1.append(ret1)
+                cases += '\n' + str(AssertReturn('{lane_type}.{op1}-{lane_type}.{op2}'.format(lane_type=self.LANE_TYPE, op1=op1, op2=op2),
+                                                 [SIMD.v128_const('-1', self.LANE_TYPE),
+                                                  SIMD.v128_const('0', self.LANE_TYPE)],
+                                                 SIMD.v128_const(result1, self.LANE_TYPE)))
+                """unary vs binary"""
+                result2 = []
+                ret2 = o1.binary_op('0', '-1', self.LANE_VALUE)
+                ret2 = o2.unary_op(ret2, self.LANE_VALUE)
+                result2.append(ret2)
+                cases += '\n' + str(AssertReturn('{lane_type}.{op1}-{lane_type}.{op2}'.format(lane_type=self.LANE_TYPE, op1=op2, op2=op1),
+                                                 [SIMD.v128_const('0', self.LANE_TYPE),
+                                                  SIMD.v128_const('-1', self.LANE_TYPE)],
+                                                 SIMD.v128_const(result2, self.LANE_TYPE)))
+        for op1 in self.UNARY_OPS:
+            """unary vs unary"""
+            o1 = ArithmeticOp(op1)
+            for op2 in unary_ops:
+                o2 = ArithmeticOp(op2)
+                result3 = []
+                ret3 = o2.unary_op('-1', self.LANE_VALUE)
+                ret3 = o1.unary_op(ret3, self.LANE_VALUE)
+                result3.append(ret3)
+                cases += '\n' + str(AssertReturn('{lane_type}.{op1}-{lane_type}.{op2}'.format(lane_type=self.LANE_TYPE, op1=op1, op2=op2),
+                                                 [SIMD.v128_const('-1', self.LANE_TYPE)],
+                                                 SIMD.v128_const(result3, self.LANE_TYPE)))
+
+        cases += '\n'
+        return cases
+
+    @property
+    def gen_test_case_empty_argument(self):
+        """generate empty argument test cases"""
+
+        cases = []
+
+        cases.append('\n\n;; Test operation with empty argument\n')
+
+        case_data = {
+            'op': '',
+            'extended_name': 'arg-empty',
+            'param_type': '',
+            'result_type': '(result v128)',
+            'params': '',
+        }
+
+        for op in self.BINARY_OPS:
+            case_data['op'] = '{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op)
+            case_data['extended_name'] = '1st-arg-empty'
+            case_data['params'] = SIMD.v128_const('0', self.LANE_TYPE)
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        for op in self.UNARY_OPS:
+            case_data['op'] = '{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op)
+
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        return '\n'.join(cases)
+
+    @property
+    def gen_funcs(self):
+        """generate functions"""
+        funcs = ''
+        funcs += '\n\n(module'
+        funcs += self.gen_funcs_normal
+        funcs += self.gen_funcs_with_const
+        funcs += '\n)\n'
+
+        return funcs
+
+    def get_all_cases(self):
+        """generate all test cases"""
+        cases = self.class_summary.format(lane_type=self.LANE_TYPE) \
+            + self.gen_funcs \
+            + self.gen_test_case \
+            + self.gen_funcs_combination \
+            + self.gen_test_case_combination
+
+        return cases
+
+    def gen_test_cases(self):
+        """generate case file"""
+        wast_filename = '../simd_{lane_type}_arith2.wast'.format(lane_type=self.LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            fp.write(self.get_all_cases())
+
+
+class Simdi64x2Case(SimdLaneWiseInteger):
+    LANE_TYPE = 'i64x2'
+    class_summary = """;; Tests for {lane_type} [abs] operations."""
+    BINARY_OPS = ()
+
+    UNKNOWN_BINARY_OPS = ()
+
+
+class Simdi32x4Case(SimdLaneWiseInteger):
+    LANE_TYPE = 'i32x4'
+    class_summary = """;; Tests for {lane_type} [min_s, min_u, max_s, max_u, abs] operations."""
+
+    UNKNOWN_BINARY_OPS = ('f32x4.min_s', 'f32x4.min_u', 'f32x4.max_s', 'f32x4.max_u',
+                   'i64x2.min_s', 'i64x2.min_u', 'i64x2.max_s', 'i64x2.max_u',
+                   'f64x2.min_s', 'f64x2.min_u', 'f64x2.max_s', 'f64x2.max_u')
+
+
+class Simdi16x8Case(SimdLaneWiseInteger):
+    LANE_TYPE = 'i16x8'
+
+    BINARY_OPS = ('min_s', 'min_u', 'max_s', 'max_u', 'avgr_u')
+    UNKNOWN_BINARY_OPS = ('i16x8.avgr', 'i16x8.avgr_s')
+
+
+class Simdi8x16Case(SimdLaneWiseInteger):
+    LANE_TYPE = 'i8x16'
+
+    UNARY_OPS = ('abs','popcnt')
+    BINARY_OPS = ('min_s', 'min_u', 'max_s', 'max_u', 'avgr_u')
+    UNKNOWN_BINARY_OPS = ('i32x4.avgr_u', 'f32x4.avgr_u',
+                   'i64x2.avgr_u', 'f64x2.avgr_u',
+                   'i8x16.avgr', 'i8x16.avgr_s')
+
+
+def gen_test_cases():
+    simd_i64x2_case = Simdi64x2Case()
+    simd_i64x2_case.gen_test_cases()
+
+    simd_i32x4_case = Simdi32x4Case()
+    simd_i32x4_case.gen_test_cases()
+
+    simd_i16x8_case = Simdi16x8Case()
+    simd_i16x8_case.gen_test_cases()
+
+    simd_i8x16_case = Simdi8x16Case()
+    simd_i8x16_case.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_int_to_int_extend.py b/test/core/simd/meta/simd_int_to_int_extend.py
new file mode 100644
index 000000000..b92b0d8e4
--- /dev/null
+++ b/test/core/simd/meta/simd_int_to_int_extend.py
@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+
+"""
+Generates all integer-to-integer extension test cases.
+"""
+
+from simd import SIMD
+from simd_arithmetic import SimdArithmeticCase
+from test_assert import AssertReturn, AssertInvalid
+
+
+class SimdIntToIntExtend(SimdArithmeticCase):
+    LANE_TYPE = ""  # unused, can be anything
+    BINARY_OPS = ()
+    UNARY_OPS = (
+        "i16x8.extend_high_i8x16_s",
+        "i16x8.extend_high_i8x16_u",
+        "i16x8.extend_low_i8x16_s",
+        "i16x8.extend_low_i8x16_u",
+        "i32x4.extend_high_i16x8_s",
+        "i32x4.extend_high_i16x8_u",
+        "i32x4.extend_low_i16x8_s",
+        "i32x4.extend_low_i16x8_u",
+        "i64x2.extend_high_i32x4_s",
+        "i64x2.extend_high_i32x4_u",
+        "i64x2.extend_low_i32x4_s",
+        "i64x2.extend_low_i32x4_u",
+    )
+
+    TEST_FUNC_TEMPLATE_HEADER = ";; Tests for int-to-int extension operations.\n"
+
+    def op_name(self, op):
+        # Override base class implementation, since the lane type is already
+        # part of the op name.
+        return "{op}".format(lane_type=self.LANE_TYPE, op=op)
+
+    def is_unsigned(self, op):
+        return op.endswith("_u")
+
+    def src_lane_type(self, op):
+        return op[-7:-2]
+
+    def dst_lane_type(self, op):
+        return op[0:5]
+
+    def get_test_cases(self, src_value):
+        return [
+            (0, 0),
+            (0, 1),
+            (0, -1),
+            (1, 0),
+            (-1, 0),
+            (1, -1),
+            ((-1, 1)),
+            ((src_value.max - 1), (src_value.max)),
+            ((src_value.max), (src_value.max - 1)),
+            ((src_value.max), (src_value.max)),
+            ((src_value.min), (src_value.min)),
+            ((src_value.max), (src_value.min)),
+            ((src_value.min), (src_value.max)),
+            ((src_value.max), -1),
+            (-1, (src_value.max)),
+            (((src_value.min + 1), (src_value.min))),
+            ((src_value.min), (src_value.min + 1)),
+            ((src_value.min), (-1)),
+            ((-1), (src_value.min)),
+        ]
+
+    def get_normal_case(self):
+        cases = []
+
+        for op in self.UNARY_OPS:
+            src_lane_type = self.src_lane_type(op)
+            src_value = self.LANE_VALUE[src_lane_type]
+            operands = self.get_test_cases(src_value)
+
+            for (low, high) in operands:
+                result = low if "low" in op else high
+
+                if self.is_unsigned(op):
+                    # Unsign-extend, mask top bits.
+                    result = result & src_value.mask
+
+                cases.append(
+                    str(
+                        AssertReturn(
+                            op,
+                            [SIMD.v128_const([str(low), str(high)], src_lane_type)],
+                            SIMD.v128_const(str(result), self.dst_lane_type(op)),
+                        )
+                    )
+                )
+
+            cases.append("")
+
+        return "\n".join(cases)
+
+    def gen_test_cases(self):
+        wast_filename = "../simd_int_to_int_extend.wast"
+        with open(wast_filename, "w") as fp:
+            fp.write(self.get_all_cases())
+
+    def get_combine_cases(self):
+        return ""
+
+
+def gen_test_cases():
+    simd_int_to_int_extend = SimdIntToIntExtend()
+    simd_int_to_int_extend.gen_test_cases()
+
+
+if __name__ == "__main__":
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_int_trunc_sat_float.py b/test/core/simd/meta/simd_int_trunc_sat_float.py
new file mode 100644
index 000000000..88048b6c9
--- /dev/null
+++ b/test/core/simd/meta/simd_int_trunc_sat_float.py
@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+
+"""Base class for generating SIMD <int>.trun_sat_<float> test cases.
+Subclasses should set:
+    - LANE_TYPE
+    - SRC_LANE_TYPE
+    - UNARY_OPS
+"""
+
+from abc import abstractmethod
+import struct
+from math import trunc
+from simd import SIMD
+from simd_arithmetic import SimdArithmeticCase
+from test_assert import AssertReturn
+from simd_float_op import FloatingPointOp, FloatingPointRoundingOp
+from simd_integer_op import ArithmeticOp
+
+
+class SimdConversionCase(SimdArithmeticCase):
+    BINARY_OPS = ()
+    TEST_FUNC_TEMPLATE_HEADER = ";; Tests for {} trunc sat conversions from float.\n"
+
+    def is_signed(self, op):
+        return op.endswith("_s") or op.endswith("_s_zero")
+
+    def get_test_data(self, lane):
+        return [
+            "0.0",
+            "-0.0",
+            "1.5",
+            "-1.5",
+            "1.9",
+            "2.0",
+            "-1.9",
+            "-2.0",
+            str(float(lane.max - 127)),
+            str(float(-(lane.max - 127))),
+            str(float(lane.max + 1)),
+            str(float(-(lane.max + 1))),
+            str(float(lane.max * 2)),
+            str(float(-(lane.max * 2))),
+            str(float(lane.max)),
+            str(float(-lane.max)),
+            str(float(lane.mask - 1)),
+            str(float(lane.mask)),
+            str(float(lane.mask + 1)),
+            "0x1p-149",
+            "-0x1p-149",
+            "0x1p-126",
+            "-0x1p-126",
+            "0x1p-1",
+            "-0x1p-1",
+            "0x1p+0",
+            "-0x1p+0",
+            "0x1.19999ap+0",
+            "-0x1.19999ap+0",
+            "0x1.921fb6p+2",
+            "-0x1.921fb6p+2",
+            "0x1.fffffep+127",
+            "-0x1.fffffep+127",
+            "0x1.ccccccp-1",
+            "-0x1.ccccccp-1",
+            "0x1.fffffep-1",
+            "-0x1.fffffep-1",
+            "0x1.921fb6p+2",
+            "-0x1.921fb6p+2",
+            "0x1.fffffep+127",
+            "-0x1.fffffep+127",
+            "+inf",
+            "-inf",
+            "+nan",
+            "-nan",
+            "nan:0x444444",
+            "-nan:0x444444",
+            "42",
+            "-42",
+            "0123456792.0",
+            "01234567890.0",
+        ]
+
+    def to_float_precision(self, value):
+        # Python supports double precision, so given an an input that cannot be
+        # precisely represented in f32, we need to round it.
+        return value
+
+    @abstractmethod
+    def to_results(self, result: str):
+        # Subclasses can override this to set the shape of the results. This is
+        # useful if instructions zero top lanes.
+        pass
+
+    def conversion_op(self, op, operand):
+        fop = FloatingPointRoundingOp()
+        signed = self.is_signed(op)
+        sat_op = ArithmeticOp("sat_s") if signed else ArithmeticOp("sat_u")
+        result = fop.unary_op("trunc", operand, hex_form=False)
+        if result == "nan":
+            return "0"
+        elif result == "+inf":
+            return str(str(self.lane.max) if signed else str(self.lane.mask))
+        elif result == "-inf":
+            return str(self.lane.min if signed else 0)
+        else:
+            float_result = self.to_float_precision(float(result))
+            trunced = int(trunc(float_result))
+            saturated = sat_op.unary_op(trunced, self.lane)
+            return str(saturated)
+
+    def get_case_data(self):
+        test_data = []
+        for op in self.UNARY_OPS:
+            op_name = "{}.{}".format(self.LANE_TYPE, op)
+            test_data.append(["#", op_name])
+
+            for operand in self.get_test_data(self.lane):
+                operand = str(operand)
+                if "nan" in operand:
+                    test_data.append(
+                        [op_name, [operand], "0", [self.SRC_LANE_TYPE, self.LANE_TYPE]]
+                    )
+                else:
+                    result = self.conversion_op(op_name, operand)
+                    results = self.to_results(result)
+                    assert "nan" not in result
+                    test_data.append(
+                        [
+                            op_name,
+                            [operand],
+                            results,
+                            [self.SRC_LANE_TYPE, self.LANE_TYPE],
+                        ]
+                    )
+
+        return test_data
+
+    def gen_test_cases(self):
+        wast_filename = "../simd_{}_trunc_sat_{}.wast".format(
+            self.LANE_TYPE, self.SRC_LANE_TYPE
+        )
+        with open(wast_filename, "w") as fp:
+            fp.write(self.get_all_cases())
+
+    def get_combine_cases(self):
+        return ""
+
+
+class SimdI32x4TruncSatF32x4Case(SimdConversionCase):
+    LANE_TYPE = "i32x4"
+    SRC_LANE_TYPE = "f32x4"
+    UNARY_OPS = ("trunc_sat_f32x4_s", "trunc_sat_f32x4_u")
+
+    def to_float_precision(self, value):
+        fop = FloatingPointOp()
+        return fop.to_single_precision(value)
+
+    def to_results(self, value: str):
+        return [value]
+
+
+class SimdI32x4TruncSatF64x2Case(SimdConversionCase):
+    LANE_TYPE = "i32x4"
+    SRC_LANE_TYPE = "f64x2"
+    UNARY_OPS = ("trunc_sat_f64x2_s_zero", "trunc_sat_f64x2_u_zero")
+
+    def to_results(self, value: str):
+        return [value, "0"]
+
+
+def gen_test_cases():
+    i32x4_trunc_sat = SimdI32x4TruncSatF32x4Case()
+    i32x4_trunc_sat.gen_test_cases()
+    i32x4_trunc_sat = SimdI32x4TruncSatF64x2Case()
+    i32x4_trunc_sat.gen_test_cases()
+
+
+if __name__ == "__main__":
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_integer_op.py b/test/core/simd/meta/simd_integer_op.py
new file mode 100644
index 000000000..69ed7235e
--- /dev/null
+++ b/test/core/simd/meta/simd_integer_op.py
@@ -0,0 +1,209 @@
+#!/usr/bin/env python3
+
+"""Common integer value operations"""
+
+from simd_lane_value import LaneValue
+
+
+class ArithmeticOp:
+    """This class provides methods to simulate integer arithmetic
+    and saturating integer arithmetic operations for the purpose of
+    getting corresponding expected results. One or more operands
+    may be required for the operations.
+    The following operators are covered:
+    add, sub, mul, neg,
+    add_sat_s, add_sat_u,
+    sub_sat_s, sub_sat_u,
+    min_s, min_u, max_s, max_u, avgr_u, abs
+    ext_mul_s, ext_mul_u
+    """
+    def __init__(self, op: str):
+        self.op = op
+
+    @staticmethod
+    def get_valid_value(value: int, lane: LaneValue, signed=True) -> int:
+        """Get the valid integer value in the scope of the specified lane size.
+
+        For a integer value, convert it to the valid value with the same bits
+        of the lane width. The value can be signed or unsigned, with the scope
+        of -0x80... to 0x7f... or 0 to 0xff...
+
+        :param value: the value of the integer
+        :param lane: the LaneValue instance of a lane in v128
+        :param signed: specify if the lane is interpreted as a signed or
+                        an unsigned number.
+        :return : the valid value in either signed or unsigned number
+        """
+        value &= lane.mask
+        if signed:
+            if value > lane.max:
+                return value - lane.mod
+            if value < lane.min:
+                return value + lane.mod
+        return value
+
+    def _saturate(self, operand1: int, operand2: int, lane: LaneValue) -> int:
+        """Get the result of saturating arithmetic operation on 2 operands.
+        The operands can be both signed or unsigned. The following ops
+        are covered:
+        add_sat_s, sub_sat_s, add_sat_u, sub_sat_u,
+
+        Saturating arithmetic can make sure:
+        When the operation result is less than the minimum, return the minimum.
+        When the operation result is greater than the maximum, return the maximum.
+        For other operation results, simply return themselves.
+        :param operand1: the integer operand 1
+        :param operand2: the integer operand 2
+        :param lane: the LaneValue instance of a lane in v128
+        :return: the result of the saturating arithmetic operation
+        """
+        if self.op.endswith('sat_s'):
+            if operand1 > lane.max:
+                operand1 -= lane.mod
+            if operand2 > lane.max:
+                operand2 -= lane.mod
+
+            if self.op.startswith('add'):
+                value = operand1 + operand2
+            if self.op.startswith('sub'):
+                value = operand1 - operand2
+
+            return lane.sat_s(value)
+
+        if self.op.endswith('sat_u'):
+            if operand1 < 0:
+                operand1 += lane.mod
+            if operand2 < 0:
+                operand2 += lane.mod
+            if self.op.startswith('add'):
+                value = operand1 + operand2
+            if self.op.startswith('sub'):
+                value = operand1 - operand2
+
+            return lane.sat_u(value)
+
+        return value
+
+    def unary_op(self, operand, lane):
+        """General integer arithmetic and saturating arithmetic operations
+        with only one operand.
+
+        Supported ops: neg, abs
+
+        :param operand: the operand, integer or literal string in hex or decimal format
+        :param lane: the LaneValue instance of a lane in v128
+        :return: the string of the result of <self.op p> in hex or decimal format
+        """
+        v = operand
+        base = 10
+        if isinstance(operand, str):
+            if '0x' in operand:
+                base = 16
+            v = int(operand, base)
+
+        if self.op == 'neg':
+            result = self.get_valid_value(-v, lane)
+        elif self.op == 'abs':
+            result = self.get_valid_value(v, lane)
+            if result >= 0:
+                return operand
+            else:
+                result = -result
+            if base == 16:
+                return hex(result)
+        elif self.op == 'popcnt':
+            result = self.get_valid_value(v, lane)
+            return str(bin(result % lane.mod).count('1'))
+        elif self.op == 'sat_s':
+            # Don't call get_valid_value, it will truncate results.
+            return lane.sat_s(v)
+        elif self.op == 'sat_u':
+            # Don't call get_valid_value, it will truncate results.
+            return lane.sat_u(v)
+        else:
+            raise Exception('Unknown unary operation')
+
+        return str(result)
+
+    def binary_op(self, operand1, operand2, src_lane, dst_lane=None):
+        """General integer arithmetic and saturating arithmetic operations
+        with 2 operands.
+
+        Supported ops:
+        add, sub, mul,
+        add_sat_s, add_sat_u,
+        sub_sat_s, sub_sat_u,
+        min_s, min_u, max_s, max_u, avgr_u,
+        ext_mul_s, ext_mul_u (same as mul),
+        q15mulr_sat_s
+
+        :param operand1: the operand 1, integer or literal string in hex or decimal format
+        :param operand2: the operand 2, integer or literal string in hex or decimal format
+        :param src_lane: the LaneValue instance of a lane in v128
+        :return: the string of the result of <p1 self.op p2> in hex or decimal format
+        """
+        if not dst_lane:
+            dst_lane = src_lane
+        v1 = operand1
+        v2 = operand2
+        base1 = base2 = 10
+        if isinstance(operand1, str):
+            if '0x' in operand1:
+                base1 = 16
+            v1 = int(operand1, base1)
+        if isinstance(operand2, str):
+            if '0x' in operand2:
+                base2 = 16
+            v2 = int(operand2, base2)
+
+        result_signed = True
+        if self.op == 'add':
+            value = v1 + v2
+        elif self.op == 'sub':
+            value = v1 - v2
+        elif self.op == 'mul':
+            value = v1 * v2
+        elif self.op.startswith('extmul_'):
+            if self.op.endswith('s'):
+                i1 = self.get_valid_value(v1, src_lane)
+                i2 = self.get_valid_value(v2, src_lane)
+            else:
+                i1 = self.get_valid_value(v1, src_lane, signed=False)
+                i2 = self.get_valid_value(v2, src_lane, signed=False)
+            value = i1 * i2
+        elif self.op == 'q15mulr_sat_s':
+            # This should be before 'sat' case.
+            i1 = ArithmeticOp.get_valid_value(v1, src_lane)
+            i2 = ArithmeticOp.get_valid_value(v2, src_lane)
+            return src_lane.sat_s((i1 * i2 + 0x4000) >> 15)
+        elif 'sat' in self.op:
+            value = self._saturate(v1, v2, src_lane)
+            if self.op.endswith('_u'):
+                result_signed = False
+        elif self.op in ['min_s', 'max_s']:
+            i1 = self.get_valid_value(v1, src_lane)
+            i2 = self.get_valid_value(v2, src_lane)
+            if self.op == 'min_s':
+                return operand1 if i1 <= i2 else operand2
+            else:
+                return operand1 if i1 >= i2 else operand2
+        elif self.op in ['min_u', 'max_u']:
+            i1 = self.get_valid_value(v1, src_lane, signed=False)
+            i2 = self.get_valid_value(v2, src_lane, signed=False)
+            if self.op == 'min_u':
+                return operand1 if i1 <= i2 else operand2
+            else:
+                return operand1 if i1 >= i2 else operand2
+        elif self.op == 'avgr_u':
+            i1 = self.get_valid_value(v1, src_lane, signed=False)
+            i2 = self.get_valid_value(v2, src_lane, signed=False)
+            result = (i1 + i2 + 1) // 2
+            if base1 == 16 or base2 == 16:
+                return hex(result)
+            else:
+                return str(result)
+        else:
+            raise Exception('Unknown binary operation')
+
+        result = self.get_valid_value(value, dst_lane, signed=result_signed)
+        return str(result)
diff --git a/test/core/simd/meta/simd_lane_value.py b/test/core/simd/meta/simd_lane_value.py
new file mode 100644
index 000000000..a280b0661
--- /dev/null
+++ b/test/core/simd/meta/simd_lane_value.py
@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+
+
+class LaneValue:
+    """This class stands for the value of signed integer represented by a lane in v128.
+    Suppose a bit number of the lane is n, then:
+    For signed integer:
+        minimum = -pow(2, n - 1), maximum = pow(2, n - 1) - 1
+    The bit number of the lane can be 8, 16, 32, 64"""
+    def __init__(self, lane_width):
+        """lane_width: bit number of each lane in SIMD v128"""
+        self.lane_width = lane_width
+
+    @property
+    def min(self):
+        return -pow(2, self.lane_width - 1)
+
+    @property
+    def max(self):
+        return pow(2, self.lane_width - 1) - 1
+
+    @property
+    def mask(self):
+        return pow(2, self.lane_width) - 1
+
+    @property
+    def mod(self):
+        return pow(2, self.lane_width)
+
+    @property
+    def quarter(self):
+        return pow(2, self.lane_width - 2)
+
+    def sat_s(self, v):
+        return max(self.min, min(v, self.max))
+
+    def sat_u(self, v):
+        return max(0, min(v, self.mask))
diff --git a/test/core/simd/meta/simd_load_lane.py b/test/core/simd/meta/simd_load_lane.py
new file mode 100644
index 000000000..2900e9850
--- /dev/null
+++ b/test/core/simd/meta/simd_load_lane.py
@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+
+from simd import SIMD
+from test_assert import AssertReturn, AssertInvalid
+
+def list_stringify(l):
+    return list(map(lambda x: str(x), l))
+
+"""Base class for generating SIMD load lane tests. Subclasses only to:
+    - define self.LANE_LEN, self.LANE_TYPE, self.NUM_LANES, self.MAX_ALIGN
+    - override get_normal_case to provide test data  (consult comments for details)
+
+It generates test cases that:
+    - load to all valid lane indices
+    - load using memarg offset
+    - load with memarg alignment
+    - load with invalid lane index
+    - load with invalid memarg alignment
+    - fails typecheck
+"""
+class SimdLoadLane:
+    def valid_alignments(self):
+        return [a for a in range(1, self.MAX_ALIGN+1) if a & (a-1) == 0]
+
+    def get_case_data(self):
+        # return value should be a list of tuples:
+        #   (address to load from : i32, initial value : v128, return value : v128)
+        # e.g. [(0, [0], [0x0100, 0, 0, 0, 0, 0, 0, 0]), ... ]
+        raise Exception("Subclasses should override this to provide test data")
+
+    def get_normal_case(self):
+        s = SIMD()
+        cases = []
+
+        # load using arg
+        for (addr, val, ret) in self.get_case_data():
+            i32_addr = s.const(addr, "i32")
+            v128_val = s.v128_const(list_stringify(val), self.LANE_TYPE)
+            v128_result = s.v128_const(list_stringify(ret), self.LANE_TYPE)
+            instr = "v128.load{lane_len}_lane_{idx}".format(lane_len=self.LANE_LEN, idx=addr)
+            cases.append(str(AssertReturn(instr, [i32_addr, v128_val], v128_result)))
+
+        # load using offset
+        for (addr, val, ret) in self.get_case_data():
+            v128_val = s.v128_const(list_stringify(val), self.LANE_TYPE)
+            v128_result = s.v128_const(list_stringify(ret), self.LANE_TYPE)
+            instr = "v128.load{lane_len}_lane_{idx}_offset_{idx}".format(lane_len=self.LANE_LEN, idx=addr)
+            cases.append(str(AssertReturn(instr, [v128_val], v128_result)))
+
+        # load using offset with alignment
+        for (addr, val, ret) in self.get_case_data():
+            for align in self.valid_alignments():
+                i32_addr = s.const(addr, "i32")
+                v128_val = s.v128_const(list_stringify(val), self.LANE_TYPE)
+                v128_result = s.v128_const(list_stringify(ret), self.LANE_TYPE)
+                instr = "v128.load{lane_len}_lane_{idx}_align_{align}".format(lane_len=self.LANE_LEN, idx=addr, align=align)
+                cases.append(str(AssertReturn(instr, [i32_addr, v128_val], v128_result)))
+
+        return '\n'.join(cases)
+
+    def gen_test_func_template(self):
+        template = [
+            ';; Tests for load lane operations.\n\n',
+            '(module',
+            '  (memory 1)',
+            '  (data (i32.const 0) "\\00\\01\\02\\03\\04\\05\\06\\07\\08\\09\\0A\\0B\\0C\\0D\\0E\\0F")',
+            ]
+
+        lane_indices = list(range(self.NUM_LANES))
+
+        # load using i32.const arg
+        for idx in lane_indices:
+            template.append(
+                '  (func (export "v128.load{lane_len}_lane_{idx}")\n'
+                '    (param $address i32) (param $x v128) (result v128)\n'
+                '    (v128.load{lane_len}_lane {idx} (local.get $address) (local.get $x)))'
+                .format(idx=idx, lane_len=self.LANE_LEN))
+
+        # load using memarg offset
+        for idx in lane_indices:
+            template.append(
+                '  (func (export "v128.load{lane_len}_lane_{idx}_offset_{idx}")\n'
+                '    (param $x v128) (result v128)\n'
+                '    (v128.load{lane_len}_lane offset={idx} {idx} (i32.const 0) (local.get $x)))'
+                .format(idx=idx, lane_len=self.LANE_LEN))
+
+        # with memarg aligment
+        for idx in lane_indices:
+            for align in self.valid_alignments():
+                template.append(
+                    '  (func (export "v128.load{lane_len}_lane_{idx}_align_{align}")\n'
+                    '    (param $address i32) (param $x v128) (result v128)\n'
+                    '    (v128.load{lane_len}_lane align={align} {idx} (local.get $address) (local.get $x)))'
+                    .format(idx=idx, lane_len=self.LANE_LEN, align=align))
+
+        template.append(')\n')
+        return template
+
+    def gen_test_template(self):
+        template = self.gen_test_func_template()
+
+        template.append('{normal_cases}')
+        template.append('\n{invalid_cases}')
+
+        return '\n'.join(template)
+
+    def get_invalid_cases(self):
+        invalid_cases = [';; type check']
+        invalid_cases.append(
+            '(assert_invalid'
+            '  (module (memory 1)\n'
+            '          (func (param $x v128) (result v128)\n'
+            '            (v128.load{lane_len}_lane 0 (local.get $x) (i32.const 0))))\n'
+            '  "type mismatch")'.format(lane_len=self.LANE_LEN))
+        invalid_cases.append('')
+
+        invalid_cases.append(';; invalid lane index')
+        invalid_cases.append(
+            '(assert_invalid'
+            '  (module (memory 1)\n'
+            '          (func (param $x v128) (result v128)\n'
+            '            (v128.load{lane_len}_lane {idx} (i32.const 0) (local.get $x))))\n'
+            '  "invalid lane index")'.format(idx=self.NUM_LANES, lane_len=self.LANE_LEN))
+
+        invalid_cases.append('')
+
+        invalid_cases.append(';; invalid memarg alignment')
+        invalid_cases.append(
+            '(assert_invalid\n'
+            '  (module (memory 1)\n'
+            '          (func (param $x v128) (result v128)\n'
+            '          (v128.load{lane_len}_lane align={align} 0 (i32.const 0) (local.get $x))))\n'
+            '  "alignment must not be larger than natural")'
+            .format(lane_len=self.LANE_LEN, align=self.MAX_ALIGN*2))
+        return '\n'.join(invalid_cases)
+
+    def get_all_cases(self):
+        case_data = {'lane_len': self.LANE_LEN,
+                     'normal_cases': self.get_normal_case(),
+                     'invalid_cases': self.get_invalid_cases(),
+                     }
+        return self.gen_test_template().format(**case_data)
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_load{lane_type}_lane.wast'.format(lane_type=self.LANE_LEN)
+        with open(wast_filename, 'w') as fp:
+            fp.write(self.get_all_cases())
+
+class SimdLoad8Lane(SimdLoadLane):
+    LANE_LEN = '8'
+    LANE_TYPE = 'i8x16'
+    NUM_LANES = 16
+    MAX_ALIGN = 1
+
+    def get_case_data(self):
+        return [
+            (0, [0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (1, [0], [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (2, [0], [0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (3, [0], [0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (4, [0], [0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (5, [0], [0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (6, [0], [0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (7, [0], [0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (8, [0], [0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0]),
+            (9, [0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0]),
+            (10, [0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0]),
+            (11, [0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0]),
+            (12, [0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0]),
+            (13, [0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0]),
+            (14, [0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0]),
+            (15, [0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15])]
+
+class SimdLoad16Lane(SimdLoadLane):
+    LANE_LEN = '16'
+    LANE_TYPE = 'i16x8'
+    NUM_LANES = 8
+    MAX_ALIGN = 2
+
+    def get_case_data(self):
+        return [
+            (0, [0], [0x0100, 0, 0, 0, 0, 0, 0, 0]),
+            (1, [0], [0, 0x0201, 0, 0, 0, 0, 0, 0]),
+            (2, [0], [0, 0, 0x0302, 0, 0, 0, 0, 0]),
+            (3, [0], [0, 0, 0, 0x0403, 0, 0, 0, 0]),
+            (4, [0], [0, 0, 0, 0, 0x0504, 0, 0, 0]),
+            (5, [0], [0, 0, 0, 0, 0, 0x0605, 0, 0]),
+            (6, [0], [0, 0, 0, 0, 0, 0, 0x0706, 0]),
+            (7, [0], [0, 0, 0, 0, 0, 0, 0, 0x0807])]
+
+class SimdLoad32Lane(SimdLoadLane):
+    LANE_LEN = '32'
+    LANE_TYPE = 'i32x4'
+    NUM_LANES = 4
+    MAX_ALIGN = 4
+
+    def get_case_data(self):
+        return [
+            (0, [0], [0x03020100, 0, 0, 0,]),
+            (1, [0], [0, 0x04030201, 0, 0,]),
+            (2, [0], [0, 0, 0x05040302, 0,]),
+            (3, [0], [0, 0, 0, 0x06050403,])]
+
+class SimdLoad64Lane(SimdLoadLane):
+    LANE_LEN = '64'
+    LANE_TYPE = 'i64x2'
+    NUM_LANES = 2
+    MAX_ALIGN = 8
+
+    def get_case_data(self):
+        return [
+            (0, [0], [0x0706050403020100, 0]),
+            (1, [0], [0, 0x0807060504030201])]
+
+def gen_test_cases():
+    simd_load8_lane = SimdLoad8Lane()
+    simd_load8_lane.gen_test_cases()
+    simd_load16_lane = SimdLoad16Lane()
+    simd_load16_lane.gen_test_cases()
+    simd_load32_lane = SimdLoad32Lane()
+    simd_load32_lane.gen_test_cases()
+    simd_load64_lane = SimdLoad64Lane()
+    simd_load64_lane.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_sat_arith.py b/test/core/simd/meta/simd_sat_arith.py
new file mode 100644
index 000000000..5831f5c76
--- /dev/null
+++ b/test/core/simd/meta/simd_sat_arith.py
@@ -0,0 +1,456 @@
+#!/usr/bin/env python3
+
+"""
+Generate saturating integer arithmetic operation cases.
+"""
+
+from simd_arithmetic import SimdArithmeticCase
+from test_assert import AssertReturn
+from simd import SIMD
+
+
+class SimdSaturateArithmeticCases(SimdArithmeticCase):
+    UNARY_OPS = ()
+    BINARY_OPS = ('add_sat_s', 'add_sat_u',
+                  'sub_sat_s', 'sub_sat_u')
+    malformed_template = '(assert_malformed (module quote\n    "(func (result v128) ' \
+                         '({lane_type}.{op} ({operand_1}) ({operand_2})))")\n    "unknown operator")'
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_{lane_type}_sat_arith.wast'.format(lane_type=self.LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            fp.write(self.get_all_cases())
+
+    def gen_test_template(self):
+        return super().gen_test_template().replace('{invalid_cases}',
+                                                   '{malformed_cases}\n\n{invalid_cases}')
+
+    def v128_const(self, lane, value, lane_len=None):
+        if not lane_len:
+            lane_len = self.LANE_LEN
+
+        return 'v128.const {lane_type} {value}'.format(lane_type=lane, value=' '.join([str(value)] * lane_len))
+
+    def get_malformed_cases(self):
+        malformed_cases = [';; Malformed cases: non-existent op names']
+        inst_ops = ['add', 'sub', 'mul', 'div']
+
+        # The op names should contain _s or _u suffixes, there is no mul or div
+        # for saturating integer arithmetic operation
+        for op in inst_ops:
+            malformed_cases.append(self.malformed_template.format(
+                lane_type=self.LANE_TYPE, op='_'.join([op, 'sat']),
+                operand_1=self.v128_const(self.LANE_TYPE, '1'), operand_2=self.v128_const(self.LANE_TYPE, '2')))
+
+        return '\n'.join(malformed_cases)
+
+    def argument_empty_cases(self):
+        """Test cases with empty argument.
+        """
+        cases = []
+
+        case_data = {
+            'op': '',
+            'extended_name': 'arg-empty',
+            'param_type': '',
+            'result_type': '(result v128)',
+            'params': '',
+        }
+
+        for op in self.BINARY_OPS:
+            case_data['op'] = '{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op)
+            case_data['extended_name'] = '1st-arg-empty'
+            case_data['params'] = SIMD.v128_const('0', self.LANE_TYPE)
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        return '\n'.join(cases)
+
+    def get_all_cases(self):
+        case_data = {'lane_type': self.LANE_TYPE,
+                     'normal_cases': self.get_normal_case(),
+                     'malformed_cases': self.get_malformed_cases(),
+                     'invalid_cases': self.get_invalid_cases(),
+                     'combine_cases': self.get_combine_cases()
+                     }
+        return self.gen_test_template().format(**case_data)
+
+    @property
+    def combine_ternary_arith_test_data(self):
+        return {
+            'sat-add_s-sub_s': [
+                [str(self.lane.quarter)] * self.LANE_LEN,
+                [str(self.lane.max)] * self.LANE_LEN,
+                [str(self.lane.min)] * self.LANE_LEN,
+                [str(self.lane.min)] * self.LANE_LEN
+            ],
+            'sat-add_s-sub_u': [
+                [str(self.lane.mask)] * self.LANE_LEN,
+                [str(self.lane.min)] * self.LANE_LEN,
+                [str(self.lane.min)] * self.LANE_LEN,
+                ['-1'] * self.LANE_LEN
+            ],
+            'sat-add_u-sub_s': [
+                [str(self.lane.max)] * self.LANE_LEN,
+                ['-1'] * self.LANE_LEN,
+                [str(self.lane.max)] * self.LANE_LEN,
+                [str(self.lane.mask - 1)] * self.LANE_LEN
+            ],
+            'sat-add_u-sub_u': [
+                [str(self.lane.mask)] * self.LANE_LEN,
+                ['0'] * self.LANE_LEN,
+                ['1'] * self.LANE_LEN,
+                [str(self.lane.mask)] * self.LANE_LEN
+            ]
+        }
+
+    @property
+    def combine_binary_arith_test_data(self):
+        return {
+            'sat-add_s-neg': [
+                [str(self.lane.min)] * self.LANE_LEN,
+                [str(self.lane.max)] * self.LANE_LEN,
+                ['-1'] * self.LANE_LEN
+            ],
+            'sat-add_u-neg': [
+                [str(self.lane.max)] * self.LANE_LEN,
+                [str(self.lane.min)] * self.LANE_LEN,
+                [str(self.lane.mask)] * self.LANE_LEN
+            ],
+            'sat-sub_s-neg': [
+                [str(self.lane.min)] * self.LANE_LEN,
+                [str(self.lane.max)] * self.LANE_LEN,
+                [str(self.lane.min)] * self.LANE_LEN
+            ],
+            'sat-sub_u-neg': [
+                [str(self.lane.max)] * self.LANE_LEN,
+                [str(self.lane.min)] * self.LANE_LEN,
+                ['1'] * self.LANE_LEN
+            ]
+        }
+
+    def get_combine_cases(self):
+        combine_cases = [';; combination\n(module']
+        ternary_func_template = '  (func (export "{func}") (param v128 v128 v128) (result v128)\n' \
+                              '    ({lane}.{op1} ({lane}.{op2} (local.get 0) (local.get 1))'\
+                              '(local.get 2)))'
+        for func in sorted(self.combine_ternary_arith_test_data):
+            func_parts = func.split('-')
+            op1 = func_parts[1].replace('_', '_sat_')
+            op2 = func_parts[2].replace('_', '_sat_')
+            combine_cases.append(ternary_func_template.format(func=func,
+                                                            lane=self.LANE_TYPE,
+                                                            op1=op1,
+                                                            op2=op2))
+        binary_func_template = '  (func (export "{func}") (param v128 v128) (result v128)\n'\
+                             '    ({lane}.{op1} ({lane}.{op2} (local.get 0)) (local.get 1)))'
+        for func in sorted(self.combine_binary_arith_test_data):
+            func_parts = func.split('-')
+            op1 = func_parts[1].replace('_', '_sat_')
+            combine_cases.append(binary_func_template.format(func=func,
+                                                           lane=self.LANE_TYPE,
+                                                           op1=op1,
+                                                           op2=func_parts[2]))
+        combine_cases.append(')\n')
+
+        for func, test in sorted(self.combine_ternary_arith_test_data.items()):
+            combine_cases.append(str(AssertReturn(func,
+                                 [SIMD.v128_const(elem, self.LANE_TYPE) for elem in test[:-1]],
+                                 SIMD.v128_const(test[-1], self.LANE_TYPE))))
+
+        for func, test in sorted(self.combine_binary_arith_test_data.items()):
+            combine_cases.append(str(AssertReturn(func,
+                                 [SIMD.v128_const(elem, self.LANE_TYPE) for elem in test[:-1]],
+                                 SIMD.v128_const(test[-1], self.LANE_TYPE))))
+
+        return '\n'.join(combine_cases)
+
+
+class SimdI8x16SaturateArithmeticCases(SimdSaturateArithmeticCases):
+    LANE_LEN = 16
+    LANE_TYPE = 'i8x16'
+
+    @property
+    def hex_binary_op_test_data(self):
+        return [
+            ('0x3f', '0x40'),
+            ('0x40', '0x40'),
+            ('-0x3f', '-0x40'),
+            ('-0x40', '-0x40'),
+            ('-0x40', '-0x41'),
+            ('0x7f', '0x7f'),
+            ('0x7f', '0x01'),
+            ('0x80', '-0x01'),
+            ('0x7f', '0x80'),
+            ('0x80', '0x80'),
+            ('0xff', '0x01'),
+            ('0xff', '0xff')
+        ]
+
+    @property
+    def hex_unary_op_test_data(self):
+        return ['0x01', '-0x01', '-0x80', '-0x7f', '0x7f', '0x80', '0xff']
+
+    @property
+    def i8x16_f32x4_test_data(self):
+        return {
+            'i8x16.add_sat_s': [
+                [['0x80', '-0.0'], '0x80', ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '+inf'], ['0x01', '0x01', '0x81', '0x7f'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '-inf'], ['0x01', '0x01', '0x81', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', 'nan'], ['0x01', '0x01', '0xc1', '0x7f'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '-nan'], ['0x01', '0x01', '0xc1', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']]
+            ],
+            'i8x16.add_sat_u': [
+                [['0x80', '-0.0'], ['0x80', '0x80', '0x80', '0xff'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '+inf'], ['0x01', '0x01', '0x81', '0x80'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '-inf'], ['0x01', '0x01', '0x81', '0xff'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', 'nan'], ['0x01', '0x01', '0xc1', '0x80'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '-nan'], ['0x01', '0x01', '0xc1', '0xff'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+            ],
+            'i8x16.sub_sat_s': [
+                [['0x80', '-0.0'], ['0x80', '0x80', '0x80', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '+inf'], ['0x01', '0x01', '0x7f', '0x82'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '-inf'], ['0x01', '0x01', '0x7f', '0x02'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', 'nan'], ['0x01', '0x01', '0x41', '0x82'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '-nan'], ['0x01', '0x01', '0x41', '0x02'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+            ],
+            'i8x16.sub_sat_u': [
+                [['0x80', '-0.0'], ['0x80', '0x80', '0x80', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '+inf'], ['0x01', '0x01', '0', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '-inf'], ['0x01', '0x01', '0', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', 'nan'], ['0x01', '0x01', '0', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+                [['1', '-nan'], ['0x01', '0x01', '0', '0'] * 4, ['i8x16', 'f32x4', 'i8x16']],
+            ]
+        }
+
+    @property
+    def combine_dec_hex_test_data(self):
+        return {
+            'i8x16.add_sat_s': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15'],
+                  ['0', '0xff', '0xfe', '0xfd', '0xfc', '0xfb', '0xfa', '0xf9', '0xf8', '0xf7', '0xf6', '0xf5',
+                   '0xf4', '0xf3', '0xf2', '0xf1']],
+                 ['0'] * 16, ['i8x16', 'i8x16', 'i8x16']]
+            ],
+            'i8x16.add_sat_u': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15'],
+                  ['0', '0xff', '0xfe', '0xfd', '0xfc', '0xfb', '0xfa', '0xf9', '0xf8', '0xf7', '0xf6', '0xf5',
+                   '0xf4', '0xf3', '0xf2', '0xf1']],
+                 ['0'] + ['0xff'] * 15, ['i8x16', 'i8x16', 'i8x16']]
+            ],
+            'i8x16.sub_sat_s': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15'],
+                  ['0', '0xff', '0xfe', '0xfd', '0xfc', '0xfb', '0xfa', '0xf9', '0xf8', '0xf7', '0xf6', '0xf5',
+                   '0xf4', '0xf3', '0xf2', '0xf1']],
+                 ['0', '0x02', '0x04', '0x06', '0x08', '0x0a', '0x0c', '0x0e', '0x10', '0x12', '0x14', '0x16',
+                  '0x18', '0x1a', '0x1c', '0x1e'],
+                 ['i8x16', 'i8x16', 'i8x16']]
+            ],
+            'i8x16.sub_sat_u': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15'],
+                  ['0', '0xff', '0xfe', '0xfd', '0xfc', '0xfb', '0xfa', '0xf9', '0xf8', '0xf7', '0xf6', '0xf5',
+                   '0xf4', '0xf3', '0xf2', '0xf1']],
+                 ['0'] * 16,
+                 ['i8x16', 'i8x16', 'i8x16']]
+            ],
+        }
+
+    @property
+    def range_test_data(self):
+        return {
+            'i8x16.add_sat_s': [
+                [[[str(i) for i in range(16)], [str(i * 2) for i in range(16)]],
+                 [str(i * 3) for i in range(16)], ['i8x16', 'i8x16', 'i8x16']]
+            ],
+            'i8x16.add_sat_u': [
+                [[[str(i) for i in range(16)], [str(i * 2) for i in range(16)]],
+                 [str(i * 3) for i in range(16)], ['i8x16', 'i8x16', 'i8x16']]
+            ],
+            'i8x16.sub_sat_s': [
+                [[[str(i) for i in range(16)], [str(i * 2) for i in range(16)]],
+                 [str(-i) for i in range(16)], ['i8x16', 'i8x16', 'i8x16']]
+            ],
+            'i8x16.sub_sat_u': [
+                [[[str(i) for i in range(16)], [str(i * 2) for i in range(16)]],
+                 ['0'] * 16, ['i8x16', 'i8x16', 'i8x16']]
+            ],
+        }
+
+    @property
+    def full_bin_test_data(self):
+        return [
+            self.i8x16_f32x4_test_data,
+            self.combine_dec_hex_test_data,
+            self.range_test_data
+        ]
+
+    def get_malformed_cases(self):
+        malformed_cases = []
+        # There is no saturating integer arithmetic operation for i32x4 or f32x4.
+        for prefix in ['i32x4', 'f32x4']:
+            for op in ['add', 'sub']:
+                for suffix in ['s', 'u']:
+                    malformed_cases.append(self.malformed_template.format(
+                        lane_type=prefix, op='_'.join([op, 'sat', suffix]),
+                        operand_1=self.v128_const(prefix, '0', lane_len=4),
+                        operand_2=self.v128_const(prefix, '0', lane_len=4)
+                    ))
+        return super().get_malformed_cases() + '\n' + '\n'.join(malformed_cases)
+
+
+class SimdI16x8SaturateArithmeticCases(SimdSaturateArithmeticCases):
+    LANE_LEN = 8
+    LANE_TYPE = 'i16x8'
+
+    @property
+    def hex_binary_op_test_data(self):
+        return [
+            ('0x3fff', '0x4000'),
+            ('0x4000', '0x4000'),
+            ('-0x3fff', '-0x4000'),
+            ('-0x4000', '-0x4000'),
+            ('-0x4000', '-0x4001'),
+            ('0x7fff', '0x7fff'),
+            ('0x7fff', '0x01'),
+            ('0x8000', '-0x01'),
+            ('0x7fff', '0x8000'),
+            ('0x8000', '0x8000'),
+            ('0xffff', '0x01'),
+            ('0xffff', '0xffff')
+        ]
+
+    @property
+    def hex_unary_op_test_data(self):
+        return ['0x01', '-0x01', '-0x8000', '-0x7fff', '0x7fff', '0x8000', '0xffff']
+
+    @property
+    def underscore_literal_test_data(self):
+        return {
+            'i16x8.add_sat_s': [
+                [['012_345', '032_123'], '032_767', ['i16x8'] * 3],
+                [['012_345', '056_789'], '03_598', ['i16x8'] * 3],
+                [['0x0_1234', '0x0_5678'], '0x0_68ac', ['i16x8'] * 3],
+                [['0x0_90AB', '0x0_cdef'], '-0x0_8000', ['i16x8'] * 3]
+            ],
+            'i16x8.add_sat_u': [
+                [['012_345', '056_789'], '065_535', ['i16x8'] * 3],
+                [['012_345', '-012_345'], '065_535', ['i16x8'] * 3],
+                [['0x0_1234', '0x0_5678'], '0x0_68ac', ['i16x8'] * 3],
+                [['0x0_90AB', '0x0_cdef'], '0x0_ffff', ['i16x8'] * 3]
+            ],
+            'i16x8.sub_sat_s': [
+                [['012_345', '056_789'], '021_092', ['i16x8'] * 3],
+                [['012_345', '-012_345'], '024_690', ['i16x8'] * 3],
+                [['0x0_1234', '0x0_5678'], '0x0_bbbc', ['i16x8'] * 3],
+                [['0x0_90AB', '-0x1234'], '0xa2df', ['i16x8'] * 3]
+            ],
+            'i16x8.sub_sat_u': [
+                [['012_345', '056_789'], '0', ['i16x8'] * 3],
+                [['056_789', '-12_345'], '03_598', ['i16x8'] * 3],
+                [['0x0_1234', '-0x0_5678'], '0', ['i16x8'] * 3],
+                [['0x0_cdef', '0x0_90AB'], '0x0_3d44', ['i16x8'] * 3]
+            ]
+        }
+
+    @property
+    def i16x8_f32x4_test_data(self):
+        return {
+            'i16x8.add_sat_s': [
+                [['0x8000', '-0.0'], '0x8000', ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '+inf'], ['0x01', '0x7f81'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '-inf'], ['0x01', '0xff81'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', 'nan'], ['0x01', '0x7fc1'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '-nan'], ['0x01', '0xffc1'] * 4, ['i16x8', 'f32x4', 'i16x8']]
+            ],
+            'i16x8.add_sat_u': [
+                [['0x8000', '-0.0'], ['0x8000', '0xffff'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '+inf'], ['0x01', '0x7f81'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '-inf'], ['0x01', '0xff81'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', 'nan'], ['0x01', '0x7fc1'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', 'nan'], ['0x01', '0x7fc1'] * 4, ['i16x8', 'f32x4', 'i16x8']]
+            ],
+            'i16x8.sub_sat_s': [
+                [['0x8000', '-0.0'], ['0x8000', '0'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '+inf'], ['0x01', '0x8081'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '-inf'], ['0x01', '0x81'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', 'nan'], ['0x01', '0x8041'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '-nan'], ['0x01', '0x41'] * 4, ['i16x8', 'f32x4', 'i16x8']]
+            ],
+            'i16x8.sub_sat_u': [
+                [['0x8000', '-0.0'], ['0x8000', '0'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '+inf'], ['0x01', '0'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '-inf'], ['0x01', '0'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', 'nan'], ['0x01', '0'] * 4, ['i16x8', 'f32x4', 'i16x8']],
+                [['1', '-nan'], ['0x01', '0'] * 4, ['i16x8', 'f32x4', 'i16x8']]
+            ],
+        }
+
+    @property
+    def combine_dec_hex_test_data(self):
+        return {
+            'i16x8.add_sat_s': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7'],
+                  ['0', '0xffff', '0xfffe', '0xfffd', '0xfffc', '0xfffb', '0xfffa', '0xfff9']],
+                 ['0'] * 8, ['i16x8'] * 3]
+            ],
+            'i16x8.add_sat_u': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7'],
+                  ['0', '0xffff', '0xfffe', '0xfffd', '0xfffc', '0xfffb', '0xfffa', '0xfff9']],
+                 ['0'] + ['0xffff'] * 7, ['i16x8'] * 3]
+            ],
+            'i16x8.sub_sat_s': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7'],
+                  ['0', '0xffff', '0xfffe', '0xfffd', '0xfffc', '0xfffb', '0xfffa', '0xfff9']],
+                 ['0', '2', '4', '6', '8', '10', '12', '14'], ['i16x8'] * 3]
+            ],
+            'i16x8.sub_sat_u': [
+                [[['0', '1', '2', '3', '4', '5', '6', '7'],
+                  ['0', '0xffff', '0xfffe', '0xfffd', '0xfffc', '0xfffb', '0xfffa', '0xfff9']],
+                 ['0'] * 8, ['i16x8'] * 3]
+            ]
+        }
+
+    @property
+    def range_test_data(self):
+        return {
+            'i16x8.add_sat_s': [
+                [[[str(i) for i in range(8)], [str(i * 2) for i in range(8)]],
+                 [str(i * 3) for i in range(8)], ['i16x8'] * 3]
+            ],
+            'i16x8.add_sat_u': [
+                [[[str(i) for i in range(8)], [str(i * 2) for i in range(8)]],
+                 [str(i * 3) for i in range(8)], ['i16x8'] * 3]
+            ],
+            'i16x8.sub_sat_s': [
+                [[[str(i) for i in range(8)], [str(i * 2) for i in range(8)]],
+                 [str(-i) for i in range(8)], ['i16x8'] * 3]
+            ],
+            'i16x8.sub_sat_u': [
+                [[[str(i) for i in range(8)], [str(i * 2) for i in range(8)]],
+                 ['0'] * 8, ['i16x8'] * 3]
+            ]
+        }
+
+    @property
+    def full_bin_test_data(self):
+        return [
+            self.i16x8_f32x4_test_data,
+            self.combine_dec_hex_test_data,
+            self.range_test_data,
+            self.underscore_literal_test_data
+        ]
+
+
+def gen_test_cases():
+    simd_i8x16_sat_arith = SimdI8x16SaturateArithmeticCases()
+    simd_i8x16_sat_arith.gen_test_cases()
+    simd_i16x8_sat_arith = SimdI16x8SaturateArithmeticCases()
+    simd_i16x8_sat_arith.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/simd_store_lane.py b/test/core/simd/meta/simd_store_lane.py
new file mode 100644
index 000000000..f0a8e284f
--- /dev/null
+++ b/test/core/simd/meta/simd_store_lane.py
@@ -0,0 +1,237 @@
+#!/usr/bin/env python3
+
+from simd import SIMD
+from test_assert import AssertReturn, AssertInvalid
+
+def list_stringify(l):
+    return list(map(lambda x: str(x), l))
+
+"""Base class for generating SIMD store lane tests. Subclasses only to:
+    - define self.LANE_LEN, self.LANE_TYPE, self.NUM_LANES, self.MAX_ALIGN
+    - override get_normal_case to provide test data  (consult comments for details)
+
+It generates test cases that:
+    - store to all valid lane indices
+    - store using memarg offset
+    - store with memarg alignment
+    - store with invalid lane index
+    - store with invalid memarg alignment
+    - fails typecheck
+"""
+class SimdStoreLane:
+    def valid_alignments(self):
+        return [a for a in range(1, self.MAX_ALIGN+1) if a & (a-1) == 0]
+
+    def get_case_data(self):
+        # return value should be a list of tuples:
+        #   (address to store to : i32, v128, return value : v128)
+        # e.g. [(0, [0x0100, 0, 0, 0, 0, 0, 0, 0]), ... ]
+        # the expected result is return_value[address].
+        raise Exception("Subclasses should override this to provide test data")
+
+    def get_normal_case(self):
+        s = SIMD()
+        cases = []
+
+        # store using arg
+        for (addr, ret) in self.get_case_data():
+            i32_addr = s.const(addr, "i32")
+            v128_val = s.v128_const(list_stringify(ret), self.LANE_TYPE)
+            result = s.const(ret[addr], "i64")
+            instr = "v128.store{lane_len}_lane_{idx}".format(lane_len=self.LANE_LEN, idx=addr)
+            cases.append(str(AssertReturn(instr, [i32_addr, v128_val], result)))
+
+        # store using offset
+        for (addr, ret) in self.get_case_data():
+            v128_val = s.v128_const(list_stringify(ret), self.LANE_TYPE)
+            result = s.const(ret[addr], "i64")
+            instr = "v128.store{lane_len}_lane_{idx}_offset_{idx}".format(lane_len=self.LANE_LEN, idx=addr)
+            cases.append(str(AssertReturn(instr, [v128_val], result)))
+
+        # store using offset with alignment
+        for (addr, ret) in self.get_case_data():
+            for align in self.valid_alignments():
+                i32_addr = s.const(addr, "i32")
+                v128_val = s.v128_const(list_stringify(ret), self.LANE_TYPE)
+                result = s.const(ret[addr], "i64")
+                instr = "v128.store{lane_len}_lane_{idx}_align_{align}".format(lane_len=self.LANE_LEN, idx=addr, align=align)
+                cases.append(str(AssertReturn(instr, [i32_addr, v128_val], result)))
+
+        return '\n'.join(cases)
+
+    def gen_test_func_template(self):
+        template = [
+            ';; Tests for store lane operations.\n\n',
+            '(module',
+            '  (memory 1)',
+            '  (global $zero (mut v128) (v128.const i32x4 0 0 0 0))',
+            ]
+
+        lane_indices = list(range(self.NUM_LANES))
+
+        # store using i32.const arg
+        for idx in lane_indices:
+            template.append(
+                '  (func (export "v128.store{lane_len}_lane_{idx}")\n'
+                '    (param $address i32) (param $x v128) (result i64) (local $ret i64)\n'
+                '    (v128.store{lane_len}_lane {idx} (local.get $address) (local.get $x))\n'
+                '    (local.set $ret (i64.load (local.get $address)))\n'
+                '    (v128.store (local.get $address) (global.get $zero))'
+                '    (local.get $ret))'
+                .format(idx=idx, lane_len=self.LANE_LEN))
+
+        # store using memarg offset
+        for idx in lane_indices:
+            template.append(
+                '  (func (export "v128.store{lane_len}_lane_{idx}_offset_{idx}")\n'
+                '    (param $x v128) (result i64) (local $ret i64)\n'
+                '    (v128.store{lane_len}_lane offset={idx} {idx} (i32.const 0) (local.get $x))\n'
+                '    (local.set $ret (i64.load offset={idx} (i32.const 0)))\n'
+                '    (v128.store offset={idx} (i32.const 0) (global.get $zero))\n'
+                '    (local.get $ret))'
+                .format(idx=idx, lane_len=self.LANE_LEN))
+
+        # with memarg aligment
+        for idx in lane_indices:
+            for align in self.valid_alignments():
+                template.append(
+                    '  (func (export "v128.store{lane_len}_lane_{idx}_align_{align}")\n'
+                    '    (param $address i32) (param $x v128) (result i64) (local $ret i64)\n'
+                    '    (v128.store{lane_len}_lane align={align} {idx} (local.get $address) (local.get $x))\n'
+                    '    (local.set $ret (i64.load (local.get $address)))\n'
+                    '    (v128.store offset={idx} (i32.const 0) (global.get $zero))\n'
+                    '    (local.get $ret))'
+                    .format(idx=idx, lane_len=self.LANE_LEN, align=align))
+
+        template.append(')\n')
+        return template
+
+    def gen_test_template(self):
+        template = self.gen_test_func_template()
+
+        template.append('{normal_cases}')
+        template.append('\n{invalid_cases}')
+
+        return '\n'.join(template)
+
+    def get_invalid_cases(self):
+        invalid_cases = [';; type check']
+        invalid_cases.append(
+            '(assert_invalid'
+            '  (module (memory 1)\n'
+            '          (func (param $x v128) (result v128)\n'
+            '            (v128.store{lane_len}_lane 0 (local.get $x) (i32.const 0))))\n'
+            '  "type mismatch")'.format(lane_len=self.LANE_LEN))
+        invalid_cases.append('')
+
+        invalid_cases.append(';; invalid lane index')
+        invalid_cases.append(
+            '(assert_invalid'
+            '  (module (memory 1)\n'
+            '          (func (param $x v128) (result v128)\n'
+            '            (v128.store{lane_len}_lane {idx} (i32.const 0) (local.get $x))))\n'
+            '  "invalid lane index")'.format(idx=self.NUM_LANES, lane_len=self.LANE_LEN))
+
+        invalid_cases.append('')
+
+        invalid_cases.append(';; invalid memarg alignment')
+        invalid_cases.append(
+            '(assert_invalid\n'
+            '  (module (memory 1)\n'
+            '          (func (param $x v128) (result v128)\n'
+            '          (v128.store{lane_len}_lane align={align} 0 (i32.const 0) (local.get $x))))\n'
+            '  "alignment must not be larger than natural")'
+            .format(lane_len=self.LANE_LEN, align=self.MAX_ALIGN*2))
+        return '\n'.join(invalid_cases)
+
+    def get_all_cases(self):
+        case_data = {'lane_len': self.LANE_LEN,
+                     'normal_cases': self.get_normal_case(),
+                     'invalid_cases': self.get_invalid_cases(),
+                     }
+        return self.gen_test_template().format(**case_data)
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_store{lane_type}_lane.wast'.format(lane_type=self.LANE_LEN)
+        with open(wast_filename, 'w') as fp:
+            fp.write(self.get_all_cases())
+
+class SimdStore8Lane(SimdStoreLane):
+    LANE_LEN = '8'
+    LANE_TYPE = 'i8x16'
+    NUM_LANES = 16
+    MAX_ALIGN = 1
+
+    def get_case_data(self):
+        return [
+            (0, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (1, [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (2, [0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (3, [0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (4, [0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (5, [0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (6, [0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (7, [0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0]),
+            (8, [0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0]),
+            (9, [0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0]),
+            (10, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0]),
+            (11, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0]),
+            (12, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0]),
+            (13, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0]),
+            (14, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0]),
+            (15, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15])]
+
+class SimdStore16Lane(SimdStoreLane):
+    LANE_LEN = '16'
+    LANE_TYPE = 'i16x8'
+    NUM_LANES = 8
+    MAX_ALIGN = 2
+
+    def get_case_data(self):
+        return [
+            (0, [0x0100, 0, 0, 0, 0, 0, 0, 0]),
+            (1, [0, 0x0201, 0, 0, 0, 0, 0, 0]),
+            (2, [0, 0, 0x0302, 0, 0, 0, 0, 0]),
+            (3, [0, 0, 0, 0x0403, 0, 0, 0, 0]),
+            (4, [0, 0, 0, 0, 0x0504, 0, 0, 0]),
+            (5, [0, 0, 0, 0, 0, 0x0605, 0, 0]),
+            (6, [0, 0, 0, 0, 0, 0, 0x0706, 0]),
+            (7, [0, 0, 0, 0, 0, 0, 0, 0x0807])]
+
+class SimdStore32Lane(SimdStoreLane):
+    LANE_LEN = '32'
+    LANE_TYPE = 'i32x4'
+    NUM_LANES = 4
+    MAX_ALIGN = 4
+
+    def get_case_data(self):
+        return [
+            (0, [0x03020100, 0, 0, 0,]),
+            (1, [0, 0x04030201, 0, 0,]),
+            (2, [0, 0, 0x05040302, 0,]),
+            (3, [0, 0, 0, 0x06050403,])]
+
+class SimdStore64Lane(SimdStoreLane):
+    LANE_LEN = '64'
+    LANE_TYPE = 'i64x2'
+    NUM_LANES = 2
+    MAX_ALIGN = 8
+
+    def get_case_data(self):
+        return [
+            (0, [0x0706050403020100, 0]),
+            (1, [0, 0x0807060504030201])]
+
+def gen_test_cases():
+    simd_store8_lane = SimdStore8Lane()
+    simd_store8_lane.gen_test_cases()
+    simd_store16_lane = SimdStore16Lane()
+    simd_store16_lane.gen_test_cases()
+    simd_store32_lane = SimdStore32Lane()
+    simd_store32_lane.gen_test_cases()
+    simd_store64_lane = SimdStore64Lane()
+    simd_store64_lane.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
diff --git a/test/core/simd/meta/test_assert.py b/test/core/simd/meta/test_assert.py
new file mode 100644
index 000000000..1147ce07d
--- /dev/null
+++ b/test/core/simd/meta/test_assert.py
@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+This python file is a tool class for test generation.
+Currently only the 'AssertReturn' class that is used
+to generate the 'assert_return' assertion.
+TODO: Add more assertions
+"""
+
+
+# Generate assert_return to test
+class AssertReturn:
+
+    op = ''
+    params = ''
+    expected_result = ''
+
+    def __init__(self, op, params, expected_result):
+
+        # Convert to list if got str
+        if isinstance(params, str):
+            params = [params]
+        if isinstance(expected_result, str):
+            expected_result = [expected_result]
+
+        self.op = op
+        self.params = params
+        self.expected_result = expected_result
+
+    def __str__(self):
+        assert_return = '(assert_return (invoke "{}"'.format(self.op)
+
+        head_len = len(assert_return)
+
+        # Add write space to make the test case easier to read
+        params = []
+        for param in self.params:
+            white_space = ' '
+            if len(params) != 0:
+                white_space = '\n ' + ' ' * head_len
+            params.append(white_space + param)
+
+        results = []
+        for result in self.expected_result:
+            white_space = ' '
+            if len(params) != 0 or len(results) != 0:
+                white_space = '\n ' + ' ' * head_len
+            results.append(white_space + result)
+
+        return '{assert_head}{params}){expected_result})'.format(assert_head=assert_return, params=''.join(params), expected_result=''.join(results))
+
+
+# Generate assert_invalid to test
+class AssertInvalid:
+
+    @staticmethod
+    def get_arg_empty_test(op, extended_name, param_type, result_type, params):
+
+        arg_empty_test = '(assert_invalid' \
+                         '\n  (module' \
+                         '\n    (func ${op}-{extended_name}{param_type}{result_type}' \
+                         '\n      ({op}{params})' \
+                         '\n    )' \
+                         '\n  )' \
+                         '\n  "type mismatch"' \
+                         '\n)'
+
+        def str_with_space(input_str):
+            return (' ' if input_str else '') + input_str
+
+        param_map = {
+            'op': op,
+            'extended_name': extended_name,
+            'param_type': str_with_space(param_type),
+            'result_type': str_with_space(result_type),
+            'params': str_with_space(params),
+        }
+
+        return arg_empty_test.format(**param_map)
+
+
+class AssertMalformed:
+    """Generate an assert_malformed test"""
+
+    @staticmethod
+    def get_unknown_op_test(op, result_type, *params):
+        malformed_template = '(assert_malformed (module quote "(memory 1) (func (result {result_type}) ({operator} {param}))") "unknown operator")'
+        return malformed_template.format(
+            operator=op, result_type=result_type, param=' '.join(params)
+        )
\ No newline at end of file
diff --git a/test/core/simd/simd_address.wast b/test/core/simd/simd_address.wast
new file mode 100644
index 000000000..9e023008b
--- /dev/null
+++ b/test/core/simd/simd_address.wast
@@ -0,0 +1,157 @@
+;; Load/Store v128 data with different valid offset/alignment
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\10\11\12\13\14\15")
+  (data (offset (i32.const 65505)) "\16\17\18\19\20\21\22\23\24\25\26\27\28\29\30\31")
+
+  (func (export "load_data_1") (param $i i32) (result v128)
+    (v128.load offset=0 (local.get $i))                   ;; 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15
+  )
+  (func (export "load_data_2") (param $i i32) (result v128)
+    (v128.load align=1 (local.get $i))                    ;; 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15
+  )
+  (func (export "load_data_3") (param $i i32) (result v128)
+    (v128.load offset=1 align=1 (local.get $i))           ;; 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00
+  )
+  (func (export "load_data_4") (param $i i32) (result v128)
+    (v128.load offset=2 align=1 (local.get $i))           ;; 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00 0x00
+  )
+  (func (export "load_data_5") (param $i i32) (result v128)
+    (v128.load offset=15 align=1 (local.get $i))          ;; 0x15 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
+  )
+
+  (func (export "store_data_0") (result v128)
+    (v128.store offset=0 (i32.const 0) (v128.const f32x4 0 1 2 3))
+    (v128.load offset=0 (i32.const 0))
+  )
+  (func (export "store_data_1") (result v128)
+    (v128.store align=1 (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load align=1 (i32.const 0))
+  )
+  (func (export "store_data_2") (result v128)
+    (v128.store offset=1 align=1 (i32.const 0) (v128.const i16x8 0 1 2 3 4 5 6 7))
+    (v128.load offset=1 align=1 (i32.const 0))
+  )
+  (func (export "store_data_3") (result v128)
+    (v128.store offset=2 align=1 (i32.const 0) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+    (v128.load offset=2 align=1 (i32.const 0))
+  )
+  (func (export "store_data_4") (result v128)
+    (v128.store offset=15 align=1 (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load offset=15 (i32.const 0))
+  )
+  (func (export "store_data_5") (result v128)
+    (v128.store offset=65520 align=1 (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load offset=65520 (i32.const 0))
+  )
+  (func (export "store_data_6") (param $i i32)
+    (v128.store offset=1 align=1 (local.get $i) (v128.const i32x4 0 1 2 3))
+  )
+)
+
+(assert_return (invoke "load_data_1" (i32.const 0)) (v128.const i32x4 0x03020100 0x07060504 0x11100908 0x15141312))
+(assert_return (invoke "load_data_2" (i32.const 0)) (v128.const i32x4 0x03020100 0x07060504 0x11100908 0x15141312))
+(assert_return (invoke "load_data_3" (i32.const 0)) (v128.const i32x4 0x04030201 0x08070605 0x12111009 0x00151413))
+(assert_return (invoke "load_data_4" (i32.const 0)) (v128.const i32x4 0x05040302 0x09080706 0x13121110 0x00001514))
+(assert_return (invoke "load_data_5" (i32.const 0)) (v128.const i32x4 0x00000015 0x00000000 0x00000000 0x00000000))
+
+(assert_return (invoke "load_data_1" (i32.const 0)) (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x1110 0x1312 0x1514))
+(assert_return (invoke "load_data_2" (i32.const 0)) (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x1110 0x1312 0x1514))
+(assert_return (invoke "load_data_3" (i32.const 0)) (v128.const i16x8 0x0201 0x0403 0x0605 0x0807 0x1009 0x1211 0x1413 0x0015))
+(assert_return (invoke "load_data_4" (i32.const 0)) (v128.const i16x8 0x0302 0x0504 0x0706 0x0908 0x1110 0x1312 0x1514 0x0000))
+(assert_return (invoke "load_data_5" (i32.const 0)) (v128.const i16x8 0x0015 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+
+(assert_return (invoke "load_data_1" (i32.const 0)) (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15))
+(assert_return (invoke "load_data_2" (i32.const 0)) (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15))
+(assert_return (invoke "load_data_3" (i32.const 0)) (v128.const i8x16 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00))
+(assert_return (invoke "load_data_4" (i32.const 0)) (v128.const i8x16 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00 0x00))
+(assert_return (invoke "load_data_5" (i32.const 0)) (v128.const i8x16 0x15 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+
+(assert_return (invoke "load_data_1" (i32.const 65505)) (v128.const i32x4 0x19181716 0x23222120 0x27262524 0x31302928))
+(assert_return (invoke "load_data_2" (i32.const 65505)) (v128.const i32x4 0x19181716 0x23222120 0x27262524 0x31302928))
+(assert_return (invoke "load_data_3" (i32.const 65505)) (v128.const i32x4 0x20191817 0x24232221 0x28272625 0x00313029))
+(assert_return (invoke "load_data_4" (i32.const 65505)) (v128.const i32x4 0x21201918 0x25242322 0x29282726 0x00003130))
+(assert_return (invoke "load_data_5" (i32.const 65505)) (v128.const i32x4 0x00000031 0x00000000 0x00000000 0x00000000))
+
+(assert_return (invoke "load_data_1" (i32.const 65505)) (v128.const i16x8 0x1716 0x1918 0x2120 0x2322 0x2524 0x2726 0x2928 0x3130))
+(assert_return (invoke "load_data_2" (i32.const 65505)) (v128.const i16x8 0x1716 0x1918 0x2120 0x2322 0x2524 0x2726 0x2928 0x3130))
+(assert_return (invoke "load_data_3" (i32.const 65505)) (v128.const i16x8 0x1817 0x2019 0x2221 0x2423 0x2625 0x2827 0x3029 0x0031))
+(assert_return (invoke "load_data_4" (i32.const 65505)) (v128.const i16x8 0x1918 0x2120 0x2322 0x2524 0x2726 0x2928 0x3130 0x0000))
+(assert_return (invoke "load_data_5" (i32.const 65505)) (v128.const i16x8 0x0031 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+
+(assert_return (invoke "load_data_1" (i32.const 65505)) (v128.const i8x16 0x16 0x17 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31))
+(assert_return (invoke "load_data_2" (i32.const 65505)) (v128.const i8x16 0x16 0x17 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31))
+(assert_return (invoke "load_data_3" (i32.const 65505)) (v128.const i8x16 0x17 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31 0x00))
+(assert_return (invoke "load_data_4" (i32.const 65505)) (v128.const i8x16 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31 0x00 0x00))
+(assert_return (invoke "load_data_5" (i32.const 65505)) (v128.const i8x16 0x31 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+
+(assert_trap (invoke "load_data_3" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "load_data_5" (i32.const 65506)) "out of bounds memory access")
+
+(assert_return (invoke "store_data_0") (v128.const f32x4 0 1 2 3))
+(assert_return (invoke "store_data_1") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "store_data_2") (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "store_data_3") (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "store_data_4") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "store_data_5") (v128.const i32x4 0 1 2 3))
+
+(assert_trap (invoke "store_data_6" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "store_data_6" (i32.const 65535)) "out of bounds memory access")
+
+;; Load/Store v128 data with invalid offset
+
+(module
+  (memory 1)
+  (func (export "v128.load_offset_65521")
+    (drop (v128.load offset=65521 (i32.const 0)))
+  )
+)
+(assert_trap (invoke "v128.load_offset_65521") "out of bounds memory access")
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func"
+    "  (drop (v128.load offset=-1 (i32.const 0)))"
+    ")"
+  )
+  "unknown operator"
+)
+
+(module
+  (memory 1)
+  (func (export "v128.store_offset_65521")
+    (v128.store offset=65521 (i32.const 0) (v128.const i32x4 0 0 0 0))
+  )
+)
+(assert_trap (invoke "v128.store_offset_65521") "out of bounds memory access")
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func"
+    "  (v128.store offset=-1 (i32.const 0) (v128.const i32x4 0 0 0 0))"
+    ")"
+  )
+  "unknown operator"
+)
+
+
+;; Offset constant out of range
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (drop (v128.load offset=4294967296 (i32.const 0))))"
+  )
+  "i32 constant"
+)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store offset=4294967296 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "i32 constant"
+)
diff --git a/test/core/simd/simd_align.wast b/test/core/simd/simd_align.wast
new file mode 100644
index 000000000..ed91ed5c6
--- /dev/null
+++ b/test/core/simd/simd_align.wast
@@ -0,0 +1,355 @@
+;; Valid alignment
+
+(module (memory 1) (func (drop (v128.load align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load align=16 (i32.const 0)))))
+
+(module (memory 1) (func (v128.store align=1 (i32.const 0) (v128.const i32x4 0 1 2 3))))
+(module (memory 1) (func (v128.store align=2 (i32.const 0) (v128.const i32x4 0 1 2 3))))
+(module (memory 1) (func (v128.store align=4 (i32.const 0) (v128.const i32x4 0 1 2 3))))
+(module (memory 1) (func (v128.store align=8 (i32.const 0) (v128.const i32x4 0 1 2 3))))
+(module (memory 1) (func (v128.store align=16 (i32.const 0) (v128.const i32x4 0 1 2 3))))
+
+(module (memory 1) (func (drop (v128.load8x8_s align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_s align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_s align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_s align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_u align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_u align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_u align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_u align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_s align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_s align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_s align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_s align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_u align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_u align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_u align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_u align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_s align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_s align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_s align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_s align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_u align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_u align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_u align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_u align=8 (i32.const 0)))))
+
+(module (memory 1) (func (drop (v128.load8_splat align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16_splat align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16_splat align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32_splat align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32_splat align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32_splat align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load64_splat align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load64_splat align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load64_splat align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load64_splat align=8 (i32.const 0)))))
+
+;; Invalid alignment
+
+(assert_invalid
+  (module (memory 1) (func (drop (v128.load align=32 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func(v128.store align=32 (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load8x8_s align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load8x8_u align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load16x4_s align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load16x4_u align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load32x2_s align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load32x2_u align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load8_splat align=2 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load16_splat align=4 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load32_splat align=8 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load64_splat align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+
+;; Malformed alignment
+
+(assert_malformed
+  (module quote
+    "(memory 1) (func (drop (v128.load align=-1 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (drop (v128.load align=0 (i32.const 0))))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (drop (v128.load align=7 (i32.const 0))))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (v128.store align=-1 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 0) (func (v128.store align=0 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 0) (func (v128.store align=7 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_s align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_s align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_s align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_u align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_u align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_u align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_s align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_s align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_s align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_u align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_u align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_u align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_s align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_s align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_s align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_u align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_u align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_u align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8_splat align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8_splat align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16_splat align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16_splat align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32_splat align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32_splat align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32_splat align=3 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load64_splat align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load64_splat align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load64_splat align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+
+;; Test that misaligned SIMD loads/stores don't trap
+
+(module
+  (memory 1 1)
+  (func (export "v128.load align=16") (param $address i32) (result v128)
+    (v128.load align=16 (local.get $address))
+  )
+  (func (export "v128.store align=16") (param $address i32) (param $value v128)
+    (v128.store align=16 (local.get $address) (local.get $value))
+  )
+)
+
+(assert_return (invoke "v128.load align=16" (i32.const 0)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "v128.load align=16" (i32.const 1)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "v128.store align=16" (i32.const 1) (v128.const i8x16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)))
+(assert_return (invoke "v128.load align=16" (i32.const 0)) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+
+;; Test aligned and unaligned read/write
+
+(module
+  (memory 1)
+  (func (export "v128_unaligned_read_and_write") (result v128)
+    (local v128)
+    (v128.store (i32.const 0) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128_aligned_read_and_write") (result v128)
+    (local v128)
+    (v128.store align=2 (i32.const 0) (v128.const i16x8 0 1 2 3 4 5 6 7))
+    (v128.load align=2  (i32.const 0))
+  )
+  (func (export "v128_aligned_read_and_unaligned_write") (result v128)
+    (local v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load align=2 (i32.const 0))
+  )
+  (func (export "v128_unaligned_read_and_aligned_write") (result v128)
+    (local v128)
+    (v128.store align=2 (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load (i32.const 0))
+  )
+)
+
+(assert_return (invoke "v128_unaligned_read_and_write") (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "v128_aligned_read_and_write") (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "v128_aligned_read_and_unaligned_write") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "v128_unaligned_read_and_aligned_write") (v128.const i32x4 0 1 2 3))
diff --git a/test/core/simd/simd_bit_shift.wast b/test/core/simd/simd_bit_shift.wast
new file mode 100644
index 000000000..98e155651
--- /dev/null
+++ b/test/core/simd/simd_bit_shift.wast
@@ -0,0 +1,1104 @@
+;; Test all the bit shift operators on major boundary values and all special values.
+
+(module
+  (func (export "i8x16.shl") (param $0 v128) (param $1 i32) (result v128) (i8x16.shl (local.get $0) (local.get $1)))
+  (func (export "i8x16.shr_s") (param $0 v128) (param $1 i32) (result v128) (i8x16.shr_s (local.get $0) (local.get $1)))
+  (func (export "i8x16.shr_u") (param $0 v128) (param $1 i32) (result v128) (i8x16.shr_u (local.get $0) (local.get $1)))
+
+  (func (export "i16x8.shl") (param $0 v128) (param $1 i32) (result v128) (i16x8.shl (local.get $0) (local.get $1)))
+  (func (export "i16x8.shr_s") (param $0 v128) (param $1 i32) (result v128) (i16x8.shr_s (local.get $0) (local.get $1)))
+  (func (export "i16x8.shr_u") (param $0 v128) (param $1 i32) (result v128) (i16x8.shr_u (local.get $0) (local.get $1)))
+
+  (func (export "i32x4.shl") (param $0 v128) (param $1 i32) (result v128) (i32x4.shl (local.get $0) (local.get $1)))
+  (func (export "i32x4.shr_s") (param $0 v128) (param $1 i32) (result v128) (i32x4.shr_s (local.get $0) (local.get $1)))
+  (func (export "i32x4.shr_u") (param $0 v128) (param $1 i32) (result v128) (i32x4.shr_u (local.get $0) (local.get $1)))
+
+  (func (export "i64x2.shl") (param $0 v128) (param $1 i32) (result v128) (i64x2.shl (local.get $0) (local.get $1)))
+  (func (export "i64x2.shr_s") (param $0 v128) (param $1 i32) (result v128) (i64x2.shr_s (local.get $0) (local.get $1)))
+  (func (export "i64x2.shr_u") (param $0 v128) (param $1 i32) (result v128) (i64x2.shr_u (local.get $0) (local.get $1)))
+
+  ;; shifting by a constant amount
+  ;; i8x16
+  (func (export "i8x16.shl_1") (param $0 v128) (result v128) (i8x16.shl (local.get $0) (i32.const 1)))
+  (func (export "i8x16.shr_u_8") (param $0 v128) (result v128) (i8x16.shr_u (local.get $0) (i32.const 8)))
+  (func (export "i8x16.shr_s_9") (param $0 v128) (result v128) (i8x16.shr_s (local.get $0) (i32.const 9)))
+
+  ;; i16x8
+  (func (export "i16x8.shl_1") (param $0 v128) (result v128) (i16x8.shl (local.get $0) (i32.const 1)))
+  (func (export "i16x8.shr_u_16") (param $0 v128) (result v128) (i16x8.shr_u (local.get $0) (i32.const 16)))
+  (func (export "i16x8.shr_s_17") (param $0 v128) (result v128) (i16x8.shr_s (local.get $0) (i32.const 17)))
+
+  ;; i32x4
+  (func (export "i32x4.shl_1") (param $0 v128) (result v128) (i32x4.shl (local.get $0) (i32.const 1)))
+  (func (export "i32x4.shr_u_32") (param $0 v128) (result v128) (i32x4.shr_u (local.get $0) (i32.const 32)))
+  (func (export "i32x4.shr_s_33") (param $0 v128) (result v128) (i32x4.shr_s (local.get $0) (i32.const 33)))
+
+  ;; i64x2
+  (func (export "i64x2.shl_1") (param $0 v128) (result v128) (i64x2.shl (local.get $0) (i32.const 1)))
+  (func (export "i64x2.shr_u_64") (param $0 v128) (result v128) (i64x2.shr_u (local.get $0) (i32.const 64)))
+  (func (export "i64x2.shr_s_65") (param $0 v128) (result v128) (i64x2.shr_s (local.get $0) (i32.const 65)))
+)
+
+;; i8x16 shl
+;; amount less than lane width
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                   (i32.const 1))
+                                   (v128.const i8x16 0 -128 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0xAA 0xBB 0xCC 0xDD 0xEE 0xFF 0xA0 0xB0 0xC0 0xD0 0xE0 0xF0 0x0A 0x0B 0x0C 0x0D)
+                                   (i32.const 4))
+                                   (v128.const i8x16 0xA0 0xB0 0xC0 0xD0 0xE0 0xF0 0x00 0x00 0x00 0x00 0x00 0x00 0xA0 0xB0 0xC0 0xD0))
+;; amount is multiple of lane width
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 8))
+                                   (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 32))
+                                   (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 128))
+                                   (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 256))
+                                   (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                   (i32.const 9))
+                                   (v128.const i8x16 0 -128 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 9))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 17))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 33))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 129))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 257))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 513))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 514))
+                                   (v128.const i8x16 0 4 8 12 16 20 24 28 32 36 0x28 0x2C 0x30 0x34 0x38 0x3C))
+;; i8x16 shr_u
+;; amount less than lane width
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 1))
+                                     (v128.const i8x16 64 96 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0xAA 0xBB 0xCC 0xDD 0xEE 0xFF 0xA0 0xB0 0xC0 0xD0 0xE0 0xF0 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 4))
+                                     (v128.const i8x16 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F 0x00 0x00 0x00 0x00))
+;; amount is multiple of lane width
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 8))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 9))
+                                     (v128.const i8x16 64 96 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 9))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 17))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 33))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 0x02 0x02 0x03 0x03 0x03 0x03))
+;; i8x16 shr_s
+;; amount less than lane width
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 1))
+                                     (v128.const i8x16 192 224 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0xAA 0xBB 0xCC 0xDD 0xEE 0xFF 0xA0 0xB0 0xC0 0xD0 0xE0 0xF0 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 4))
+                                     (v128.const i8x16 0xFA 0xFB 0xFC 0xFD 0xFE 0xFF 0xFA 0xFB 0xFC 0xFD 0xFE 0xFF 0x00 0x00 0x00 0x00))
+;; amount is multiple of lane width
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 8))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 9))
+                                     (v128.const i8x16 192 224 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 9))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 17))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 33))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 0x02 0x02 0x03 0x03 0x03 0x03))
+;; shifting by a constant amount
+(assert_return (invoke "i8x16.shl_1" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+                                     (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shr_u_8" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+                                       (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_s_9" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+                                       (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+
+;; i16x8 shl
+;; amount less than lane width
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                   (i32.const 1))
+                                   (v128.const i16x8 65280 65408 0 2 4 6 8 10))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                   (i32.const 2))
+                                   (v128.const i16x8 49380 49380 49380 49380 49380 49380 49380 49380))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                   (i32.const 2))
+                                   (v128.const i16x8 0x48d0 0x48d0 0x48d0 0x48d0 0x48d0 0x48d0 0x48d0 0x48d0))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0xAABB 0xCCDD 0xEEFF 0xA0B0 0xC0D0 0xE0F0 0x0A0B 0x0C0D)
+                                   (i32.const 4))
+                                   (v128.const i16x8 0xABB0 0xCDD0 0xEFF0 0xB00 0xD00 0xF00 0xA0B0 0xC0D0))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 8))
+                                   (v128.const i16x8 0 256 512 768 1024 1280 1536 1792))
+;; amount is multiple of lane width
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 32))
+                                   (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 128))
+                                   (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 256))
+                                   (v128.const i16x8 0 1 2 3 4 5 6 7))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                   (i32.const 17))
+                                   (v128.const i16x8 65280 65408 0 2 4 6 8 10))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 17))
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 33))
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 129))
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 257))
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 513))
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 514))
+                                   (v128.const i16x8 0 4 8 12 16 20 24 28))
+
+;; i16x8 shr_u
+;; amount less than lane width
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                     (i32.const 1))
+                                     (v128.const i16x8 32704 32736 0 0 1 1 2 2))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                     (i32.const 2))
+                                     (v128.const i16x8 3086 3086 3086 3086 3086 3086 3086 3086))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                     (i32.const 2))
+                                     (v128.const i16x8 0x242a 0x242a 0x242a 0x242a 0x242a 0x242a 0x242a 0x242a))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0xAABB 0xCCDD 0xEEFF 0xA0B0 0xC0D0 0xE0F0 0x0A0B 0x0C0D)
+                                     (i32.const 4))
+                                     (v128.const i16x8 0xAAB 0xCCD 0xEEF 0xA0B 0xC0D 0xE0F 0x0A0 0x0C0))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 8))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+;; amount is multiple of lane width
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 32))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 128))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 256))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                     (i32.const 17))
+                                     (v128.const i16x8 32704 32736 0 0 1 1 2 2))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 17))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 33))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 129))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 257))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 513))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 514))
+                                     (v128.const i16x8 0 0 0 0 1 1 1 1))
+
+;; i16x8 shr_s
+;; amount less than lane width
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                     (i32.const 1))
+                                     (v128.const i16x8 65472 65504 0 0 1 1 2 2))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                     (i32.const 2))
+                                     (v128.const i16x8 3086 3086 3086 3086 3086 3086 3086 3086))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                     (i32.const 2))
+                                     (v128.const i16x8 0xe42a 0xe42a 0xe42a 0xe42a 0xe42a 0xe42a 0xe42a 0xe42a))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0xAABB 0xCCDD 0xEEFF 0xA0B0 0xC0D0 0xE0F0 0x0A0B 0x0C0D)
+                                     (i32.const 4))
+                                     (v128.const i16x8 0xFAAB 0xFCCD 0xFEEF 0xFA0B 0xFC0D 0xFE0F 0x00A0 0x00C0))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 8))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+;; amount is multiple of lane width
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 32))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 128))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 256))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                     (i32.const 17))
+                                     (v128.const i16x8 65472 65504 0 0 1 1 2 2))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 17))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 33))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 129))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 257))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 513))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 514))
+                                     (v128.const i16x8 0 0 0 0 1 1 1 1))
+
+;; shifting by a constant amount
+(assert_return (invoke "i16x8.shl_1" (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                     (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shr_u_16" (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                        (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shr_s_17" (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                        (v128.const i16x8 0 0 1 1 2 2 3 3))
+
+;; i32x4 shl
+;; amount less than lane width
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 -2147483648 -32768 0 0x0A0B0C0D)
+                                   (i32.const 1))
+                                   (v128.const i32x4 0 4294901760 0 0x1416181A))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                   (i32.const 2))
+                                   (v128.const i32x4 643304264 643304264 643304264 643304264))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                                   (i32.const 2))
+                                   (v128.const i32x4 0x48d159e0 0x48d159e0 0x48d159e0 0x48d159e0))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0xAABBCCDD 0xEEFFA0B0 0xC0D0E0F0 0x0A0B0C0D)
+                                   (i32.const 4))
+                                   (v128.const i32x4 0xABBCCDD0 0xEFFA0B00 0x0D0E0F00 0xA0B0C0D0))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 8))
+                                   (v128.const i32x4 0 256 0x00000E00 0x00000F00))
+;; amount is multiple of lane width
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 32))
+                                   (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 128))
+                                   (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 256))
+                                   (v128.const i32x4 0 1 0x0E 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 -2147483648 -32768 0 0x0A0B0C0D)
+                                   (i32.const 33))
+                                   (v128.const i32x4 0 4294901760 0 0x1416181A))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 33))
+                                   (v128.const i32x4 0 2 0x1C 0x1E))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 65))
+                                   (v128.const i32x4 0 2 0x1C 0x1E))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 129))
+                                   (v128.const i32x4 0 2 0x1C 0x1E))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 257))
+                                   (v128.const i32x4 0 2 0x1C 0x1E))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 513))
+                                   (v128.const i32x4 0 2 0x1C 0x1E))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 514))
+                                   (v128.const i32x4 0 4 0x38 0x3C))
+
+;; i32x4 shr_u
+;; amount less than lane width
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 -2147483648 -32768 0x0000000C 0x0000000D)
+                                     (i32.const 1))
+                                     (v128.const i32x4 1073741824 2147467264 0x00000006 0x00000006))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                     (i32.const 2))
+                                     (v128.const i32x4 308641972 308641972 308641972 308641972))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                     (i32.const 2))
+                                     (v128.const i32x4 0x242af37b 0x242af37b 0x242af37b 0x242af37b))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0xAABBCCDD 0xEEFFA0B0 0xC0D0E0F0 0x0A0B0C0D)
+                                     (i32.const 4))
+                                     (v128.const i32x4 0x0AABBCCD 0x0EEFFA0B 0x0C0D0E0F 0x00A0B0C0))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 8))
+                                     (v128.const i32x4 0 0 0x00000000 0x00000000))
+;; amount is multiple of lane width
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 -2147483648 -32768 0x0000000C 0x0000000D)
+                                     (i32.const 33))
+                                     (v128.const i32x4 1073741824 2147467264 0x00000006 0x00000006))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 33))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 65))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i32x4 0 0 0x03 0x03))
+
+;; i32x4 shr_s
+;; amount less than lane width
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 -2147483648 -32768 0x0C 0x0D)
+                                     (i32.const 1))
+                                     (v128.const i32x4 3221225472 4294950912 0x06 0x06))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                     (i32.const 2))
+                                     (v128.const i32x4 308641972 308641972 308641972 308641972))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                     (i32.const 2))
+                                     (v128.const i32x4 0xe42af37b 0xe42af37b 0xe42af37b 0xe42af37b))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0xAABBCCDD 0xEEFFA0B0 0xC0D0E0F0 0x0A0B0C0D)
+                                     (i32.const 4))
+                                     (v128.const i32x4 0xfaabbccd 0xFEEFFA0B 0xFC0D0E0F 0x00A0B0C0))
+;; amount is multiple of lane width
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 8))
+                                     (v128.const i32x4 0 0 0x00000000 0x00000000))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 -2147483648 -32768 0x0C 0x0D)
+                                     (i32.const 33))
+                                     (v128.const i32x4 3221225472 4294950912 0x06 0x06))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 33))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 65))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i32x4 0 0 0x03 0x03))
+
+;; shifting by a constant amount
+(assert_return (invoke "i32x4.shl_1" (v128.const i32x4 0 1 0x0E 0x0F))
+                                     (v128.const i32x4 0 2 28 30))
+(assert_return (invoke "i32x4.shr_u_32" (v128.const i32x4 0 1 0x0E 0x0F))
+                                        (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shr_s_33" (v128.const i32x4 0 1 0x0E 0x0F))
+                                        (v128.const i32x4 0 0 7 7))
+
+;; i64x2 shl
+;; amount less than lane width
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 -9223372036854775808 -2147483648)
+                                   (i32.const 1))
+                                   (v128.const i64x2 0 18446744069414584320))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)
+                                   (i32.const 2))
+                                   (v128.const i64x2 4938271560493827156 4938271560493827156))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef)
+                                   (i32.const 2))
+                                   (v128.const i64x2 0x48d159e242af37bc 0x48d159e242af37bc))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D)
+                                   (i32.const 4))
+                                   (v128.const i64x2 0xABBCCDDEEFFA0B00 0xD0E0F00A0B0C0D0))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D)
+                                   (i32.const 8))
+                                   (v128.const i64x2 0xBBCCDDEEFFA0B000 0xD0E0F00A0B0C0D00))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 16))
+                                   (v128.const i64x2 65536 0xF0000))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 32))
+                                   (v128.const i64x2 4294967296 0xF00000000))
+;; amount is multiple of lane width
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 128))
+                                   (v128.const i64x2 1 0x0F))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 256))
+                                   (v128.const i64x2 1 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 65))
+                                   (v128.const i64x2 2 0x1E))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 129))
+                                   (v128.const i64x2 2 0x1E))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 257))
+                                   (v128.const i64x2 2 0x1E))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 513))
+                                   (v128.const i64x2 2 0x1E))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 514))
+                                   (v128.const i64x2 4 0x3C))
+
+;; i64x2 shr_u
+;; amount less than lane width
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 -9223372036854775808 -2147483648)
+                                     (i32.const 1))
+                                     (v128.const i64x2 4611686018427387904 9223372035781033984))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)
+                                     (i32.const 2))
+                                     (v128.const i64x2 308641972530864197 308641972530864197))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 0x0_90AB_cdef_8765_4321 0x0_90AB_cdef_8765_4321)
+                                     (i32.const 2))
+                                     (v128.const i64x2 0x242af37be1d950c8 0x242af37be1d950c8))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D)
+                                     (i32.const 4))
+                                     (v128.const i64x2 0xAABBCCDDEEFFA0B 0xC0D0E0F00A0B0C0))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D)
+                                     (i32.const 8))
+                                     (v128.const i64x2 0xAABBCCDDEEFFA0 0xC0D0E0F00A0B0C))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 16))
+                                     (v128.const i64x2 0 0x00))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i64x2 0 0x00))
+;; amount is multiple of lane width
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i64x2 1 0x0F))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i64x2 1 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 65))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 0 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i64x2 0 0x03))
+
+;; i64x2 shr_s
+;; amount less than lane width
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 -9223372036854775808 -2147483648)
+                                     (i32.const 1))
+                                     (v128.const i64x2 13835058055282163712 18446744072635809792))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)
+                                     (i32.const 2))
+                                     (v128.const i64x2 308641972530864197 308641972530864197))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 0x0_90AB_cdef_8765_4321 0x0_90AB_cdef_8765_4321)
+                                     (i32.const 2))
+                                     (v128.const i64x2 0xe42af37be1d950c8 0xe42af37be1d950c8))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D)
+                                     (i32.const 4))
+                                     (v128.const i64x2 0xFAABBCCDDEEFFA0B 0xFC0D0E0F00A0B0C0))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 0xFFAABBCCDDEEFFA0 0xC0D0E0F00A0B0C0D)
+                                     (i32.const 8))
+                                     (v128.const i64x2 0xFFFFAABBCCDDEEFF 0xFFC0D0E0F00A0B0C))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 16))
+                                     (v128.const i64x2 0 0x00))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i64x2 0 0x00))
+;; amount is multiple of lane width
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i64x2 1 0x0F))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i64x2 1 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 -9223372036854775808 -2147483648)
+                                     (i32.const 65))
+                                     (v128.const i64x2 13835058055282163712 18446744072635809792))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 0x0C 0x0D)
+                                     (i32.const 65))
+                                     (v128.const i64x2 0x06 0x06))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i64x2 0 0x03))
+
+;; shifting by a constant amount
+(assert_return (invoke "i64x2.shl_1" (v128.const i64x2 1 0x0F))
+                                     (v128.const i64x2 2 0x1E))
+(assert_return (invoke "i64x2.shr_u_64" (v128.const i64x2 1 0x0F))
+                                        (v128.const i64x2 1 0x0F))
+(assert_return (invoke "i64x2.shr_s_65" (v128.const i64x2 1 0x0F))
+                                        (v128.const i64x2 0 0x07))
+
+;; Combination
+
+(module (memory 1)
+  (func (export "i8x16.shl-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.shl
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i8x16.shr_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.shr_s
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i8x16.shr_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.shr_u
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i16x8.shl-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.shl
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i16x8.shr_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.shr_s
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i16x8.shr_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.shr_u
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i32x4.shl-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.shl
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i32x4.shr_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.shr_s
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i32x4.shr_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.shr_u
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i64x2.shl-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i64x2.shl
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i64x2.shr_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i64x2.shr_s
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i64x2.shr_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i64x2.shr_u
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-i8x16.shl")
+    (drop
+      (i8x16.shl
+        (i8x16.shl
+          (i8x16.shl
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i8x16.shr_s")
+    (drop
+      (i8x16.shr_s
+        (i8x16.shr_s
+          (i8x16.shr_s
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i8x16.shr_u")
+    (drop
+      (i8x16.shr_u
+        (i8x16.shr_u
+          (i8x16.shr_u
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i16x8.shl")
+    (drop
+      (i16x8.shl
+        (i16x8.shl
+          (i16x8.shl
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i16x8.shr_s")
+    (drop
+      (i16x8.shr_s
+        (i16x8.shr_s
+          (i16x8.shr_s
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i16x8.shr_u")
+    (drop
+      (i16x8.shr_u
+        (i16x8.shr_u
+          (i16x8.shr_u
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i32x4.shl")
+    (drop
+      (i32x4.shl
+        (i32x4.shl
+          (i32x4.shl
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i32x4.shr_s")
+    (drop
+      (i32x4.shr_s
+        (i32x4.shr_s
+          (i32x4.shr_s
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i32x4.shr_u")
+    (drop
+      (i32x4.shr_u
+        (i32x4.shr_u
+          (i32x4.shr_u
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i64x2.shl")
+    (drop
+      (i64x2.shl
+        (i64x2.shl
+          (i64x2.shl
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i64x2.shr_s")
+    (drop
+      (i64x2.shr_s
+        (i64x2.shr_s
+          (i64x2.shr_s
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i64x2.shr_u")
+    (drop
+      (i64x2.shr_u
+        (i64x2.shr_u
+          (i64x2.shr_u
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+)
+
+(assert_return (invoke "i8x16.shl-in-block"))
+(assert_return (invoke "i8x16.shr_s-in-block"))
+(assert_return (invoke "i8x16.shr_u-in-block"))
+(assert_return (invoke "i16x8.shl-in-block"))
+(assert_return (invoke "i16x8.shr_s-in-block"))
+(assert_return (invoke "i16x8.shr_u-in-block"))
+(assert_return (invoke "i32x4.shl-in-block"))
+(assert_return (invoke "i32x4.shr_s-in-block"))
+(assert_return (invoke "i32x4.shr_u-in-block"))
+(assert_return (invoke "i64x2.shl-in-block"))
+(assert_return (invoke "i64x2.shr_s-in-block"))
+(assert_return (invoke "i64x2.shr_u-in-block"))
+(assert_return (invoke "nested-i8x16.shl"))
+(assert_return (invoke "nested-i8x16.shr_s"))
+(assert_return (invoke "nested-i8x16.shr_u"))
+(assert_return (invoke "nested-i16x8.shl"))
+(assert_return (invoke "nested-i16x8.shr_s"))
+(assert_return (invoke "nested-i16x8.shr_u"))
+(assert_return (invoke "nested-i32x4.shl"))
+(assert_return (invoke "nested-i32x4.shr_s"))
+(assert_return (invoke "nested-i32x4.shr_u"))
+(assert_return (invoke "nested-i64x2.shl"))
+(assert_return (invoke "nested-i64x2.shr_s"))
+(assert_return (invoke "nested-i64x2.shr_u"))
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (i8x16.shl   (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.shr_s (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.shr_u (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.shl   (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.shr_s (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.shr_u (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.shl   (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.shr_s (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.shr_u (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.shl   (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.shr_s (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.shr_u (i32.const 0) (i32.const 0)))) "type mismatch")
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.shl_s (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.shl_r (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.shr   (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.shl_s (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.shl_r (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.shr   (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.shl_s (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.shl_r (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.shr   (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.shl_s (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.shl_r (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.shr   (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.shl   (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.shr_s (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.shr_u (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.shl-1st-arg-empty (result v128)
+      (i8x16.shl (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.shl-last-arg-empty (result v128)
+      (i8x16.shl (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.shl-arg-empty (result v128)
+      (i8x16.shl)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.shr_u-1st-arg-empty (result v128)
+      (i16x8.shr_u (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.shr_u-last-arg-empty (result v128)
+      (i16x8.shr_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.shr_u-arg-empty (result v128)
+      (i16x8.shr_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.shr_s-1st-arg-empty (result v128)
+      (i32x4.shr_s (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.shr_s-last-arg-empty (result v128)
+      (i32x4.shr_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.shr_s-arg-empty (result v128)
+      (i32x4.shr_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.shl-1st-arg-empty (result v128)
+      (i64x2.shl (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.shr_u-last-arg-empty (result v128)
+      (i64x2.shr_u (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.shr_s-arg-empty (result v128)
+      (i64x2.shr_s)
+    )
+  )
+  "type mismatch"
+)
diff --git a/test/core/simd/simd_bitwise.wast b/test/core/simd/simd_bitwise.wast
new file mode 100644
index 000000000..f646bf61d
--- /dev/null
+++ b/test/core/simd/simd_bitwise.wast
@@ -0,0 +1,812 @@
+;; Test all the bitwise operators on major boundary values and all special values.
+
+(module
+  (func (export "not") (param $0 v128) (result v128) (v128.not (local.get $0)))
+  (func (export "and") (param $0 v128) (param $1 v128) (result v128) (v128.and (local.get $0) (local.get $1)))
+  (func (export "or") (param $0 v128) (param $1 v128) (result v128) (v128.or (local.get $0) (local.get $1)))
+  (func (export "xor") (param $0 v128) (param $1 v128) (result v128) (v128.xor (local.get $0) (local.get $1)))
+  (func (export "bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+    (v128.bitselect (local.get $0) (local.get $1) (local.get $2))
+  )
+  (func (export "andnot") (param $0 v128) (param $1 v128) (result v128) (v128.andnot (local.get $0) (local.get $1)))
+)
+
+;; i32x4
+(assert_return (invoke "not" (v128.const i32x4 0 0 0 0))
+                             (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "not" (v128.const i32x4 -1 -1 -1 -1))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "not" (v128.const i32x4 -1 0 -1 0))
+                             (v128.const i32x4 0 -1 0 -1))
+(assert_return (invoke "not" (v128.const i32x4 0 -1 0 -1))
+                             (v128.const i32x4 -1 0 -1 0))
+(assert_return (invoke "not" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+                             (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+(assert_return (invoke "not" (v128.const i32x4 3435973836 3435973836 3435973836 3435973836))
+                             (v128.const i32x4 858993459 858993459 858993459 858993459))
+(assert_return (invoke "not" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                             (v128.const i32x4 3060399405 3060399405 3060399405 3060399405))
+(assert_return (invoke "not" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                             (v128.const i32x4 0xedcba987 0xedcba987 0xedcba987 0xedcba987))
+(assert_return (invoke "and" (v128.const i32x4 0 0 -1 -1)
+                             (v128.const i32x4 0 -1 0 -1))
+                             (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "and" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 0 0 0 0))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "and" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 -1 -1 -1 -1))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "and" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "and" (v128.const i32x4 1 1 1 1)
+                             (v128.const i32x4 1 1 1 1))
+                             (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "and" (v128.const i32x4 255 255 255 255)
+                             (v128.const i32x4 85 85 85 85))
+                             (v128.const i32x4 85 85 85 85))
+(assert_return (invoke "and" (v128.const i32x4 255 255 255 255)
+                             (v128.const i32x4 128 128 128 128))
+                             (v128.const i32x4 128 128 128 128))
+(assert_return (invoke "and" (v128.const i32x4 2863311530 2863311530 2863311530 2863311530)
+                             (v128.const i32x4 10 128 5 165))
+                             (v128.const i32x4 10 128 0 160))
+(assert_return (invoke "and" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+                             (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+(assert_return (invoke "and" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                             (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+(assert_return (invoke "and" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0x0 0x0 0x0 0x0))
+                             (v128.const i32x4 0x0 0x0 0x0 0x0))
+(assert_return (invoke "and" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                             (v128.const i32x4 0x5555 0xFFFF 0x55FF 0x5FFF))
+                             (v128.const i32x4 0x5555 0x5555 0x5555 0x5555))
+(assert_return (invoke "and" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                             (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                             (v128.const i32x4 1234567890 1234567890 1234567890 1234567890))
+(assert_return (invoke "and" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                             (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                             (v128.const i32x4 0x10204468 0x10204468 0x10204468 0x10204468))
+(assert_return (invoke "or" (v128.const i32x4 0 0 -1 -1)
+                            (v128.const i32x4 0 -1 0 -1))
+                            (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "or" (v128.const i32x4 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "or" (v128.const i32x4 0 0 0 0)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "or" (v128.const i32x4 0 0 0 0)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "or" (v128.const i32x4 1 1 1 1)
+                            (v128.const i32x4 1 1 1 1))
+                            (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "or" (v128.const i32x4 255 255 255 255)
+                            (v128.const i32x4 85 85 85 85))
+                            (v128.const i32x4 255 255 255 255))
+(assert_return (invoke "or" (v128.const i32x4 255 255 255 255)
+                            (v128.const i32x4 128 128 128 128))
+                            (v128.const i32x4 255 255 255 255))
+(assert_return (invoke "or" (v128.const i32x4 2863311530 2863311530 2863311530 2863311530)
+                            (v128.const i32x4 10 128 5 165))
+                            (v128.const i32x4 2863311530 2863311530 2863311535 2863311535))
+(assert_return (invoke "or" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "or" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "or" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0x0 0x0 0x0 0x0))
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "or" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                            (v128.const i32x4 0x5555 0xFFFF 0x55FF 0x5FFF))
+                            (v128.const i32x4 0x55555555 0x5555ffff 0x555555ff 0x55555fff))
+(assert_return (invoke "or" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                            (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                            (v128.const i32x4 1234567890 1234567890 1234567890 1234567890))
+(assert_return (invoke "or" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                            (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                            (v128.const i32x4 0x92bfdfff 0x92bfdfff 0x92bfdfff 0x92bfdfff))
+(assert_return (invoke "xor" (v128.const i32x4 0 0 -1 -1)
+                             (v128.const i32x4 0 -1 0 -1))
+                             (v128.const i32x4 0 -1 -1 0))
+(assert_return (invoke "xor" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 0 0 0 0))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 -1 -1 -1 -1))
+                             (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "xor" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                             (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "xor" (v128.const i32x4 1 1 1 1)
+                             (v128.const i32x4 1 1 1 1))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const i32x4 255 255 255 255)
+                             (v128.const i32x4 85 85 85 85))
+                             (v128.const i32x4 170 170 170 170))
+(assert_return (invoke "xor" (v128.const i32x4 255 255 255 255)
+                             (v128.const i32x4 128 128 128 128))
+                             (v128.const i32x4 127 127 127 127))
+(assert_return (invoke "xor" (v128.const i32x4 2863311530 2863311530 2863311530 2863311530)
+                             (v128.const i32x4 10 128 5 165))
+                             (v128.const i32x4 2863311520 2863311402 2863311535 2863311375))
+(assert_return (invoke "xor" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+                             (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+(assert_return (invoke "xor" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                             (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+(assert_return (invoke "xor" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0x0 0x0 0x0 0x0))
+                             (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "xor" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                             (v128.const i32x4 0x5555 0xFFFF 0x55FF 0x5FFF))
+                             (v128.const i32x4 0x55550000 0x5555AAAA 0x555500AA 0x55550AAA))
+(assert_return (invoke "xor" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                             (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                             (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                             (v128.const i32x4 0x829f9b97 0x829f9b97 0x829f9b97 0x829f9b97))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB)
+                                   (v128.const i32x4 0x00112345 0xF00FFFFF 0x10112021 0xBBAABBAA))
+                                   (v128.const i32x4 0xBBAABABA 0xABBAAAAA 0xABAABBBA 0xAABBAABB))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB)
+                                   (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                                   (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB)
+                                   (v128.const i32x4 0x11111111 0x11111111 0x11111111 0x11111111))
+                                   (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB)
+                                   (v128.const i32x4 0x01234567 0x89ABCDEF 0xFEDCBA98 0x76543210))
+                                   (v128.const i32x4 0xBABABABA 0xBABABABA 0xABABABAB 0xABABABAB))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                                   (v128.const i32x4 0x01234567 0x89ABCDEF 0xFEDCBA98 0x76543210))
+                                   (v128.const i32x4 0x54761032 0xDCFE98BA 0xAB89EFCD 0x23016745))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                                   (v128.const i32x4 0x55555555 0xAAAAAAAA 0x00000000 0xFFFFFFFF))
+                                   (v128.const i32x4 0x00000000 0xFFFFFFFF 0x55555555 0xAAAAAAAA))
+(assert_return (invoke "bitselect" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                   (v128.const i32x4 03_060_399_406 03_060_399_406 03_060_399_406 03_060_399_406)
+                                   (v128.const i32x4 0xcdefcdef 0xcdefcdef 0xcdefcdef 0xcdefcdef))
+                                   (v128.const i32x4 2072391874 2072391874 2072391874 2072391874))
+(assert_return (invoke "bitselect" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                                   (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                   (v128.const i32x4 0xcdefcdef 0xcdefcdef 0xcdefcdef 0xcdefcdef))
+                                   (v128.const i32x4 0x10244468 0x10244468 0x10244468 0x10244468))
+(assert_return (invoke "andnot" (v128.const i32x4 0 0 -1 -1)
+                                (v128.const i32x4 0 -1 0 -1))
+                                (v128.const i32x4 0 0 -1 0))
+(assert_return (invoke "andnot" (v128.const i32x4 0 0 0 0)
+                                (v128.const i32x4 0 0 0 0))
+                                (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "andnot" (v128.const i32x4 0 0 0 0)
+                                (v128.const i32x4 -1 -1 -1 -1))
+                                (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "andnot" (v128.const i32x4 0 0 0 0)
+                                (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                                (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "andnot" (v128.const i32x4 1 1 1 1)
+                                (v128.const i32x4 1 1 1 1))
+                                (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "andnot" (v128.const i32x4 255 255 255 255)
+                                (v128.const i32x4 85 85 85 85))
+                                (v128.const i32x4 170 170 170 170))
+(assert_return (invoke "andnot" (v128.const i32x4 255 255 255 255)
+                                (v128.const i32x4 128 128 128 128))
+                                (v128.const i32x4 127 127 127 127))
+(assert_return (invoke "andnot" (v128.const i32x4 2863311530 2863311530 2863311530 2863311530)
+                                (v128.const i32x4 10 128 5 165))
+                                (v128.const i32x4 2863311520 2863311402 2863311530 2863311370))
+(assert_return (invoke "andnot" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                                (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+                                (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+(assert_return (invoke "andnot" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                                (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                                (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+(assert_return (invoke "andnot" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                                (v128.const i32x4 0x0 0x0 0x0 0x0))
+                                (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "andnot" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                                (v128.const i32x4 0x5555 0xFFFF 0x55FF 0x5FFF))
+                                (v128.const i32x4 0x55550000 0x55550000 0x55550000 0x55550000))
+(assert_return (invoke "andnot" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "andnot" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                                (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                                (v128.const i32x4 0x02141210 0x02141210 0x02141210 0x02141210))
+
+;; for float special data [e.g. -nan nan -inf inf]
+(assert_return (invoke "not" (v128.const f32x4 -nan -nan -nan -nan))
+                             (v128.const f32x4 5.87747e-39 5.87747e-39 5.87747e-39 5.87747e-39))
+(assert_return (invoke "not" (v128.const f32x4 nan nan nan nan))
+                             (v128.const f32x4 -5.87747e-39 -5.87747e-39 -5.87747e-39 -5.87747e-39))
+(assert_return (invoke "not" (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const i32x4 0x007fffff 0x007fffff 0x007fffff 0x007fffff))
+(assert_return (invoke "not" (v128.const f32x4 inf inf inf inf))
+                             (v128.const i32x4 0x807fffff 0x807fffff 0x807fffff 0x807fffff))
+(assert_return (invoke "and" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 -nan -nan -nan -nan))
+                             (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "and" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 nan nan nan nan))
+                             (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "and" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "and" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "and" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 nan nan nan nan))
+                             (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "and" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "and" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "and" (v128.const f32x4 -inf -inf -inf -inf)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "and" (v128.const f32x4 -inf -inf -inf -inf)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "and" (v128.const f32x4 inf inf inf inf)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "or" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "or" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "or" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "or" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "or" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "or" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "or" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "or" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "or" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "or" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "xor" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 -nan -nan -nan -nan))
+                             (v128.const f32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 nan nan nan nan))
+                             (v128.const f32x4 -0 -0 -0 -0))
+(assert_return (invoke "xor" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000))
+(assert_return (invoke "xor" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const i32x4 0x80400000 0x80400000 0x80400000 0x80400000))
+(assert_return (invoke "xor" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 nan nan nan nan))
+                             (v128.const f32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const i32x4 0x80400000 0x80400000 0x80400000 0x80400000))
+(assert_return (invoke "xor" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000))
+(assert_return (invoke "xor" (v128.const f32x4 -inf -inf -inf -inf)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const f32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const f32x4 -inf -inf -inf -inf)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "xor" (v128.const f32x4 inf inf inf inf)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const f32x4 0 0 0 0))
+(assert_return (invoke "bitselect" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "bitselect" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "bitselect" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "bitselect" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "andnot" (v128.const f32x4 -nan -nan -nan -nan)
+                                (v128.const f32x4 -nan -nan -nan -nan))
+                                (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "andnot" (v128.const f32x4 -nan -nan -nan -nan)
+                                (v128.const f32x4 nan nan nan nan))
+                                (v128.const f32x4 -0 -0 -0 -0))
+(assert_return (invoke "andnot" (v128.const f32x4 -nan -nan -nan -nan)
+                                (v128.const f32x4 -inf -inf -inf -inf))
+                                (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000))
+(assert_return (invoke "andnot" (v128.const f32x4 -nan -nan -nan -nan)
+                                (v128.const f32x4 inf inf inf inf))
+                                (v128.const i32x4 0x80400000 0x80400000 0x80400000 0x80400000))
+(assert_return (invoke "andnot" (v128.const f32x4 nan nan nan nan)
+                                (v128.const f32x4 nan nan nan nan))
+                                (v128.const f32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "andnot" (v128.const f32x4 nan nan nan nan)
+                                (v128.const f32x4 -inf -inf -inf -inf))
+                                (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000))
+(assert_return (invoke "andnot" (v128.const f32x4 nan nan nan nan)
+                                (v128.const f32x4 inf inf inf inf))
+                                (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000))
+(assert_return (invoke "andnot" (v128.const f32x4 -inf -inf -inf -inf)
+                                (v128.const f32x4 -inf -inf -inf -inf))
+                                (v128.const f32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "andnot" (v128.const f32x4 -inf -inf -inf -inf)
+                                (v128.const f32x4 inf inf inf inf))
+                                (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "andnot" (v128.const f32x4 inf inf inf inf)
+                                (v128.const f32x4 inf inf inf inf))
+                                (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+
+;; Type check
+
+;; not
+(assert_invalid (module (func (result v128) (v128.not (i32.const 0)))) "type mismatch")
+;; and
+(assert_invalid (module (func (result v128) (v128.and (i32.const 0) (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.and (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.and (i32.const 0) (i32.const 0)))) "type mismatch")
+;; or
+(assert_invalid (module (func (result v128) (v128.or (i32.const 0) (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.or (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.or (i32.const 0) (i32.const 0)))) "type mismatch")
+;; xor
+(assert_invalid (module (func (result v128) (v128.xor (i32.const 0) (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.xor (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.xor (i32.const 0) (i32.const 0)))) "type mismatch")
+;; bitselect
+(assert_invalid (module (func (result v128) (v128.bitselect (i32.const 0) (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.bitselect (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.bitselect (i32.const 0) (i32.const 0) (i32.const 0)))) "type mismatch")
+;; andnot
+(assert_invalid (module (func (result v128) (v128.andnot (i32.const 0) (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.andnot (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.andnot (i32.const 0) (i32.const 0)))) "type mismatch")
+
+;; Combination
+
+(module (memory 1)
+  (func (export "v128.not-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.not
+            (block (result v128) (v128.load (i32.const 0)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "v128.and-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.and
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "v128.or-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.or
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "v128.xor-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.xor
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "v128.bitselect-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.bitselect
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+            (block (result v128) (v128.load (i32.const 2)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "v128.andnot-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.andnot
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.not")
+    (drop
+      (v128.not
+        (v128.not
+          (v128.not
+            (v128.load (i32.const 0))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.and")
+    (drop
+      (v128.and
+        (v128.and
+          (v128.and
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.and
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+        (v128.and
+          (v128.and
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.and
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.or")
+    (drop
+      (v128.or
+        (v128.or
+          (v128.or
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.or
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+        (v128.or
+          (v128.or
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.or
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.xor")
+    (drop
+      (v128.xor
+        (v128.xor
+          (v128.xor
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.xor
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+        (v128.xor
+          (v128.xor
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.xor
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.bitselect")
+    (drop
+      (v128.bitselect
+        (v128.bitselect
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+        )
+        (v128.bitselect
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+        )
+        (v128.bitselect
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.andnot")
+    (drop
+      (v128.andnot
+        (v128.andnot
+          (v128.andnot
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.andnot
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+        (v128.andnot
+          (v128.andnot
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.andnot
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (v128.or
+        (v128.and
+          (v128.not
+            (v128.load (i32.const 0))
+          )
+          (v128.not
+            (v128.load (i32.const 1))
+          )
+        )
+        (v128.xor
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.andnot
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "v128.not-in-block"))
+(assert_return (invoke "v128.and-in-block"))
+(assert_return (invoke "v128.or-in-block"))
+(assert_return (invoke "v128.xor-in-block"))
+(assert_return (invoke "v128.bitselect-in-block"))
+(assert_return (invoke "v128.andnot-in-block"))
+(assert_return (invoke "nested-v128.not"))
+(assert_return (invoke "nested-v128.and"))
+(assert_return (invoke "nested-v128.or"))
+(assert_return (invoke "nested-v128.xor"))
+(assert_return (invoke "nested-v128.bitselect"))
+(assert_return (invoke "nested-v128.andnot"))
+(assert_return (invoke "as-param"))
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $v128.not-arg-empty (result v128)
+      (v128.not)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.and-1st-arg-empty (result v128)
+      (v128.and (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.and-arg-empty (result v128)
+      (v128.and)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.or-1st-arg-empty (result v128)
+      (v128.or (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.or-arg-empty (result v128)
+      (v128.or)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.xor-1st-arg-empty (result v128)
+      (v128.xor (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.xor-arg-empty (result v128)
+      (v128.xor)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.andnot-1st-arg-empty (result v128)
+      (v128.andnot (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.andnot-arg-empty (result v128)
+      (v128.andnot)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.bitselect-1st-arg-empty (result v128)
+      (v128.bitselect (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.bitselect-two-args-empty (result v128)
+      (v128.bitselect (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.bitselect-arg-empty (result v128)
+      (v128.bitselect)
+    )
+  )
+  "type mismatch"
+)
diff --git a/test/core/simd/simd_boolean.wast b/test/core/simd/simd_boolean.wast
new file mode 100644
index 000000000..6ab330fe5
--- /dev/null
+++ b/test/core/simd/simd_boolean.wast
@@ -0,0 +1,1058 @@
+;; Test all the boolean operators on major boundary values and all special values.
+
+(module
+  (func (export "i8x16.any_true") (param $0 v128) (result i32) (v128.any_true (local.get $0)))
+  (func (export "i8x16.all_true") (param $0 v128) (result i32) (i8x16.all_true (local.get $0)))
+  (func (export "i8x16.bitmask") (param $0 v128) (result i32) (i8x16.bitmask (local.get $0)))
+
+  (func (export "i16x8.any_true") (param $0 v128) (result i32) (v128.any_true (local.get $0)))
+  (func (export "i16x8.all_true") (param $0 v128) (result i32) (i16x8.all_true (local.get $0)))
+  (func (export "i16x8.bitmask") (param $0 v128) (result i32) (i16x8.bitmask (local.get $0)))
+
+  (func (export "i32x4.any_true") (param $0 v128) (result i32) (v128.any_true (local.get $0)))
+  (func (export "i32x4.all_true") (param $0 v128) (result i32) (i32x4.all_true (local.get $0)))
+  (func (export "i32x4.bitmask") (param $0 v128) (result i32) (i32x4.bitmask (local.get $0)))
+
+  (func (export "i64x2.all_true") (param $0 v128) (result i32) (i64x2.all_true (local.get $0)))
+  (func (export "i64x2.bitmask") (param $0 v128) (result i32) (i64x2.bitmask (local.get $0)))
+)
+
+;; i8x16
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 -1 0 1 2 3 4 5 6 7 8 9 0xA 0xB 0xC 0xD 0xF))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 -1 0 1 2 3 4 5 6 7 8 9 0xA 0xB 0xC 0xD 0xF))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.bitmask" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 0x0000FFFF))
+(assert_return (invoke "i8x16.bitmask" (v128.const i8x16 -1 0 1 2 3 4 5 6 7 8 9 0xA 0xB 0xC 0xD 0xF))
+                                        (i32.const 0x00000001))
+
+;; i16x8
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 -1 0 1 2 0xB 0xC 0xD 0xF))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 -1 0 1 2 0xB 0xC 0xD 0xF))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.bitmask" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                                        (i32.const 0x000000FF))
+(assert_return (invoke "i16x8.bitmask" (v128.const i16x8 -1 0 1 2 0xB 0xC 0xD 0xF))
+                                        (i32.const 0x00000001))
+
+;; i32x4
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0 0 1 0))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 1 1 0 1))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 -1 0 1 0xF))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0 0 1 0))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 1 1 0 1))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 -1 0 1 0xF))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.bitmask" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                                        (i32.const 0x0000000F))
+(assert_return (invoke "i32x4.bitmask" (v128.const i32x4 -1 0 1 0xF))
+                                        (i32.const 0x00000001))
+
+;; i64x2
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0 1))
+                                        (i32.const 0))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 1 0))
+                                        (i32.const 0))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 -1 0))
+                                        (i32.const 0))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i64x2.bitmask" (v128.const i64x2 0xFFFFFFFF_FFFFFFFF 0xFFFFFFFF_FFFFFFFF))
+                                        (i32.const 0x00000003))
+(assert_return (invoke "i64x2.bitmask" (v128.const i64x2 -1 0xF))
+                                        (i32.const 0x00000001))
+
+;; Combination
+
+(module (memory 1)
+    ;; as if condition
+    (func (export "i8x16_any_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (v128.any_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    (func (export "i16x8_any_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (v128.any_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    (func (export "i32x4_any_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (v128.any_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    (func (export "i8x16_all_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (i8x16.all_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    (func (export "i16x8_all_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (i16x8.all_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    (func (export "i32x4_all_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (i32x4.all_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    ;; any_true as select condition
+    (func (export "i8x16_any_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (v128.any_true (local.get 0)))
+    )
+    (func (export "i16x8_any_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (v128.any_true (local.get 0)))
+    )
+    (func (export "i32x4_any_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (v128.any_true (local.get 0)))
+    )
+    ;; all_true as select condition
+    (func (export "i8x16_all_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (i8x16.all_true (local.get 0)))
+    )
+    (func (export "i16x8_all_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (i16x8.all_true (local.get 0)))
+    )
+    (func (export "i32x4_all_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (i32x4.all_true (local.get 0)))
+    )
+    ;; any_true as br_if condition
+    (func (export "i8x16_any_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (v128.any_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    (func (export "i16x8_any_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (v128.any_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    (func (export "i32x4_any_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (v128.any_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    ;; all_true as br_if condition
+    (func (export "i8x16_all_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (i8x16.all_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    (func (export "i16x8_all_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (i16x8.all_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    (func (export "i32x4_all_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (i32x4.all_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    ;; any_true as i32.and operand
+    (func (export "i8x16_any_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i16x8_any_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i32x4_any_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+     ;; any_true as i32.or operand
+    (func (export "i8x16_any_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i16x8_any_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i32x4_any_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+     ;; any_true as i32.xor operand
+    (func (export "i8x16_any_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i16x8_any_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i32x4_any_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+     ;; all_true as i32.and operand
+    (func (export "i8x16_all_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (i8x16.all_true (local.get $0)) (i8x16.all_true (local.get $1)))
+    )
+    (func (export "i16x8_all_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (i16x8.all_true (local.get $0)) (i16x8.all_true (local.get $1)))
+    )
+    (func (export "i32x4_all_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (i32x4.all_true (local.get $0)) (i32x4.all_true (local.get $1)))
+    )
+     ;; all_true as i32.or operand
+    (func (export "i8x16_all_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (i8x16.all_true (local.get $0)) (i8x16.all_true (local.get $1)))
+    )
+    (func (export "i16x8_all_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (i16x8.all_true (local.get $0)) (i16x8.all_true (local.get $1)))
+    )
+    (func (export "i32x4_all_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (i32x4.all_true (local.get $0)) (i32x4.all_true (local.get $1)))
+    )
+     ;; all_true as i32.xor operand
+    (func (export "i8x16_all_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (i8x16.all_true (local.get $0)) (i8x16.all_true (local.get $1)))
+    )
+    (func (export "i16x8_all_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (i16x8.all_true (local.get $0)) (i16x8.all_true (local.get $1)))
+    )
+    (func (export "i32x4_all_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (i32x4.all_true (local.get $0)) (i32x4.all_true (local.get $1)))
+    )
+    ;; any_true with v128.not
+    (func (export "i8x16_any_true_with_v128.not") (param $0 v128) (result i32)
+       (v128.any_true (v128.not (local.get $0)))
+    )
+    (func (export "i16x8_any_true_with_v128.not") (param $0 v128) (result i32)
+       (v128.any_true (v128.not (local.get $0)))
+    )
+    (func (export "i32x4_any_true_with_v128.not") (param $0 v128) (result i32)
+       (v128.any_true (v128.not (local.get $0)))
+    )
+    ;; any_true with v128.and
+    (func (export "i8x16_any_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.and (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_any_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.and (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_any_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.and (local.get $0) (local.get $1)))
+    )
+    ;; any_true with v128.or
+    (func (export "i8x16_any_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.or (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_any_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.or (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_any_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.or (local.get $0) (local.get $1)))
+    )
+    ;; any_true with v128.xor
+    (func (export "i8x16_any_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_any_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_any_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    ;; any_true with v128.bitselect
+    (func (export "i8x16_any_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (v128.any_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+    (func (export "i16x8_any_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (v128.any_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+    (func (export "i32x4_any_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (v128.any_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+    ;; all_true with v128.not
+    (func (export "i8x16_all_true_with_v128.not") (param $0 v128) (result i32)
+       (i8x16.all_true (v128.not (local.get $0)))
+    )
+    (func (export "i16x8_all_true_with_v128.not") (param $0 v128) (result i32)
+       (i16x8.all_true (v128.not (local.get $0)))
+    )
+    (func (export "i32x4_all_true_with_v128.not") (param $0 v128) (result i32)
+       (i32x4.all_true (v128.not (local.get $0)))
+    )
+    ;; all_true with v128.and
+    (func (export "i8x16_all_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (i8x16.all_true (v128.and (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_all_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (i16x8.all_true (v128.and (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_all_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (i32x4.all_true (v128.and (local.get $0) (local.get $1)))
+    )
+    ;; all_true with v128.or
+    (func (export "i8x16_all_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (i8x16.all_true (v128.or (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_all_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (i16x8.all_true (v128.or (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_all_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (i32x4.all_true (v128.or (local.get $0) (local.get $1)))
+    )
+    ;; all_true with v128.xor
+    (func (export "i8x16_all_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (i8x16.all_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_all_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (i16x8.all_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_all_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (i32x4.all_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    ;; all_true with v128.bitselect
+    (func (export "i8x16_all_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (i8x16.all_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+    (func (export "i16x8_all_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (i16x8.all_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+    (func (export "i32x4_all_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (i32x4.all_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+)
+
+;; 'any_true' as 'if' condition
+;; i8x16
+(assert_return (invoke "i8x16_any_true_as_if_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_if_cond" (v128.const i8x16 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0))
+                                                   (i32.const 1))
+(assert_return (invoke "i8x16_any_true_as_if_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (i32.const 1))
+;; i16x8
+(assert_return (invoke "i16x8_any_true_as_if_cond" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_if_cond" (v128.const i16x8 0 0 1 0 0 0 1 0))
+                                                   (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_if_cond" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (i32.const 1))
+;; i32x4
+(assert_return (invoke "i32x4_any_true_as_if_cond" (v128.const i32x4 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_if_cond" (v128.const i32x4 0 0 1 0))
+                                                   (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_if_cond" (v128.const i32x4 1 1 1 1))
+                                                   (i32.const 1))
+
+;; 'all_true' as 'if' condition
+;; i8x16
+(assert_return (invoke "i8x16_all_true_as_if_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i8x16_all_true_as_if_cond" (v128.const i8x16 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i8x16_all_true_as_if_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (i32.const 1))
+;; i16x8
+(assert_return (invoke "i16x8_all_true_as_if_cond" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_if_cond" (v128.const i16x8 1 1 1 0 1 1 1 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_if_cond" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (i32.const 1))
+;; i32x4
+(assert_return (invoke "i32x4_all_true_as_if_cond" (v128.const i32x4 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_if_cond" (v128.const i32x4 1 1 1 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_if_cond" (v128.const i32x4 1 1 1 1))
+                                                   (i32.const 1))
+
+;; any_true as select condition
+(assert_return (invoke "i8x16_any_true_as_select_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                       (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_select_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                       (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_select_cond" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                       (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_select_cond" (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                       (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_select_cond" (v128.const i32x4 0 0 0 0))
+                                                       (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_select_cond" (v128.const i32x4 0 0 1 0))
+                                                       (i32.const 1))
+;; all_true as select condition
+(assert_return (invoke "i8x16_all_true_as_select_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                       (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_select_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                                       (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_select_cond" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                       (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_select_cond" (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                                       (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_select_cond" (v128.const i32x4 1 1 1 1))
+                                                       (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_select_cond" (v128.const i32x4 1 1 0 1))
+                                                       (i32.const 0))
+;; any_true as br_if condition
+(assert_return (invoke "i8x16_any_true_as_br_if_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_br_if_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_br_if_cond" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_br_if_cond" (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_br_if_cond" (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_br_if_cond" (v128.const i32x4 0 0 1 0))
+                                                      (i32.const 1))
+;; all_true as br_if condition
+(assert_return (invoke "i8x16_all_true_as_br_if_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                      (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_br_if_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_br_if_cond" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_br_if_cond" (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_br_if_cond" (v128.const i32x4 1 1 1 1))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_br_if_cond" (v128.const i32x4 1 1 0 1))
+                                                      (i32.const 0))
+;; any_true as and operand
+(assert_return (invoke "i8x16_any_true_as_i32.and_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_i32.and_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_i32.and_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                           (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_i32.and_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_i32.and_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_i32.and_operand" (v128.const i16x8 0 0 0 0 0 0 1 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                           (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_i32.and_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_i32.and_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_i32.and_operand" (v128.const i32x4 0 0 1 0)
+                                                           (v128.const i32x4 0 0 1 0))
+                                                           (i32.const 1))
+;; any_true as or operand
+(assert_return (invoke "i8x16_any_true_as_i32.or_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                          (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                          (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_i32.or_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                          (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                          (i32.const 1))
+(assert_return (invoke "i8x16_any_true_as_i32.or_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)
+                                                          (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                          (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_i32.or_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                          (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                          (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_i32.or_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                          (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                          (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_i32.or_operand" (v128.const i16x8 0 0 0 0 0 0 1 0)
+                                                          (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                          (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_i32.or_operand" (v128.const i32x4 0 0 0 0)
+                                                          (v128.const i32x4 0 0 0 0))
+                                                          (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_i32.or_operand" (v128.const i32x4 0 0 0 0)
+                                                          (v128.const i32x4 0 0 1 0))
+                                                          (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_i32.or_operand" (v128.const i32x4 0 0 1 0)
+                                                          (v128.const i32x4 0 0 1 0))
+                                                          (i32.const 1))
+;; any_true as xor operand
+(assert_return (invoke "i8x16_any_true_as_i32.xor_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_i32.xor_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                           (i32.const 1))
+(assert_return (invoke "i8x16_any_true_as_i32.xor_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_i32.xor_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_i32.xor_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                           (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_i32.xor_operand" (v128.const i16x8 0 0 0 0 0 0 1 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_i32.xor_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_i32.xor_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 1 0))
+                                                           (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_i32.xor_operand" (v128.const i32x4 0 0 1 0)
+                                                           (v128.const i32x4 0 0 1 0))
+                                                           (i32.const 0))
+;; all_true as and operand
+(assert_return (invoke "i8x16_all_true_as_i32.and_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                           (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_i32.and_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                           (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i8x16_all_true_as_i32.and_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_i32.and_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_i32.and_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                           (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_i32.and_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_i32.and_operand" (v128.const i32x4 1 1 1 1)
+                                                           (v128.const i32x4 1 1 1 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_i32.and_operand" (v128.const i32x4 1 1 1 1)
+                                                           (v128.const i32x4 1 1 0 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_i32.and_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 1 0))
+                                                           (i32.const 0))
+;; all_true as or operand
+(assert_return (invoke "i8x16_all_true_as_i32.or_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                          (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_i32.or_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                          (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_i32.or_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                          (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                          (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_i32.or_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                          (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_i32.or_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                          (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_i32.or_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                          (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                          (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_i32.or_operand" (v128.const i32x4 1 1 1 1)
+                                                          (v128.const i32x4 1 1 1 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_i32.or_operand" (v128.const i32x4 1 1 1 1)
+                                                          (v128.const i32x4 1 1 0 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_i32.or_operand" (v128.const i32x4 0 0 0 0)
+                                                          (v128.const i32x4 0 0 0 0))
+                                                          (i32.const 0))
+;; all_true as xor operand
+(assert_return (invoke "i8x16_all_true_as_i32.xor_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                           (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i8x16_all_true_as_i32.xor_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                           (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_i32.xor_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_i32.xor_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_i32.xor_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                           (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_i32.xor_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_i32.xor_operand" (v128.const i32x4 1 1 1 1)
+                                                           (v128.const i32x4 1 1 1 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_i32.xor_operand" (v128.const i32x4 1 1 1 1)
+                                                           (v128.const i32x4 1 1 0 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_i32.xor_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 0 0))
+                                                           (i32.const 0))
+;; any_true with v128.not
+(assert_return (invoke "i8x16_any_true_with_v128.not" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i8x16_any_true_with_v128.not" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.not" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.not" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.not" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.not" (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.not" (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.not" (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.not" (v128.const i32x4 0 0 -1 0))
+                                                      (i32.const 1))
+;; any_true with v128.and
+(assert_return (invoke "i8x16_any_true_with_v128.and" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.and" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i8x16_any_true_with_v128.and" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.and" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.and" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.and" (v128.const i16x8 0 0 0 0 0 0 -1 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.and" (v128.const i32x4 0 0 0 0)
+                                                      (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.and" (v128.const i32x4 -1 -1 -1 -1)
+                                                      (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.and" (v128.const i32x4 0 0 -1 0)
+                                                      (v128.const i32x4 0 0 -1 0))
+                                                      (i32.const 1))
+;; any_true with v128.or
+(assert_return (invoke "i8x16_any_true_with_v128.or" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.or" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i8x16_any_true_with_v128.or" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                     (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.or" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.or" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.or" (v128.const i16x8 0 0 0 0 0 0 -1 0)
+                                                     (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                     (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.or" (v128.const i32x4 0 0 0 0)
+                                                     (v128.const i32x4 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.or" (v128.const i32x4 -1 -1 -1 -1)
+                                                     (v128.const i32x4 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.or" (v128.const i32x4 0 0 -1 0)
+                                                     (v128.const i32x4 0 0 -1 0))
+                                                     (i32.const 1))
+;; any_true with v128.xor
+(assert_return (invoke "i8x16_any_true_with_v128.xor" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.xor" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.xor" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.xor" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.xor" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.xor" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.xor" (v128.const i32x4 0 0 0 0)
+                                                      (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.xor" (v128.const i32x4 -1 -1 -1 -1)
+                                                      (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.xor" (v128.const i32x4 0 0 0 0)
+                                                      (v128.const i32x4 0 0 -1 0))
+                                                      (i32.const 1))
+;; any_true with v128.bitselect
+(assert_return (invoke "i8x16_any_true_with_v128.bitselect" (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.bitselect" (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0xFF 0x55))
+                                                            (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.bitselect" (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.bitselect" (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0xFF 0x55))
+                                                            (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.bitselect" (v128.const i32x4 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.bitselect" (v128.const i32x4 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55)
+                                                            (v128.const i32x4 0x55 0x55 0xFF 0x55))
+                                                            (i32.const 1))
+;; all_true with v128.not
+(assert_return (invoke "i8x16_all_true_with_v128.not" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i8x16_all_true_with_v128.not" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.not" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.not" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_all_true_with_v128.not" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.not" (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.not" (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_all_true_with_v128.not" (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.not" (v128.const i32x4 0 0 -1 0))
+                                                      (i32.const 0))
+;; all_true with v128.and
+(assert_return (invoke "i8x16_all_true_with_v128.and" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.and" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i8x16_all_true_with_v128.and" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.and" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.and" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_all_true_with_v128.and" (v128.const i16x8 0 0 0 0 0 0 -1 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.and" (v128.const i32x4 0 0 0 0)
+                                                      (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.and" (v128.const i32x4 -1 -1 -1 -1)
+                                                      (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_all_true_with_v128.and" (v128.const i32x4 0 0 -1 0)
+                                                      (v128.const i32x4 0 0 -1 0))
+                                                      (i32.const 0))
+;; all_true with v128.or
+(assert_return (invoke "i8x16_all_true_with_v128.or" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.or" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i8x16_all_true_with_v128.or" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.or" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.or" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i16x8_all_true_with_v128.or" (v128.const i16x8 0 0 0 0 0 0 -1 0)
+                                                     (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.or" (v128.const i32x4 0 0 0 0)
+                                                     (v128.const i32x4 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.or" (v128.const i32x4 -1 -1 -1 -1)
+                                                     (v128.const i32x4 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i32x4_all_true_with_v128.or" (v128.const i32x4 0 0 -1 0)
+                                                     (v128.const i32x4 0 0 -1 0))
+                                                     (i32.const 0))
+;; all_true with v128.xor
+(assert_return (invoke "i8x16_all_true_with_v128.xor" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.xor" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.xor" (v128.const i8x16 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1)
+                                                      (v128.const i8x16 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_all_true_with_v128.xor" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.xor" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.xor" (v128.const i16x8 0 -1 0 -1 0 -1 0 -1)
+                                                      (v128.const i16x8 -1 0 -1 0 -1 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_all_true_with_v128.xor" (v128.const i32x4 0 0 0 0)
+                                                      (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.xor" (v128.const i32x4 -1 -1 -1 -1)
+                                                      (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.xor" (v128.const i32x4 0 -1 0 -1)
+                                                      (v128.const i32x4 -1 0 -1 0))
+                                                      (i32.const 1))
+;; all_true with v128.bitselect
+(assert_return (invoke "i8x16_all_true_with_v128.bitselect" (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.bitselect" (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                                                            (i32.const 1))
+(assert_return (invoke "i16x8_all_true_with_v128.bitselect" (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.bitselect" (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                                                            (i32.const 1))
+(assert_return (invoke "i32x4_all_true_with_v128.bitselect" (v128.const i32x4 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.bitselect" (v128.const i32x4 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55)
+                                                            (v128.const i32x4 0xAA 0xAA 0xAA 0xAA))
+                                                            (i32.const 1))
+
+;; Type check
+
+(assert_invalid (module (func (result i32) (v128.any_true (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i8x16.all_true (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (v128.any_true (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i16x8.all_true (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (v128.any_true (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32x4.all_true (i32.const 0)))) "type mismatch")
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result i32) (f32x4.any_true (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result i32) (f32x4.all_true (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result i32) (f64x2.any_true (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result i32) (f64x2.all_true (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $v128.any_true-arg-empty (result v128)
+      (v128.any_true)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.all_true-arg-empty (result v128)
+      (i8x16.all_true)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.any_true-arg-empty (result v128)
+      (v128.any_true)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.all_true-arg-empty (result v128)
+      (i16x8.all_true)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.any_true-arg-empty (result v128)
+      (v128.any_true)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.all_true-arg-empty (result v128)
+      (i32x4.all_true)
+    )
+  )
+  "type mismatch"
+)
diff --git a/test/core/simd/simd_const.wast b/test/core/simd/simd_const.wast
new file mode 100644
index 000000000..8080cfb0f
--- /dev/null
+++ b/test/core/simd/simd_const.wast
@@ -0,0 +1,1664 @@
+;; v128.const normal parameter (e.g. (i8x16, i16x8 i32x4, f32x4))
+
+(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF) drop))
+(module (func (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) drop))
+(module (func (v128.const i8x16  255  255  255  255  255  255  255  255  255  255  255  255  255  255  255  255) drop))
+(module (func (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) drop))
+(module (func (v128.const i16x8  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF) drop))
+(module (func (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000) drop))
+(module (func (v128.const i16x8  65535  65535  65535  65535  65535  65535  65535  65535) drop))
+(module (func (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) drop))
+(module (func (v128.const i16x8  65_535  65_535  65_535  65_535  65_535  65_535  65_535  65_535) drop))
+(module (func (v128.const i16x8 -32_768 -32_768 -32_768 -32_768 -32_768 -32_768 -32_768 -32_768) drop))
+(module (func (v128.const i16x8  0_123_45 0_123_45 0_123_45 0_123_45 0_123_45 0_123_45 0_123_45 0_123_45) drop))
+(module (func (v128.const i16x8  0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) drop))
+(module (func (v128.const i32x4  0xffffffff  0xffffffff  0xffffffff  0xffffffff) drop))
+(module (func (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000) drop))
+(module (func (v128.const i32x4  4294967295  4294967295  4294967295  4294967295) drop))
+(module (func (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) drop))
+(module (func (v128.const i32x4  0xffff_ffff  0xffff_ffff  0xffff_ffff  0xffff_ffff) drop))
+(module (func (v128.const i32x4 -0x8000_0000 -0x8000_0000 -0x8000_0000 -0x8000_0000) drop))
+(module (func (v128.const i32x4 4_294_967_295  4_294_967_295  4_294_967_295  4_294_967_295) drop))
+(module (func (v128.const i32x4 -2_147_483_648 -2_147_483_648 -2_147_483_648 -2_147_483_648) drop))
+(module (func (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789) drop))
+(module (func (v128.const i32x4 0x0_9acf_fBDF 0x0_9acf_fBDF 0x0_9acf_fBDF 0x0_9acf_fBDF) drop))
+(module (func (v128.const i64x2  0xffffffffffffffff  0xffffffffffffffff) drop))
+(module (func (v128.const i64x2 -0x8000000000000000 -0x8000000000000000) drop))
+(module (func (v128.const i64x2  18446744073709551615 18446744073709551615) drop))
+(module (func (v128.const i64x2 -9223372036854775808 -9223372036854775808) drop))
+(module (func (v128.const i64x2  0xffff_ffff_ffff_ffff  0xffff_ffff_ffff_ffff) drop))
+(module (func (v128.const i64x2 -0x8000_0000_0000_0000 -0x8000_0000_0000_0000) drop))
+(module (func (v128.const i64x2  18_446_744_073_709_551_615 18_446_744_073_709_551_615) drop))
+(module (func (v128.const i64x2 -9_223_372_036_854_775_808 -9_223_372_036_854_775_808) drop))
+(module (func (v128.const i64x2  0_123_456_789 0_123_456_789) drop))
+(module (func (v128.const i64x2  0x0125_6789_ADEF_bcef 0x0125_6789_ADEF_bcef) drop))
+(module (func (v128.const f32x4  0x1p127  0x1p127  0x1p127  0x1p127) drop))
+(module (func (v128.const f32x4 -0x1p127 -0x1p127 -0x1p127 -0x1p127) drop))
+(module (func (v128.const f32x4  1e38  1e38  1e38  1e38) drop))
+(module (func (v128.const f32x4 -1e38 -1e38 -1e38 -1e38) drop))
+(module (func (v128.const f32x4  340282356779733623858607532500980858880 340282356779733623858607532500980858880
+                                 340282356779733623858607532500980858880 340282356779733623858607532500980858880) drop))
+(module (func (v128.const f32x4 -340282356779733623858607532500980858880 -340282356779733623858607532500980858880
+                                -340282356779733623858607532500980858880 -340282356779733623858607532500980858880) drop))
+(module (func (v128.const f32x4 nan:0x1 nan:0x1 nan:0x1 nan:0x1) drop))
+(module (func (v128.const f32x4 nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff) drop))
+(module (func (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) drop))
+(module (func (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) drop))
+(module (func (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) drop))
+(module (func (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) drop))
+(module (func (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) drop))
+(module (func (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) drop))
+(module (func (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) drop))
+(module (func (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) drop))
+(module (func (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) drop))
+(module (func (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) drop))
+(module (func (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) drop))
+(module (func (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) drop))
+(module (func (v128.const f64x2  0x1p1023  0x1p1023) drop))
+(module (func (v128.const f64x2 -0x1p1023 -0x1p1023) drop))
+(module (func (v128.const f64x2  1e308  1e308) drop))
+(module (func (v128.const f64x2 -1e308 -1e308) drop))
+(module (func (v128.const f64x2  179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368
+                                 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop))
+(module (func (v128.const f64x2 -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368
+                                -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop))
+(module (func (v128.const f64x2 nan:0x1 nan:0x1) drop))
+(module (func (v128.const f64x2 nan:0xf_ffff_ffff_ffff nan:0xf_ffff_ffff_ffff) drop))
+(module (func (v128.const f64x2 0123456789 0123456789) drop))
+(module (func (v128.const f64x2 0123456789e019 0123456789e019) drop))
+(module (func (v128.const f64x2 0123456789e+019 0123456789e+019) drop))
+(module (func (v128.const f64x2 0123456789e-019 0123456789e-019) drop))
+(module (func (v128.const f64x2 0123456789. 0123456789.) drop))
+(module (func (v128.const f64x2 0123456789.e019 0123456789.e019) drop))
+(module (func (v128.const f64x2 0123456789.e+019 0123456789.e+019) drop))
+(module (func (v128.const f64x2 0123456789.e-019 0123456789.e-019) drop))
+(module (func (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) drop))
+(module (func (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) drop))
+(module (func (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) drop))
+(module (func (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) drop))
+
+;; Non-splat cases
+
+(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF
+                                -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) drop))
+(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF   255   255   255   255
+                                -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) drop))
+(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF   255   255   255   255
+                                -0x80 -0x80 -0x80 -0x80  -128  -128  -128  -128) drop))
+(module (func (v128.const i16x8 0xFF 0xFF  0xFF  0xFF -0x8000 -0x8000 -0x8000 -0x8000) drop))
+(module (func (v128.const i16x8 0xFF 0xFF 65535 65535 -0x8000 -0x8000 -0x8000 -0x8000) drop))
+(module (func (v128.const i16x8 0xFF 0xFF 65535 65535 -0x8000 -0x8000  -32768  -32768) drop))
+(module (func (v128.const i32x4 0xffffffff 0xffffffff -0x80000000 -0x80000000) drop))
+(module (func (v128.const i32x4 0xffffffff 4294967295 -0x80000000 -0x80000000) drop))
+(module (func (v128.const i32x4 0xffffffff 4294967295 -0x80000000 -2147483648) drop))
+(module (func (v128.const f32x4 0x1p127 0x1p127 -0x1p127 -1e38) drop))
+(module (func (v128.const f32x4 0x1p127 340282356779733623858607532500980858880 -1e38 -340282356779733623858607532500980858880) drop))
+(module (func (v128.const f32x4 nan -nan inf -inf) drop))
+(module (func (v128.const i64x2 0xffffffffffffffff 0x8000000000000000) drop))
+(module (func (v128.const i64x2 0xffffffffffffffff -9223372036854775808) drop))
+(module (func (v128.const f64x2 0x1p1023 -1e308) drop))
+(module (func (v128.const f64x2 nan -inf) drop))
+
+;; Constant out of range (int literal is too large)
+
+(module (memory 1))
+(assert_malformed
+  (module quote "(func (v128.const i8x16 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 0x10000 0x10000 0x10000 0x10000 0x10000 0x10000 0x10000 0x10000) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 65536 65536 65536 65536 65536 65536 65536 65536) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 -32769 -32769 -32769 -32769 -32769 -32769 -32769 -32769) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4  0x100000000  0x100000000  0x100000000  0x100000000) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 -0x80000001 -0x80000001 -0x80000001 -0x80000001) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4  4294967296  4294967296  4294967296  4294967296) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 -2147483649 -2147483649 -2147483649 -2147483649) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4  0x1p128  0x1p128  0x1p128  0x1p128) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 -0x1p128 -0x1p128 -0x1p128 -0x1p128) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4  1e39  1e39  1e39  1e39) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 -1e39 -1e39 -1e39 -1e39) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4  340282356779733661637539395458142568448 340282356779733661637539395458142568448"
+                "                         340282356779733661637539395458142568448 340282356779733661637539395458142568448) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 -340282356779733661637539395458142568448 -340282356779733661637539395458142568448"
+                "                        -340282356779733661637539395458142568448 -340282356779733661637539395458142568448) drop)")
+  "constant out of range"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f32x4 nan:0x80_0000 nan:0x80_0000 nan:0x80_0000 nan:0x80_0000) drop)")
+  "constant out of range"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f64x2  269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552"
+                "                         269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 -269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552"
+                "                        -269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop)")
+  "constant out of range"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f64x2 nan:0x10_0000_0000_0000 nan:0x10_0000_0000_0000) drop)")
+  "constant out of range"
+)
+
+;; More malformed v128.const forms
+(assert_malformed
+  (module quote "(func (v128.const) drop)")
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const 0 0 0 0) drop)")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg) drop)")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const i16x8) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 0x 0x 0x 0x 0x 0x 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 1x 1x 1x 1x 1x 1x 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg) drop)")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const i32x4) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 0x 0x 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 1x 1x 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 0xg 0xg 0xg 0xg) drop)")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const i64x2) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const i64x2 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0xg 0xg) drop)")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f32x4) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 .0 .0 .0 .0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 .0e0 .0e0 .0e0 .0e0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0e 0e 0e 0e) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0e+ 0e+ 0e+ 0e+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0.0e 0.0e 0.0e 0.0e) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0.0e- 0.0e- 0.0e- 0.0e-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x 0x 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 1x 1x 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0xg 0xg 0xg 0xg) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x. 0x. 0x. 0x.) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0.g 0x0.g 0x0.g 0x0.g) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0p 0x0p 0x0p 0x0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0p+ 0x0p+ 0x0p+ 0x0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0p- 0x0p- 0x0p- 0x0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0.0p 0x0.0p 0x0.0p 0x0.0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0.0p+ 0x0.0p+ 0x0.0p+ 0x0.0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0.0p- 0x0.0p- 0x0.0p- 0x0.0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0pA 0x0pA 0x0pA 0x0pA) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 nan:1 nan:1 nan:1 nan:1) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 nan:0x0 nan:0x0 nan:0x0 nan:0x0) drop)")
+  "constant out of range"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f64x2) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 .0 .0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 .0e0 .0e0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0e 0e) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0e+ 0e+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0.0e+ 0.0e+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0.0e- 0.0e-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0xg 0xg) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x. 0x.) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0.g 0x0.g) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0p 0x0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0p+ 0x0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0p- 0x0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0.0p 0x0.0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0.0p+ 0x0.0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0.0p- 0x0.0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0pA 0x0pA) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 nan:1 nan:1) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 nan:0x0 nan:0x0) drop)")
+  "constant out of range"
+)
+
+;; too little arguments
+
+(assert_malformed
+  (module quote "(func (v128.const i32x4 0x10000000000000000 0x10000000000000000) drop)")
+  "wrong number of lane literals"
+)
+
+;; too many arguments
+(assert_malformed
+  (module quote "(func (v128.const i32x4 0x1 0x1 0x1 0x1 0x1) drop)")
+  "wrong number of lane literals"
+)
+
+;; Rounding behaviour
+
+;; f32x4, small exponent
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000100000000000p-50 +0x1.00000100000000000p-50 +0x1.00000100000000000p-50 +0x1.00000100000000000p-50)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000100000000000p-50 -0x1.00000100000000000p-50 -0x1.00000100000000000p-50 -0x1.00000100000000000p-50)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000500000000001p-50 +0x1.00000500000000001p-50 +0x1.00000500000000001p-50 +0x1.00000500000000001p-50)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000500000000001p-50 -0x1.00000500000000001p-50 -0x1.00000500000000001p-50 -0x1.00000500000000001p-50)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50))
+
+(module (func (export "f") (result v128) (v128.const f32x4 +0x4000.004000000p-64 +0x4000.004000000p-64 +0x4000.004000000p-64 +0x4000.004000000p-64)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x4000.004000000p-64 -0x4000.004000000p-64 -0x4000.004000000p-64 -0x4000.004000000p-64)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x4000.014000001p-64 +0x4000.014000001p-64 +0x4000.014000001p-64 +0x4000.014000001p-64)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x4000.014000001p-64 -0x4000.014000001p-64 -0x4000.014000001p-64 -0x4000.014000001p-64)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50))
+
+(module (func (export "f") (result v128) (v128.const f32x4 +8.8817847263968443573e-16 +8.8817847263968443573e-16 +8.8817847263968443573e-16 +8.8817847263968443573e-16)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -8.8817847263968443573e-16 -8.8817847263968443573e-16 -8.8817847263968443573e-16 -8.8817847263968443573e-16)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 +8.8817857851880284253e-16 +8.8817857851880284253e-16 +8.8817857851880284253e-16 +8.8817857851880284253e-16)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000004p-50 +0x1.000004p-50 +0x1.000004p-50 +0x1.000004p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -8.8817857851880284253e-16 -8.8817857851880284253e-16 -8.8817857851880284253e-16 -8.8817857851880284253e-16)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000004p-50 -0x1.000004p-50 -0x1.000004p-50 -0x1.000004p-50))
+
+;; f32x4, large exponent
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000100000000000p+50 +0x1.00000100000000000p+50 +0x1.00000100000000000p+50 +0x1.00000100000000000p+50)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000100000000000p+50 -0x1.00000100000000000p+50 -0x1.00000100000000000p+50 -0x1.00000100000000000p+50)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000500000000001p+50 +0x1.00000500000000001p+50 +0x1.00000500000000001p+50 +0x1.00000500000000001p+50)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000006p+50 +0x1.000006p+50 +0x1.000006p+50 +0x1.000006p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000500000000001p+50 -0x1.00000500000000001p+50 -0x1.00000500000000001p+50 -0x1.00000500000000001p+50)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000006p+50 -0x1.000006p+50 -0x1.000006p+50 -0x1.000006p+50))
+
+(module (func (export "f") (result v128) (v128.const f32x4 +0x4000004000000 +0x4000004000000 +0x4000004000000 +0x4000004000000)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x4000004000000 -0x4000004000000 -0x4000004000000 -0x4000004000000)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x400000c000000 +0x400000c000000 +0x400000c000000 +0x400000c000000)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x400000c000000 -0x400000c000000 -0x400000c000000 -0x400000c000000)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50))
+
+(module (func (export "f") (result v128) (v128.const f32x4 +1125899973951488 +1125899973951488 +1125899973951488 +1125899973951488)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -1125899973951488 -1125899973951488 -1125899973951488 -1125899973951488)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 +1125900108169216 +1125900108169216 +1125900108169216 +1125900108169216)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -1125900108169216 -1125900108169216 -1125900108169216 -1125900108169216)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50))
+
+;; f32x4, subnormal
+(module (func (export "f") (result v128) (v128.const f32x4 +0x0.00000100000000000p-126 +0x0.00000100000000000p-126 +0x0.00000100000000000p-126 +0x0.00000100000000000p-126)))
+(assert_return (invoke "f") (v128.const f32x4 +0x0.000000p-126 +0x0.000000p-126 +0x0.000000p-126 +0x0.000000p-126))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126)))
+(assert_return (invoke "f") (v128.const f32x4 -0x0.000000p-126 -0x0.000000p-126 -0x0.000000p-126 -0x0.000000p-126))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126)))
+(assert_return (invoke "f") (v128.const f32x4 +0x0.000006p-126 +0x0.000006p-126 +0x0.000006p-126 +0x0.000006p-126))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x0.00000500000000001p-126 -0x0.00000500000000001p-126 -0x0.00000500000000001p-126 -0x0.00000500000000001p-126)))
+(assert_return (invoke "f") (v128.const f32x4 -0x0.000006p-126 -0x0.000006p-126 -0x0.000006p-126 -0x0.000006p-126))
+
+;; f32x4, round down at limit to infinity
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.fffffe8p127 +0x1.fffffe8p127 +0x1.fffffe8p127 +0x1.fffffe8p127)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.fffffe8p127 -0x1.fffffe8p127 -0x1.fffffe8p127 -0x1.fffffe8p127)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.fffffefffffffffffp127 +0x1.fffffefffffffffffp127 +0x1.fffffefffffffffffp127 +0x1.fffffefffffffffffp127)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.fffffefffffffffffp127 -0x1.fffffefffffffffffp127 -0x1.fffffefffffffffffp127 -0x1.fffffefffffffffffp127)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127))
+
+;; f64x2, small exponent
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.0000000000000fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.0000000000000fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.00000000000017ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.00000000000017ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.0000000000001fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.0000000000001fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.00000000000027ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.00000000000027ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.0000007fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.0000007fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000bfffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000bfffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000ffffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000ffffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.0000013fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.0000013fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000001400000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000001400000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313371995e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000000p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313371995e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000000p+999))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313371996e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313371996e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313383891e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313383891e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313383892e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313383892e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p+999))
+
+;; f64, large exponent
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000080000000000p+600 +0x1.000000000000080000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000000p+600 +0x1.0000000000000p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000080000000000p+600 -0x1.000000000000080000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000000p+600 -0x1.0000000000000p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000080000000001p+600 +0x1.000000000000080000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000080000000001p+600 -0x1.000000000000080000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.0000000000000fffffffffffp+600 +0x1.0000000000000fffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.0000000000000fffffffffffp+600 -0x1.0000000000000fffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000100000000000p+600 +0x1.000000000000100000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000100000000000p+600 -0x1.000000000000100000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000100000000001p+600 +0x1.000000000000100000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000100000000001p+600 -0x1.000000000000100000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.00000000000017ffffffffffp+600 +0x1.00000000000017ffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.00000000000017ffffffffffp+600 -0x1.00000000000017ffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000180000000000p+600 +0x1.000000000000180000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000180000000000p+600 -0x1.000000000000180000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000180000000001p+600 +0x1.000000000000180000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000180000000001p+600 -0x1.000000000000180000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.0000000000001fffffffffffp+600 +0x1.0000000000001fffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.0000000000001fffffffffffp+600 -0x1.0000000000001fffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000200000000000p+600 +0x1.000000000000200000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000200000000000p+600 -0x1.000000000000200000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000200000000001p+600 +0x1.000000000000200000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000200000000001p+600 -0x1.000000000000200000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.00000000000027ffffffffffp+600 +0x1.00000000000027ffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.00000000000027ffffffffffp+600 -0x1.00000000000027ffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000280000000000p+600 +0x1.000000000000280000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000280000000000p+600 -0x1.000000000000280000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000280000000001p+600 +0x1.000000000000280000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000003p+600 +0x1.0000000000003p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000280000000001p+600 -0x1.000000000000280000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000003p+600 -0x1.0000000000003p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000100000000000 +0x2000000000000100000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000000p+97 +0x1.0000000000000p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000100000000000 -0x2000000000000100000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000000p+97 -0x1.0000000000000p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000100000000001 +0x2000000000000100000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000100000000001 -0x2000000000000100000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000001fffffffffff +0x20000000000001fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000001fffffffffff -0x20000000000001fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000200000000000 +0x2000000000000200000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000200000000000 -0x2000000000000200000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000200000000001 +0x2000000000000200000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000200000000001 -0x2000000000000200000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000002fffffffffff +0x20000000000002fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000002fffffffffff -0x20000000000002fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000300000000000 +0x2000000000000300000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000300000000000 -0x2000000000000300000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000300000000001 +0x2000000000000300000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000300000000001 -0x2000000000000300000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000003fffffffffff +0x20000000000003fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000003fffffffffff -0x20000000000003fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000400000000000 +0x2000000000000400000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000400000000000 -0x2000000000000400000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000400000000001 +0x2000000000000400000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000400000000001 -0x2000000000000400000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000004fffffffffff +0x20000000000004fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000004fffffffffff -0x20000000000004fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000500000000000 +0x2000000000000500000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000500000000000 -0x2000000000000500000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000500000000001 +0x2000000000000500000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000003p+97 +0x1.0000000000003p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000500000000001 -0x2000000000000500000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000003p+97 -0x1.0000000000003p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847104 +1152921504606847104)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000000p+60 +0x1.0000000000000p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847104 -1152921504606847104)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000000p+60 -0x1.0000000000000p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847105 +1152921504606847105)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+60 +0x1.0000000000001p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847105 -1152921504606847105)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+60 -0x1.0000000000001p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847359 +1152921504606847359)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+60 +0x1.0000000000001p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847359 -1152921504606847359)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+60 -0x1.0000000000001p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847360 +1152921504606847360)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+60 +0x1.0000000000002p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847360 -1152921504606847360)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+60 -0x1.0000000000002p+60))
+
+;; f64x2, subnormal
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000080000000000p-1022 +0x0.000000000000080000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000000p-1022 +0x0.0000000000000p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000080000000000p-1022 -0x0.000000000000080000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000000p-1022 -0x0.0000000000000p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000080000000001p-1022 +0x0.000000000000080000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000080000000001p-1022 -0x0.000000000000080000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.0000000000000fffffffffffp-1022 +0x0.0000000000000fffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.0000000000000fffffffffffp-1022 -0x0.0000000000000fffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000100000000000p-1022 +0x0.000000000000100000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000100000000000p-1022 -0x0.000000000000100000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000100000000001p-1022 +0x0.000000000000100000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000100000000001p-1022 -0x0.000000000000100000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.00000000000017ffffffffffp-1022 +0x0.00000000000017ffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.00000000000017ffffffffffp-1022 -0x0.00000000000017ffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000180000000000p-1022 +0x0.000000000000180000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000180000000000p-1022 -0x0.000000000000180000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000180000000001p-1022 +0x0.000000000000180000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000180000000001p-1022 -0x0.000000000000180000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.0000000000001fffffffffffp-1022 +0x0.0000000000001fffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.0000000000001fffffffffffp-1022 -0x0.0000000000001fffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000200000000000p-1022 +0x0.000000000000200000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000200000000000p-1022 -0x0.000000000000200000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000200000000001p-1022 +0x0.000000000000200000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000200000000001p-1022 -0x0.000000000000200000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.00000000000027ffffffffffp-1022 +0x0.00000000000027ffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.00000000000027ffffffffffp-1022 -0x0.00000000000027ffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000280000000000p-1022 +0x0.000000000000280000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000280000000000p-1022 -0x0.000000000000280000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000280000000001p-1022 +0x1.000000000000280000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000003p-1022 +0x1.0000000000003p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000280000000001p-1022 -0x1.000000000000280000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000003p-1022 -0x1.0000000000003p-1022))
+
+;; f64x2, round down at limit to infinity
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.fffffffffffff4p1023 +0x1.fffffffffffff4p1023)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.fffffffffffffp1023 +0x1.fffffffffffffp1023))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.fffffffffffff4p1023 -0x1.fffffffffffff4p1023)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.fffffffffffffp1023 -0x1.fffffffffffffp1023))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.fffffffffffff7ffffffp1023 +0x1.fffffffffffff7ffffffp1023)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.fffffffffffffp1023 +0x1.fffffffffffffp1023))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.fffffffffffff7ffffffp1023 -0x1.fffffffffffff7ffffffp1023)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.fffffffffffffp1023 -0x1.fffffffffffffp1023))
+
+;; As parameters of control constructs
+
+(module (memory 1)
+  (func (export "as-br-retval") (result v128)
+    (block (result v128) (br 0 (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c)))
+  )
+  (func (export "as-br_if-retval") (result v128)
+    (block (result v128)
+      (br_if 0 (v128.const i32x4 0 1 2 3) (i32.const 1))
+    )
+  )
+  (func (export "as-return-retval") (result v128)
+    (return (v128.const i32x4 0 1 2 3))
+  )
+  (func (export "as-if-then-retval") (result v128)
+    (if (result v128) (i32.const 1)
+      (then (v128.const i32x4 0 1 2 3)) (else (v128.const i32x4 3 2 1 0))
+    )
+  )
+  (func (export "as-if-else-retval") (result v128)
+    (if (result v128) (i32.const 0)
+      (then (v128.const i32x4 0 1 2 3)) (else (v128.const i32x4 3 2 1 0))
+    )
+  )
+  (func $f (param v128 v128 v128) (result v128) (v128.const i32x4 0 1 2 3))
+  (func (export "as-call-param") (result v128)
+    (call $f (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3))
+  )
+  (func (export "as-block-retval") (result v128)
+    (block (result v128) (v128.const i32x4 0 1 2 3))
+  )
+  (func (export "as-loop-retval") (result v128)
+    (loop (result v128) (v128.const i32x4 0 1 2 3))
+  )
+  (func (export "as-drop-operand")
+    (drop (v128.const i32x4 0 1 2 3))
+  )
+
+  (func (export "as-br-retval2") (result v128)
+    (block (result v128) (br 0 (v128.const i64x2 0x0302010007060504 0x0b0a09080f0e0d0c)))
+  )
+  (func (export "as-br_if-retval2") (result v128)
+    (block (result v128)
+      (br_if 0 (v128.const i64x2 0 1) (i32.const 1))
+    )
+  )
+  (func (export "as-return-retval2") (result v128)
+    (return (v128.const i64x2 0 1))
+  )
+  (func (export "as-if-then-retval2") (result v128)
+    (if (result v128) (i32.const 1)
+      (then (v128.const i64x2 0 1)) (else (v128.const i64x2 1 0))
+    )
+  )
+  (func (export "as-if-else-retval2") (result v128)
+    (if (result v128) (i32.const 0)
+      (then (v128.const i64x2 0 1)) (else (v128.const i64x2 1 0))
+    )
+  )
+  (func $f2 (param v128 v128 v128) (result v128) (v128.const i64x2 0 1))
+  (func (export "as-call-param2") (result v128)
+    (call $f2 (v128.const i64x2 0 1) (v128.const i64x2 0 1) (v128.const i64x2 0 1))
+  )
+
+  (type $sig (func (param v128 v128 v128) (result v128)))
+  (table funcref (elem $f $f2))
+  (func (export "as-call_indirect-param") (result v128)
+    (call_indirect (type $sig)
+      (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-param2") (result v128)
+    (call_indirect (type $sig)
+      (v128.const i64x2 0 1) (v128.const i64x2 0 1) (v128.const i64x2 0 1) (i32.const 1)
+    )
+  )
+  (func (export "as-block-retval2") (result v128)
+    (block (result v128) (v128.const i64x2 0 1))
+  )
+  (func (export "as-loop-retval2") (result v128)
+    (loop (result v128) (v128.const i64x2 0 1))
+  )
+  (func (export "as-drop-operand2")
+    (drop (v128.const i64x2 0 1))
+  )
+)
+
+(assert_return (invoke "as-br-retval") (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c))
+(assert_return (invoke "as-br_if-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-return-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-if-then-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-if-else-retval") (v128.const i32x4 3 2 1 0))
+(assert_return (invoke "as-call-param") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-call_indirect-param") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-block-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-loop-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-drop-operand"))
+
+(assert_return (invoke "as-br-retval2") (v128.const i64x2 0x0302010007060504 0x0b0a09080f0e0d0c))
+(assert_return (invoke "as-br_if-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-return-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-if-then-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-if-else-retval2") (v128.const i64x2 1 0))
+(assert_return (invoke "as-call-param2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-call_indirect-param2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-block-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-loop-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-drop-operand2"))
+
+;; v128 locals
+
+(module (memory 1)
+  (func (export "as-local.set/get-value_0_0") (param $0 v128) (result v128)
+    (local v128 v128 v128 v128)
+    (local.set 0 (local.get $0))
+    (local.get 0)
+  )
+  (func (export "as-local.set/get-value_0_1") (param $0 v128) (result v128)
+    (local v128 v128 v128 v128)
+    (local.set 0 (local.get $0))
+    (local.set 1 (local.get 0))
+    (local.set 2 (local.get 1))
+    (local.set 3 (local.get 2))
+    (local.get 0)
+  )
+  (func (export "as-local.set/get-value_3_0") (param $0 v128) (result v128)
+    (local v128 v128 v128 v128)
+    (local.set 0 (local.get $0))
+    (local.set 1 (local.get 0))
+    (local.set 2 (local.get 1))
+    (local.set 3 (local.get 2))
+    (local.get 3)
+  )
+  (func (export "as-local.tee-value") (result v128)
+    (local v128)
+    (local.tee 0 (v128.const i32x4 0 1 2 3))
+  )
+)
+
+(assert_return (invoke "as-local.set/get-value_0_0" (v128.const i32x4 0 0 0 0)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "as-local.set/get-value_0_1" (v128.const i32x4 1 1 1 1)) (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "as-local.set/get-value_3_0" (v128.const i32x4 2 2 2 2)) (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "as-local.tee-value") (v128.const i32x4 0 1 2 3))
+
+
+;; v128 globals
+
+(module (memory 1)
+  (global $g0 (mut v128) (v128.const i32x4 0 1 2 3))
+  (global $g1 (mut v128) (v128.const i32x4 4 5 6 7))
+  (global $g2 (mut v128) (v128.const i32x4 8 9 10 11))
+  (global $g3 (mut v128) (v128.const i32x4 12 13 14 15))
+  (global $g4 (mut v128) (v128.const i32x4 16 17 18 19))
+
+  (func $set_g0 (export "as-global.set_value_$g0") (param $0 v128)
+    (global.set $g0 (local.get $0))
+  )
+  (func $set_g1_g2 (export "as-global.set_value_$g1_$g2") (param $0 v128) (param $1 v128)
+    (global.set $g1 (local.get $0))
+    (global.set $g2 (local.get $1))
+  )
+  (func $set_g0_g1_g2_g3 (export "as-global.set_value_$g0_$g1_$g2_$g3") (param $0 v128) (param $1 v128) (param $2 v128) (param $3 v128)
+    (call $set_g0 (local.get $0))
+    (call $set_g1_g2 (local.get $1) (local.get $2))
+    (global.set $g3 (local.get $3))
+  )
+  (func (export "global.get_g0") (result v128)
+    (global.get $g0)
+  )
+  (func (export "global.get_g1") (result v128)
+    (global.get $g1)
+  )
+  (func (export "global.get_g2") (result v128)
+    (global.get $g2)
+  )
+  (func (export "global.get_g3") (result v128)
+    (global.get $g3)
+  )
+)
+
+(assert_return (invoke "as-global.set_value_$g0_$g1_$g2_$g3" (v128.const i32x4 1 1 1 1)
+                                                             (v128.const i32x4 2 2 2 2)
+                                                             (v128.const i32x4 3 3 3 3)
+                                                             (v128.const i32x4 4 4 4 4)))
+(assert_return (invoke "global.get_g0") (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "global.get_g1") (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "global.get_g2") (v128.const i32x4 3 3 3 3))
+(assert_return (invoke "global.get_g3") (v128.const i32x4 4 4 4 4))
+
+
+;; Test integer literal parsing.
+
+(module
+  (func (export "i32x4.test") (result v128) (return (v128.const i32x4 0x0bAdD00D 0x0bAdD00D 0x0bAdD00D 0x0bAdD00D)))
+  (func (export "i32x4.smax") (result v128) (return (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)))
+  (func (export "i32x4.neg_smax") (result v128) (return (v128.const i32x4 -0x7fffffff -0x7fffffff -0x7fffffff -0x7fffffff)))
+  (func (export "i32x4.inc_smin") (result v128) (return (i32x4.add (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000) (v128.const i32x4 1 1 1 1))))
+  (func (export "i32x4.neg_zero") (result v128) (return (v128.const i32x4 -0x0 -0x0 -0x0 -0x0)))
+  (func (export "i32x4.not_octal") (result v128) (return (v128.const i32x4 010 010 010 010)))
+  (func (export "i32x4.plus_sign") (result v128) (return (v128.const i32x4 +42 +42 +42 +42)))
+
+  (func (export "i32x4-dec-sep1") (result v128) (v128.const i32x4 1_000_000 1_000_000 1_000_000 1_000_000))
+  (func (export "i32x4-dec-sep2") (result v128) (v128.const i32x4 1_0_0_0 1_0_0_0 1_0_0_0 1_0_0_0))
+  (func (export "i32x4-hex-sep1") (result v128) (v128.const i32x4 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99))
+  (func (export "i32x4-hex-sep2") (result v128) (v128.const i32x4 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f))
+
+  (func (export "i64x2.test") (result v128) (return (v128.const i64x2 0x0bAdD00D0bAdD00D 0x0bAdD00D0bAdD00D)))
+  (func (export "i64x2.smax") (result v128) (return (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)))
+  (func (export "i64x2.neg_smax") (result v128) (return (v128.const i64x2 -0x7fffffffffffffff -0x7fffffffffffffff)))
+  (func (export "i64x2.inc_smin") (result v128) (return (i64x2.add (v128.const i64x2 -0x8000000000000000 -0x8000000000000000) (v128.const i64x2 1 1))))
+  (func (export "i64x2.neg_zero") (result v128) (return (v128.const i64x2 -0x0 -0x0)))
+  (func (export "i64x2.not_octal") (result v128) (return (v128.const i64x2 010010 010010)))
+  (func (export "i64x2.plus_sign") (result v128) (return (v128.const i64x2 +42 +42)))
+
+  (func (export "i64x2-dec-sep1") (result v128) (v128.const i64x2 10_000_000_000_000 10_000_000_000_000))
+  (func (export "i64x2-dec-sep2") (result v128) (v128.const i64x2 1_0_0_0_0_0_0_0 1_0_0_0_0_0_0_0))
+  (func (export "i64x2-hex-sep1") (result v128) (v128.const i64x2 0xa_0f_00_99_0a_0f_00_99 0xa_0f_00_99_0a_0f_00_99))
+  (func (export "i64x2-hex-sep2") (result v128) (v128.const i64x2 0x1_a_A_0_f_1_a_A_0_f 0x1_a_A_0_f_1_a_A_0_f))
+)
+
+(assert_return (invoke "i32x4.test") (v128.const i32x4 195940365 195940365 195940365 195940365))
+(assert_return (invoke "i32x4.smax") (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.neg_smax") (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.inc_smin") (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.neg_zero") (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.not_octal") (v128.const i32x4 10 10 10 10))
+(assert_return (invoke "i32x4.plus_sign") (v128.const i32x4 42 42 42 42))
+
+(assert_return (invoke "i32x4-dec-sep1") (v128.const i32x4 1000000 1000000 1000000 1000000))
+(assert_return (invoke "i32x4-dec-sep2") (v128.const i32x4 1000 1000 1000 1000))
+(assert_return (invoke "i32x4-hex-sep1") (v128.const i32x4 0xa0f0099 0xa0f0099 0xa0f0099 0xa0f0099))
+(assert_return (invoke "i32x4-hex-sep2") (v128.const i32x4 0x1aa0f 0x1aa0f 0x1aa0f 0x1aa0f))
+
+(assert_return (invoke "i64x2.test") (v128.const i64x2 841557459837243405 841557459837243405))
+(assert_return (invoke "i64x2.smax") (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.neg_smax") (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.inc_smin") (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.neg_zero") (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.not_octal") (v128.const i64x2 10010 10010))
+(assert_return (invoke "i64x2.plus_sign") (v128.const i64x2 42 42))
+
+(assert_return (invoke "i64x2-dec-sep1") (v128.const i64x2 10000000000000 10000000000000))
+(assert_return (invoke "i64x2-dec-sep2") (v128.const i64x2 10000000 10000000))
+(assert_return (invoke "i64x2-hex-sep1") (v128.const i64x2 0xa0f00990a0f0099 0xa0f00990a0f0099))
+(assert_return (invoke "i64x2-hex-sep2") (v128.const i64x2 0x1aa0f1aa0f 0x1aa0f1aa0f))
+
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 _100 _100 _100 _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 +_100 +_100 +_100 +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 -_100 -_100 -_100 -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 99_ 99_ 99_ 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 1__000 1__000 1__000 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 _0x100 _0x100 _0x100 _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 0_x100 0_x100 0_x100 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 0x_100 0x_100 0x_100 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 0x00_ 0x00_ 0x00_ 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 0xff__ffff 0xff__ffff 0xff__ffff 0xff__ffff))")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 _100_100 _100_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 +_100_100 +_100_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 -_100_100 -_100_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 99_99_ 99_99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 1__000_000 1__000_000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 _0x100000 _0x100000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 0_x100000 0_x100000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 0x_100000 0x_100000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 0x00_ 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 0xff__ffff_ffff_ffff 0xff__ffff_ffff_ffff))")
+  "unknown operator"
+)
+
+;; Test floating-point literal parsing.
+
+(module
+  (func (export "f32-dec-sep1") (result v128) (v128.const f32x4 1_000_000 1_000_000 1_000_000 1_000_000))
+  (func (export "f32-dec-sep2") (result v128) (v128.const f32x4 1_0_0_0 1_0_0_0 1_0_0_0 1_0_0_0))
+  (func (export "f32-dec-sep3") (result v128) (v128.const f32x4 100_3.141_592 100_3.141_592 100_3.141_592 100_3.141_592))
+  (func (export "f32-dec-sep4") (result v128) (v128.const f32x4 99e+1_3 99e+1_3 99e+1_3 99e+1_3))
+  (func (export "f32-dec-sep5") (result v128) (v128.const f32x4 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3))
+  (func (export "f32-hex-sep1") (result v128) (v128.const f32x4 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99))
+  (func (export "f32-hex-sep2") (result v128) (v128.const f32x4 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f))
+  (func (export "f32-hex-sep3") (result v128) (v128.const f32x4 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a))
+  (func (export "f32-hex-sep4") (result v128) (v128.const f32x4 0xf0P+1_3 0xf0P+1_3 0xf0P+1_3 0xf0P+1_3))
+  (func (export "f32-hex-sep5") (result v128) (v128.const f32x4 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3))
+  (func (export "f64-dec-sep1") (result v128) (v128.const f64x2 1_000_000 1_000_000))
+  (func (export "f64-dec-sep2") (result v128) (v128.const f64x2 1_0_0_0 1_0_0_0))
+  (func (export "f64-dec-sep3") (result v128) (v128.const f64x2 100_3.141_592 100_3.141_592))
+  (func (export "f64-dec-sep4") (result v128) (v128.const f64x2 99e+1_3 99e+1_3))
+  (func (export "f64-dec-sep5") (result v128) (v128.const f64x2 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3))
+  (func (export "f64-hex-sep1") (result v128) (v128.const f64x2 0xa_0f_00_99 0xa_0f_00_99))
+  (func (export "f64-hex-sep2") (result v128) (v128.const f64x2 0x1_a_A_0_f 0x1_a_A_0_f))
+  (func (export "f64-hex-sep3") (result v128) (v128.const f64x2 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a))
+  (func (export "f64-hex-sep4") (result v128) (v128.const f64x2 0xf0P+1_3 0xf0P+1_3))
+  (func (export "f64-hex-sep5") (result v128) (v128.const f64x2 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3))
+)
+
+(assert_return (invoke "f32-dec-sep1") (v128.const f32x4 1000000 1000000 1000000 1000000))
+(assert_return (invoke "f32-dec-sep2") (v128.const f32x4 1000 1000 1000 1000))
+(assert_return (invoke "f32-dec-sep3") (v128.const f32x4 1003.141592 1003.141592 1003.141592 1003.141592))
+(assert_return (invoke "f32-dec-sep4") (v128.const f32x4 99e+13 99e+13 99e+13 99e+13))
+(assert_return (invoke "f32-dec-sep5") (v128.const f32x4 122000.11354e23 122000.11354e23 122000.11354e23 122000.11354e23))
+(assert_return (invoke "f32-hex-sep1") (v128.const f32x4 0xa0f0099 0xa0f0099 0xa0f0099 0xa0f0099))
+(assert_return (invoke "f32-hex-sep2") (v128.const f32x4 0x1aa0f 0x1aa0f 0x1aa0f 0x1aa0f))
+(assert_return (invoke "f32-hex-sep3") (v128.const f32x4 0xa0ff.f141a59a 0xa0ff.f141a59a 0xa0ff.f141a59a 0xa0ff.f141a59a))
+(assert_return (invoke "f32-hex-sep4") (v128.const f32x4 0xf0P+13 0xf0P+13 0xf0P+13 0xf0P+13))
+(assert_return (invoke "f32-hex-sep5") (v128.const f32x4 0x2af00a.1f3eep23 0x2af00a.1f3eep23 0x2af00a.1f3eep23 0x2af00a.1f3eep23))
+(assert_return (invoke "f64-dec-sep1") (v128.const f64x2 1000000 1000000))
+(assert_return (invoke "f64-dec-sep2") (v128.const f64x2 1000 1000))
+(assert_return (invoke "f64-dec-sep3") (v128.const f64x2 1003.141592 1003.141592))
+(assert_return (invoke "f64-dec-sep4") (v128.const f64x2 99e+13 99e+13))
+(assert_return (invoke "f64-dec-sep5") (v128.const f64x2 122000.11354e23 122000.11354e23))
+(assert_return (invoke "f64-hex-sep1") (v128.const f64x2 0xa0f0099 0xa0f0099))
+(assert_return (invoke "f64-hex-sep2") (v128.const f64x2 0x1aa0f 0x1aa0f))
+(assert_return (invoke "f64-hex-sep3") (v128.const f64x2 0xa0ff.f141a59a 0xa0ff.f141a59a))
+(assert_return (invoke "f64-hex-sep4") (v128.const f64x2 0xf0P+13 0xf0P+13))
+(assert_return (invoke "f64-hex-sep5") (v128.const f64x2 0x2af00a.1f3eep23 0x2af00a.1f3eep23))
+
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _100 _100 _100 _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 +_100 +_100 +_100 +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 -_100 -_100 -_100 -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 99_ 99_ 99_ 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1__000 1__000 1__000 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _1.0 _1.0 _1.0 _1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0_ 1.0_ 1.0_ 1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1_.0 1_.0 1_.0 1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1._0 1._0 1._0 1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _1e1 _1e1 _1e1 _1e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1e1_ 1e1_ 1e1_ 1e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1_e1 1_e1 1_e1 1_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1e_1 1e_1 1e_1 1e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _1.0e1 _1.0e1 _1.0e1 _1.0e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0e1_ 1.0e1_ 1.0e1_ 1.0e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0_e1 1.0_e1 1.0_e1 1.0_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0e_1 1.0e_1 1.0e_1 1.0e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0e+_1 1.0e+_1 1.0e+_1 1.0e+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0e_+1 1.0e_+1 1.0e_+1 1.0e_+1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _0x100 _0x100 _0x100 _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0_x100 0_x100 0_x100 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x_100 0x_100 0x_100 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x00_ 0x00_ 0x00_ 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0xff__ffff 0xff__ffff 0xff__ffff 0xff__ffff))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x_1.0 0x_1.0 0x_1.0 0x_1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0_ 0x1.0_ 0x1.0_ 0x1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1_.0 0x1_.0 0x1_.0 0x1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1._0 0x1._0 0x1._0 0x1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x_1p1 0x_1p1 0x_1p1 0x_1p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1p1_ 0x1p1_ 0x1p1_ 0x1p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1_p1 0x1_p1 0x1_p1 0x1_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1p_1 0x1p_1 0x1p_1 0x1p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x_1.0p1 0x_1.0p1 0x_1.0p1 0x_1.0p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0p1_ 0x1.0p1_ 0x1.0p1_ 0x1.0p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0_p1 0x1.0_p1 0x1.0_p1 0x1.0_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0p_1 0x1.0p_1 0x1.0p_1 0x1.0p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0p+_1 0x1.0p+_1 0x1.0p+_1 0x1.0p+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0p_+1 0x1.0p_+1 0x1.0p_+1 0x1.0p_+1))")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _100 _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 +_100 +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 -_100 -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 99_ 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1__000 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _1.0 _1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0_ 1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1_.0 1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1._0 1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _1e1 _1e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1e1_ 1e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1_e1 1_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1e_1 1e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _1.0e1 _1.0e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0e1_ 1.0e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0_e1 1.0_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0e_1 1.0e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0e+_1 1.0e+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0e_+1 1.0e_+1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _0x100 _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0_x100 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x_100 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x00_ 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0xff__ffff 0xff__ffff))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x_1.0 0x_1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0_ 0x1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1_.0 0x1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1._0 0x1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x_1p1 0x_1p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1p1_ 0x1p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1_p1 0x1_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1p_1 0x1p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x_1.0p1 0x_1.0p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0p1_ 0x1.0p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0_p1 0x1.0_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0p_1 0x1.0p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0p+_1 0x1.0p+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0p_+1 0x1.0p_+1))")
+  "unknown operator"
+)
+
+;; Test parsing an integer from binary
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\69\38\78\31\36\00\00"  ;; export name (parse_i8x16)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\00\00\00\00"                             ;; data lane 0~3   (0,    0,    0,    0)
+  "\80\80\80\80"                             ;; data lane 4~7   (-128, -128, -128, -128)
+  "\ff\ff\ff\ff"                             ;; data lane 8~11  (0xff, 0xff, 0xff, 0xff)
+  "\ff\ff\ff\ff"                             ;; data lane 12~15 (255,  255,  255,  255)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_i8x16") (v128.const i8x16 0 0 0 0 -128 -128 -128 -128 0xff 0xff 0xff 0xff 255 255 255 255))
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\69\31\36\78\38\00\00"  ;; export name (parse_i16x8)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\00\00\00\00"                             ;; data lane 0, 1 (0,      0)
+  "\00\80\00\80"                             ;; data lane 2, 3 (-32768, -32768)
+  "\ff\ff\ff\ff"                             ;; data lane 4, 5 (65535,  65535)
+  "\ff\ff\ff\ff"                             ;; data lane 6, 7 (0xffff, 0xffff)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_i16x8") (v128.const i16x8 0 0 -32768 -32768 65535 65535 0xffff 0xffff))
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\69\33\32\78\34\00\00"  ;; export name (parse_i32x4)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\d1\ff\ff\ff"                             ;; data lane 0 (4294967249)
+  "\d1\ff\ff\ff"                             ;; data lane 1 (4294967249)
+  "\d1\ff\ff\ff"                             ;; data lane 2 (4294967249)
+  "\d1\ff\ff\ff"                             ;; data lane 3 (4294967249)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_i32x4") (v128.const i32x4 4294967249 4294967249 4294967249 4294967249))
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\69\36\34\78\32\00\00"  ;; export name (parse_i64x2)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\ff\ff\ff\ff\ff\ff\ff\7f"                 ;; data lane 0 (9223372036854775807)
+  "\ff\ff\ff\ff\ff\ff\ff\7f"                 ;; data lane 1 (9223372036854775807)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_i64x2") (v128.const i64x2 9223372036854775807 9223372036854775807))
+
+;; Test parsing a float from binary
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\66\33\32\78\34\00\00"  ;; export name (parse_f32x4)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\00\00\80\4f"                             ;; data lane 0 (4294967249)
+  "\00\00\80\4f"                             ;; data lane 1 (4294967249)
+  "\00\00\80\4f"                             ;; data lane 2 (4294967249)
+  "\00\00\80\4f"                             ;; data lane 3 (4294967249)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_f32x4") (v128.const f32x4 4294967249 4294967249 4294967249 4294967249))
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\66\36\34\78\32\00\00"  ;; export name (parse_f64x2)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\ff\ff\ff\ff\ff\ff\ef\7f"                 ;; data lane 0 (0x1.fffffffffffffp+1023)
+  "\ff\ff\ff\ff\ff\ff\ef\7f"                 ;; data lane 1 (0x1.fffffffffffffp+1023)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_f64x2") (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
diff --git a/test/core/simd/simd_conversions.wast b/test/core/simd/simd_conversions.wast
new file mode 100644
index 000000000..552e94361
--- /dev/null
+++ b/test/core/simd/simd_conversions.wast
@@ -0,0 +1,899 @@
+;; Web Assembly SIMD-related type conversion tests
+
+(module
+  ;; Integer to floating point
+  (func (export "f32x4.convert_i32x4_s") (param v128) (result v128)
+    (f32x4.convert_i32x4_s (local.get 0)))
+  (func (export "f32x4.convert_i32x4_u") (param v128) (result v128)
+    (f32x4.convert_i32x4_u (local.get 0)))
+
+  (func (export "f64x2.convert_low_i32x4_s") (param v128) (result v128)
+    (f64x2.convert_low_i32x4_s (local.get 0)))
+  (func (export "f64x2.convert_low_i32x4_u") (param v128) (result v128)
+    (f64x2.convert_low_i32x4_u (local.get 0)))
+
+  ;; Integer to integer narrowing
+  (func (export "i8x16.narrow_i16x8_s") (param v128 v128) (result v128)
+    (i8x16.narrow_i16x8_s (local.get 0) (local.get 1)))
+  (func (export "i8x16.narrow_i16x8_u") (param v128 v128) (result v128)
+    (i8x16.narrow_i16x8_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.narrow_i32x4_s") (param v128 v128) (result v128)
+    (i16x8.narrow_i32x4_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.narrow_i32x4_u") (param v128 v128) (result v128)
+    (i16x8.narrow_i32x4_u (local.get 0)(local.get 1)))
+
+  ;; Float to float promote/demote
+  (func (export "f64x2.promote_low_f32x4") (param v128) (result v128)
+    (f64x2.promote_low_f32x4 (local.get 0)))
+  (func (export "f32x4.demote_f64x2_zero") (param v128) (result v128)
+    (f32x4.demote_f64x2_zero (local.get 0)))
+)
+
+;; f64x2.promote_low_f32x4
+;; Float constants copied from test/core/conversions.wast.
+
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0.0 0.0 0.0 0.0))
+                                                 (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                                 (v128.const f64x2 -0.0 -0.0))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                                 (v128.const f64x2 0x1p-149 0x1p-149))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                                 (v128.const f64x2 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                                 (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                                 (v128.const f64x2 -1.0 -1.0))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+;; Generated randomly by picking a random int and reinterpret it to float.
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0x1p-119 0x1p-119 0x1p-119 0x1p-119))
+                                                 (v128.const f64x2 0x1p-119 0x1p-119))
+;; Generated randomly by picking a random float.
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0x1.8f867ep+125 0x1.8f867ep+125 0x1.8f867ep+125 0x1.8f867ep+125))
+                                                 (v128.const f64x2 6.6382536710104395e+37 6.6382536710104395e+37))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 inf inf inf inf))
+                                                 (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -inf -inf -inf -inf))
+                                                 (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 nan nan nan nan))
+                                                 (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                                 (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -nan -nan -nan -nan))
+                                                 (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                                 (v128.const f64x2 nan:arithmetic nan:arithmetic))
+
+;; f32x4.demote_f64x2_zero
+;; Float constants copied from test/core/conversions.wast.
+
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0.0 0.0))
+                                                 (v128.const f32x4 0.0 0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0.0 -0.0))
+                                                 (v128.const f32x4 -0.0 -0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                                 (v128.const f32x4 0.0 0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+                                                 (v128.const f32x4 -0.0 -0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 1.0 1.0))
+                                                 (v128.const f32x4 1.0 1.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -1.0 -1.0))
+                                                 (v128.const f32x4 -1.0 -1.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffe0000000p-127 0x1.fffffe0000000p-127))
+                                                 (v128.const f32x4 0x1p-126 0x1p-126 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffe0000000p-127 -0x1.fffffe0000000p-127))
+                                                 (v128.const f32x4 -0x1p-126 -0x1p-126 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffdfffffffp-127 0x1.fffffdfffffffp-127))
+                                                 (v128.const f32x4 0x1.fffffcp-127 0x1.fffffcp-127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffdfffffffp-127 -0x1.fffffdfffffffp-127))
+                                                 (v128.const f32x4 -0x1.fffffcp-127 -0x1.fffffcp-127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1p-149 0x1p-149))
+                                                 (v128.const f32x4 0x1p-149 0x1p-149 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1p-149 -0x1p-149))
+                                                 (v128.const f32x4 -0x1p-149 -0x1p-149 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffd0000000p+127 0x1.fffffd0000000p+127))
+                                                 (v128.const f32x4 0x1.fffffcp+127 0x1.fffffcp+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffd0000000p+127 -0x1.fffffd0000000p+127))
+                                                 (v128.const f32x4 -0x1.fffffcp+127 -0x1.fffffcp+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffd0000001p+127 0x1.fffffd0000001p+127))
+                                                 (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffd0000001p+127 -0x1.fffffd0000001p+127))
+                                                 (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffefffffffp+127 0x1.fffffefffffffp+127))
+                                                 (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffefffffffp+127 -0x1.fffffefffffffp+127))
+                                                 (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.ffffffp+127 0x1.ffffffp+127))
+                                                 (v128.const f32x4 inf inf 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.ffffffp+127 -0x1.ffffffp+127))
+                                                 (v128.const f32x4 -inf -inf 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1p-119 0x1p-119))
+                                                 (v128.const f32x4 0x1p-119 0x1p-119 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.8f867ep+125 0x1.8f867ep+125))
+                                                 (v128.const f32x4 0x1.8f867ep+125 0x1.8f867ep+125 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 inf inf))
+                                                 (v128.const f32x4 inf inf 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -inf -inf))
+                                                 (v128.const f32x4 -inf -inf 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000000000001p+0 0x1.0000000000001p+0))
+                                                 (v128.const f32x4 1.0 1.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffffffffffp-1 0x1.fffffffffffffp-1))
+                                                 (v128.const f32x4 1.0 1.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000010000000p+0 0x1.0000010000000p+0))
+                                                 (v128.const f32x4 0x1.000000p+0 0x1.000000p+0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000010000001p+0 0x1.0000010000001p+0))
+                                                 (v128.const f32x4 0x1.000002p+0 0x1.000002p+0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.000002fffffffp+0 0x1.000002fffffffp+0))
+                                                 (v128.const f32x4 0x1.000002p+0 0x1.000002p+0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000030000000p+0 0x1.0000030000000p+0))
+                                                 (v128.const f32x4 0x1.000004p+0 0x1.000004p+0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000050000000p+0 0x1.0000050000000p+0))
+                                                 (v128.const f32x4 0x1.000004p+0 0x1.000004p+0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000010000000p+24 0x1.0000010000000p+24))
+                                                 (v128.const f32x4 0x1.0p+24 0x1.0p+24 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000010000001p+24 0x1.0000010000001p+24))
+                                                 (v128.const f32x4 0x1.000002p+24 0x1.000002p+24 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.000002fffffffp+24 0x1.000002fffffffp+24))
+                                                 (v128.const f32x4 0x1.000002p+24 0x1.000002p+24 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000030000000p+24 0x1.0000030000000p+24))
+                                                 (v128.const f32x4 0x1.000004p+24 0x1.000004p+24 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.4eae4f7024c7p+108 0x1.4eae4f7024c7p+108))
+                                                 (v128.const f32x4 0x1.4eae5p+108 0x1.4eae5p+108 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.a12e71e358685p-113 0x1.a12e71e358685p-113))
+                                                 (v128.const f32x4 0x1.a12e72p-113 0x1.a12e72p-113 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.cb98354d521ffp-127 0x1.cb98354d521ffp-127))
+                                                 (v128.const f32x4 0x1.cb9834p-127 0x1.cb9834p-127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.6972b30cfb562p+1 -0x1.6972b30cfb562p+1))
+                                                 (v128.const f32x4 -0x1.6972b4p+1 -0x1.6972b4p+1 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.bedbe4819d4c4p+112 -0x1.bedbe4819d4c4p+112))
+                                                 (v128.const f32x4 -0x1.bedbe4p+112 -0x1.bedbe4p+112 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 nan nan))
+                                                 (v128.const f32x4 nan:canonical nan:canonical 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                                 (v128.const f32x4 nan:arithmetic nan:arithmetic 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -nan -nan))
+                                                 (v128.const f32x4 nan:canonical nan:canonical 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                                 (v128.const f32x4 nan:arithmetic nan:arithmetic 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                                 (v128.const f32x4 0.0 0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                                 (v128.const f32x4 -0.0 -0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0p-150 0x1.0p-150))
+                                                 (v128.const f32x4 0.0 0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.0p-150 -0x1.0p-150))
+                                                 (v128.const f32x4 -0.0 -0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000000000001p-150 0x1.0000000000001p-150))
+                                                 (v128.const f32x4 0x1p-149 0x1p-149 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.0000000000001p-150 -0x1.0000000000001p-150))
+                                                 (v128.const f32x4 -0x1p-149 -0x1p-149 0 0))
+
+
+;; Integer to floating point
+;; f32x4.convert_i32x4_s
+
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 0 0 0 0))
+                                               (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 1 1 1 1))
+                                               (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                               (v128.const f32x4 2147483647.0 2147483647.0 2147483647.0 2147483647.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                               (v128.const f32x4 -2147483648.0 -2147483648.0 -2147483648.0 -2147483648.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 1234567890 1234567890 1234567890 1234567890))
+                                               (v128.const f32x4 0x1.26580cp+30 0x1.26580cp+30 0x1.26580cp+30 0x1.26580cp+30))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 0_123_456_792 0_123_456_792 0_123_456_792 0_123_456_792))
+                                               (v128.const f32x4 123456792.0 123456792.0 123456792.0 123456792.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 0x0_1234_5680 0x0_1234_5680 0x0_1234_5680 0x0_1234_5680))
+                                               (v128.const f32x4 305419904.0 305419904.0 305419904.0 305419904.0))
+;; Test rounding directions.
+
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 16777217 16777217 16777217 16777217))
+                                               (v128.const f32x4 16777216.0 16777216.0 16777216.0 16777216.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 -16777217 -16777217 -16777217 -16777217))
+                                               (v128.const f32x4 -16777216.0 -16777216.0 -16777216.0 -16777216.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 16777219 16777219 16777219 16777219))
+                                               (v128.const f32x4 16777220.0 16777220.0 16777220.0 16777220.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 -16777219 -16777219 -16777219 -16777219))
+                                               (v128.const f32x4 -16777220.0 -16777220.0 -16777220.0 -16777220.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 0 -1 0x7fffffff 0x80000000))
+                                               (v128.const f32x4 0.0 -1.0 2147483647.0 -2147483648.0))
+
+;; f32x4.convert_i32x4_u
+
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0 0 0 0))
+                                               (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 1 1 1 1))
+                                               (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const f32x4 4294967295.0 4294967295.0 4294967295.0 4294967295.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                               (v128.const f32x4 2147483648.0 2147483648.0 2147483648.0 2147483648.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                               (v128.const f32x4 2147483648.0 2147483648.0 2147483648.0 2147483648.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                                               (v128.const f32x4 0x1.234568p+28 0x1.234568p+28 0x1.234568p+28 0x1.234568p+28))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x80000080 0x80000080 0x80000080 0x80000080))
+                                               (v128.const f32x4 0x1.000000p+31 0x1.000000p+31 0x1.000000p+31 0x1.000000p+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x80000081 0x80000081 0x80000081 0x80000081))
+                                               (v128.const f32x4 0x1.000002p+31 0x1.000002p+31 0x1.000002p+31 0x1.000002p+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x80000082 0x80000082 0x80000082 0x80000082))
+                                               (v128.const f32x4 0x1.000002p+31 0x1.000002p+31 0x1.000002p+31 0x1.000002p+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0xfffffe80 0xfffffe80 0xfffffe80 0xfffffe80))
+                                               (v128.const f32x4 0x1.fffffcp+31 0x1.fffffcp+31 0x1.fffffcp+31 0x1.fffffcp+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0xfffffe81 0xfffffe81 0xfffffe81 0xfffffe81))
+                                               (v128.const f32x4 0x1.fffffep+31 0x1.fffffep+31 0x1.fffffep+31 0x1.fffffep+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0xfffffe82 0xfffffe82 0xfffffe82 0xfffffe82))
+                                               (v128.const f32x4 0x1.fffffep+31 0x1.fffffep+31 0x1.fffffep+31 0x1.fffffep+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0_123_456_792 0_123_456_792 0_123_456_792 0_123_456_792))
+                                               (v128.const f32x4 123456792.0 123456792.0 123456792.0 123456792.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                                               (v128.const f32x4 2427178496.0 2427178496.0 2427178496.0 2427178496.0))
+;; Test rounding directions.
+
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 16777217 16777217 16777217 16777217))
+                                               (v128.const f32x4 16777216.0 16777216.0 16777216.0 16777216.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 16777219 16777219 16777219 16777219))
+                                               (v128.const f32x4 16777220.0 16777220.0 16777220.0 16777220.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0 -1 0x7fffffff 0x80000000))
+                                               (v128.const f32x4 0.0 4294967295.0 2147483647.0 2147483648.0))
+
+;; f64x2.convert_i32x4_s
+;; constants copied from test/core/conversions.wast.
+
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 1 1 0 0))
+                                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 -1 -1 0 0))
+                                                   (v128.const f64x2 -1.0 -1.0))
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 0 0 0 0))
+                                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 0 0))
+                                                   (v128.const f64x2 2147483647 2147483647))
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 0 0))
+                                                   (v128.const f64x2 -2147483648 -2147483648))
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 987654321 987654321 0 0))
+                                                   (v128.const f64x2 987654321 987654321))
+
+;; f64x2.convert_i32x4_u
+;; constants copied from test/core/conversions.wast.
+
+(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 1 1 0 0))
+                                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 0 0 0 0))
+                                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 0 0))
+                                                   (v128.const f64x2 2147483647 2147483647))
+(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 0 0))
+                                                   (v128.const f64x2 2147483648 2147483648))
+(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 0xffffffff 0xffffffff 0 0))
+                                                   (v128.const f64x2 4294967295.0 4294967295.0))
+
+;; Integer to integer narrowing
+;; i8x16.narrow_i16x8_s
+
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                              (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                              (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f)
+                                              (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                              (v128.const i8x16 0x81 0x81 0x81 0x81 0x81 0x81 0x81 0x81 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x81 0x81 0x81 0x81 0x81 0x81 0x81 0x81))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81)
+                                              (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81)
+                                              (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81)
+                                              (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                              (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                              (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+;; i8x16.narrow_i16x8_u
+
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                              (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                              (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                              (v128.const i16x8 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe))
+                                              (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100)
+                                              (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+                                              (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                              (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+                                              (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789)
+                                              (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                              (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+;; i16x8.narrow_i32x4_s
+
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 1 1 1 1))
+                                              (v128.const i16x8 0 0 0 0 1 1 1 1))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 -1 -1 -1 -1))
+                                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                              (v128.const i32x4 -1 -1 -1 -1))
+                                              (v128.const i16x8 1 1 1 1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 1 1 1 1))
+                                              (v128.const i16x8 -1 -1 -1 -1 1 1 1 1))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7ffe 0x7ffe 0x7ffe 0x7ffe)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x7ffe 0x7ffe 0x7ffe 0x7ffe 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)
+                                              (v128.const i32x4 0x7ffe 0x7ffe 0x7ffe 0x7ffe))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7ffe 0x7ffe 0x7ffe 0x7ffe))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                              (v128.const i32x4 0x8000 0x8000 0x8000 0x8000))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)
+                                              (v128.const i32x4 0x8000 0x8000 0x8000 0x8000))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x7fff -0x7fff -0x7fff -0x7fff)
+                                              (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000))
+                                              (v128.const i16x8 0x8001 0x8001 0x8001 0x8001 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 -0x7fff -0x7fff -0x7fff -0x7fff))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8001 0x8001 0x8001 0x8001))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001)
+                                              (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001)
+                                              (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 0x8000 0x8000 0x8000 0x8000))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001)
+                                              (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000000 -0x8000000 -0x8000000 -0x8000000)
+                                              (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                                              (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                              (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+;; i16x8.narrow_i32x4_u
+
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 1 1 1 1))
+                                              (v128.const i16x8 0 0 0 0 1 1 1 1))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 -1 -1 -1 -1))
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                              (v128.const i32x4 -1 -1 -1 -1))
+                                              (v128.const i16x8 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 1 1 1 1))
+                                              (v128.const i16x8 0 0 0 0 1 1 1 1))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0xfffe 0xfffe 0xfffe 0xfffe)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0xfffe 0xfffe 0xfffe 0xfffe 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)
+                                              (v128.const i32x4 0xfffe 0xfffe 0xfffe 0xfffe))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xfffe 0xfffe 0xfffe 0xfffe))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0x10000 0x10000 0x10000 0x10000)
+                                              (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)
+                                              (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0x10000 0x10000 0x10000 0x10000)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+                                              (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+                                              (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000)
+                                              (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                                              (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                              (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                                              (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff))
+
+
+;; Unknown operator
+
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.trunc_sat_f32x4 (v128.const f32x4 0.0 0.0 0.0 0.0)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.trunc_s_sat_f32x4 (v128.const f32x4 -2.0 -1.0 1.0 2.0)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.trunc_u_sat_f32x4 (v128.const f32x4 -2.0 -1.0 1.0 2.0)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.convert_f32x4 (v128.const f32x4 -1 0 1 2)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.convert_s_f32x4 (v128.const f32x4 -1 0 1 2)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.convert_u_f32x4 (v128.const f32x4 -1 0 1 2)))")
+  "unknown operator")
+
+(assert_malformed (module quote
+  "(func (result v128) (i64x2.trunc_sat_f64x2_s (v128.const f64x2 0.0 0.0)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i64x2.trunc_sat_f64x2_u (v128.const f64x2 -2.0 -1.0)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (f64x2.convert_i64x2_s (v128.const i64x2 1 2)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (f64x2.convert_i64x2_u (v128.const i64x2 1 2)))")
+  "unknown operator")
+
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.narrow_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.narrow_i8x16 (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.narrow_i8x16_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.narrow_i8x16_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.narrow_i32x4 (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.narrow_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.narrow_i16x8_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.narrow_i16x8_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_low_i8x16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.extend_low_i16x8_s (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.extend_low_i16x8_u (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_high_i8x16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.extend_high_i16x8_s (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.extend_high_i16x8_u (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.extend_low_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_low_i32x4_s (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_low_i32x4_u (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.extend_high_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_high_i32x4_s (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_high_i32x4_u (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+
+
+;; Type mismatch
+
+(assert_invalid (module (func (result v128) (f32x4.convert_i32x4_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.convert_i32x4_s (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.convert_i32x4_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.convert_i32x4_u (i64.const 0)))) "type mismatch")
+
+(assert_invalid (module (func (result v128) (i8x16.narrow_i16x8_s (i32.const 0) (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.narrow_i16x8_u (i32.const 0) (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.narrow_i32x4_s (f32.const 0.0) (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.narrow_i32x4_s (f32.const 0.0) (f64.const 0.0)))) "type mismatch")
+
+
+;; Combinations
+
+(module
+  (func (export "f32x4_convert_i32x4_s_add") (param v128 v128) (result v128)
+    (f32x4.convert_i32x4_s (i32x4.add (local.get 0) (local.get 1))))
+  (func (export "f32x4_convert_i32x4_s_sub") (param  v128 v128) (result v128)
+    (f32x4.convert_i32x4_s (i32x4.sub (local.get 0) (local.get 1))))
+  (func (export "f32x4_convert_i32x4_u_mul") (param  v128 v128) (result v128)
+    (f32x4.convert_i32x4_u (i32x4.mul (local.get 0) (local.get 1))))
+
+  (func (export "i16x8_low_extend_narrow_ss") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_s (i8x16.narrow_i16x8_s (local.get 0) (local.get 1))))
+  (func (export "i16x8_low_extend_narrow_su") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_s (i8x16.narrow_i16x8_u (local.get 0) (local.get 1))))
+  (func (export "i16x8_high_extend_narrow_ss") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_s (i8x16.narrow_i16x8_s (local.get 0) (local.get 1))))
+  (func (export "i16x8_high_extend_narrow_su") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_s (i8x16.narrow_i16x8_u (local.get 0) (local.get 1))))
+  (func (export "i16x8_low_extend_narrow_uu") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_u (i8x16.narrow_i16x8_u (local.get 0) (local.get 1))))
+  (func (export "i16x8_low_extend_narrow_us") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_u (i8x16.narrow_i16x8_s (local.get 0) (local.get 1))))
+  (func (export "i16x8_high_extend_narrow_uu") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_u (i8x16.narrow_i16x8_u (local.get 0) (local.get 1))))
+  (func (export "i16x8_high_extend_narrow_us") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_u (i8x16.narrow_i16x8_s (local.get 0) (local.get 1))))
+
+  (func (export "i32x4_low_extend_narrow_ss") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_s (i16x8.narrow_i32x4_s (local.get 0) (local.get 1))))
+  (func (export "i32x4_low_extend_narrow_su") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_s (i16x8.narrow_i32x4_u (local.get 0) (local.get 1))))
+  (func (export "i32x4_high_extend_narrow_ss") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_s (i16x8.narrow_i32x4_s (local.get 0) (local.get 1))))
+  (func (export "i32x4_high_extend_narrow_su") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_s (i16x8.narrow_i32x4_u (local.get 0) (local.get 1))))
+  (func (export "i32x4_low_extend_narrow_uu") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_u (i16x8.narrow_i32x4_u (local.get 0) (local.get 1))))
+  (func (export "i32x4_low_extend_narrow_us") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_u (i16x8.narrow_i32x4_s (local.get 0) (local.get 1))))
+  (func (export "i32x4_high_extend_narrow_uu") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_u (i16x8.narrow_i32x4_u (local.get 0) (local.get 1))))
+  (func (export "i32x4_high_extend_narrow_us") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_u (i16x8.narrow_i32x4_s (local.get 0) (local.get 1))))
+)
+
+(assert_return (invoke "f32x4_convert_i32x4_s_add" (v128.const i32x4 1 2 3 4)
+                                                   (v128.const i32x4 2 3 4 5))
+                                                   (v128.const f32x4 3.0 5.0 7.0 9.0))
+(assert_return (invoke "f32x4_convert_i32x4_s_sub" (v128.const i32x4 0 1 2 3)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const f32x4 -1.0 0.0 1.0 2.0))
+(assert_return (invoke "f32x4_convert_i32x4_u_mul" (v128.const i32x4 1 2 3 4)
+                                                   (v128.const i32x4 1 2 3 4))
+                                                   (v128.const f32x4 1.0 4.0 9.0 16.0))
+
+(assert_return (invoke "i16x8_low_extend_narrow_ss" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000)
+                                                    (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000))
+                                                    (v128.const i16x8 0xff80 0xff80 0x7f 0xff80 0xff80 0xff80 0x7f 0xff80))
+(assert_return (invoke "i16x8_low_extend_narrow_su" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff)
+                                                    (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff))
+                                                    (v128.const i16x8 0 0 0xffff 0 0 0 0xffff 0))
+(assert_return (invoke "i16x8_high_extend_narrow_ss" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000)
+                                                     (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000))
+                                                     (v128.const i16x8 0xff80 0xff80 0x7f 0xff80 0xff80 0xff80 0x7f 0xff80))
+(assert_return (invoke "i16x8_high_extend_narrow_su" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff)
+                                                     (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff))
+                                                     (v128.const i16x8 0 0 0xffff 0 0 0 0xffff 0))
+(assert_return (invoke "i16x8_low_extend_narrow_uu" (v128.const i16x8 -0x8000 -0x7fff 0x8000 0xffff -0x8000 -0x7fff 0x8000 0xffff)
+                                                    (v128.const i16x8 -0x8000 -0x7fff 0x8000 0xffff -0x8000 -0x7fff 0x8000 0xffff))
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_low_extend_narrow_us" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000)
+                                                    (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000))
+                                                    (v128.const i16x8 0x80 0x80 0x7f 0x80 0x80 0x80 0x7f 0x80))
+(assert_return (invoke "i16x8_high_extend_narrow_uu" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff)
+                                                     (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff))
+                                                     (v128.const i16x8 0 0 0xff 0 0 0 0xff 0))
+(assert_return (invoke "i16x8_high_extend_narrow_us" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000)
+                                                     (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000))
+                                                     (v128.const i16x8 0x80 0x80 0x7f 0x80 0x80 0x80 0x7f 0x80))
+
+(assert_return (invoke "i32x4_low_extend_narrow_ss" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000)
+                                                    (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000))
+                                                    (v128.const i32x4 0xffff8000 0xffff8000 0x7fff 0x7fff))
+(assert_return (invoke "i32x4_low_extend_narrow_su" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff)
+                                                    (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff))
+                                                    (v128.const i32x4 0 0 0xffffffff 0))
+(assert_return (invoke "i32x4_high_extend_narrow_ss" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000)
+                                                     (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000))
+                                                     (v128.const i32x4 0xffff8000 0xffff8000 0x7fff 0x7fff))
+(assert_return (invoke "i32x4_high_extend_narrow_su" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff)
+                                                     (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff))
+                                                     (v128.const i32x4 0 0 0xffffffff 0))
+(assert_return (invoke "i32x4_low_extend_narrow_uu" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff)
+                                                    (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff))
+                                                    (v128.const i32x4 0 0 0xffff 0))
+(assert_return (invoke "i32x4_low_extend_narrow_us" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000)
+                                                    (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000))
+                                                    (v128.const i32x4 0x8000 0x8000 0x7fff 0x7fff))
+(assert_return (invoke "i32x4_high_extend_narrow_uu" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff)
+                                                     (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff))
+                                                     (v128.const i32x4 0 0 0xffff 0))
+(assert_return (invoke "i32x4_high_extend_narrow_us" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000)
+                                                     (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000))
+                                                     (v128.const i32x4 0x8000 0x8000 0x7fff 0x7fff))
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.convert_i32x4_s-arg-empty (result v128)
+      (f32x4.convert_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.convert_i32x4_u-arg-empty (result v128)
+      (f32x4.convert_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.narrow_i16x8_s-1st-arg-empty (result v128)
+      (i8x16.narrow_i16x8_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.narrow_i16x8_s-arg-empty (result v128)
+      (i8x16.narrow_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.narrow_i16x8_u-1st-arg-empty (result v128)
+      (i8x16.narrow_i16x8_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.narrow_i16x8_u-arg-empty (result v128)
+      (i8x16.narrow_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.narrow_i32x4_s-1st-arg-empty (result v128)
+      (i16x8.narrow_i32x4_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.narrow_i32x4_s-arg-empty (result v128)
+      (i16x8.narrow_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.narrow_i32x4_u-1st-arg-empty (result v128)
+      (i16x8.narrow_i32x4_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.narrow_i32x4_u-arg-empty (result v128)
+      (i16x8.narrow_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
diff --git a/test/core/simd/simd_f32x4.wast b/test/core/simd/simd_f32x4.wast
new file mode 100644
index 000000000..819db8cfd
--- /dev/null
+++ b/test/core/simd/simd_f32x4.wast
@@ -0,0 +1,2407 @@
+;; Tests for f32x4 [abs, min, max] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f32x4.min") (param v128 v128) (result v128) (f32x4.min (local.get 0) (local.get 1)))
+  (func (export "f32x4.max") (param v128 v128) (result v128) (f32x4.max (local.get 0) (local.get 1)))
+  (func (export "f32x4.abs") (param v128) (result v128) (f32x4.abs (local.get 0)))
+  ;; f32x4.min const vs const
+  (func (export "f32x4.min_with_const_0") (result v128) (f32x4.min (v128.const f32x4 0 1 2 -3) (v128.const f32x4 0 2 1 3)))
+  (func (export "f32x4.min_with_const_1") (result v128) (f32x4.min (v128.const f32x4 0 1 2 3) (v128.const f32x4 0 1 2 3)))
+  (func (export "f32x4.min_with_const_2") (result v128) (f32x4.min (v128.const f32x4 0x00 0x01 0x02 0x80000000) (v128.const f32x4 0x00 0x02 0x01 2147483648)))
+  (func (export "f32x4.min_with_const_3") (result v128) (f32x4.min (v128.const f32x4 0x00 0x01 0x02 0x80000000) (v128.const f32x4 0x00 0x01 0x02 0x80000000)))
+  ;; f32x4.min param vs const
+  (func (export "f32x4.min_with_const_5")(param v128) (result v128) (f32x4.min (local.get 0) (v128.const f32x4 0 1 2 -3)))
+  (func (export "f32x4.min_with_const_6")(param v128) (result v128) (f32x4.min (v128.const f32x4 0 1 2 3) (local.get 0)))
+  (func (export "f32x4.min_with_const_7")(param v128) (result v128) (f32x4.min (v128.const f32x4 0x00 0x01 0x02 0x80000000) (local.get 0)))
+  (func (export "f32x4.min_with_const_8")(param v128) (result v128) (f32x4.min (local.get 0) (v128.const f32x4 0x00 0x01 0x02 0x80000000)))
+  ;; f32x4.max const vs const
+  (func (export "f32x4.max_with_const_10") (result v128) (f32x4.max (v128.const f32x4 0 1 2 -3) (v128.const f32x4 0 2 1 3)))
+  (func (export "f32x4.max_with_const_11") (result v128) (f32x4.max (v128.const f32x4 0 1 2 3) (v128.const f32x4 0 1 2 3)))
+  (func (export "f32x4.max_with_const_12") (result v128) (f32x4.max (v128.const f32x4 0x00 0x01 0x02 0x80000000) (v128.const f32x4 0x00 0x02 0x01 2147483648)))
+  (func (export "f32x4.max_with_const_13") (result v128) (f32x4.max (v128.const f32x4 0x00 0x01 0x02 0x80000000) (v128.const f32x4 0x00 0x01 0x02 0x80000000)))
+  ;; f32x4.max param vs const
+  (func (export "f32x4.max_with_const_15")(param v128) (result v128) (f32x4.max (local.get 0) (v128.const f32x4 0 1 2 -3)))
+  (func (export "f32x4.max_with_const_16")(param v128) (result v128) (f32x4.max (v128.const f32x4 0 1 2 3) (local.get 0)))
+  (func (export "f32x4.max_with_const_17")(param v128) (result v128) (f32x4.max (v128.const f32x4 0x00 0x01 0x02 0x80000000) (local.get 0)))
+  (func (export "f32x4.max_with_const_18")(param v128) (result v128) (f32x4.max (local.get 0) (v128.const f32x4 0x00 0x01 0x02 0x80000000)))
+
+  (func (export "f32x4.abs_with_const") (result v128) (f32x4.abs (v128.const f32x4 -0 -1 -2 -3)))
+)
+
+;; f32x4.min const vs const
+(assert_return (invoke "f32x4.min_with_const_0") (v128.const f32x4 0 1 1 -3))
+(assert_return (invoke "f32x4.min_with_const_1") (v128.const f32x4 0 1 2 3))
+(assert_return (invoke "f32x4.min_with_const_2") (v128.const f32x4 0x00 0x01 0x01 0x80000000))
+(assert_return (invoke "f32x4.min_with_const_3") (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+;; f32x4.min param vs const
+(assert_return (invoke "f32x4.min_with_const_5" (v128.const f32x4 0 2 1 3))
+                                                (v128.const f32x4 0 1 1 -3))
+(assert_return (invoke "f32x4.min_with_const_6" (v128.const f32x4 0 1 2 3))
+                                                (v128.const f32x4 0 1 2 3))
+(assert_return (invoke "f32x4.min_with_const_7" (v128.const f32x4 0x00 0x02 0x01 2147483648))
+                                                (v128.const f32x4 0x00 0x01 0x01 0x80000000))
+(assert_return (invoke "f32x4.min_with_const_8" (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+                                                (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+;; f32x4.max const vs const
+(assert_return (invoke "f32x4.max_with_const_10") (v128.const f32x4 0 2 2 3))
+(assert_return (invoke "f32x4.max_with_const_11") (v128.const f32x4 0 1 2 3))
+(assert_return (invoke "f32x4.max_with_const_12") (v128.const f32x4 0x00 0x02 0x02 2147483648))
+(assert_return (invoke "f32x4.max_with_const_13") (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+;; f32x4.max param vs const
+(assert_return (invoke "f32x4.max_with_const_15" (v128.const f32x4 0 2 1 3))
+                                                 (v128.const f32x4 0 2 2 3))
+(assert_return (invoke "f32x4.max_with_const_16" (v128.const f32x4 0 1 2 3))
+                                                 (v128.const f32x4 0 1 2 3))
+(assert_return (invoke "f32x4.max_with_const_17" (v128.const f32x4 0x00 0x02 0x01 2147483648))
+                                                 (v128.const f32x4 0x00 0x02 0x02 2147483648))
+(assert_return (invoke "f32x4.max_with_const_18" (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+                                                 (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+
+(assert_return (invoke "f32x4.abs_with_const") (v128.const f32x4 0 1 2 3))
+
+;; Test different lanes go through different if-then clauses
+;; f32x4.min
+(assert_return
+  (invoke "f32x4.min"
+    (v128.const f32x4 nan 0 0 1)
+    (v128.const f32x4 0 -nan 1 0)
+  )
+  (v128.const f32x4 nan:canonical nan:canonical 0 0)
+)
+;; f32x4.min
+(assert_return
+  (invoke "f32x4.min"
+    (v128.const f32x4 nan 0 0 0)
+    (v128.const f32x4 0 -nan 1 0)
+  )
+  (v128.const f32x4 nan:canonical nan:canonical 0 0)
+)
+;; f32x4.max
+(assert_return
+  (invoke "f32x4.max"
+    (v128.const f32x4 nan 0 0 1)
+    (v128.const f32x4 0 -nan 1 0)
+  )
+  (v128.const f32x4 nan:canonical nan:canonical 1 1)
+)
+;; f32x4.max
+(assert_return
+  (invoke "f32x4.max"
+    (v128.const f32x4 nan 0 0 0)
+    (v128.const f32x4 0 -nan 1 0)
+  )
+  (v128.const f32x4 nan:canonical nan:canonical 1 0)
+)
+
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+
+;; Test opposite signs of zero
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0 0 -0 +0)
+                                   (v128.const f32x4 +0 -0 +0 -0))
+                                   (v128.const f32x4 0 -0 -0 -0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0 -0 -0 -0)
+                                   (v128.const f32x4 +0 +0 +0 +0))
+                                   (v128.const f32x4 -0 -0 -0 -0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0 0 -0 +0)
+                                   (v128.const f32x4 +0 -0 +0 -0))
+                                   (v128.const f32x4 0 0 0 0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0 -0 -0 -0)
+                                   (v128.const f32x4 +0 +0 +0 +0))
+                                   (v128.const f32x4 +0 +0 +0 +0))
+
+
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f32x4.abs (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.min (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.max (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.abs-arg-empty (result v128)
+      (f32x4.abs)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.min-1st-arg-empty (result v128)
+      (f32x4.min (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.min-arg-empty (result v128)
+      (f32x4.min)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.max-1st-arg-empty (result v128)
+      (f32x4.max (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.max-arg-empty (result v128)
+      (f32x4.max)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "max-min") (param v128 v128 v128) (result v128)
+    (f32x4.max (f32x4.min (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "min-max") (param v128 v128 v128) (result v128)
+    (f32x4.min (f32x4.max (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "max-abs") (param v128 v128) (result v128)
+    (f32x4.max (f32x4.abs (local.get 0)) (local.get 1)))
+  (func (export "min-abs") (param v128 v128) (result v128)
+    (f32x4.min (f32x4.abs (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "max-min" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+(assert_return (invoke "min-max" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+(assert_return (invoke "max-abs" (v128.const f32x4 -1.125 -1.125 -1.125 -1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 1.125 1.125 1.125 1.125))
+(assert_return (invoke "min-abs" (v128.const f32x4 -1.125 -1.125 -1.125 -1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
\ No newline at end of file
diff --git a/test/core/simd/simd_f32x4_arith.wast b/test/core/simd/simd_f32x4_arith.wast
new file mode 100644
index 000000000..56f80f547
--- /dev/null
+++ b/test/core/simd/simd_f32x4_arith.wast
@@ -0,0 +1,5476 @@
+;; Tests for f32x4 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f32x4.add") (param v128 v128) (result v128) (f32x4.add (local.get 0) (local.get 1)))
+  (func (export "f32x4.sub") (param v128 v128) (result v128) (f32x4.sub (local.get 0) (local.get 1)))
+  (func (export "f32x4.mul") (param v128 v128) (result v128) (f32x4.mul (local.get 0) (local.get 1)))
+  (func (export "f32x4.div") (param v128 v128) (result v128) (f32x4.div (local.get 0) (local.get 1)))
+  (func (export "f32x4.neg") (param v128) (result v128) (f32x4.neg (local.get 0)))
+  (func (export "f32x4.sqrt") (param v128) (result v128) (f32x4.sqrt (local.get 0)))
+)
+
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                   (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                   (v128.const f32x4 246913578.0 246913578.0 246913578.0 246913578.0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 2.46913578e+27 2.46913578e+27 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                   (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                   (v128.const f32x4 2.46913578e+27 2.46913578e+27 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 2.46913578e-11 2.46913578e-11 2.46913578e-11 2.46913578e-11))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                   (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                   (v128.const f32x4 246913578.0 246913578.0 246913578.0 246913578.0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 2.46913578e+27 2.46913578e+27 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 2.46913578e+27 2.46913578e+27 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f32x4 2.46913578e-11 2.46913578e-11 2.46913578e-11 2.46913578e-11))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f32x4 246913578.02469134 246913578.02469134 246913578.02469134 246913578.02469134))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f32x4 2.4691357802469137e+27 2.4691357802469137e+27 2.4691357802469137e+27 2.4691357802469137e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f32x4 2.4691357802469137e+27 2.4691357802469137e+27 2.4691357802469137e+27 2.4691357802469137e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f32x4 2.4691357802469137e-11 2.4691357802469137e-11 2.4691357802469137e-11 2.4691357802469137e-11))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                   (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                   (v128.const f32x4 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                   (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                   (v128.const f32x4 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                   (v128.const f32x4 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                   (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                   (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                   (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                   (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                   (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-298 0x1.0000000000000p-298 0x1.0000000000000p-298 0x1.0000000000000p-298))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-298 -0x1.0000000000000p-298 -0x1.0000000000000p-298 -0x1.0000000000000p-298))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-298 -0x1.0000000000000p-298 -0x1.0000000000000p-298 -0x1.0000000000000p-298))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-298 0x1.0000000000000p-298 0x1.0000000000000p-298 0x1.0000000000000p-298))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-252 0x1.0000000000000p-252 0x1.0000000000000p-252 0x1.0000000000000p-252))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-252 -0x1.0000000000000p-252 -0x1.0000000000000p-252 -0x1.0000000000000p-252))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-252 -0x1.0000000000000p-252 -0x1.0000000000000p-252 -0x1.0000000000000p-252))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-252 0x1.0000000000000p-252 0x1.0000000000000p-252 0x1.0000000000000p-252))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-2 0x1.0000000000000p-2 0x1.0000000000000p-2 0x1.0000000000000p-2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-2 -0x1.0000000000000p-2 -0x1.0000000000000p-2 -0x1.0000000000000p-2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-2 -0x1.0000000000000p-2 -0x1.0000000000000p-2 -0x1.0000000000000p-2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-2 0x1.0000000000000p-2 0x1.0000000000000p-2 0x1.0000000000000p-2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                   (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                   (v128.const f32x4 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                   (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                   (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                   (v128.const f32x4 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f32x4 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f32x4 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f32x4 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                   (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                   (v128.const f32x4 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                   (v128.const f32x4 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                   (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                   (v128.const f32x4 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                   (v128.const f32x4 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                   (v128.const f32x4 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                   (v128.const f32x4 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-23 0x1.0000000000000p-23 0x1.0000000000000p-23 0x1.0000000000000p-23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-23 -0x1.0000000000000p-23 -0x1.0000000000000p-23 -0x1.0000000000000p-23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-277 0x1.0000010000010p-277 0x1.0000010000010p-277 0x1.0000010000010p-277))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-277 -0x1.0000010000010p-277 -0x1.0000010000010p-277 -0x1.0000010000010p-277))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-23 -0x1.0000000000000p-23 -0x1.0000000000000p-23 -0x1.0000000000000p-23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-23 0x1.0000000000000p-23 0x1.0000000000000p-23 0x1.0000000000000p-23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-277 -0x1.0000010000010p-277 -0x1.0000010000010p-277 -0x1.0000010000010p-277))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-277 0x1.0000010000010p-277 0x1.0000010000010p-277 0x1.0000010000010p-277))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+23 0x1.0000000000000p+23 0x1.0000000000000p+23 0x1.0000000000000p+23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+23 -0x1.0000000000000p+23 -0x1.0000000000000p+23 -0x1.0000000000000p+23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-254 0x1.0000010000010p-254 0x1.0000010000010p-254 0x1.0000010000010p-254))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-254 -0x1.0000010000010p-254 -0x1.0000010000010p-254 -0x1.0000010000010p-254))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+23 -0x1.0000000000000p+23 -0x1.0000000000000p+23 -0x1.0000000000000p+23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+23 0x1.0000000000000p+23 0x1.0000000000000p+23 0x1.0000000000000p+23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-254 -0x1.0000010000010p-254 -0x1.0000010000010p-254 -0x1.0000010000010p-254))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-254 0x1.0000010000010p-254 0x1.0000010000010p-254 0x1.0000010000010p-254))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+125 0x1.0000000000000p+125 0x1.0000000000000p+125 0x1.0000000000000p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+125 -0x1.0000000000000p+125 -0x1.0000000000000p+125 -0x1.0000000000000p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-129 0x1.0000010000010p-129 0x1.0000010000010p-129 0x1.0000010000010p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-129 -0x1.0000010000010p-129 -0x1.0000010000010p-129 -0x1.0000010000010p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+125 -0x1.0000000000000p+125 -0x1.0000000000000p+125 -0x1.0000000000000p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+125 0x1.0000000000000p+125 0x1.0000000000000p+125 0x1.0000000000000p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-129 -0x1.0000010000010p-129 -0x1.0000010000010p-129 -0x1.0000010000010p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-129 0x1.0000010000010p-129 0x1.0000010000010p-129 0x1.0000010000010p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+126 0x1.0000000000000p+126 0x1.0000000000000p+126 0x1.0000000000000p+126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+126 -0x1.0000000000000p+126 -0x1.0000000000000p+126 -0x1.0000000000000p+126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-128 0x1.0000010000010p-128 0x1.0000010000010p-128 0x1.0000010000010p-128))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-128 -0x1.0000010000010p-128 -0x1.0000010000010p-128 -0x1.0000010000010p-128))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+126 -0x1.0000000000000p+126 -0x1.0000000000000p+126 -0x1.0000000000000p+126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+126 0x1.0000000000000p+126 0x1.0000000000000p+126 0x1.0000000000000p+126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-128 -0x1.0000010000010p-128 -0x1.0000010000010p-128 -0x1.0000010000010p-128))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-128 0x1.0000010000010p-128 0x1.0000010000010p-128 0x1.0000010000010p-128))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                   (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                   (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                   (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                   (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                   (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.6a09e667f3bcdp-75 0x1.6a09e667f3bcdp-75 0x1.6a09e667f3bcdp-75 0x1.6a09e667f3bcdp-75))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-63 0x1.0000000000000p-63 0x1.0000000000000p-63 0x1.0000000000000p-63))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.6a09e667f3bcdp-1 0x1.6a09e667f3bcdp-1 0x1.6a09e667f3bcdp-1 0x1.6a09e667f3bcdp-1))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.40d9324a48138p+1 0x1.40d9324a48138p+1 0x1.40d9324a48138p+1 0x1.40d9324a48138p+1))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffeffffffcp+63 0x1.fffffeffffffcp+63 0x1.fffffeffffffcp+63 0x1.fffffeffffffcp+63))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 11111.111060555555 11111.111060555555 11111.111060555555 11111.111060555555))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 35136418286444.62 35136418286444.62 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 35136418286444.62 35136418286444.62 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 3.5136418286444623e-06 3.5136418286444623e-06 3.5136418286444623e-06 3.5136418286444623e-06))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 11111.111060555555 11111.111060555555 11111.111060555555 11111.111060555555))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 35136418286444.62 35136418286444.62 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 35136418286444.62 35136418286444.62 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 3.5136418286444623e-06 3.5136418286444623e-06 3.5136418286444623e-06 3.5136418286444623e-06))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 11111.11106111111 11111.11106111111 11111.11106111111 11111.11106111111))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 35136418288201.445 35136418288201.445 35136418288201.445 35136418288201.445))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 35136418288201.445 35136418288201.445 35136418288201.445 35136418288201.445))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 3.513641828820144e-06 3.513641828820144e-06 3.513641828820144e-06 3.513641828820144e-06))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                   (v128.const f32x4 -123456789.0 -123456789.0 -123456789.0 -123456789.0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                   (v128.const f32x4 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 -1.23456789e-11 -1.23456789e-11 -1.23456789e-11 -1.23456789e-11))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                   (v128.const f32x4 -123456789.0 -123456789.0 -123456789.0 -123456789.0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f32x4 -1.23456789e-11 -1.23456789e-11 -1.23456789e-11 -1.23456789e-11))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f32x4 -123456789.01234567 -123456789.01234567 -123456789.01234567 -123456789.01234567))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f32x4 -1.2345678901234569e+27 -1.2345678901234569e+27 -1.2345678901234569e+27 -1.2345678901234569e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f32x4 -1.2345678901234569e+27 -1.2345678901234569e+27 -1.2345678901234569e+27 -1.2345678901234569e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f32x4 -1.2345678901234568e-11 -1.2345678901234568e-11 -1.2345678901234568e-11 -1.2345678901234568e-11))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37))
+
+
+;; Mixed f32x4 tests when some lanes are NaNs
+(module
+
+  (func (export "f32x4_sqrt_arith") (result v128)
+    (f32x4.sqrt (v128.const f32x4 nan:0x200000 -nan:0x200000 16.0 25.0)))
+  (func (export "f32x4_sqrt_canon") (result v128)
+    (f32x4.sqrt (v128.const f32x4 -1.0 nan 4.0 9.0)))
+  (func (export "f32x4_sqrt_mixed") (result v128)
+    (f32x4.sqrt (v128.const f32x4 -inf nan:0x200000 36.0 49.0)))
+)
+
+(assert_return (invoke "f32x4_sqrt_arith") (v128.const f32x4 nan:arithmetic nan:arithmetic 4.0 5.0))
+(assert_return (invoke "f32x4_sqrt_canon") (v128.const f32x4 nan:canonical nan:canonical 2.0 3.0))
+(assert_return (invoke "f32x4_sqrt_mixed") (v128.const f32x4 nan:canonical nan:arithmetic 6.0 7.0))
+
+;; type check
+(assert_invalid (module (func (result v128) (f32x4.neg (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.sqrt (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.add (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.sub (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.mul (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.div (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.neg-arg-empty (result v128)
+      (f32x4.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.sqrt-arg-empty (result v128)
+      (f32x4.sqrt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.add-1st-arg-empty (result v128)
+      (f32x4.add (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.add-arg-empty (result v128)
+      (f32x4.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.sub-1st-arg-empty (result v128)
+      (f32x4.sub (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.sub-arg-empty (result v128)
+      (f32x4.sub)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.mul-1st-arg-empty (result v128)
+      (f32x4.mul (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.mul-arg-empty (result v128)
+      (f32x4.mul)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.div-1st-arg-empty (result v128)
+      (f32x4.div (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.div-arg-empty (result v128)
+      (f32x4.div)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (f32x4.add (f32x4.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-add") (param v128 v128 v128) (result v128)
+    (f32x4.div (f32x4.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-mul") (param v128 v128 v128) (result v128)
+    (f32x4.div (f32x4.mul (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-sub") (param v128 v128 v128) (result v128)
+    (f32x4.div (f32x4.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-add") (param v128 v128 v128) (result v128)
+    (f32x4.mul (f32x4.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-div") (param v128 v128 v128) (result v128)
+    (f32x4.mul (f32x4.div (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-sub") (param v128 v128 v128) (result v128)
+    (f32x4.mul (f32x4.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (f32x4.sub (f32x4.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (f32x4.add (f32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "add-sqrt") (param v128 v128) (result v128)
+    (f32x4.add (f32x4.sqrt (local.get 0)) (local.get 1)))
+  (func (export "div-neg") (param v128 v128) (result v128)
+    (f32x4.div (f32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "div-sqrt") (param v128 v128) (result v128)
+    (f32x4.div (f32x4.sqrt (local.get 0)) (local.get 1)))
+  (func (export "mul-neg") (param v128 v128) (result v128)
+    (f32x4.mul (f32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "mul-sqrt") (param v128 v128) (result v128)
+    (f32x4.mul (f32x4.sqrt (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (f32x4.sub (f32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-sqrt") (param v128 v128) (result v128)
+    (f32x4.sub (f32x4.sqrt (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "div-add" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 5.0 5.0 5.0 5.0))
+(assert_return (invoke "div-mul" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 4 4 4 4)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 18.0 18.0 18.0 18.0))
+(assert_return (invoke "div-sub" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 4.0 4.0 4.0 4.0))
+(assert_return (invoke "mul-add" (v128.const f32x4 1.25 1.25 1.25 1.25)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 0.375 0.375 0.375 0.375))
+(assert_return (invoke "mul-div" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 2.25 2.25 2.25 2.25))
+(assert_return (invoke "mul-sub" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+(assert_return (invoke "sub-add" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 1.25 1.25 1.25 1.25))
+(assert_return (invoke "add-neg" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+(assert_return (invoke "add-sqrt" (v128.const f32x4 2.25 2.25 2.25 2.25)
+                                  (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                  (v128.const f32x4 1.75 1.75 1.75 1.75))
+(assert_return (invoke "div-neg" (v128.const f32x4 1.5 1.5 1.5 1.5)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 -6 -6 -6 -6))
+(assert_return (invoke "div-sqrt" (v128.const f32x4 2.25 2.25 2.25 2.25)
+                                  (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                  (v128.const f32x4 6 6 6 6))
+(assert_return (invoke "mul-neg" (v128.const f32x4 1.5 1.5 1.5 1.5)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 -0.375 -0.375 -0.375 -0.375))
+(assert_return (invoke "mul-sqrt" (v128.const f32x4 2.25 2.25 2.25 2.25)
+                                  (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                  (v128.const f32x4 0.375 0.375 0.375 0.375))
+(assert_return (invoke "sub-neg" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 -1.25 -1.25 -1.25 -1.25))
+(assert_return (invoke "sub-sqrt" (v128.const f32x4 2.25 2.25 2.25 2.25)
+                                  (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                  (v128.const f32x4 1.25 1.25 1.25 1.25))
\ No newline at end of file
diff --git a/test/core/simd/simd_f32x4_cmp.wast b/test/core/simd/simd_f32x4_cmp.wast
new file mode 100644
index 000000000..9e9a8735b
--- /dev/null
+++ b/test/core/simd/simd_f32x4_cmp.wast
@@ -0,0 +1,8167 @@
+;; Test all the f32x4 comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (f32x4.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (f32x4.ne (local.get $x) (local.get $y)))
+  (func (export "lt") (param $x v128) (param $y v128) (result v128) (f32x4.lt (local.get $x) (local.get $y)))
+  (func (export "le") (param $x v128) (param $y v128) (result v128) (f32x4.le (local.get $x) (local.get $y)))
+  (func (export "gt") (param $x v128) (param $y v128) (result v128) (f32x4.gt (local.get $x) (local.get $y)))
+  (func (export "ge") (param $x v128) (param $y v128) (result v128) (f32x4.ge (local.get $x) (local.get $y)))
+)
+
+;; eq
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; ne
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+
+;; lt
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+
+;; le
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; gt
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+
+;; ge
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; eq
+
+;; f32x4.eq  (f32x4) (i8x16)
+(assert_return (invoke "eq" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 0 -1 0 0))
+
+;; f32x4.eq  (f32x4) (i16x8)
+(assert_return (invoke "eq" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 0 -1 0 0))
+
+;; f32x4.eq  (f32x4) (i32x4)
+(assert_return (invoke "eq" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 -1 -1 0 0 ))
+
+;; ne
+
+;; f32x4.ne  (f32x4) (i8x16)
+(assert_return (invoke "ne" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 -1 0 -1 -1))
+
+;; f32x4.ne  (f32x4) (i16x8)
+(assert_return (invoke "ne" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 -1 0 -1 -1))
+
+;; f32x4.ne  (f32x4) (i32x4)
+(assert_return (invoke "ne" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 0 0 -1 -1))
+
+;; lt
+
+;; f32x4.lt  (f32x4) (i8x16)
+(assert_return (invoke "lt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 0 0 0 0))
+
+;; f32x4.lt  (f32x4) (i16x8)
+(assert_return (invoke "lt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 0 0 0 0))
+
+;; f32x4.lt  (f32x4) (i32x4)
+(assert_return (invoke "lt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 0 0 0 0))
+
+;; le
+
+;; f32x4.le  (f32x4) (i8x16)
+(assert_return (invoke "le" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 0 -1 0 0))
+
+;; f32x4.le  (f32x4) (i16x8)
+(assert_return (invoke "le" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 0 -1 0 0))
+
+;; f32x4.le  (f32x4) (i32x4)
+(assert_return (invoke "le" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 -1 -1 0 0))
+
+;; gt
+
+;; f32x4.gt  (f32x4) (i8x16)
+(assert_return (invoke "gt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 0 0 -1 -1))
+
+;; f32x4.gt  (f32x4) (i16x8)
+(assert_return (invoke "gt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 0 0 -1 -1))
+
+;; f32x4.gt  (f32x4) (i32x4)
+(assert_return (invoke "gt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 0 0 -1 -1))
+
+;; ge
+
+;; f32x4.ge  (f32x4) (i8x16)
+(assert_return (invoke "ge" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 0 -1 -1 -1))
+
+;; f32x4.ge  (f32x4) (i16x8)
+(assert_return (invoke "ge" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 0 -1 -1 -1))
+
+;; f32x4.ge  (f32x4) (i32x4)
+(assert_return (invoke "ge" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (f32x4.eq (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.ge (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.gt (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.le (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.lt (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.ne (i64.const 0) (f64.const 0)))) "type mismatch")
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.eq (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.ge (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.gt (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.le (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.lt (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.ne (local.get $x) (local.get $y)))") "unknown operator")
+
+
+;; Combination
+
+(module (memory 1)
+  (func (export "eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "lt-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.lt
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "le-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.le
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "gt-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.gt
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ge-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.ge
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-eq")
+    (drop
+      (f32x4.eq
+        (f32x4.eq
+          (f32x4.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.eq
+          (f32x4.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ne")
+    (drop
+      (f32x4.ne
+        (f32x4.ne
+          (f32x4.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.ne
+          (f32x4.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-lt")
+    (drop
+      (f32x4.lt
+        (f32x4.lt
+          (f32x4.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.lt
+          (f32x4.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-le")
+    (drop
+      (f32x4.le
+        (f32x4.le
+          (f32x4.le
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.le
+          (f32x4.le
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-gt")
+    (drop
+      (f32x4.gt
+        (f32x4.gt
+          (f32x4.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.gt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.gt
+          (f32x4.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.gt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ge")
+    (drop
+      (f32x4.ge
+        (f32x4.ge
+          (f32x4.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ge
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.ge
+          (f32x4.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ge
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (f32x4.ge
+        (f32x4.eq
+          (f32x4.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.ne
+          (f32x4.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+
+(assert_return (invoke "eq-in-block"))
+(assert_return (invoke "ne-in-block"))
+(assert_return (invoke "lt-in-block"))
+(assert_return (invoke "le-in-block"))
+(assert_return (invoke "gt-in-block"))
+(assert_return (invoke "ge-in-block"))
+(assert_return (invoke "nested-eq"))
+(assert_return (invoke "nested-ne"))
+(assert_return (invoke "nested-lt"))
+(assert_return (invoke "nested-le"))
+(assert_return (invoke "nested-gt"))
+(assert_return (invoke "nested-ge"))
+(assert_return (invoke "as-param"))
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.eq-1st-arg-empty (result v128)
+      (f32x4.eq (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.eq-arg-empty (result v128)
+      (f32x4.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.ne-1st-arg-empty (result v128)
+      (f32x4.ne (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.ne-arg-empty (result v128)
+      (f32x4.ne)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.lt-1st-arg-empty (result v128)
+      (f32x4.lt (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.lt-arg-empty (result v128)
+      (f32x4.lt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.le-1st-arg-empty (result v128)
+      (f32x4.le (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.le-arg-empty (result v128)
+      (f32x4.le)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.gt-1st-arg-empty (result v128)
+      (f32x4.gt (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.gt-arg-empty (result v128)
+      (f32x4.gt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.ge-1st-arg-empty (result v128)
+      (f32x4.ge (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.ge-arg-empty (result v128)
+      (f32x4.ge)
+    )
+  )
+  "type mismatch"
+)
\ No newline at end of file
diff --git a/test/core/simd/simd_f32x4_pmin_pmax.wast b/test/core/simd/simd_f32x4_pmin_pmax.wast
new file mode 100644
index 000000000..b0f47b380
--- /dev/null
+++ b/test/core/simd/simd_f32x4_pmin_pmax.wast
@@ -0,0 +1,11676 @@
+;; Tests for f32x4 [pmin, pmax] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f32x4.pmin") (param v128 v128) (result v128) (f32x4.pmin (local.get 0) (local.get 1)))
+  (func (export "f32x4.pmax") (param v128 v128) (result v128) (f32x4.pmax (local.get 0) (local.get 1)))
+)
+
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f32x4.pmin (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.pmax (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.pmin-1st-arg-empty (result v128)
+      (f32x4.pmin (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.pmin-arg-empty (result v128)
+      (f32x4.pmin)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.pmax-1st-arg-empty (result v128)
+      (f32x4.pmax (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.pmax-arg-empty (result v128)
+      (f32x4.pmax)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_f32x4_rounding.wast b/test/core/simd/simd_f32x4_rounding.wast
new file mode 100644
index 000000000..e59f99a77
--- /dev/null
+++ b/test/core/simd/simd_f32x4_rounding.wast
@@ -0,0 +1,424 @@
+;; Tests for f32x4 [ceil, floor, trunc, nearest] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f32x4.ceil") (param v128) (result v128) (f32x4.ceil (local.get 0)))
+  (func (export "f32x4.floor") (param v128) (result v128) (f32x4.floor (local.get 0)))
+  (func (export "f32x4.trunc") (param v128) (result v128) (f32x4.trunc (local.get 0)))
+  (func (export "f32x4.nearest") (param v128) (result v128) (f32x4.nearest (local.get 0)))
+)
+
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.c000000000000p+2 0x1.c000000000000p+2 0x1.c000000000000p+2 0x1.c000000000000p+2))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 123456790.0 123456790.0 123456790.0 123456790.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 156374987062.0 156374987062.0 156374987062.0 156374987062.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 156374987062.0 156374987062.0 156374987062.0 156374987062.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 156374987062.0 156374987062.0 156374987062.0 156374987062.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                     (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                     (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                     (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                     (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                     (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                     (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                     (v128.const f32x4 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                     (v128.const f32x4 -0x1.c000000000000p+2 -0x1.c000000000000p+2 -0x1.c000000000000p+2 -0x1.c000000000000p+2))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                     (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                     (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 inf inf inf inf))
+                                     (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -inf -inf -inf -inf))
+                                     (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                     (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                     (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 nan nan nan nan))
+                                     (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -nan -nan -nan -nan))
+                                     (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                     (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                     (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                     (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                     (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                     (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                     (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                     (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                     (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                     (v128.const f32x4 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                     (v128.const f32x4 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                     (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                     (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 inf inf inf inf))
+                                     (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -inf -inf -inf -inf))
+                                     (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                     (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                     (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 nan nan nan nan))
+                                     (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -nan -nan -nan -nan))
+                                     (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                     (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                     (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                       (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                       (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                       (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                       (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                       (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                       (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                       (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                       (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                       (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                       (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                       (v128.const f32x4 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                       (v128.const f32x4 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                       (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                       (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 inf inf inf inf))
+                                       (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -inf -inf -inf -inf))
+                                       (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                       (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                       (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                       (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                       (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                       (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                       (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                       (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                       (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                       (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                       (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                       (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                       (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                       (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                       (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                       (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                       (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                       (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                       (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 nan nan nan nan))
+                                       (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -nan -nan -nan -nan))
+                                       (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                       (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                       (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f32x4.ceil (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.floor (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.trunc (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.nearest (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.ceil-arg-empty (result v128)
+      (f32x4.ceil)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.floor-arg-empty (result v128)
+      (f32x4.floor)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.trunc-arg-empty (result v128)
+      (f32x4.trunc)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.nearest-arg-empty (result v128)
+      (f32x4.nearest)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_f64x2.wast b/test/core/simd/simd_f64x2.wast
new file mode 100644
index 000000000..8ebd33b36
--- /dev/null
+++ b/test/core/simd/simd_f64x2.wast
@@ -0,0 +1,2459 @@
+;; Tests for f64x2 [abs, min, max] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f64x2.min") (param v128 v128) (result v128) (f64x2.min (local.get 0) (local.get 1)))
+  (func (export "f64x2.max") (param v128 v128) (result v128) (f64x2.max (local.get 0) (local.get 1)))
+  (func (export "f64x2.abs") (param v128) (result v128) (f64x2.abs (local.get 0)))
+  ;; f64x2.min const vs const
+  (func (export "f64x2.min_with_const_0") (result v128) (f64x2.min (v128.const f64x2 0 1) (v128.const f64x2 0 2)))
+  (func (export "f64x2.min_with_const_1") (result v128) (f64x2.min (v128.const f64x2 2 -3) (v128.const f64x2 1 3)))
+  (func (export "f64x2.min_with_const_2") (result v128) (f64x2.min (v128.const f64x2 0 1) (v128.const f64x2 0 1)))
+  (func (export "f64x2.min_with_const_3") (result v128) (f64x2.min (v128.const f64x2 2 3) (v128.const f64x2 2 3)))
+  (func (export "f64x2.min_with_const_4") (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x02)))
+  (func (export "f64x2.min_with_const_5") (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x01 2147483648)))
+  (func (export "f64x2.min_with_const_6") (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x01)))
+  (func (export "f64x2.min_with_const_7") (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x02 0x80000000)))
+  ;; f64x2.min param vs const
+  (func (export "f64x2.min_with_const_9") (param v128) (result v128) (f64x2.min (local.get 0) (v128.const f64x2 0 1)))
+  (func (export "f64x2.min_with_const_10") (param v128) (result v128) (f64x2.min (v128.const f64x2 2 -3) (local.get 0)))
+  (func (export "f64x2.min_with_const_11") (param v128) (result v128) (f64x2.min (v128.const f64x2 0 1) (local.get 0)))
+  (func (export "f64x2.min_with_const_12") (param v128) (result v128) (f64x2.min (local.get 0) (v128.const f64x2 2 3)))
+  (func (export "f64x2.min_with_const_13") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.min_with_const_14") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+  (func (export "f64x2.min_with_const_15") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.min_with_const_16") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+  ;; f64x2.max const vs const
+  (func (export "f64x2.max_with_const_18") (result v128) (f64x2.max (v128.const f64x2 0 1) (v128.const f64x2 0 2)))
+  (func (export "f64x2.max_with_const_19") (result v128) (f64x2.max (v128.const f64x2 2 -3) (v128.const f64x2 1 3)))
+  (func (export "f64x2.max_with_const_20") (result v128) (f64x2.max (v128.const f64x2 0 1) (v128.const f64x2 0 1)))
+  (func (export "f64x2.max_with_const_21") (result v128) (f64x2.max (v128.const f64x2 2 3) (v128.const f64x2 2 3)))
+  (func (export "f64x2.max_with_const_22") (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x02)))
+  (func (export "f64x2.max_with_const_23") (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x01 2147483648)))
+  (func (export "f64x2.max_with_const_24") (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x01)))
+  (func (export "f64x2.max_with_const_25") (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x02 0x80000000)))
+  ;; f64x2.max param vs const
+  (func (export "f64x2.max_with_const_27") (param v128) (result v128) (f64x2.max (local.get 0) (v128.const f64x2 0 1)))
+  (func (export "f64x2.max_with_const_28") (param v128) (result v128) (f64x2.max (v128.const f64x2 2 -3) (local.get 0)))
+  (func (export "f64x2.max_with_const_29") (param v128) (result v128) (f64x2.max (v128.const f64x2 0 1) (local.get 0)))
+  (func (export "f64x2.max_with_const_30") (param v128) (result v128) (f64x2.max (local.get 0) (v128.const f64x2 2 3)))
+  (func (export "f64x2.max_with_const_31") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.max_with_const_32") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+  (func (export "f64x2.max_with_const_33") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.max_with_const_34") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+
+  (func (export "f64x2.abs_with_const_35") (result v128) (f64x2.abs (v128.const f64x2 -0 -1)))
+  (func (export "f64x2.abs_with_const_36") (result v128) (f64x2.abs (v128.const f64x2 -2 -3)))
+)
+
+;; f64x2.min const vs const
+(assert_return (invoke "f64x2.min_with_const_0") (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.min_with_const_1") (v128.const f64x2 1 -3))
+(assert_return (invoke "f64x2.min_with_const_2") (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.min_with_const_3") (v128.const f64x2 2 3))
+;; f64x2.min param vs const
+(assert_return (invoke "f64x2.min_with_const_4") (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.min_with_const_5") (v128.const f64x2 0x01 0x80000000))
+(assert_return (invoke "f64x2.min_with_const_6") (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.min_with_const_7") (v128.const f64x2 0x02 0x80000000))
+(assert_return (invoke "f64x2.min_with_const_9" (v128.const f64x2 0 2))
+                                                (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.min_with_const_10" (v128.const f64x2 1 3))
+                                                 (v128.const f64x2 1 -3))
+(assert_return (invoke "f64x2.min_with_const_11" (v128.const f64x2 0 1))
+                                                 (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.min_with_const_12" (v128.const f64x2 2 3))
+                                                 (v128.const f64x2 2 3))
+(assert_return (invoke "f64x2.min_with_const_13" (v128.const f64x2 0x00 0x02))
+                                                 (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.min_with_const_14" (v128.const f64x2 0x01 2147483648))
+                                                 (v128.const f64x2 0x01 0x80000000))
+(assert_return (invoke "f64x2.min_with_const_15" (v128.const f64x2 0x00 0x01))
+                                                 (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.min_with_const_16" (v128.const f64x2 0x02 0x80000000))
+                                                 (v128.const f64x2 0x02 0x80000000))
+;; f64x2.max const vs const
+(assert_return (invoke "f64x2.max_with_const_18") (v128.const f64x2 0 2))
+(assert_return (invoke "f64x2.max_with_const_19") (v128.const f64x2 2 3))
+(assert_return (invoke "f64x2.max_with_const_20") (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.max_with_const_21") (v128.const f64x2 2 3))
+;; f64x2.max param vs const
+(assert_return (invoke "f64x2.max_with_const_22") (v128.const f64x2 0x00 0x02))
+(assert_return (invoke "f64x2.max_with_const_23") (v128.const f64x2 0x02 2147483648))
+(assert_return (invoke "f64x2.max_with_const_24") (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.max_with_const_25") (v128.const f64x2 0x02 0x80000000))
+(assert_return (invoke "f64x2.max_with_const_27" (v128.const f64x2 0 2))
+                                                 (v128.const f64x2 0 2))
+(assert_return (invoke "f64x2.max_with_const_28" (v128.const f64x2 1 3))
+                                                 (v128.const f64x2 2 3))
+(assert_return (invoke "f64x2.max_with_const_29" (v128.const f64x2 0 1))
+                                                 (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.max_with_const_30" (v128.const f64x2 2 3))
+                                                 (v128.const f64x2 2 3))
+(assert_return (invoke "f64x2.max_with_const_31" (v128.const f64x2 0x00 0x02))
+                                                 (v128.const f64x2 0x00 0x02))
+(assert_return (invoke "f64x2.max_with_const_32" (v128.const f64x2 0x01 2147483648))
+                                                 (v128.const f64x2 0x02 2147483648))
+(assert_return (invoke "f64x2.max_with_const_33" (v128.const f64x2 0x00 0x01))
+                                                 (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.max_with_const_34" (v128.const f64x2 0x02 0x80000000))
+                                                 (v128.const f64x2 0x02 0x80000000))
+
+(assert_return (invoke "f64x2.abs_with_const_35") (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.abs_with_const_36") (v128.const f64x2 2 3))
+
+;; Test different lanes go through different if-then clauses
+;; f64x2.min
+(assert_return
+  (invoke "f64x2.min"
+    (v128.const f64x2 nan 0)
+    (v128.const f64x2 0 1)
+  )
+  (v128.const f64x2 nan:canonical 0)
+)
+;; f64x2.min
+(assert_return
+  (invoke "f64x2.min"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 0)
+  )
+  (v128.const f64x2 nan:canonical 0)
+)
+;; f64x2.min
+(assert_return
+  (invoke "f64x2.min"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 1)
+  )
+  (v128.const f64x2 nan:canonical 1)
+)
+;; f64x2.max
+(assert_return
+  (invoke "f64x2.max"
+    (v128.const f64x2 nan 0)
+    (v128.const f64x2 0 1)
+  )
+  (v128.const f64x2 nan:canonical 1)
+)
+;; f64x2.max
+(assert_return
+  (invoke "f64x2.max"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 0)
+  )
+  (v128.const f64x2 nan:canonical 1)
+)
+;; f64x2.max
+(assert_return
+  (invoke "f64x2.max"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 1)
+  )
+  (v128.const f64x2 nan:canonical 1)
+)
+
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+
+;; Test opposite signs of zero
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0 0)
+                                   (v128.const f64x2 +0 -0))
+                                   (v128.const f64x2 0 -0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0 +0)
+                                   (v128.const f64x2 +0 -0))
+                                   (v128.const f64x2 -0 -0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0 -0)
+                                   (v128.const f64x2 +0 +0))
+                                   (v128.const f64x2 -0 -0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0 0)
+                                   (v128.const f64x2 +0 -0))
+                                   (v128.const f64x2 0 0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0 +0)
+                                   (v128.const f64x2 +0 -0))
+                                   (v128.const f64x2 0 0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0 -0)
+                                   (v128.const f64x2 +0 +0))
+                                   (v128.const f64x2 +0 +0))
+
+
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+
+;; type check
+(assert_invalid (module (func (result v128) (f64x2.abs (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.min (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.max (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f64x2.abs-arg-empty (result v128)
+      (f64x2.abs)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.min-1st-arg-empty (result v128)
+      (f64x2.min (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.min-arg-empty (result v128)
+      (f64x2.min)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.max-1st-arg-empty (result v128)
+      (f64x2.max (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.max-arg-empty (result v128)
+      (f64x2.max)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "max-min") (param v128 v128 v128) (result v128)
+    (f64x2.max (f64x2.min (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "min-max") (param v128 v128 v128) (result v128)
+    (f64x2.min (f64x2.max (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "max-abs") (param v128 v128) (result v128)
+    (f64x2.max (f64x2.abs (local.get 0)) (local.get 1)))
+  (func (export "min-abs") (param v128 v128) (result v128)
+    (f64x2.min (f64x2.abs (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "max-min" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 0.25 0.25))
+(assert_return (invoke "min-max" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 0.125 0.125))
+(assert_return (invoke "max-abs" (v128.const f64x2 -1.125 -1.125)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 1.125 1.125))
+(assert_return (invoke "min-abs" (v128.const f64x2 -1.125 -1.125)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 0.125 0.125))
\ No newline at end of file
diff --git a/test/core/simd/simd_f64x2_arith.wast b/test/core/simd/simd_f64x2_arith.wast
new file mode 100644
index 000000000..4ab3b01e9
--- /dev/null
+++ b/test/core/simd/simd_f64x2_arith.wast
@@ -0,0 +1,5483 @@
+;; Tests for f64x2 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f64x2.add") (param v128 v128) (result v128) (f64x2.add (local.get 0) (local.get 1)))
+  (func (export "f64x2.sub") (param v128 v128) (result v128) (f64x2.sub (local.get 0) (local.get 1)))
+  (func (export "f64x2.mul") (param v128 v128) (result v128) (f64x2.mul (local.get 0) (local.get 1)))
+  (func (export "f64x2.div") (param v128 v128) (result v128) (f64x2.div (local.get 0) (local.get 1)))
+  (func (export "f64x2.neg") (param v128) (result v128) (f64x2.neg (local.get 0)))
+  (func (export "f64x2.sqrt") (param v128) (result v128) (f64x2.sqrt (local.get 0)))
+)
+
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1021 0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1021 -0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.b21fb54442d18p+2 0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.721fb54442d18p+2 -0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.721fb54442d18p+2 0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.b21fb54442d18p+2 -0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.d21fb54442d18p+2 0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.521fb54442d18p+2 -0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.521fb54442d18p+2 0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.d21fb54442d18p+2 -0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.b21fb54442d18p+2 0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.721fb54442d18p+2 0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.d21fb54442d18p+2 0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.521fb54442d18p+2 0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+3 0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.721fb54442d18p+2 -0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.b21fb54442d18p+2 -0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.521fb54442d18p+2 -0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.d21fb54442d18p+2 -0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+3 -0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789 0123456789)
+                                   (v128.const f64x2 0123456789 0123456789))
+                                   (v128.const f64x2 246913578.0 246913578.0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789e019 0123456789e019)
+                                   (v128.const f64x2 0123456789e019 0123456789e019))
+                                   (v128.const f64x2 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                   (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                   (v128.const f64x2 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                   (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                   (v128.const f64x2 2.46913578e-11 2.46913578e-11))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789. 0123456789.)
+                                   (v128.const f64x2 0123456789. 0123456789.))
+                                   (v128.const f64x2 246913578.0 246913578.0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                   (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                   (v128.const f64x2 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f64x2 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f64x2 2.46913578e-11 2.46913578e-11))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f64x2 246913578.02469134 246913578.02469134))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f64x2 2.4691357802469137e+27 2.4691357802469137e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f64x2 2.4691357802469137e+27 2.4691357802469137e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f64x2 2.4691357802469137e-11 2.4691357802469137e-11))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.23456789abcdfp+81 0x1.23456789abcdfp+81))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+62 0x1.23456789abcdfp+62))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                   (v128.const f64x2 0x1.23456789abcdfp+81 0x1.23456789abcdfp+81))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+62 0x1.23456789abcdfp+62))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.23456789abcdfp+81 0x1.23456789abcdfp+81))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+62 0x1.23456789abcdfp+62))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1021 0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.fffffffffffffp-1022 0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.fffffffffffffp-1022 0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1021 -0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000001p-1022 -0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000001p-1022 -0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.721fb54442d18p+2 -0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.b21fb54442d18p+2 0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.b21fb54442d18p+2 -0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.721fb54442d18p+2 0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.521fb54442d18p+2 -0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.d21fb54442d18p+2 0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.d21fb54442d18p+2 -0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.521fb54442d18p+2 0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.721fb54442d18p+2 0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.b21fb54442d18p+2 0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.521fb54442d18p+2 0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.d21fb54442d18p+2 0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+3 0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.b21fb54442d18p+2 -0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.721fb54442d18p+2 -0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.d21fb54442d18p+2 -0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.521fb54442d18p+2 -0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+3 -0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789 0123456789)
+                                   (v128.const f64x2 0123456789 0123456789))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789e019 0123456789e019)
+                                   (v128.const f64x2 0123456789e019 0123456789e019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                   (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                   (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789. 0123456789.)
+                                   (v128.const f64x2 0123456789. 0123456789.))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                   (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.8000000000000p-1022 0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.8000000000000p-1022 -0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p-1020 0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p-1020 -0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1 0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1 -0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.8000000000000p-1022 -0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.8000000000000p-1022 0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p-1020 -0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p-1020 0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1 -0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1 0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.8000000000000p-1022 0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.8000000000000p-1022 -0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-2 0x1.0000000000000p-2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-2 -0x1.0000000000000p-2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+1 0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+1 -0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1022 0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1022 -0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.8000000000000p-1022 -0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.8000000000000p-1022 0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-2 -0x1.0000000000000p-2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-2 0x1.0000000000000p-2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+1 -0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+1 0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1022 -0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1022 0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p-1020 0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p-1020 -0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+1 0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+1 -0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.3bd3cc9be45dep+5 0x1.3bd3cc9be45dep+5))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.3bd3cc9be45dep+5 -0x1.3bd3cc9be45dep+5))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000006p-1022 0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000006p-1022 0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p-1020 -0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p-1020 0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+1 -0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+1 0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.3bd3cc9be45dep+5 -0x1.3bd3cc9be45dep+5))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.3bd3cc9be45dep+5 0x1.3bd3cc9be45dep+5))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000006p-1022 -0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000006p-1022 -0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1 0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1 -0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1022 0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1022 -0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp-51 0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp-51 0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1 -0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1 0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1022 -0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1022 0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp-51 -0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp-51 -0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0000000000006p-1022 0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0000000000006p-1022 -0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp-51 0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp-51 -0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0000000000006p-1022 0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0000000000006p-1022 -0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp-51 0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp-51 -0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789 0123456789)
+                                   (v128.const f64x2 0123456789 0123456789))
+                                   (v128.const f64x2 1.524157875019052e+16 1.524157875019052e+16))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789e019 0123456789e019)
+                                   (v128.const f64x2 0123456789e019 0123456789e019))
+                                   (v128.const f64x2 1.524157875019052e+54 1.524157875019052e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                   (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                   (v128.const f64x2 1.524157875019052e+54 1.524157875019052e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                   (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                   (v128.const f64x2 1.524157875019052e-22 1.524157875019052e-22))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789. 0123456789.)
+                                   (v128.const f64x2 0123456789. 0123456789.))
+                                   (v128.const f64x2 1.524157875019052e+16 1.524157875019052e+16))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                   (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                   (v128.const f64x2 1.524157875019052e+54 1.524157875019052e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f64x2 1.524157875019052e+54 1.524157875019052e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f64x2 1.524157875019052e-22 1.524157875019052e-22))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f64x2 1.5241578753238834e+16 1.5241578753238834e+16))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f64x2 1.5241578753238838e+54 1.5241578753238838e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f64x2 1.5241578753238838e+54 1.5241578753238838e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f64x2 1.524157875323884e-22 1.524157875323884e-22))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+160 0x1.4b66dc33f6acep+160))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+122 0x1.4b66dc33f6acep+122))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+160 0x1.4b66dc33f6acep+160))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+122 0x1.4b66dc33f6acep+122))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+160 0x1.4b66dc33f6acep+160))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+122 0x1.4b66dc33f6acep+122))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1021 0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1021 -0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.28be60db93910p-1022 0x0.28be60db93910p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.28be60db93910p-1022 -0x0.28be60db93910p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+52 0x1.0000000000000p+52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+52 0x1.0000000000000p+52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1021 -0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1021 0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.28be60db93910p-1022 -0x0.28be60db93910p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.28be60db93910p-1022 0x0.28be60db93910p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+52 -0x1.0000000000000p+52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+52 -0x1.0000000000000p+52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+1021 0x1.0000000000000p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+1021 -0x1.0000000000000p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c883p-4 0x1.45f306dc9c883p-4))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c883p-4 -0x1.45f306dc9c883p-4))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.2000000000000p-1022 0x0.2000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.2000000000000p-1022 -0x0.2000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+1021 -0x1.0000000000000p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+1021 0x1.0000000000000p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c883p-4 -0x1.45f306dc9c883p-4))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c883p-4 0x1.45f306dc9c883p-4))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.2000000000000p-1022 -0x0.2000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.2000000000000p-1022 0x0.2000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+1022 0x1.0000000000000p+1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+1022 -0x1.0000000000000p+1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c883p-3 0x1.45f306dc9c883p-3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c883p-3 -0x1.45f306dc9c883p-3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.4000000000000p-1022 0x0.4000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.4000000000000p-1022 -0x0.4000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+1022 -0x1.0000000000000p+1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+1022 0x1.0000000000000p+1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c883p-3 -0x1.45f306dc9c883p-3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c883p-3 0x1.45f306dc9c883p-3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.4000000000000p-1022 -0x0.4000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.4000000000000p-1022 0x0.4000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+3 0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+3 -0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.921fb54442d19p-1022 0x1.921fb54442d19p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.921fb54442d19p-1022 -0x1.921fb54442d19p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+3 -0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+3 0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.921fb54442d19p-1022 -0x1.921fb54442d19p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.921fb54442d19p-1022 0x1.921fb54442d19p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c882p+1021 0x1.45f306dc9c882p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c882p+1021 -0x1.45f306dc9c882p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c882p+1021 -0x1.45f306dc9c882p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c882p+1021 0x1.45f306dc9c882p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-52 0x1.0000000000000p-52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-52 -0x1.0000000000000p-52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-52 0x1.0000000000000p-52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-52 -0x1.0000000000000p-52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789 0123456789)
+                                   (v128.const f64x2 0123456789 0123456789))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789e019 0123456789e019)
+                                   (v128.const f64x2 0123456789e019 0123456789e019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                   (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                   (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789. 0123456789.)
+                                   (v128.const f64x2 0123456789. 0123456789.))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                   (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-511 0x1.0000000000000p-511))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.6a09e667f3bcdp-1 0x1.6a09e667f3bcdp-1))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.40d931ff62705p+1 0x1.40d931ff62705p+1))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+511 0x1.fffffffffffffp+511))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-537 0x1.0000000000000p-537))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-537 0x1.0000000000000p-537))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 11111.111060555555 11111.111060555555))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 3.5136418286444623e-06 3.5136418286444623e-06))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 11111.111060555555 11111.111060555555))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 3.5136418286444623e-06 3.5136418286444623e-06))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 11111.11106111111 11111.11106111111))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 35136418288201.445 35136418288201.445))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 35136418288201.445 35136418288201.445))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 3.513641828820144e-06 3.513641828820144e-06))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.1111111111111p+40 0x1.1111111111111p+40))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+30 0x1.822cb17ff2eb8p+30))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.1111111111111p+40 0x1.1111111111111p+40))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+30 0x1.822cb17ff2eb8p+30))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.1111111111111p+40 0x1.1111111111111p+40))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+30 0x1.822cb17ff2eb8p+30))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789 0123456789))
+                                   (v128.const f64x2 -123456789.0 -123456789.0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789e019 0123456789e019))
+                                   (v128.const f64x2 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                   (v128.const f64x2 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                   (v128.const f64x2 -1.23456789e-11 -1.23456789e-11))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789. 0123456789.))
+                                   (v128.const f64x2 -123456789.0 -123456789.0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                   (v128.const f64x2 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f64x2 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f64x2 -1.23456789e-11 -1.23456789e-11))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f64x2 -123456789.01234567 -123456789.01234567))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f64x2 -1.2345678901234569e+27 -1.2345678901234569e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f64x2 -1.2345678901234569e+27 -1.2345678901234569e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f64x2 -1.2345678901234568e-11 -1.2345678901234568e-11))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+80 -0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+61 -0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+80 -0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+61 -0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+80 -0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+61 -0x1.23456789abcdfp+61))
+
+;; Mixed f64x2 tests when some lanes are NaNs
+(module
+  (func (export "f64x2_add_arith") (result v128)
+    (f64x2.add (v128.const f64x2 nan:0x8000000000000 1.0) (v128.const f64x2 nan 1.0)))
+  (func (export "f64x2_div_mixed") (result v128)
+    (f64x2.div (v128.const f64x2 nan 1.0) (v128.const f64x2 2.0 -nan:0x8000000000000)))
+  (func (export "f64x2_mul_mixed") (result v128)
+    (f64x2.mul (v128.const f64x2 nan:0x8000000000000 1.0) (v128.const f64x2 2.0 nan)))
+  (func (export "f64x2_neg_canon") (result v128)
+    (f64x2.neg (v128.const f64x2 nan 1.0)))
+  (func (export "f64x2_sqrt_canon") (result v128)
+    (f64x2.sqrt (v128.const f64x2 4.0 -nan)))
+  (func (export "f64x2_sub_arith") (result v128)
+    (f64x2.sub (v128.const f64x2 1.0 -1.0) (v128.const f64x2 -nan 1.0)))
+)
+
+(assert_return (invoke "f64x2_add_arith") (v128.const f64x2 nan:arithmetic 2.0))
+(assert_return (invoke "f64x2_div_mixed") (v128.const f64x2 nan:canonical nan:arithmetic))
+(assert_return (invoke "f64x2_mul_mixed") (v128.const f64x2 nan:arithmetic nan:canonical))
+(assert_return (invoke "f64x2_neg_canon") (v128.const f64x2 nan:canonical -1.0))
+(assert_return (invoke "f64x2_sqrt_canon") (v128.const f64x2 2.0 nan:canonical))
+(assert_return (invoke "f64x2_sub_arith") (v128.const f64x2 nan:canonical -2.0))
+
+;; type check
+(assert_invalid (module (func (result v128) (f64x2.neg (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.sqrt (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.add (i64.const 0) (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.sub (i64.const 0) (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.mul (i64.const 0) (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.div (i64.const 0) (f64.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f64x2.neg-arg-empty (result v128)
+      (f64x2.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.sqrt-arg-empty (result v128)
+      (f64x2.sqrt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.add-1st-arg-empty (result v128)
+      (f64x2.add (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.add-arg-empty (result v128)
+      (f64x2.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.sub-1st-arg-empty (result v128)
+      (f64x2.sub (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.sub-arg-empty (result v128)
+      (f64x2.sub)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.mul-1st-arg-empty (result v128)
+      (f64x2.mul (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.mul-arg-empty (result v128)
+      (f64x2.mul)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.div-1st-arg-empty (result v128)
+      (f64x2.div (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.div-arg-empty (result v128)
+      (f64x2.div)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (f64x2.add (f64x2.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-add") (param v128 v128 v128) (result v128)
+    (f64x2.div (f64x2.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-mul") (param v128 v128 v128) (result v128)
+    (f64x2.div (f64x2.mul (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-sub") (param v128 v128 v128) (result v128)
+    (f64x2.div (f64x2.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-add") (param v128 v128 v128) (result v128)
+    (f64x2.mul (f64x2.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-div") (param v128 v128 v128) (result v128)
+    (f64x2.mul (f64x2.div (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-sub") (param v128 v128 v128) (result v128)
+    (f64x2.mul (f64x2.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (f64x2.sub (f64x2.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (f64x2.add (f64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "add-sqrt") (param v128 v128) (result v128)
+    (f64x2.add (f64x2.sqrt (local.get 0)) (local.get 1)))
+  (func (export "div-neg") (param v128 v128) (result v128)
+    (f64x2.div (f64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "div-sqrt") (param v128 v128) (result v128)
+    (f64x2.div (f64x2.sqrt (local.get 0)) (local.get 1)))
+  (func (export "mul-neg") (param v128 v128) (result v128)
+    (f64x2.mul (f64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "mul-sqrt") (param v128 v128) (result v128)
+    (f64x2.mul (f64x2.sqrt (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (f64x2.sub (f64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-sqrt") (param v128 v128) (result v128)
+    (f64x2.sub (f64x2.sqrt (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "div-add" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 5.0 5.0))
+(assert_return (invoke "div-mul" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 4 4)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 18.0 18.0))
+(assert_return (invoke "div-sub" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 4.0 4.0))
+(assert_return (invoke "mul-add" (v128.const f64x2 1.25 1.25)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 0.375 0.375))
+(assert_return (invoke "mul-div" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 2.25 2.25))
+(assert_return (invoke "mul-sub" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 0.25 0.25))
+(assert_return (invoke "sub-add" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 1.25 1.25))
+(assert_return (invoke "add-neg" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 -1.0 -1.0))
+(assert_return (invoke "add-sqrt" (v128.const f64x2 2.25 2.25)
+                                  (v128.const f64x2 0.25 0.25))
+                                  (v128.const f64x2 1.75 1.75))
+(assert_return (invoke "div-neg" (v128.const f64x2 1.5 1.5)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 -6 -6))
+(assert_return (invoke "div-sqrt" (v128.const f64x2 2.25 2.25)
+                                  (v128.const f64x2 0.25 0.25))
+                                  (v128.const f64x2 6 6))
+(assert_return (invoke "mul-neg" (v128.const f64x2 1.5 1.5)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 -0.375 -0.375))
+(assert_return (invoke "mul-sqrt" (v128.const f64x2 2.25 2.25)
+                                  (v128.const f64x2 0.25 0.25))
+                                  (v128.const f64x2 0.375 0.375))
+(assert_return (invoke "sub-neg" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 -1.25 -1.25))
+(assert_return (invoke "sub-sqrt" (v128.const f64x2 2.25 2.25)
+                                  (v128.const f64x2 0.25 0.25))
+                                  (v128.const f64x2 1.25 1.25))
\ No newline at end of file
diff --git a/test/core/simd/simd_f64x2_cmp.wast b/test/core/simd/simd_f64x2_cmp.wast
new file mode 100644
index 000000000..cab815ea5
--- /dev/null
+++ b/test/core/simd/simd_f64x2_cmp.wast
@@ -0,0 +1,8337 @@
+;; Tests for f64x2 comparison operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f64x2.eq") (param v128 v128) (result v128) (f64x2.eq (local.get 0) (local.get 1)))
+  (func (export "f64x2.ne") (param v128 v128) (result v128) (f64x2.ne (local.get 0) (local.get 1)))
+  (func (export "f64x2.lt") (param v128 v128) (result v128) (f64x2.lt (local.get 0) (local.get 1)))
+  (func (export "f64x2.le") (param v128 v128) (result v128) (f64x2.le (local.get 0) (local.get 1)))
+  (func (export "f64x2.gt") (param v128 v128) (result v128) (f64x2.gt (local.get 0) (local.get 1)))
+  (func (export "f64x2.ge") (param v128 v128) (result v128) (f64x2.ge (local.get 0) (local.get 1)))
+)
+
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+
+
+;; unknown operators
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.eq (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.ne (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.lt (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.le (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.gt (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.ge (local.get $x) (local.get $y)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f64x2.eq (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.ne (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.lt (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.le (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.gt (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.ge (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f64x2.eq-1st-arg-empty (result v128)
+      (f64x2.eq (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.eq-arg-empty (result v128)
+      (f64x2.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.ne-1st-arg-empty (result v128)
+      (f64x2.ne (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.ne-arg-empty (result v128)
+      (f64x2.ne)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.lt-1st-arg-empty (result v128)
+      (f64x2.lt (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.lt-arg-empty (result v128)
+      (f64x2.lt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.le-1st-arg-empty (result v128)
+      (f64x2.le (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.le-arg-empty (result v128)
+      (f64x2.le)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.gt-1st-arg-empty (result v128)
+      (f64x2.gt (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.gt-arg-empty (result v128)
+      (f64x2.gt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.ge-1st-arg-empty (result v128)
+      (f64x2.ge (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.ge-arg-empty (result v128)
+      (f64x2.ge)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module (memory 1)
+  (func (export "f64x2.eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "f64x2.ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "f64x2.lt-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.lt
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "f64x2.le-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.le
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "f64x2.gt-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.gt
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "f64x2.ge-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.ge
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.eq")
+    (drop
+      (f64x2.eq
+        (f64x2.eq
+          (f64x2.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.eq
+          (f64x2.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.ne")
+    (drop
+      (f64x2.ne
+        (f64x2.ne
+          (f64x2.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.ne
+          (f64x2.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.lt")
+    (drop
+      (f64x2.lt
+        (f64x2.lt
+          (f64x2.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.lt
+          (f64x2.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.le")
+    (drop
+      (f64x2.le
+        (f64x2.le
+          (f64x2.le
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.le
+          (f64x2.le
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.gt")
+    (drop
+      (f64x2.gt
+        (f64x2.gt
+          (f64x2.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.gt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.gt
+          (f64x2.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.gt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.ge")
+    (drop
+      (f64x2.ge
+        (f64x2.ge
+          (f64x2.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.ge
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.ge
+          (f64x2.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.ge
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (f64x2.eq
+        (f64x2.ne
+          (f64x2.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.gt
+          (f64x2.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "f64x2.eq-in-block"))
+(assert_return (invoke "f64x2.ne-in-block"))
+(assert_return (invoke "f64x2.lt-in-block"))
+(assert_return (invoke "f64x2.le-in-block"))
+(assert_return (invoke "f64x2.gt-in-block"))
+(assert_return (invoke "f64x2.ge-in-block"))
+(assert_return (invoke "nested-f64x2.eq"))
+(assert_return (invoke "nested-f64x2.ne"))
+(assert_return (invoke "nested-f64x2.lt"))
+(assert_return (invoke "nested-f64x2.le"))
+(assert_return (invoke "nested-f64x2.gt"))
+(assert_return (invoke "nested-f64x2.ge"))
+(assert_return (invoke "as-param"))
diff --git a/test/core/simd/simd_f64x2_pmin_pmax.wast b/test/core/simd/simd_f64x2_pmin_pmax.wast
new file mode 100644
index 000000000..e8167b0e5
--- /dev/null
+++ b/test/core/simd/simd_f64x2_pmin_pmax.wast
@@ -0,0 +1,11676 @@
+;; Tests for f64x2 [pmin, pmax] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f64x2.pmin") (param v128 v128) (result v128) (f64x2.pmin (local.get 0) (local.get 1)))
+  (func (export "f64x2.pmax") (param v128 v128) (result v128) (f64x2.pmax (local.get 0) (local.get 1)))
+)
+
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f64x2.pmin (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.pmax (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f64x2.pmin-1st-arg-empty (result v128)
+      (f64x2.pmin (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.pmin-arg-empty (result v128)
+      (f64x2.pmin)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.pmax-1st-arg-empty (result v128)
+      (f64x2.pmax (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.pmax-arg-empty (result v128)
+      (f64x2.pmax)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_f64x2_rounding.wast b/test/core/simd/simd_f64x2_rounding.wast
new file mode 100644
index 000000000..f82c6d294
--- /dev/null
+++ b/test/core/simd/simd_f64x2_rounding.wast
@@ -0,0 +1,424 @@
+;; Tests for f64x2 [ceil, floor, trunc, nearest] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f64x2.ceil") (param v128) (result v128) (f64x2.ceil (local.get 0)))
+  (func (export "f64x2.floor") (param v128) (result v128) (f64x2.floor (local.get 0)))
+  (func (export "f64x2.trunc") (param v128) (result v128) (f64x2.trunc (local.get 0)))
+  (func (export "f64x2.nearest") (param v128) (result v128) (f64x2.nearest (local.get 0)))
+)
+
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.c000000000000p+2 0x1.c000000000000p+2))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 123456790.0 123456790.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0p+0 0x0p+0))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                     (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                     (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1p-1 0x1p-1))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                     (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1p+0 0x1p+0))
+                                     (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                     (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                     (v128.const f64x2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                     (v128.const f64x2 -0x1.c000000000000p+2 -0x1.c000000000000p+2))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                     (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                     (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 inf inf))
+                                     (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -inf -inf))
+                                     (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789 0123456789))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789e019 0123456789e019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789. 0123456789.))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                     (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                     (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 nan nan))
+                                     (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -nan -nan))
+                                     (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                     (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                     (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0p+0 0x0p+0))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                     (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                     (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1p-1 0x1p-1))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                     (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1p+0 0x1p+0))
+                                     (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                     (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                     (v128.const f64x2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                     (v128.const f64x2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                     (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                     (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 inf inf))
+                                     (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -inf -inf))
+                                     (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789 0123456789))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789e019 0123456789e019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789. 0123456789.))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                     (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                     (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 nan nan))
+                                     (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -nan -nan))
+                                     (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                     (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                     (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0p+0 0x0p+0))
+                                       (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                       (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                       (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                       (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1p-1 0x1p-1))
+                                       (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                       (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1p+0 0x1p+0))
+                                       (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                       (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                       (v128.const f64x2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                       (v128.const f64x2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                       (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                       (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                       (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                       (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 inf inf))
+                                       (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -inf -inf))
+                                       (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789 0123456789))
+                                       (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789e019 0123456789e019))
+                                       (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                       (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                       (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789. 0123456789.))
+                                       (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                       (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                       (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                       (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                       (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                       (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                       (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                       (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                       (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                       (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                       (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                       (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                       (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                       (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 nan nan))
+                                       (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -nan -nan))
+                                       (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                       (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                       (v128.const f64x2 nan:arithmetic nan:arithmetic))
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f64x2.ceil (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.floor (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.trunc (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.nearest (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f64x2.ceil-arg-empty (result v128)
+      (f64x2.ceil)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.floor-arg-empty (result v128)
+      (f64x2.floor)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.trunc-arg-empty (result v128)
+      (f64x2.trunc)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.nearest-arg-empty (result v128)
+      (f64x2.nearest)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_i16x8_arith.wast b/test/core/simd/simd_i16x8_arith.wast
new file mode 100644
index 000000000..3dc4d5ed7
--- /dev/null
+++ b/test/core/simd/simd_i16x8_arith.wast
@@ -0,0 +1,634 @@
+;; Tests for i16x8 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i16x8.add") (param v128 v128) (result v128) (i16x8.add (local.get 0) (local.get 1)))
+  (func (export "i16x8.sub") (param v128 v128) (result v128) (i16x8.sub (local.get 0) (local.get 1)))
+  (func (export "i16x8.mul") (param v128 v128) (result v128) (i16x8.mul (local.get 0) (local.get 1)))
+  (func (export "i16x8.neg") (param v128) (result v128) (i16x8.neg (local.get 0)))
+)
+
+
+;; i16x8.add
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i8x16 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i32x4 0x80008000 0x80008000 0x80008000 0x80008000))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i16x8 0x8000 0 0x8000 0 0x8000 0 0x8000 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i16x8 0x8000 0xbf80 0x8000 0xbf80 0x8000 0xbf80 0x8000 0xbf80))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i16x8 0x8000 0x3f80 0x8000 0x3f80 0x8000 0x3f80 0x8000 0x3f80))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i16x8 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i16x8 0x01 0xff81 0x01 0xff81 0x01 0xff81 0x01 0xff81))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i16x8 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                   (v128.const i16x8 0 3 6 9 12 15 18 21))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                   (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                   (v128.const i16x8 03_598 03_598 03_598 03_598 03_598 03_598 03_598 03_598))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                   (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678))
+                                   (v128.const i16x8 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac))
+
+;; i16x8.sub
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32764 32764 32764 32764 32764 32764 32764 32764))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32765 -32765 -32765 -32765 -32765 -32765 -32765 -32765))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i8x16 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i16x8 0x02 0x02 0x02 0x02 0x02 0x02 0x02 0x02))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i32x4 0x80008000 0x80008000 0x80008000 0x80008000))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i16x8 0x02 0x02 0x02 0x02 0x02 0x02 0x02 0x02))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i16x8 0x8000 0 0x8000 0 0x8000 0 0x8000 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i16x8 0x8000 0x4080 0x8000 0x4080 0x8000 0x4080 0x8000 0x4080))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i16x8 0x8000 0xc080 0x8000 0xc080 0x8000 0xc080 0x8000 0xc080))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i16x8 0x01 0x8081 0x01 0x8081 0x01 0x8081 0x01 0x8081))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i16x8 0x01 0x81 0x01 0x81 0x01 0x81 0x01 0x81))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i16x8 0x01 0x8041 0x01 0x8041 0x01 0x8041 0x01 0x8041))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                   (v128.const i16x8 0 0x02 0x04 0x06 0x08 0x0a 0x0c 0x0e))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                   (v128.const i16x8 0 -1 -2 -3 -4 -5 -6 -7))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789)
+                                   (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+                                   (v128.const i16x8 044_444 044_444 044_444 044_444 044_444 044_444 044_444 044_444))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678)
+                                   (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+                                   (v128.const i16x8 0x0_4444 0x0_4444 0x0_4444 0x0_4444 0x0_4444 0x0_4444 0x0_4444 0x0_4444))
+
+;; i16x8.mul
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x1000 0x1000 0x1000 0x1000 0x1000 0x1000 0x1000 0x1000)
+                                   (v128.const i8x16 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i32x4 0x00020002 0x00020002 0x00020002 0x00020002))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i16x8 0 0x7f80 0 0x7f80 0 0x7f80 0 0x7f80))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i16x8 0 0xff80 0 0xff80 0 0xff80 0 0xff80))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i16x8 0 0x7fc0 0 0x7fc0 0 0x7fc0 0 0x7fc0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                   (v128.const i16x8 0 0xffff 0xfffc 0xfff7 0xfff0 0xffe7 0xffdc 0xffcf))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                   (v128.const i16x8 0 0x02 0x08 0x12 0x20 0x32 0x48 0x62))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                   (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                   (v128.const i16x8 021_613 021_613 021_613 021_613 021_613 021_613 021_613 021_613))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                   (v128.const i16x8 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef))
+                                   (v128.const i16x8 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c))
+
+;; i16x8.neg
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+                                   (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -0x7fff -0x7fff -0x7fff -0x7fff -0x7fff -0x7fff -0x7fff -0x7fff))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.neg (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.add (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.sub (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.mul (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.neg-arg-empty (result v128)
+      (i16x8.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.add-1st-arg-empty (result v128)
+      (i16x8.add (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.add-arg-empty (result v128)
+      (i16x8.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub-1st-arg-empty (result v128)
+      (i16x8.sub (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub-arg-empty (result v128)
+      (i16x8.sub)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.mul-1st-arg-empty (result v128)
+      (i16x8.mul (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.mul-arg-empty (result v128)
+      (i16x8.mul)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (i16x8.add (i16x8.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-add") (param v128 v128 v128) (result v128)
+    (i16x8.mul (i16x8.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-sub") (param v128 v128 v128) (result v128)
+    (i16x8.mul (i16x8.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (i16x8.sub (i16x8.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (i16x8.add (i16x8.neg (local.get 0)) (local.get 1)))
+  (func (export "mul-neg") (param v128 v128) (result v128)
+    (i16x8.mul (i16x8.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (i16x8.sub (i16x8.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 2 4 6 8 10 12 14)
+                                 (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "mul-add" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                 (v128.const i16x8 0 4 8 12 16 20 24 28))
+(assert_return (invoke "mul-sub" (v128.const i16x8 0 2 4 6 8 10 12 14)
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                 (v128.const i16x8 0 1 4 9 16 25 36 49))
+(assert_return (invoke "sub-add" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 2 4 6 8 10 12 14)
+                                 (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "add-neg" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                 (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "mul-neg" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                 (v128.const i16x8 0 -2 -4 -6 -8 -10 -12 -14))
+(assert_return (invoke "sub-neg" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                 (v128.const i16x8 0 -2 -4 -6 -8 -10 -12 -14))
\ No newline at end of file
diff --git a/test/core/simd/simd_i16x8_arith2.wast b/test/core/simd/simd_i16x8_arith2.wast
new file mode 100644
index 000000000..454f598df
--- /dev/null
+++ b/test/core/simd/simd_i16x8_arith2.wast
@@ -0,0 +1,610 @@
+;; Tests for i16x8 [min_s, min_u, max_s, max_u, avgr_u, abs] operations.
+
+(module
+  (func (export "i16x8.min_s") (param v128 v128) (result v128) (i16x8.min_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.min_u") (param v128 v128) (result v128) (i16x8.min_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.max_s") (param v128 v128) (result v128) (i16x8.max_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.max_u") (param v128 v128) (result v128) (i16x8.max_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.avgr_u") (param v128 v128) (result v128) (i16x8.avgr_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.abs") (param v128) (result v128) (i16x8.abs (local.get 0)))
+  (func (export "i16x8.min_s_with_const_0") (result v128) (i16x8.min_s (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)))
+  (func (export "i16x8.min_s_with_const_1") (result v128) (i16x8.min_s (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0)))
+  (func (export "i16x8.min_u_with_const_2") (result v128) (i16x8.min_u (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)))
+  (func (export "i16x8.min_u_with_const_3") (result v128) (i16x8.min_u (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0)))
+  (func (export "i16x8.max_s_with_const_4") (result v128) (i16x8.max_s (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)))
+  (func (export "i16x8.max_s_with_const_5") (result v128) (i16x8.max_s (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0)))
+  (func (export "i16x8.max_u_with_const_6") (result v128) (i16x8.max_u (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)))
+  (func (export "i16x8.max_u_with_const_7") (result v128) (i16x8.max_u (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0)))
+  (func (export "i16x8.avgr_u_with_const_8") (result v128) (i16x8.avgr_u (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)))
+  (func (export "i16x8.avgr_u_with_const_9") (result v128) (i16x8.avgr_u (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0)))
+  (func (export "i16x8.abs_with_const_10") (result v128) (i16x8.abs (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.min_s_with_const_11") (param v128) (result v128) (i16x8.min_s (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.min_s_with_const_12") (param v128) (result v128) (i16x8.min_s (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3)))
+  (func (export "i16x8.min_u_with_const_13") (param v128) (result v128) (i16x8.min_u (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.min_u_with_const_14") (param v128) (result v128) (i16x8.min_u (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3)))
+  (func (export "i16x8.max_s_with_const_15") (param v128) (result v128) (i16x8.max_s (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.max_s_with_const_16") (param v128) (result v128) (i16x8.max_s (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3)))
+  (func (export "i16x8.max_u_with_const_17") (param v128) (result v128) (i16x8.max_u (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.max_u_with_const_18") (param v128) (result v128) (i16x8.max_u (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3)))
+  (func (export "i16x8.avgr_u_with_const_19") (param v128) (result v128) (i16x8.avgr_u (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.avgr_u_with_const_20") (param v128) (result v128) (i16x8.avgr_u (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3)))
+)
+
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)
+                                     (v128.const i16x8 0 0 -1 -1 0 0 -1 -1))
+                                     (v128.const i16x8 0 0 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+                                     (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 123 123 123 123 123 123 123 123)
+                                     (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)
+                                     (v128.const i16x8 0 0 -1 -1 0 0 -1 -1))
+                                     (v128.const i16x8 0 0 0 0 0 0 -1 -1))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 123 123 123 123 123 123 123 123)
+                                     (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)
+                                     (v128.const i16x8 0 0 -1 -1 0 0 -1 -1))
+                                     (v128.const i16x8 0 0 0 0 0 0 -1 -1))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 123 123 123 123 123 123 123 123)
+                                     (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)
+                                     (v128.const i16x8 0 0 -1 -1 0 0 -1 -1))
+                                     (v128.const i16x8 0 0 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+                                     (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 123 123 123 123 123 123 123 123)
+                                     (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                      (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                      (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)
+                                      (v128.const i16x8 0 0 -1 -1 0 0 -1 -1))
+                                      (v128.const i16x8 0 0 32768 32768 32768 32768 65535 65535))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                      (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                      (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                      (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                      (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                      (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                      (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                      (v128.const i16x8 128 128 128 128 128 128 128 128))
+                                      (v128.const i16x8 32832 32832 32832 32832 32832 32832 32832 32832))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                      (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                      (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                      (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                      (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 123 123 123 123 123 123 123 123)
+                                      (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                      (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                      (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                      (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i16x8 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+                                   (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000))
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                   (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3))
+                                   (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                   (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                   (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0))
+                                   (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+
+;; Const vs const
+(assert_return (invoke "i16x8.min_s_with_const_0") (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_s_with_const_1") (v128.const i16x8 0 0 1 1 1 1 0 0))
+(assert_return (invoke "i16x8.min_u_with_const_2") (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_u_with_const_3") (v128.const i16x8 0 0 1 1 1 1 0 0))
+(assert_return (invoke "i16x8.max_s_with_const_4") (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_s_with_const_5") (v128.const i16x8 3 3 2 2 2 2 3 3))
+(assert_return (invoke "i16x8.max_u_with_const_6") (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_u_with_const_7") (v128.const i16x8 3 3 2 2 2 2 3 3))
+(assert_return (invoke "i16x8.avgr_u_with_const_8") (v128.const i16x8 49152 49152 24576 24576 24576 24576 49152 49152))
+(assert_return (invoke "i16x8.avgr_u_with_const_9") (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.abs_with_const_10") (v128.const i16x8 32768 32768 32767 32767 16384 16384 1 1))
+
+;; Param vs const
+(assert_return (invoke "i16x8.min_s_with_const_11" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                                   (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_s_with_const_12" (v128.const i16x8 3 3 2 2 1 1 0 0))
+                                                   (v128.const i16x8 0 0 1 1 1 1 0 0))
+(assert_return (invoke "i16x8.min_u_with_const_13" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                                   (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_u_with_const_14" (v128.const i16x8 3 3 2 2 1 1 0 0))
+                                                   (v128.const i16x8 0 0 1 1 1 1 0 0))
+(assert_return (invoke "i16x8.max_s_with_const_15" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                                   (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_s_with_const_16" (v128.const i16x8 3 3 2 2 1 1 0 0))
+                                                   (v128.const i16x8 3 3 2 2 2 2 3 3))
+(assert_return (invoke "i16x8.max_u_with_const_17" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                                   (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_u_with_const_18" (v128.const i16x8 3 3 2 2 1 1 0 0))
+                                                   (v128.const i16x8 3 3 2 2 2 2 3 3))
+(assert_return (invoke "i16x8.avgr_u_with_const_19" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                                    (v128.const i16x8 49152 49152 24576 24576 24576 24576 49152 49152))
+(assert_return (invoke "i16x8.avgr_u_with_const_20" (v128.const i16x8 3 3 2 2 1 1 0 0))
+                                                    (v128.const i16x8 2 2 2 2 2 2 2 2))
+
+;; Test different lanes go through different if-then clauses
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)
+                                     (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                     (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 1 1 2 2 128 128)
+                                     (v128.const i16x8 0 0 2 2 1 1 128 128))
+                                     (v128.const i16x8 0 0 1 1 1 1 128 128))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)
+                                     (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                     (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 1 1 2 2 128 128)
+                                     (v128.const i16x8 0 0 2 2 1 1 128 128))
+                                     (v128.const i16x8 0 0 1 1 1 1 128 128))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)
+                                     (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                     (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 1 1 2 2 128 128)
+                                     (v128.const i16x8 0 0 2 2 1 1 128 128))
+                                     (v128.const i16x8 0 0 2 2 2 2 128 128))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)
+                                     (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                     (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 1 1 2 2 128 128)
+                                     (v128.const i16x8 0 0 2 2 1 1 128 128))
+                                     (v128.const i16x8 0 0 2 2 2 2 128 128))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)
+                                      (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                      (v128.const i16x8 49152 49152 24576 24576 24576 24576 49152 49152))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 1 1 2 2 128 128)
+                                      (v128.const i16x8 0 0 2 2 1 1 128 128))
+                                      (v128.const i16x8 0 0 2 2 2 2 128 128))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535))
+                                   (v128.const i16x8 32768 32768 32767 32767 16384 16384 1 1))
+
+;; Test opposite signs of zero
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)
+                                     (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                     (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)
+                                     (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                     (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)
+                                     (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                     (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)
+                                     (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                     (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)
+                                      (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)
+                                      (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+                                   (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                   (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+                                   (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                   (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+
+;; Unknown operators
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.avgr (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.avgr_s (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 1 1 1 1 1 1 1 1)))") "unknown operator")
+
+;; Type check
+(assert_invalid (module (func (result v128) (i16x8.min_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.min_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.max_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.max_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.avgr_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.abs (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.min_s-1st-arg-empty (result v128)
+      (i16x8.min_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.min_s-arg-empty (result v128)
+      (i16x8.min_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.min_u-1st-arg-empty (result v128)
+      (i16x8.min_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.min_u-arg-empty (result v128)
+      (i16x8.min_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.max_s-1st-arg-empty (result v128)
+      (i16x8.max_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.max_s-arg-empty (result v128)
+      (i16x8.max_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.max_u-1st-arg-empty (result v128)
+      (i16x8.max_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.max_u-arg-empty (result v128)
+      (i16x8.max_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.avgr_u-1st-arg-empty (result v128)
+      (i16x8.avgr_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.avgr_u-arg-empty (result v128)
+      (i16x8.avgr_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.abs-arg-empty (result v128)
+      (i16x8.abs)
+    )
+  )
+  "type mismatch"
+)
+
+;; Combination
+(module
+  (func (export "i16x8.min_s-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_s-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_s-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_s-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_s-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_s-i16x8.abs") (param v128 v128) (result v128) (i16x8.min_s (i16x8.abs (local.get 0))(local.get 1)))
+  (func (export "i16x8.abs-i16x8.min_s") (param v128 v128) (result v128) (i16x8.abs (i16x8.min_s (local.get 0) (local.get 1))))
+  (func (export "i16x8.min_u-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_u-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_u-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_u-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_u-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_u-i16x8.abs") (param v128 v128) (result v128) (i16x8.min_u (i16x8.abs (local.get 0))(local.get 1)))
+  (func (export "i16x8.abs-i16x8.min_u") (param v128 v128) (result v128) (i16x8.abs (i16x8.min_u (local.get 0) (local.get 1))))
+  (func (export "i16x8.max_s-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_s-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_s-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_s-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_s-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_s-i16x8.abs") (param v128 v128) (result v128) (i16x8.max_s (i16x8.abs (local.get 0))(local.get 1)))
+  (func (export "i16x8.abs-i16x8.max_s") (param v128 v128) (result v128) (i16x8.abs (i16x8.max_s (local.get 0) (local.get 1))))
+  (func (export "i16x8.max_u-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_u-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_u-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_u-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_u-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_u-i16x8.abs") (param v128 v128) (result v128) (i16x8.max_u (i16x8.abs (local.get 0))(local.get 1)))
+  (func (export "i16x8.abs-i16x8.max_u") (param v128 v128) (result v128) (i16x8.abs (i16x8.max_u (local.get 0) (local.get 1))))
+  (func (export "i16x8.avgr_u-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.avgr_u-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.avgr_u-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.avgr_u-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.avgr_u-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.avgr_u-i16x8.abs") (param v128 v128) (result v128) (i16x8.avgr_u (i16x8.abs (local.get 0))(local.get 1)))
+  (func (export "i16x8.abs-i16x8.avgr_u") (param v128 v128) (result v128) (i16x8.abs (i16x8.avgr_u (local.get 0) (local.get 1))))
+  (func (export "i16x8.abs-i16x8.abs") (param v128) (result v128) (i16x8.abs (i16x8.abs (local.get 0))))
+)
+
+(assert_return (invoke "i16x8.min_s-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_s-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_s-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_s-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_s-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_s-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.abs-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                               (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_u-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_u-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.abs-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                               (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_s-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_s-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_s-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_s-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_s-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_s-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                               (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                               (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_u-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_u-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_u-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_u-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_u-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_u-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                               (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                               (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.avgr_u-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                   (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                   (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.avgr_u-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.avgr_u-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.avgr_u-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.avgr_u-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.avgr_u-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.abs-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
diff --git a/test/core/simd/simd_i16x8_cmp.wast b/test/core/simd/simd_i16x8_cmp.wast
new file mode 100644
index 000000000..24068ce32
--- /dev/null
+++ b/test/core/simd/simd_i16x8_cmp.wast
@@ -0,0 +1,1901 @@
+
+;; Test all the i16x8 comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (i16x8.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (i16x8.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x v128) (param $y v128) (result v128) (i16x8.lt_s (local.get $x) (local.get $y)))
+  (func (export "lt_u") (param $x v128) (param $y v128) (result v128) (i16x8.lt_u (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x v128) (param $y v128) (result v128) (i16x8.le_s (local.get $x) (local.get $y)))
+  (func (export "le_u") (param $x v128) (param $y v128) (result v128) (i16x8.le_u (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x v128) (param $y v128) (result v128) (i16x8.gt_s (local.get $x) (local.get $y)))
+  (func (export "gt_u") (param $x v128) (param $y v128) (result v128) (i16x8.gt_u (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x v128) (param $y v128) (result v128) (i16x8.ge_s (local.get $x) (local.get $y)))
+  (func (export "ge_u") (param $x v128) (param $y v128) (result v128) (i16x8.ge_u (local.get $x) (local.get $y)))
+)
+
+
+;; eq
+
+;; i16x8.eq  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                            (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                            (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                            (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                            (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                            (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                            (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "eq" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                            (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                            (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                            (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "eq" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "eq" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                            (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                            (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                            (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                            (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                            (v128.const i16x8 -1 -1 0 0 0 0 -1 -1))
+
+;; i16x8.eq  (i16x8) (i8x16)
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                            (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                            (v128.const i16x8 0 0 -1 -1 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                            (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; i16x8.eq  (i16x8) (i32x4)
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                            (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 0 0 1 1 32768 32768)
+                            (v128.const i32x4 65535 0 1 32768))
+                            (v128.const i16x8 -1 0 -1 -1 -1 0 -1 0))
+(assert_return (invoke "eq" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                            (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                            (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                            (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; ne
+
+;; i16x8.ne  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                            (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                            (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                            (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                            (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                            (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                            (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "ne" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 255 255 255 255 255 255 255 255)
+                            (v128.const i16x8 255 255 255 255 255 255 255 255))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 255 255 255 255 0 0 0 0)
+                            (v128.const i16x8 255 255 255 255 0 0 0 0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0 0 0 0 255 255 255 255)
+                            (v128.const i16x8 0 0 0 0 255 255 255 255))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 255 32767 -0 0 1 2 65534 65535)
+                            (v128.const i16x8 255 32767 0 0 1 2 -2 -1))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "ne" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "ne" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                            (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                            (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 0x8081 0x8283 0xFDFE 0xFF00 0x0001 0x027F 0x80FD 0xFEFF)
+                            (v128.const i16x8 65279 33021 639 1 65280 65022 33411 32897))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 128 129 130 131 -0 255 32766 32767)
+                            (v128.const i16x8 32767 32766 255 -0 131 130 129 28))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.ne  (i16x8) (i8x16)
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                            (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                            (v128.const i16x8 -1 -1 0 0 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                            (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.ne  (i16x8) (i32x4)
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                            (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                            (v128.const i32x4 -128 0 1 255))
+                            (v128.const i16x8 0 -1 0 0 0 -1 0 -1))
+(assert_return (invoke "ne" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                            (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                            (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                            (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; lt_s
+
+;; i16x8.lt_s  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 255 255 255 255 0 0 0 0)
+                              (v128.const i16x8 255 255 255 255 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0 0 0 0 255 255 255 255)
+                              (v128.const i16x8 0 0 0 0 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 255 32767 -0 0 1 2 65534 65535)
+                              (v128.const i16x8 255 32767 0 0 1 2 -2 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 0 0 -1 0 0 0 0 -1))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x8081 0x8283 0xFDFE 0xFF00 0x0001 0x027F 0x80FD 0xFEFF)
+                              (v128.const i16x8 65279 33021 639 1 65280 65022 33411 32897))
+                              (v128.const i16x8 -1 0 -1 -1 0 0 -1 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 128 129 130 131 -0 255 32766 32767)
+                              (v128.const i16x8 32767 32766 255 -0 131 130 129 28))
+                              (v128.const i16x8 -1 -1 -1 0 -1 0 0 0))
+
+;; i16x8.lt_s  (i16x8) (i8x16)
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 -1 -1 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; i16x8.lt_s  (i16x8) (i32x4)
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 0 -1 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; lt_u
+
+;; i16x8.lt_u  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 255 255 255 255 0 0 0 0)
+                              (v128.const i16x8 255 255 255 255 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0 0 0 0 255 255 255 255)
+                              (v128.const i16x8 0 0 0 0 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 255 32767 -0 0 1 2 65534 65535)
+                              (v128.const i16x8 255 32767 0 0 1 2 -2 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 -1 -1 -1 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x8081 0x8283 0xFDFE 0xFF00 0x0001 0x027F 0x80FD 0xFEFF)
+                              (v128.const i16x8 65279 33021 639 1 65280 65022 33411 32897))
+                              (v128.const i16x8 -1 0 0 0 -1 -1 -1 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 128 129 130 131 -0 255 32766 32767)
+                              (v128.const i16x8 32767 32766 255 -0 131 130 129 28))
+                              (v128.const i16x8 -1 -1 -1 0 -1 0 0 0))
+
+;; i16x8.lt_u  (i16x8) (i8x16)
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.lt_u  (i16x8) (i32x4)
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 0 -1 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; le_s
+
+;; i16x8.le_s  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                              (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                              (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                              (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 0 0 -1 0 0 0 0 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "le_s" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 -1 -1))
+
+;; i16x8.le_s  (i16x8) (i8x16)
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 0 0 -1 -1 -1 -1 0 0))
+(assert_return (invoke "le_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; i16x8.le_s  (i16x8) (i32x4)
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 0 -1 0))
+(assert_return (invoke "le_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "le_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; le_u
+
+;; i16x8.le_u  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                              (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                              (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                              (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 -1 -1 -1 0 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 -1 -1 -1 0 -1 0 -1 -1))
+
+;; i16x8.le_u  (i16x8) (i8x16)
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 0 0 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.le_u  (i16x8) (i32x4)
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 0 -1 0))
+(assert_return (invoke "le_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb)
+                              (v128.const i16x8 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; gt_s
+
+;; i16x8.gt_s  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                              (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                              (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                              (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 -1 -1 0 -1 -1 -1 -1 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 0 0 0 0 -1 -1 0 0))
+
+;; i16x8.gt_s  (i16x8) (i8x16)
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 -1 -1 0 0 0 0 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.gt_s  (i16x8) (i32x4)
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 0 0 1 1 32768 32768)
+                              (v128.const i32x4 65535 0 1 32768))
+                              (v128.const i16x8 0 0 0 0 0 -1 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; gt_u
+
+;; i16x8.gt_u  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "eq" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                            (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                            (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                            (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 0 0 0 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 0 0 0 -1 0 -1 0 0))
+
+;; i16x8.gt_u  (i16x8) (i8x16)
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 -1 -1 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; i16x8.gt_u  (i16x8) (i32x4)
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 0 0 0 0 0 -1 0 -1))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; ge_s
+
+;; i16x8.ge_s  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                              (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                              (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                              (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 -1 -1 0 -1 -1 -1 -1 0))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 -1 -1 0 0 -1 -1 -1 -1))
+
+;; i16x8.ge_s  (i16x8) (i8x16)
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA)
+                              (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; i16x8.ge_s  (i16x8) (i32x4)
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 0 0 1 1 32768 32768)
+                              (v128.const i32x4 65535 0 1 32768))
+                              (v128.const i16x8 -1 0 -1 -1 -1 -1 -1 0))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; ge_u
+
+;; i16x8.ge_u  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                              (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                              (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                              (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 0 0 0 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 -1 -1 0 -1 0 -1 -1 -1))
+
+;; i16x8.ge_u  (i16x8) (i8x16)
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "ge_u" (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA)
+                              (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.ge_u  (i16x8) (i32x4)
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 0 0 1 1 32768 32768)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ge_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (i16x8.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.ge_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.gt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.le_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.lt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+
+
+;; combination
+
+(module (memory 1)
+  (func (export "eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "lt_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.lt_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "le_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.le_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "gt_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.gt_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ge_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.ge_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-eq")
+    (drop
+      (i16x8.eq
+        (i16x8.eq
+          (i16x8.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.eq
+          (i16x8.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ne")
+    (drop
+      (i16x8.ne
+        (i16x8.ne
+          (i16x8.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.ne
+          (i16x8.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-lt_s")
+    (drop
+      (i16x8.lt_s
+        (i16x8.lt_s
+          (i16x8.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.lt_s
+          (i16x8.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-le_u")
+    (drop
+      (i16x8.le_u
+        (i16x8.le_u
+          (i16x8.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.le_u
+          (i16x8.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-gt_u")
+    (drop
+      (i16x8.gt_u
+        (i16x8.gt_u
+          (i16x8.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.gt_u
+          (i16x8.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ge_s")
+    (drop
+      (i16x8.ge_s
+        (i16x8.ge_s
+          (i16x8.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.ge_s
+          (i16x8.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (i16x8.ge_u
+        (i16x8.eq
+          (i16x8.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.ne
+          (i16x8.gt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.lt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "eq-in-block"))
+(assert_return (invoke "ne-in-block"))
+(assert_return (invoke "lt_s-in-block"))
+(assert_return (invoke "le_u-in-block"))
+(assert_return (invoke "gt_u-in-block"))
+(assert_return (invoke "ge_s-in-block"))
+(assert_return (invoke "nested-eq"))
+(assert_return (invoke "nested-ne"))
+(assert_return (invoke "nested-lt_s"))
+(assert_return (invoke "nested-le_u"))
+(assert_return (invoke "nested-gt_u"))
+(assert_return (invoke "nested-ge_s"))
+(assert_return (invoke "as-param"))
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.eq-1st-arg-empty (result v128)
+      (i16x8.eq (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.eq-arg-empty (result v128)
+      (i16x8.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ne-1st-arg-empty (result v128)
+      (i16x8.ne (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ne-arg-empty (result v128)
+      (i16x8.ne)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.lt_s-1st-arg-empty (result v128)
+      (i16x8.lt_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.lt_s-arg-empty (result v128)
+      (i16x8.lt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.lt_u-1st-arg-empty (result v128)
+      (i16x8.lt_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.lt_u-arg-empty (result v128)
+      (i16x8.lt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.le_s-1st-arg-empty (result v128)
+      (i16x8.le_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.le_s-arg-empty (result v128)
+      (i16x8.le_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.le_u-1st-arg-empty (result v128)
+      (i16x8.le_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.le_u-arg-empty (result v128)
+      (i16x8.le_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.gt_s-1st-arg-empty (result v128)
+      (i16x8.gt_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.gt_s-arg-empty (result v128)
+      (i16x8.gt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.gt_u-1st-arg-empty (result v128)
+      (i16x8.gt_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.gt_u-arg-empty (result v128)
+      (i16x8.gt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ge_s-1st-arg-empty (result v128)
+      (i16x8.ge_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ge_s-arg-empty (result v128)
+      (i16x8.ge_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ge_u-1st-arg-empty (result v128)
+      (i16x8.ge_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ge_u-arg-empty (result v128)
+      (i16x8.ge_u)
+    )
+  )
+  "type mismatch"
+)
\ No newline at end of file
diff --git a/test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast b/test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast
new file mode 100644
index 000000000..c2267de9c
--- /dev/null
+++ b/test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast
@@ -0,0 +1,68 @@
+;; Tests for i16x8 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i16x8.extadd_pairwise_i8x16_s") (param v128) (result v128) (i16x8.extadd_pairwise_i8x16_s (local.get 0)))
+  (func (export "i16x8.extadd_pairwise_i8x16_u") (param v128) (result v128) (i16x8.extadd_pairwise_i8x16_u (local.get 0)))
+)
+
+
+;; i16x8.extadd_pairwise_i8x16_s
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                       (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                       (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                       (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+                                                       (v128.const i16x8 252 252 252 252 252 252 252 252))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                       (v128.const i16x8 -254 -254 -254 -254 -254 -254 -254 -254))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                       (v128.const i16x8 -256 -256 -256 -256 -256 -256 -256 -256))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                       (v128.const i16x8 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                       (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+
+;; i16x8.extadd_pairwise_i8x16_u
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                       (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                       (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                       (v128.const i16x8 510 510 510 510 510 510 510 510))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+                                                       (v128.const i16x8 252 252 252 252 252 252 252 252))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                       (v128.const i16x8 258 258 258 258 258 258 258 258))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                       (v128.const i16x8 256 256 256 256 256 256 256 256))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                       (v128.const i16x8 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                       (v128.const i16x8 510 510 510 510 510 510 510 510))
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.extadd_pairwise_i8x16_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extadd_pairwise_i8x16_u (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.extadd_pairwise_i8x16_s-arg-empty (result v128)
+      (i16x8.extadd_pairwise_i8x16_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extadd_pairwise_i8x16_u-arg-empty (result v128)
+      (i16x8.extadd_pairwise_i8x16_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_i16x8_extmul_i8x16.wast b/test/core/simd/simd_i16x8_extmul_i8x16.wast
new file mode 100644
index 000000000..cc8cf8f40
--- /dev/null
+++ b/test/core/simd/simd_i16x8_extmul_i8x16.wast
@@ -0,0 +1,404 @@
+;; Tests for i16x8 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i16x8.extmul_low_i8x16_s") (param v128 v128) (result v128) (i16x8.extmul_low_i8x16_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.extmul_high_i8x16_s") (param v128 v128) (result v128) (i16x8.extmul_high_i8x16_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.extmul_low_i8x16_u") (param v128 v128) (result v128) (i16x8.extmul_low_i8x16_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.extmul_high_i8x16_u") (param v128 v128) (result v128) (i16x8.extmul_high_i8x16_u (local.get 0) (local.get 1)))
+)
+
+
+;; i16x8.extmul_low_i8x16_s
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                                  (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                  (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                                  (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                  (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 4160 4160 4160 4160 4160 4160 4160 4160))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                                  (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 16129 16129 16129 16129 16129 16129 16129 16129))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                  (v128.const i16x8 16256 16256 16256 16256 16256 16256 16256 16256))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+
+;; i16x8.extmul_high_i8x16_s
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                   (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                   (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 4160 4160 4160 4160 4160 4160 4160 4160))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 16129 16129 16129 16129 16129 16129 16129 16129))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                   (v128.const i16x8 16256 16256 16256 16256 16256 16256 16256 16256))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+
+;; i16x8.extmul_low_i8x16_u
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                                  (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                  (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                                  (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                  (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 -28480 -28480 -28480 -28480 -28480 -28480 -28480 -28480))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 -28672 -28672 -28672 -28672 -28672 -28672 -28672 -28672))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 -28864 -28864 -28864 -28864 -28864 -28864 -28864 -28864))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -32386 -32386 -32386 -32386 -32386 -32386 -32386 -32386))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -32641 -32641 -32641 -32641 -32641 -32641 -32641 -32641))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 32640 32640 32640 32640 32640 32640 32640 32640))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                                  (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 16129 16129 16129 16129 16129 16129 16129 16129))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                  (v128.const i16x8 16512 16512 16512 16512 16512 16512 16512 16512))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 32385 32385 32385 32385 32385 32385 32385 32385))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 32640 32640 32640 32640 32640 32640 32640 32640))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                  (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+
+;; i16x8.extmul_high_i8x16_u
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                   (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                   (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 -28480 -28480 -28480 -28480 -28480 -28480 -28480 -28480))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 -28672 -28672 -28672 -28672 -28672 -28672 -28672 -28672))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 -28864 -28864 -28864 -28864 -28864 -28864 -28864 -28864))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -32386 -32386 -32386 -32386 -32386 -32386 -32386 -32386))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -32641 -32641 -32641 -32641 -32641 -32641 -32641 -32641))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 32640 32640 32640 32640 32640 32640 32640 32640))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 16129 16129 16129 16129 16129 16129 16129 16129))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                   (v128.const i16x8 16512 16512 16512 16512 16512 16512 16512 16512))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 32385 32385 32385 32385 32385 32385 32385 32385))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 32640 32640 32640 32640 32640 32640 32640 32640))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                   (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.extmul_low_i8x16_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extmul_high_i8x16_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extmul_low_i8x16_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extmul_high_i8x16_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.extmul_low_i8x16_s-1st-arg-empty (result v128)
+      (i16x8.extmul_low_i8x16_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_low_i8x16_s-arg-empty (result v128)
+      (i16x8.extmul_low_i8x16_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_high_i8x16_s-1st-arg-empty (result v128)
+      (i16x8.extmul_high_i8x16_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_high_i8x16_s-arg-empty (result v128)
+      (i16x8.extmul_high_i8x16_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_low_i8x16_u-1st-arg-empty (result v128)
+      (i16x8.extmul_low_i8x16_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_low_i8x16_u-arg-empty (result v128)
+      (i16x8.extmul_low_i8x16_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_high_i8x16_u-1st-arg-empty (result v128)
+      (i16x8.extmul_high_i8x16_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_high_i8x16_u-arg-empty (result v128)
+      (i16x8.extmul_high_i8x16_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_i16x8_q15mulr_sat_s.wast b/test/core/simd/simd_i16x8_q15mulr_sat_s.wast
new file mode 100644
index 000000000..2cea8cc74
--- /dev/null
+++ b/test/core/simd/simd_i16x8_q15mulr_sat_s.wast
@@ -0,0 +1,110 @@
+;; Tests for i16x8 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i16x8.q15mulr_sat_s") (param v128 v128) (result v128) (i16x8.q15mulr_sat_s (local.get 0) (local.get 1)))
+)
+
+
+;; i16x8.q15mulr_sat_s
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                             (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                             (v128.const i16x8 8192 8192 8192 8192 8192 8192 8192 8192))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                             (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                             (v128.const i16x8 8192 8192 8192 8192 8192 8192 8192 8192))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                             (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                             (v128.const i16x8 8192 8192 8192 8192 8192 8192 8192 8192))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                             (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                             (v128.const i16x8 8192 8192 8192 8192 8192 8192 8192 8192))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                             (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                             (v128.const i16x8 8193 8193 8193 8193 8193 8193 8193 8193))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                             (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                             (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                             (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                             (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                             (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                             (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.q15mulr_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.q15mulr_sat_s-1st-arg-empty (result v128)
+      (i16x8.q15mulr_sat_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.q15mulr_sat_s-arg-empty (result v128)
+      (i16x8.q15mulr_sat_s)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_i16x8_sat_arith.wast b/test/core/simd/simd_i16x8_sat_arith.wast
new file mode 100644
index 000000000..cea4ebbc7
--- /dev/null
+++ b/test/core/simd/simd_i16x8_sat_arith.wast
@@ -0,0 +1,742 @@
+;; Tests for i16x8 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i16x8.add_sat_s") (param v128 v128) (result v128) (i16x8.add_sat_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.add_sat_u") (param v128 v128) (result v128) (i16x8.add_sat_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.sub_sat_s") (param v128 v128) (result v128) (i16x8.sub_sat_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.sub_sat_u") (param v128 v128) (result v128) (i16x8.sub_sat_u (local.get 0) (local.get 1)))
+)
+
+
+;; i16x8.add_sat_s
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i16x8 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i16x8 0x01 0xff81 0x01 0xff81 0x01 0xff81 0x01 0xff81))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i16x8 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i16x8 0x01 0xffc1 0x01 0xffc1 0x01 0xffc1 0x01 0xffc1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                         (v128.const i16x8 0 3 6 9 12 15 18 21))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 032_123 032_123 032_123 032_123 032_123 032_123 032_123 032_123))
+                                         (v128.const i16x8 032_767 032_767 032_767 032_767 032_767 032_767 032_767 032_767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                         (v128.const i16x8 03_598 03_598 03_598 03_598 03_598 03_598 03_598 03_598))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                         (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678))
+                                         (v128.const i16x8 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                         (v128.const i16x8 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef))
+                                         (v128.const i16x8 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000))
+
+;; i16x8.add_sat_u
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32769 32769 32769 32769 32769 32769 32769 32769))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                         (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i16x8 0x8000 0xffff 0x8000 0xffff 0x8000 0xffff 0x8000 0xffff))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i16x8 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i16x8 0x01 0xff81 0x01 0xff81 0x01 0xff81 0x01 0xff81))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i16x8 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i16x8 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                         (v128.const i16x8 0 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                         (v128.const i16x8 0 3 6 9 12 15 18 21))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                         (v128.const i16x8 065_535 065_535 065_535 065_535 065_535 065_535 065_535 065_535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345))
+                                         (v128.const i16x8 065_535 065_535 065_535 065_535 065_535 065_535 065_535 065_535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                         (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678))
+                                         (v128.const i16x8 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                         (v128.const i16x8 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef))
+                                         (v128.const i16x8 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff))
+
+;; i16x8.sub_sat_s
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32764 32764 32764 32764 32764 32764 32764 32764))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32765 -32765 -32765 -32765 -32765 -32765 -32765 -32765))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i16x8 0x8000 0 0x8000 0 0x8000 0 0x8000 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i16x8 0x01 0x8081 0x01 0x8081 0x01 0x8081 0x01 0x8081))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i16x8 0x01 0x81 0x01 0x81 0x01 0x81 0x01 0x81))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i16x8 0x01 0x8041 0x01 0x8041 0x01 0x8041 0x01 0x8041))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i16x8 0x01 0x41 0x01 0x41 0x01 0x41 0x01 0x41))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                         (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                         (v128.const i16x8 0 -1 -2 -3 -4 -5 -6 -7))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                         (v128.const i16x8 021_092 021_092 021_092 021_092 021_092 021_092 021_092 021_092))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345))
+                                         (v128.const i16x8 024_690 024_690 024_690 024_690 024_690 024_690 024_690 024_690))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                         (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678))
+                                         (v128.const i16x8 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                         (v128.const i16x8 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234))
+                                         (v128.const i16x8 0xa2df 0xa2df 0xa2df 0xa2df 0xa2df 0xa2df 0xa2df 0xa2df))
+
+;; i16x8.sub_sat_u
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32764 32764 32764 32764 32764 32764 32764 32764))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i16x8 0x8000 0 0x8000 0 0x8000 0 0x8000 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i16x8 0x01 0 0x01 0 0x01 0 0x01 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i16x8 0x01 0 0x01 0 0x01 0 0x01 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i16x8 0x01 0 0x01 0 0x01 0 0x01 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i16x8 0x01 0 0x01 0 0x01 0 0x01 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789)
+                                         (v128.const i16x8 -12_345 -12_345 -12_345 -12_345 -12_345 -12_345 -12_345 -12_345))
+                                         (v128.const i16x8 03_598 03_598 03_598 03_598 03_598 03_598 03_598 03_598))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                         (v128.const i16x8 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef)
+                                         (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB))
+                                         (v128.const i16x8 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44))
+
+;; Malformed cases: non-existent op names
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.add_sat (v128.const i16x8 1 1 1 1 1 1 1 1) (v128.const i16x8 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.sub_sat (v128.const i16x8 1 1 1 1 1 1 1 1) (v128.const i16x8 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.mul_sat (v128.const i16x8 1 1 1 1 1 1 1 1) (v128.const i16x8 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.div_sat (v128.const i16x8 1 1 1 1 1 1 1 1) (v128.const i16x8 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.add_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.add_sat_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.sub_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.sub_sat_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.add_sat_s-1st-arg-empty (result v128)
+      (i16x8.add_sat_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.add_sat_s-arg-empty (result v128)
+      (i16x8.add_sat_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.add_sat_u-1st-arg-empty (result v128)
+      (i16x8.add_sat_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.add_sat_u-arg-empty (result v128)
+      (i16x8.add_sat_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub_sat_s-1st-arg-empty (result v128)
+      (i16x8.sub_sat_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub_sat_s-arg-empty (result v128)
+      (i16x8.sub_sat_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub_sat_u-1st-arg-empty (result v128)
+      (i16x8.sub_sat_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub_sat_u-arg-empty (result v128)
+      (i16x8.sub_sat_u)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "sat-add_s-sub_s") (param v128 v128 v128) (result v128)
+    (i16x8.add_sat_s (i16x8.sub_sat_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_s-sub_u") (param v128 v128 v128) (result v128)
+    (i16x8.add_sat_s (i16x8.sub_sat_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_u-sub_s") (param v128 v128 v128) (result v128)
+    (i16x8.add_sat_u (i16x8.sub_sat_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_u-sub_u") (param v128 v128 v128) (result v128)
+    (i16x8.add_sat_u (i16x8.sub_sat_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_s-neg") (param v128 v128) (result v128)
+    (i16x8.add_sat_s (i16x8.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-add_u-neg") (param v128 v128) (result v128)
+    (i16x8.add_sat_u (i16x8.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-sub_s-neg") (param v128 v128) (result v128)
+    (i16x8.sub_sat_s (i16x8.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-sub_u-neg") (param v128 v128) (result v128)
+    (i16x8.sub_sat_u (i16x8.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "sat-add_s-sub_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "sat-add_s-sub_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "sat-add_u-sub_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534))
+(assert_return (invoke "sat-add_u-sub_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "sat-add_s-neg" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                       (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                       (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "sat-add_u-neg" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                       (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                       (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "sat-sub_s-neg" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                       (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                       (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "sat-sub_u-neg" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                       (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                       (v128.const i16x8 1 1 1 1 1 1 1 1))
\ No newline at end of file
diff --git a/test/core/simd/simd_i32x4_arith.wast b/test/core/simd/simd_i32x4_arith.wast
new file mode 100644
index 000000000..f0e09b8bf
--- /dev/null
+++ b/test/core/simd/simd_i32x4_arith.wast
@@ -0,0 +1,634 @@
+;; Tests for i32x4 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i32x4.add") (param v128 v128) (result v128) (i32x4.add (local.get 0) (local.get 1)))
+  (func (export "i32x4.sub") (param v128 v128) (result v128) (i32x4.sub (local.get 0) (local.get 1)))
+  (func (export "i32x4.mul") (param v128 v128) (result v128) (i32x4.mul (local.get 0) (local.get 1)))
+  (func (export "i32x4.neg") (param v128) (result v128) (i32x4.neg (local.get 0)))
+)
+
+
+;; i32x4.add
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -1 -1 -1 -1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x3fffffff 0x3fffffff 0x3fffffff 0x3fffffff)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -0x3fffffff -0x3fffffff -0x3fffffff -0x3fffffff)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000001 -0x40000001 -0x40000001 -0x40000001))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i8x16 0 0 0 0x80 0 0 0 0x80 0 0 0 0x80 0 0 0 0x80))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i16x8 0 0x8000 0 0x8000 0 0x8000 0 0x8000))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i32x4 0xbf800000 0xbf800000 0xbf800000 0xbf800000))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i32x4 0x3f800000 0x3f800000 0x3f800000 0x3f800000))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i32x4 0x7f800001 0x7f800001 0x7f800001 0x7f800001))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i32x4 0xff800001 0xff800001 0xff800001 0xff800001))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i32x4 0x7fc00001 0x7fc00001 0x7fc00001 0x7fc00001))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 0xffffffff 0xfffffffe 0xfffffffd))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 2 4 6))
+                                   (v128.const i32x4 0 3 6 9))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                   (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                   (v128.const i32x4 02_469_135_780 02_469_135_780 02_469_135_780 02_469_135_780))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                                   (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                                   (v128.const i32x4 0x0_a2e0_2467 0x0_a2e0_2467 0x0_a2e0_2467 0x0_a2e0_2467))
+
+;; i32x4.sub
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -1 -1 -1 -1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483644 2147483644 2147483644 2147483644))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483645 2147483645 2147483645 2147483645))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483645 -2147483645 -2147483645 -2147483645))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x3fffffff 0x3fffffff 0x3fffffff 0x3fffffff)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -0x3fffffff -0x3fffffff -0x3fffffff -0x3fffffff)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000001 -0x40000001 -0x40000001 -0x40000001))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i8x16 0 0 0 0x80 0 0 0 0x80 0 0 0 0x80 0 0 0 0x80))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i16x8 0 0x8000 0 0x8000 0 0x8000 0 0x8000))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i32x4 0x02 0x02 0x02 0x02))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i32x4 0x40800000 0x40800000 0x40800000 0x40800000))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i32x4 0xc0800000 0xc0800000 0xc0800000 0xc0800000))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i32x4 0x80800001 0x80800001 0x80800001 0x80800001))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i32x4 0x00800001 0x00800001 0x00800001 0x00800001))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i32x4 0x80400001 0x80400001 0x80400001 0x80400001))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 0xffffffff 0xfffffffe 0xfffffffd))
+                                   (v128.const i32x4 0 0x02 0x04 0x06))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 2 4 6))
+                                   (v128.const i32x4 0 -1 -2 -3))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 03_214_567_890  03_214_567_890  03_214_567_890  03_214_567_890 )
+                                   (v128.const i32x4 01_234_567_890  01_234_567_890  01_234_567_890  01_234_567_890 ))
+                                   (v128.const i32x4 01_980_000_000 01_980_000_000 01_980_000_000 01_980_000_000))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                   (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                                   (v128.const i32x4 0x0_7e77_7777 0x0_7e77_7777 0x0_7e77_7777 0x0_7e77_7777))
+
+;; i32x4.mul
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -1 -1 -1 -1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483645 2147483645 2147483645 2147483645))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x3fffffff 0x3fffffff 0x3fffffff 0x3fffffff)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -0x3fffffff -0x3fffffff -0x3fffffff -0x3fffffff)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000001 -0x40000001 -0x40000001 -0x40000001))
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x10000000 0x10000000 0x10000000 0x10000000)
+                                   (v128.const i8x16 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i16x8 0 0x02 0 0x02 0 0x02 0 0x02))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i32x4 0x7f800000 0x7f800000 0x7f800000 0x7f800000))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i32x4 0xff800000 0xff800000 0xff800000 0xff800000))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i32x4 0x7fc00000 0x7fc00000 0x7fc00000 0x7fc00000))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 0xffffffff 0xfffffffe 0xfffffffd))
+                                   (v128.const i32x4 0 0xffffffff 0xfffffffc 0xfffffff7))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 2 4 6))
+                                   (v128.const i32x4 0 0x02 0x08 0x12))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                                   (v128.const i32x4 0_987_654_321 0_987_654_321 0_987_654_321 0_987_654_321))
+                                   (v128.const i32x4 04_227_814_277 04_227_814_277 04_227_814_277 04_227_814_277))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                                   (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                                   (v128.const i32x4 0x0_2a42_d208 0x0_2a42_d208 0x0_2a42_d208 0x0_2a42_d208))
+
+;; i32x4.neg
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+                                   (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -0x7fffffff -0x7fffffff -0x7fffffff -0x7fffffff))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i32x4 1 1 1 1))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.neg (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.add (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.sub (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.mul (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.neg-arg-empty (result v128)
+      (i32x4.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.add-1st-arg-empty (result v128)
+      (i32x4.add (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.add-arg-empty (result v128)
+      (i32x4.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.sub-1st-arg-empty (result v128)
+      (i32x4.sub (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.sub-arg-empty (result v128)
+      (i32x4.sub)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.mul-1st-arg-empty (result v128)
+      (i32x4.mul (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.mul-arg-empty (result v128)
+      (i32x4.mul)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (i32x4.add (i32x4.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-add") (param v128 v128 v128) (result v128)
+    (i32x4.mul (i32x4.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-sub") (param v128 v128 v128) (result v128)
+    (i32x4.mul (i32x4.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (i32x4.sub (i32x4.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (i32x4.add (i32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "mul-neg") (param v128 v128) (result v128)
+    (i32x4.mul (i32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (i32x4.sub (i32x4.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 2 4 6)
+                                 (v128.const i32x4 0 2 4 6))
+                                 (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "mul-add" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 2 2 2 2))
+                                 (v128.const i32x4 0 4 8 12))
+(assert_return (invoke "mul-sub" (v128.const i32x4 0 2 4 6)
+                                 (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 1 2 3))
+                                 (v128.const i32x4 0 1 4 9))
+(assert_return (invoke "sub-add" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 2 4 6)
+                                 (v128.const i32x4 0 2 4 6))
+                                 (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "add-neg" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 1 2 3))
+                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "mul-neg" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 2 2 2 2))
+                                 (v128.const i32x4 0 -2 -4 -6))
+(assert_return (invoke "sub-neg" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 1 2 3))
+                                 (v128.const i32x4 0 -2 -4 -6))
\ No newline at end of file
diff --git a/test/core/simd/simd_i32x4_arith2.wast b/test/core/simd/simd_i32x4_arith2.wast
new file mode 100644
index 000000000..63c3f4a42
--- /dev/null
+++ b/test/core/simd/simd_i32x4_arith2.wast
@@ -0,0 +1,494 @@
+;; Tests for i32x4 [min_s, min_u, max_s, max_u, abs] operations.
+
+(module
+  (func (export "i32x4.min_s") (param v128 v128) (result v128) (i32x4.min_s (local.get 0) (local.get 1)))
+  (func (export "i32x4.min_u") (param v128 v128) (result v128) (i32x4.min_u (local.get 0) (local.get 1)))
+  (func (export "i32x4.max_s") (param v128 v128) (result v128) (i32x4.max_s (local.get 0) (local.get 1)))
+  (func (export "i32x4.max_u") (param v128 v128) (result v128) (i32x4.max_u (local.get 0) (local.get 1)))
+  (func (export "i32x4.abs") (param v128) (result v128) (i32x4.abs (local.get 0)))
+  (func (export "i32x4.min_s_with_const_0") (result v128) (i32x4.min_s (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)))
+  (func (export "i32x4.min_s_with_const_1") (result v128) (i32x4.min_s (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0)))
+  (func (export "i32x4.min_u_with_const_2") (result v128) (i32x4.min_u (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)))
+  (func (export "i32x4.min_u_with_const_3") (result v128) (i32x4.min_u (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0)))
+  (func (export "i32x4.max_s_with_const_4") (result v128) (i32x4.max_s (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)))
+  (func (export "i32x4.max_s_with_const_5") (result v128) (i32x4.max_s (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0)))
+  (func (export "i32x4.max_u_with_const_6") (result v128) (i32x4.max_u (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)))
+  (func (export "i32x4.max_u_with_const_7") (result v128) (i32x4.max_u (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0)))
+  (func (export "i32x4.abs_with_const_8") (result v128) (i32x4.abs (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)))
+  (func (export "i32x4.min_s_with_const_9") (param v128) (result v128) (i32x4.min_s (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)))
+  (func (export "i32x4.min_s_with_const_10") (param v128) (result v128) (i32x4.min_s (local.get 0) (v128.const i32x4 0 1 2 3)))
+  (func (export "i32x4.min_u_with_const_11") (param v128) (result v128) (i32x4.min_u (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)))
+  (func (export "i32x4.min_u_with_const_12") (param v128) (result v128) (i32x4.min_u (local.get 0) (v128.const i32x4 0 1 2 3)))
+  (func (export "i32x4.max_s_with_const_13") (param v128) (result v128) (i32x4.max_s (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)))
+  (func (export "i32x4.max_s_with_const_14") (param v128) (result v128) (i32x4.max_s (local.get 0) (v128.const i32x4 0 1 2 3)))
+  (func (export "i32x4.max_u_with_const_15") (param v128) (result v128) (i32x4.max_u (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)))
+  (func (export "i32x4.max_u_with_const_16") (param v128) (result v128) (i32x4.max_u (local.get 0) (v128.const i32x4 0 1 2 3)))
+)
+
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0 0 0 0))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 -1 -1 -1 -1))
+                                     (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 -1 -1)
+                                     (v128.const i32x4 0 -1 0 -1))
+                                     (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 1 1 1 1)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 128 128 128 128))
+                                     (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 123 123 123 123)
+                                     (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i32x4 123 123 123 123))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0x80 0x80 0x80 0x80)
+                                     (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0 0 0 0))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 -1 -1 -1 -1))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 -1 -1)
+                                     (v128.const i32x4 0 -1 0 -1))
+                                     (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 1 1 1 1)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 128 128 128 128))
+                                     (v128.const i32x4 128 128 128 128))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 123 123 123 123)
+                                     (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i32x4 123 123 123 123))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0x80 0x80 0x80 0x80)
+                                     (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0 0 0 0))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 -1 -1 -1 -1))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 -1 -1)
+                                     (v128.const i32x4 0 -1 0 -1))
+                                     (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 1 1 1 1)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 128 128 128 128))
+                                     (v128.const i32x4 128 128 128 128))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 123 123 123 123)
+                                     (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i32x4 123 123 123 123))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0x80 0x80 0x80 0x80)
+                                     (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0 0 0 0))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 -1 -1 -1 -1))
+                                     (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 -1 -1)
+                                     (v128.const i32x4 0 -1 0 -1))
+                                     (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 1 1 1 1)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 128 128 128 128))
+                                     (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 123 123 123 123)
+                                     (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i32x4 123 123 123 123))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0x80 0x80 0x80 0x80)
+                                     (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i32x4 0x1 0x1 0x1 0x1))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+                                   (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000))
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+                                   (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -01_2_3 -01_2_3 -01_2_3 -01_2_3))
+                                   (v128.const i32x4 123 123 123 123))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 0x80 0x80 0x80 0x80))
+                                   (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0x80 -0x80 -0x80 -0x80))
+                                   (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                   (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0))
+                                   (v128.const i32x4 0x80 0x80 0x80 0x80))
+
+;; Const vs const
+(assert_return (invoke "i32x4.min_s_with_const_0") (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_s_with_const_1") (v128.const i32x4 0 1 1 0))
+(assert_return (invoke "i32x4.min_u_with_const_2") (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_u_with_const_3") (v128.const i32x4 0 1 1 0))
+(assert_return (invoke "i32x4.max_s_with_const_4") (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_s_with_const_5") (v128.const i32x4 3 2 2 3))
+(assert_return (invoke "i32x4.max_u_with_const_6") (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_u_with_const_7") (v128.const i32x4 3 2 2 3))
+(assert_return (invoke "i32x4.abs_with_const_8") (v128.const i32x4 2147483648 2147483647 1073741824 1))
+
+;; Param vs const
+(assert_return (invoke "i32x4.min_s_with_const_9" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                                  (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_s_with_const_10" (v128.const i32x4 3 2 1 0))
+                                                   (v128.const i32x4 0 1 1 0))
+(assert_return (invoke "i32x4.min_u_with_const_11" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                                   (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_u_with_const_12" (v128.const i32x4 3 2 1 0))
+                                                   (v128.const i32x4 0 1 1 0))
+(assert_return (invoke "i32x4.max_s_with_const_13" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                                   (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_s_with_const_14" (v128.const i32x4 3 2 1 0))
+                                                   (v128.const i32x4 3 2 2 3))
+(assert_return (invoke "i32x4.max_u_with_const_15" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                                   (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_u_with_const_16" (v128.const i32x4 3 2 1 0))
+                                                   (v128.const i32x4 3 2 2 3))
+
+;; Test different lanes go through different if-then clauses
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)
+                                     (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                     (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 1 2 128)
+                                     (v128.const i32x4 0 2 1 128))
+                                     (v128.const i32x4 0 1 1 128))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)
+                                     (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                     (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 1 2 128)
+                                     (v128.const i32x4 0 2 1 128))
+                                     (v128.const i32x4 0 1 1 128))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)
+                                     (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                     (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 1 2 128)
+                                     (v128.const i32x4 0 2 1 128))
+                                     (v128.const i32x4 0 2 2 128))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)
+                                     (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                     (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 1 2 128)
+                                     (v128.const i32x4 0 2 1 128))
+                                     (v128.const i32x4 0 2 2 128))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295))
+                                   (v128.const i32x4 2147483648 2147483647 1073741824 1))
+
+;; Test opposite signs of zero
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 -0 -0 +0 +0)
+                                     (v128.const i32x4 +0 0 -0 0))
+                                     (v128.const i32x4 -0 -0 +0 +0))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 -0 -0 -0 -0)
+                                     (v128.const i32x4 +0 +0 +0 +0))
+                                     (v128.const i32x4 -0 -0 -0 -0))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 -0 -0 +0 +0)
+                                     (v128.const i32x4 +0 0 -0 0))
+                                     (v128.const i32x4 -0 -0 +0 +0))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 -0 -0 -0 -0)
+                                     (v128.const i32x4 +0 +0 +0 +0))
+                                     (v128.const i32x4 -0 -0 -0 -0))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 -0 -0 +0 +0)
+                                     (v128.const i32x4 +0 0 -0 0))
+                                     (v128.const i32x4 -0 -0 +0 +0))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 -0 -0 -0 -0)
+                                     (v128.const i32x4 +0 +0 +0 +0))
+                                     (v128.const i32x4 -0 -0 -0 -0))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 -0 -0 +0 +0)
+                                     (v128.const i32x4 +0 0 -0 0))
+                                     (v128.const i32x4 -0 -0 +0 +0))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 -0 -0 -0 -0)
+                                     (v128.const i32x4 +0 +0 +0 +0))
+                                     (v128.const i32x4 -0 -0 -0 -0))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0 -0 +0 +0))
+                                   (v128.const i32x4 -0 -0 +0 +0))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 +0 0 -0 0))
+                                   (v128.const i32x4 +0 0 -0 0))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0 -0 -0 -0))
+                                   (v128.const i32x4 -0 -0 -0 -0))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 +0 +0 +0 +0))
+                                   (v128.const i32x4 +0 +0 +0 +0))
+
+;; Unknown operators
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.min_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.min_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.max_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.max_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.min_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.min_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.max_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.max_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.min_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.min_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.max_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.max_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+
+;; Type check
+(assert_invalid (module (func (result v128) (i32x4.min_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.min_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.max_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.max_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.abs (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.min_s-1st-arg-empty (result v128)
+      (i32x4.min_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.min_s-arg-empty (result v128)
+      (i32x4.min_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.min_u-1st-arg-empty (result v128)
+      (i32x4.min_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.min_u-arg-empty (result v128)
+      (i32x4.min_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.max_s-1st-arg-empty (result v128)
+      (i32x4.max_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.max_s-arg-empty (result v128)
+      (i32x4.max_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.max_u-1st-arg-empty (result v128)
+      (i32x4.max_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.max_u-arg-empty (result v128)
+      (i32x4.max_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.abs-arg-empty (result v128)
+      (i32x4.abs)
+    )
+  )
+  "type mismatch"
+)
+
+;; Combination
+(module
+  (func (export "i32x4.min_s-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_s-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_s-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_s-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_s-i32x4.abs") (param v128 v128) (result v128) (i32x4.min_s (i32x4.abs (local.get 0))(local.get 1)))
+  (func (export "i32x4.abs-i32x4.min_s") (param v128 v128) (result v128) (i32x4.abs (i32x4.min_s (local.get 0) (local.get 1))))
+  (func (export "i32x4.min_u-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_u-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_u-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_u-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_u-i32x4.abs") (param v128 v128) (result v128) (i32x4.min_u (i32x4.abs (local.get 0))(local.get 1)))
+  (func (export "i32x4.abs-i32x4.min_u") (param v128 v128) (result v128) (i32x4.abs (i32x4.min_u (local.get 0) (local.get 1))))
+  (func (export "i32x4.max_s-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_s-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_s-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_s-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_s-i32x4.abs") (param v128 v128) (result v128) (i32x4.max_s (i32x4.abs (local.get 0))(local.get 1)))
+  (func (export "i32x4.abs-i32x4.max_s") (param v128 v128) (result v128) (i32x4.abs (i32x4.max_s (local.get 0) (local.get 1))))
+  (func (export "i32x4.max_u-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_u-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_u-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_u-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_u-i32x4.abs") (param v128 v128) (result v128) (i32x4.max_u (i32x4.abs (local.get 0))(local.get 1)))
+  (func (export "i32x4.abs-i32x4.max_u") (param v128 v128) (result v128) (i32x4.abs (i32x4.max_u (local.get 0) (local.get 1))))
+  (func (export "i32x4.abs-i32x4.abs") (param v128) (result v128) (i32x4.abs (i32x4.abs (local.get 0))))
+)
+
+(assert_return (invoke "i32x4.min_s-i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_s-i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_s-i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_s-i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_s-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1)
+                                               (v128.const i32x4 0 0 0 0))
+                                               (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.abs-i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                               (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_u-i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_u-i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_u-i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_u-i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_u-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1)
+                                               (v128.const i32x4 0 0 0 0))
+                                               (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.abs-i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                               (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_s-i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_s-i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_s-i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_s-i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_s-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1)
+                                               (v128.const i32x4 0 0 0 0))
+                                               (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs-i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                               (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_u-i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_u-i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_u-i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_u-i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_u-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1)
+                                               (v128.const i32x4 0 0 0 0))
+                                               (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs-i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                               (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1))
+                                             (v128.const i32x4 1 1 1 1))
diff --git a/test/core/simd/simd_i32x4_cmp.wast b/test/core/simd/simd_i32x4_cmp.wast
new file mode 100644
index 000000000..fca45ab96
--- /dev/null
+++ b/test/core/simd/simd_i32x4_cmp.wast
@@ -0,0 +1,1920 @@
+
+;; Test all the i32x4 comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (i32x4.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (i32x4.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x v128) (param $y v128) (result v128) (i32x4.lt_s (local.get $x) (local.get $y)))
+  (func (export "lt_u") (param $x v128) (param $y v128) (result v128) (i32x4.lt_u (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x v128) (param $y v128) (result v128) (i32x4.le_s (local.get $x) (local.get $y)))
+  (func (export "le_u") (param $x v128) (param $y v128) (result v128) (i32x4.le_u (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x v128) (param $y v128) (result v128) (i32x4.gt_s (local.get $x) (local.get $y)))
+  (func (export "gt_u") (param $x v128) (param $y v128) (result v128) (i32x4.gt_u (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x v128) (param $y v128) (result v128) (i32x4.ge_s (local.get $x) (local.get $y)))
+  (func (export "ge_u") (param $x v128) (param $y v128) (result v128) (i32x4.ge_u (local.get $x) (local.get $y)))
+)
+
+
+;; eq
+
+;; i32x4.eq  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                            (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                            (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                            (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                            (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                            (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                            (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "eq" (v128.const i32x4 -1 -1 -1 -1)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 0 0)
+                            (v128.const i32x4 4294967295 4294967295 0 0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0 0 4294967295 4294967295)
+                            (v128.const i32x4 0 0 4294967295 4294967295))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                            (v128.const i32x4 2147483649 -1 0 -1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "eq" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "eq" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                            (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                            (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                            (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i32x4 2147483648 2147483647 0 -1)
+                            (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                            (v128.const i32x4 -1 0 0 0))
+
+;; i32x4.eq  (i32x4) (i8x16)
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 -8323200 0 1 4294967295)
+                            (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                            (v128.const i32x4 0 -1 0 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                            (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                            (v128.const i32x4 0 0 0 0))
+
+;; i32x4.eq  (i32x4) (i16x8)
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                            (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 0 1 65535)
+                            (v128.const i16x8 65535 65535 0 0 1 0 65535 65535))
+                            (v128.const i32x4 -1 -1 -1 0))
+(assert_return (invoke "eq" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                            (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                            (v128.const i32x4 123456789 123456789 123456789 123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                            (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; ne
+
+;; i32x4.ne  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                            (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                            (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                            (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                            (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                            (v128.const i32x4 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                            (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                            (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i32x4 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "ne" (v128.const i32x4 -1 -1 -1 -1)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 0 0)
+                            (v128.const i32x4 4294967295 4294967295 0 0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0 0 4294967295 4294967295)
+                            (v128.const i32x4 0 0 4294967295 4294967295))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                            (v128.const i32x4 2147483649 -1 0 -1))
+                            (v128.const i32x4 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "ne" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i32x4 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "ne" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                            (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                            (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                            (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 2147483648 2147483647 0 -1)
+                            (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                            (v128.const i32x4 0 -1 -1 -1))
+
+;; i32x4.ne  (i32x4) (i8x16)
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 -8323200 0 1 4294967295)
+                            (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                            (v128.const i32x4 -1 0 -1 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                            (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.ne  (i32x4) (i16x8)
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                            (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 -128 0 1 255)
+                            (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                            (v128.const i32x4 -1 0 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                            (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                            (v128.const i32x4 123456789 123456789 123456789 123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                            (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                            (v128.const i32x4 0 0 0 0))
+
+;; lt_s
+
+;; i32x4.lt_s  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_s" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_s" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 0 0 0 -1))
+
+;; i32x4.lt_s  (i32x4) (i8x16)
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 0 0 -1 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 0 0 0 0))
+
+;; i32x4.lt_s  (i32x4) (i16x8)
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                              (v128.const i32x4 -0x6f543210 -0x6f543210 -0x6f543210 -0x6f543210))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; lt_u
+
+;; i32x4.lt_u  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_u" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_u" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 0 -1 -1 0))
+
+;; i32x4.lt_u  (i32x4) (i8x16)
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 0 0 -1 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.lt_u  (i32x4) (i16x8)
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                              (v128.const i32x4 -0x6f543210 -0x6f543210 -0x6f543210 -0x6f543210))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; le_s
+
+;; i32x4.le_s  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_s" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_s" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "le_s" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 -1 0 0 -1))
+
+;; i32x4.le_s  (i32x4)(i8x16)
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 0 0 0 0))
+
+;; i32x4.le_s  (i32x4) (i16x8)
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                              (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; le_u
+
+;; i32x4.le_u  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_u" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_u" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "le_u" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "le_u" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "le_u" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 -1 -1 -1 0))
+
+;; i32x4.le_u  (i32x4) (i8x16)
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.le_u  (i32x4) (i16x8)
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                              (v128.const i32x4 0x90ABcdef 0x90ABcdef 0x90ABcdef 0x90ABcdef))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; gt_s
+
+;; i32x4.gt_s  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_s" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_s" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 -1 -1 -1 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 0 -1 -1 0))
+
+;; i32x4.gt_s  (i32x4) (i8x16)
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.gt_s  (i32x4) (i16x8)
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 65535 0 1 32768)
+                              (v128.const i16x8 65535 65535 0 0 1 1 32768 32768))
+                              (v128.const i32x4 -1 0 0 -1))
+(assert_return (invoke "gt_s" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                              (v128.const i32x4 -0x6f543211 -0x6f543211 -0x6f543211 -0x6f543211))
+                              (v128.const i32x4 0 0 0 0))
+
+;; gt_u
+
+;; i32x4.gt_u  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_u" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_u" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 0 0 0 -1))
+
+;; i32x4.gt_u  (i32x4) (i8x16)
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 0 0 0 0))
+
+;; i32x4.gt_u  (i32x4) (i16x8)
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                              (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                              (v128.const i32x4 0 0 0 0))
+
+;; ge_s
+
+;; i32x4.ge_s  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_s" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_s" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 -1 -1 -1 0))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 -1 -1 -1 0))
+
+;; i32x4.ge_s  (i32x4) (i8x16)
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 -1 -1 0 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.ge_s  (i32x4) (i16x8)
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 65535 0 1 32768)
+                              (v128.const i16x8 65535 65535 0 0 1 1 32768 32768))
+                              (v128.const i32x4 -1 -1 0 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                              (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; ge_u
+
+;; i32x4.ge_u  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_u" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_u" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 -1 0 0 -1))
+
+;; i32x4.ge_u  (i32x4) (i8x16)
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 -1 -1 0 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.ge_u  (i32x4) (i16x8)
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 65535 65535 0 0 1 1 32768 32768))
+                              (v128.const i32x4 0 -1 0 0))
+(assert_return (invoke "ge_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                              (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (i32x4.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.ge_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.gt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.le_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.lt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+
+
+;; combination
+
+(module (memory 1)
+  (func (export "eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "lt_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.lt_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "le_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.le_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "gt_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.gt_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ge_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.ge_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-eq")
+    (drop
+      (i32x4.eq
+        (i32x4.eq
+          (i32x4.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.eq
+          (i32x4.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ne")
+    (drop
+      (i32x4.ne
+        (i32x4.ne
+          (i32x4.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.ne
+          (i32x4.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-lt_s")
+    (drop
+      (i32x4.lt_s
+        (i32x4.lt_s
+          (i32x4.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.lt_s
+          (i32x4.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-le_u")
+    (drop
+      (i32x4.le_u
+        (i32x4.le_u
+          (i32x4.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.le_u
+          (i32x4.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-gt_u")
+    (drop
+      (i32x4.gt_u
+        (i32x4.gt_u
+          (i32x4.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.gt_u
+          (i32x4.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ge_s")
+    (drop
+      (i32x4.ge_s
+        (i32x4.ge_s
+          (i32x4.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.ge_s
+          (i32x4.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (i32x4.ge_u
+        (i32x4.eq
+          (i32x4.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.ne
+          (i32x4.gt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.lt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "eq-in-block"))
+(assert_return (invoke "ne-in-block"))
+(assert_return (invoke "lt_s-in-block"))
+(assert_return (invoke "le_u-in-block"))
+(assert_return (invoke "gt_u-in-block"))
+(assert_return (invoke "ge_s-in-block"))
+(assert_return (invoke "nested-eq"))
+(assert_return (invoke "nested-ne"))
+(assert_return (invoke "nested-lt_s"))
+(assert_return (invoke "nested-le_u"))
+(assert_return (invoke "nested-gt_u"))
+(assert_return (invoke "nested-ge_s"))
+(assert_return (invoke "as-param"))
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.eq-1st-arg-empty (result v128)
+      (i32x4.eq (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.eq-arg-empty (result v128)
+      (i32x4.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ne-1st-arg-empty (result v128)
+      (i32x4.ne (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ne-arg-empty (result v128)
+      (i32x4.ne)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.lt_s-1st-arg-empty (result v128)
+      (i32x4.lt_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.lt_s-arg-empty (result v128)
+      (i32x4.lt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.lt_u-1st-arg-empty (result v128)
+      (i32x4.lt_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.lt_u-arg-empty (result v128)
+      (i32x4.lt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.le_s-1st-arg-empty (result v128)
+      (i32x4.le_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.le_s-arg-empty (result v128)
+      (i32x4.le_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.le_u-1st-arg-empty (result v128)
+      (i32x4.le_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.le_u-arg-empty (result v128)
+      (i32x4.le_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.gt_s-1st-arg-empty (result v128)
+      (i32x4.gt_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.gt_s-arg-empty (result v128)
+      (i32x4.gt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.gt_u-1st-arg-empty (result v128)
+      (i32x4.gt_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.gt_u-arg-empty (result v128)
+      (i32x4.gt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ge_s-1st-arg-empty (result v128)
+      (i32x4.ge_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ge_s-arg-empty (result v128)
+      (i32x4.ge_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ge_u-1st-arg-empty (result v128)
+      (i32x4.ge_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ge_u-arg-empty (result v128)
+      (i32x4.ge_u)
+    )
+  )
+  "type mismatch"
+)
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.eq (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ne (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.lt_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.lt_u (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.le_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.le_u (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.gt_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.gt_u (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ge_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ge_u (local.get $x) (local.get $y)))") "unknown operator")
+
diff --git a/test/core/simd/simd_i32x4_dot_i16x8.wast b/test/core/simd/simd_i32x4_dot_i16x8.wast
new file mode 100644
index 000000000..b41de74d0
--- /dev/null
+++ b/test/core/simd/simd_i32x4_dot_i16x8.wast
@@ -0,0 +1,110 @@
+;; Tests for i32x4 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i32x4.dot_i16x8_s") (param v128 v128) (result v128) (i32x4.dot_i16x8_s (local.get 0) (local.get 1)))
+)
+
+
+;; i32x4.dot_i16x8_s
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                           (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                           (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                           (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                           (v128.const i32x4 536838144 536838144 536838144 536838144))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                           (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                           (v128.const i32x4 536870912 536870912 536870912 536870912))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                           (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                           (v128.const i32x4 536838144 536838144 536838144 536838144))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                           (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                           (v128.const i32x4 536870912 536870912 536870912 536870912))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                           (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                           (v128.const i32x4 536903680 536903680 536903680 536903680))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 65530 65530 65530 65530))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 65532 65532 65532 65532))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 -65536 -65536 -65536 -65536))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 65532 65532 65532 65532))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 65534 65534 65534 65534))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 65536 65536 65536 65536))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                           (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                           (v128.const i32x4 2147352578 2147352578 2147352578 2147352578))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                           (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                           (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                           (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                           (v128.const i32x4 2147418112 2147418112 2147418112 2147418112))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                           (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                           (v128.const i32x4 -65534 -65534 -65534 -65534))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                           (v128.const i32x4 65536 65536 65536 65536))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                           (v128.const i32x4 2 2 2 2))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.dot_i16x8_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.dot_i16x8_s-1st-arg-empty (result v128)
+      (i32x4.dot_i16x8_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.dot_i16x8_s-arg-empty (result v128)
+      (i32x4.dot_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast b/test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast
new file mode 100644
index 000000000..2d1682d40
--- /dev/null
+++ b/test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast
@@ -0,0 +1,68 @@
+;; Tests for i32x4 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i32x4.extadd_pairwise_i16x8_s") (param v128) (result v128) (i32x4.extadd_pairwise_i16x8_s (local.get 0)))
+  (func (export "i32x4.extadd_pairwise_i16x8_u") (param v128) (result v128) (i32x4.extadd_pairwise_i16x8_u (local.get 0)))
+)
+
+
+;; i32x4.extadd_pairwise_i16x8_s
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                       (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                       (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                       (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+                                                       (v128.const i32x4 65532 65532 65532 65532))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                       (v128.const i32x4 -65534 -65534 -65534 -65534))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                       (v128.const i32x4 -65536 -65536 -65536 -65536))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                       (v128.const i32x4 65534 65534 65534 65534))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                       (v128.const i32x4 -2 -2 -2 -2))
+
+;; i32x4.extadd_pairwise_i16x8_u
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                       (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                       (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                       (v128.const i32x4 131070 131070 131070 131070))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+                                                       (v128.const i32x4 65532 65532 65532 65532))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                       (v128.const i32x4 65538 65538 65538 65538))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                       (v128.const i32x4 65536 65536 65536 65536))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                       (v128.const i32x4 65534 65534 65534 65534))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                       (v128.const i32x4 131070 131070 131070 131070))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.extadd_pairwise_i16x8_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extadd_pairwise_i16x8_u (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.extadd_pairwise_i16x8_s-arg-empty (result v128)
+      (i32x4.extadd_pairwise_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extadd_pairwise_i16x8_u-arg-empty (result v128)
+      (i32x4.extadd_pairwise_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_i32x4_extmul_i16x8.wast b/test/core/simd/simd_i32x4_extmul_i16x8.wast
new file mode 100644
index 000000000..f04db6770
--- /dev/null
+++ b/test/core/simd/simd_i32x4_extmul_i16x8.wast
@@ -0,0 +1,404 @@
+;; Tests for i32x4 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i32x4.extmul_low_i16x8_s") (param v128 v128) (result v128) (i32x4.extmul_low_i16x8_s (local.get 0) (local.get 1)))
+  (func (export "i32x4.extmul_high_i16x8_s") (param v128 v128) (result v128) (i32x4.extmul_high_i16x8_s (local.get 0) (local.get 1)))
+  (func (export "i32x4.extmul_low_i16x8_u") (param v128 v128) (result v128) (i32x4.extmul_low_i16x8_u (local.get 0) (local.get 1)))
+  (func (export "i32x4.extmul_high_i16x8_u") (param v128 v128) (result v128) (i32x4.extmul_high_i16x8_u (local.get 0) (local.get 1)))
+)
+
+
+;; i32x4.extmul_low_i16x8_s
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                  (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                  (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 268451840 268451840 268451840 268451840))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 32765 32765 32765 32765))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                                  (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 1073676289 1073676289 1073676289 1073676289))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                  (v128.const i32x4 1073709056 1073709056 1073709056 1073709056))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                  (v128.const i32x4 1 1 1 1))
+
+;; i32x4.extmul_high_i16x8_s
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                   (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                   (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 268451840 268451840 268451840 268451840))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 32765 32765 32765 32765))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 1073676289 1073676289 1073676289 1073676289))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                   (v128.const i32x4 1073709056 1073709056 1073709056 1073709056))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                   (v128.const i32x4 1 1 1 1))
+
+;; i32x4.extmul_low_i16x8_u
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -131071 -131071 -131071 -131071))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                  (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                  (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 -1878999040 -1878999040 -1878999040 -1878999040))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 -1879048192 -1879048192 -1879048192 -1879048192))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 -1879097344 -1879097344 -1879097344 -1879097344))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 32765 32765 32765 32765))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -2147385346 -2147385346 -2147385346 -2147385346))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -2147450881 -2147450881 -2147450881 -2147450881))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 2147450880 2147450880 2147450880 2147450880))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                                  (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 1073676289 1073676289 1073676289 1073676289))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                  (v128.const i32x4 1073774592 1073774592 1073774592 1073774592))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -131071 -131071 -131071 -131071))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 2147385345 2147385345 2147385345 2147385345))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 2147450880 2147450880 2147450880 2147450880))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                  (v128.const i32x4 -131071 -131071 -131071 -131071))
+
+;; i32x4.extmul_high_i16x8_u
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -131071 -131071 -131071 -131071))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                   (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                   (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 -1878999040 -1878999040 -1878999040 -1878999040))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 -1879048192 -1879048192 -1879048192 -1879048192))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 -1879097344 -1879097344 -1879097344 -1879097344))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 32765 32765 32765 32765))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -2147385346 -2147385346 -2147385346 -2147385346))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -2147450881 -2147450881 -2147450881 -2147450881))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 2147450880 2147450880 2147450880 2147450880))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 1073676289 1073676289 1073676289 1073676289))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                   (v128.const i32x4 1073774592 1073774592 1073774592 1073774592))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -131071 -131071 -131071 -131071))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 2147385345 2147385345 2147385345 2147385345))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 2147450880 2147450880 2147450880 2147450880))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                   (v128.const i32x4 -131071 -131071 -131071 -131071))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.extmul_low_i16x8_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extmul_high_i16x8_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extmul_low_i16x8_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extmul_high_i16x8_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.extmul_low_i16x8_s-1st-arg-empty (result v128)
+      (i32x4.extmul_low_i16x8_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_low_i16x8_s-arg-empty (result v128)
+      (i32x4.extmul_low_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_high_i16x8_s-1st-arg-empty (result v128)
+      (i32x4.extmul_high_i16x8_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_high_i16x8_s-arg-empty (result v128)
+      (i32x4.extmul_high_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_low_i16x8_u-1st-arg-empty (result v128)
+      (i32x4.extmul_low_i16x8_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_low_i16x8_u-arg-empty (result v128)
+      (i32x4.extmul_low_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_high_i16x8_u-1st-arg-empty (result v128)
+      (i32x4.extmul_high_i16x8_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_high_i16x8_u-arg-empty (result v128)
+      (i32x4.extmul_high_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_i32x4_trunc_sat_f32x4.wast b/test/core/simd/simd_i32x4_trunc_sat_f32x4.wast
new file mode 100644
index 000000000..40af590f5
--- /dev/null
+++ b/test/core/simd/simd_i32x4_trunc_sat_f32x4.wast
@@ -0,0 +1,239 @@
+;; Tests for i32x4 trunc sat conversions from float.
+
+(module
+  (func (export "i32x4.trunc_sat_f32x4_s") (param v128) (result v128) (i32x4.trunc_sat_f32x4_s (local.get 0)))
+  (func (export "i32x4.trunc_sat_f32x4_u") (param v128) (result v128) (i32x4.trunc_sat_f32x4_u (local.get 0)))
+)
+
+
+;; i32x4.trunc_sat_f32x4_s
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0.0 0.0 0.0 0.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 1.5 1.5 1.5 1.5))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -1.5 -1.5 -1.5 -1.5))
+                                                 (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 1.9 1.9 1.9 1.9))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 2.0 2.0 2.0 2.0))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -1.9 -1.9 -1.9 -1.9))
+                                                 (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -2.0 -2.0 -2.0 -2.0))
+                                                 (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 2147483520.0 2147483520.0 2147483520.0 2147483520.0))
+                                                 (v128.const i32x4 2147483520 2147483520 2147483520 2147483520))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -2147483520.0 -2147483520.0 -2147483520.0 -2147483520.0))
+                                                 (v128.const i32x4 -2147483520 -2147483520 -2147483520 -2147483520))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 2147483648.0 2147483648.0 2147483648.0 2147483648.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -2147483648.0 -2147483648.0 -2147483648.0 -2147483648.0))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 4294967294.0 4294967294.0 4294967294.0 4294967294.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -4294967294.0 -4294967294.0 -4294967294.0 -4294967294.0))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 2147483647.0 2147483647.0 2147483647.0 2147483647.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -2147483647.0 -2147483647.0 -2147483647.0 -2147483647.0))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 4294967294.0 4294967294.0 4294967294.0 4294967294.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 4294967295.0 4294967295.0 4294967295.0 4294967295.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 4294967296.0 4294967296.0 4294967296.0 4294967296.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                                 (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.19999ap+0 0x1.19999ap+0 0x1.19999ap+0 0x1.19999ap+0))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.19999ap+0 -0x1.19999ap+0 -0x1.19999ap+0 -0x1.19999ap+0))
+                                                 (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                 (v128.const i32x4 6 6 6 6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                 (v128.const i32x4 -6 -6 -6 -6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.ccccccp-1 0x1.ccccccp-1 0x1.ccccccp-1 0x1.ccccccp-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.ccccccp-1 -0x1.ccccccp-1 -0x1.ccccccp-1 -0x1.ccccccp-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.fffffep-1 0x1.fffffep-1 0x1.fffffep-1 0x1.fffffep-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.fffffep-1 -0x1.fffffep-1 -0x1.fffffep-1 -0x1.fffffep-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                 (v128.const i32x4 6 6 6 6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                 (v128.const i32x4 -6 -6 -6 -6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 +inf +inf +inf +inf))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -inf -inf -inf -inf))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 +nan +nan +nan +nan))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -nan -nan -nan -nan))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 nan:0x444444 nan:0x444444 nan:0x444444 nan:0x444444))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -nan:0x444444 -nan:0x444444 -nan:0x444444 -nan:0x444444))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 42 42 42 42))
+                                                 (v128.const i32x4 42 42 42 42))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -42 -42 -42 -42))
+                                                 (v128.const i32x4 -42 -42 -42 -42))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0123456792.0 0123456792.0 0123456792.0 0123456792.0))
+                                                 (v128.const i32x4 123456792 123456792 123456792 123456792))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 01234567890.0 01234567890.0 01234567890.0 01234567890.0))
+                                                 (v128.const i32x4 1234567936 1234567936 1234567936 1234567936))
+
+;; i32x4.trunc_sat_f32x4_u
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0.0 0.0 0.0 0.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 1.5 1.5 1.5 1.5))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -1.5 -1.5 -1.5 -1.5))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 1.9 1.9 1.9 1.9))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 2.0 2.0 2.0 2.0))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -1.9 -1.9 -1.9 -1.9))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -2.0 -2.0 -2.0 -2.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 2147483520.0 2147483520.0 2147483520.0 2147483520.0))
+                                                 (v128.const i32x4 2147483520 2147483520 2147483520 2147483520))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -2147483520.0 -2147483520.0 -2147483520.0 -2147483520.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 2147483648.0 2147483648.0 2147483648.0 2147483648.0))
+                                                 (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -2147483648.0 -2147483648.0 -2147483648.0 -2147483648.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 4294967294.0 4294967294.0 4294967294.0 4294967294.0))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -4294967294.0 -4294967294.0 -4294967294.0 -4294967294.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 2147483647.0 2147483647.0 2147483647.0 2147483647.0))
+                                                 (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -2147483647.0 -2147483647.0 -2147483647.0 -2147483647.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 4294967294.0 4294967294.0 4294967294.0 4294967294.0))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 4294967295.0 4294967295.0 4294967295.0 4294967295.0))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 4294967296.0 4294967296.0 4294967296.0 4294967296.0))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.19999ap+0 0x1.19999ap+0 0x1.19999ap+0 0x1.19999ap+0))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.19999ap+0 -0x1.19999ap+0 -0x1.19999ap+0 -0x1.19999ap+0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                 (v128.const i32x4 6 6 6 6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.ccccccp-1 0x1.ccccccp-1 0x1.ccccccp-1 0x1.ccccccp-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.ccccccp-1 -0x1.ccccccp-1 -0x1.ccccccp-1 -0x1.ccccccp-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.fffffep-1 0x1.fffffep-1 0x1.fffffep-1 0x1.fffffep-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.fffffep-1 -0x1.fffffep-1 -0x1.fffffep-1 -0x1.fffffep-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                 (v128.const i32x4 6 6 6 6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 +inf +inf +inf +inf))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -inf -inf -inf -inf))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 +nan +nan +nan +nan))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -nan -nan -nan -nan))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 nan:0x444444 nan:0x444444 nan:0x444444 nan:0x444444))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -nan:0x444444 -nan:0x444444 -nan:0x444444 -nan:0x444444))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 42 42 42 42))
+                                                 (v128.const i32x4 42 42 42 42))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -42 -42 -42 -42))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0123456792.0 0123456792.0 0123456792.0 0123456792.0))
+                                                 (v128.const i32x4 123456792 123456792 123456792 123456792))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 01234567890.0 01234567890.0 01234567890.0 01234567890.0))
+                                                 (v128.const i32x4 1234567936 1234567936 1234567936 1234567936))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.trunc_sat_f32x4_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.trunc_sat_f32x4_u (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.trunc_sat_f32x4_s-arg-empty (result v128)
+      (i32x4.trunc_sat_f32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.trunc_sat_f32x4_u-arg-empty (result v128)
+      (i32x4.trunc_sat_f32x4_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_i32x4_trunc_sat_f64x2.wast b/test/core/simd/simd_i32x4_trunc_sat_f64x2.wast
new file mode 100644
index 000000000..9bf507d77
--- /dev/null
+++ b/test/core/simd/simd_i32x4_trunc_sat_f64x2.wast
@@ -0,0 +1,239 @@
+;; Tests for i32x4 trunc sat conversions from float.
+
+(module
+  (func (export "i32x4.trunc_sat_f64x2_s_zero") (param v128) (result v128) (i32x4.trunc_sat_f64x2_s_zero (local.get 0)))
+  (func (export "i32x4.trunc_sat_f64x2_u_zero") (param v128) (result v128) (i32x4.trunc_sat_f64x2_u_zero (local.get 0)))
+)
+
+
+;; i32x4.trunc_sat_f64x2_s_zero
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0.0 0.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0.0 -0.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 1.5 1.5))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -1.5 -1.5))
+                                                      (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 1.9 1.9))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 2.0 2.0))
+                                                      (v128.const i32x4 2 2 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -1.9 -1.9))
+                                                      (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -2.0 -2.0))
+                                                      (v128.const i32x4 -2 -2 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 2147483520.0 2147483520.0))
+                                                      (v128.const i32x4 2147483520 2147483520 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -2147483520.0 -2147483520.0))
+                                                      (v128.const i32x4 -2147483520 -2147483520 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 2147483648.0 2147483648.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -2147483648.0 -2147483648.0))
+                                                      (v128.const i32x4 -2147483648 -2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 4294967294.0 4294967294.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -4294967294.0 -4294967294.0))
+                                                      (v128.const i32x4 -2147483648 -2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 2147483647.0 2147483647.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -2147483647.0 -2147483647.0))
+                                                      (v128.const i32x4 -2147483647 -2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 4294967294.0 4294967294.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 4294967295.0 4294967295.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 4294967296.0 4294967296.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1p-149 0x1p-149))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1p-149 -0x1p-149))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1p-126 0x1p-126))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1p-126 -0x1p-126))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1p-1 0x1p-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1p+0 0x1p+0))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                                      (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.19999ap+0 0x1.19999ap+0))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.19999ap+0 -0x1.19999ap+0))
+                                                      (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                      (v128.const i32x4 6 6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                      (v128.const i32x4 -6 -6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                      (v128.const i32x4 -2147483648 -2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.ccccccp-1 0x1.ccccccp-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.ccccccp-1 -0x1.ccccccp-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.fffffep-1 0x1.fffffep-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.fffffep-1 -0x1.fffffep-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                      (v128.const i32x4 6 6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                      (v128.const i32x4 -6 -6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                      (v128.const i32x4 -2147483648 -2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 +inf +inf))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -inf -inf))
+                                                      (v128.const i32x4 -2147483648 -2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 +nan +nan))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -nan -nan))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 nan:0x444444 nan:0x444444))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -nan:0x444444 -nan:0x444444))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 42 42))
+                                                      (v128.const i32x4 42 42 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -42 -42))
+                                                      (v128.const i32x4 -42 -42 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0123456792.0 0123456792.0))
+                                                      (v128.const i32x4 123456792 123456792 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 01234567890.0 01234567890.0))
+                                                      (v128.const i32x4 1234567890 1234567890 0 0))
+
+;; i32x4.trunc_sat_f64x2_u_zero
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0.0 0.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0.0 -0.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 1.5 1.5))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -1.5 -1.5))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 1.9 1.9))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 2.0 2.0))
+                                                      (v128.const i32x4 2 2 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -1.9 -1.9))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -2.0 -2.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 2147483520.0 2147483520.0))
+                                                      (v128.const i32x4 2147483520 2147483520 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -2147483520.0 -2147483520.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 2147483648.0 2147483648.0))
+                                                      (v128.const i32x4 2147483648 2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -2147483648.0 -2147483648.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 4294967294.0 4294967294.0))
+                                                      (v128.const i32x4 4294967294 4294967294 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -4294967294.0 -4294967294.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 2147483647.0 2147483647.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -2147483647.0 -2147483647.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 4294967294.0 4294967294.0))
+                                                      (v128.const i32x4 4294967294 4294967294 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 4294967295.0 4294967295.0))
+                                                      (v128.const i32x4 4294967295 4294967295 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 4294967296.0 4294967296.0))
+                                                      (v128.const i32x4 4294967295 4294967295 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1p-149 0x1p-149))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1p-149 -0x1p-149))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1p-126 0x1p-126))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1p-126 -0x1p-126))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1p-1 0x1p-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1p+0 0x1p+0))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.19999ap+0 0x1.19999ap+0))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.19999ap+0 -0x1.19999ap+0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                      (v128.const i32x4 6 6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+                                                      (v128.const i32x4 4294967295 4294967295 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.ccccccp-1 0x1.ccccccp-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.ccccccp-1 -0x1.ccccccp-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.fffffep-1 0x1.fffffep-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.fffffep-1 -0x1.fffffep-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                      (v128.const i32x4 6 6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+                                                      (v128.const i32x4 4294967295 4294967295 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 +inf +inf))
+                                                      (v128.const i32x4 4294967295 4294967295 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -inf -inf))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 +nan +nan))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -nan -nan))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 nan:0x444444 nan:0x444444))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -nan:0x444444 -nan:0x444444))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 42 42))
+                                                      (v128.const i32x4 42 42 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -42 -42))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0123456792.0 0123456792.0))
+                                                      (v128.const i32x4 123456792 123456792 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 01234567890.0 01234567890.0))
+                                                      (v128.const i32x4 1234567890 1234567890 0 0))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.trunc_sat_f64x2_s_zero (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.trunc_sat_f64x2_u_zero (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.trunc_sat_f64x2_s_zero-arg-empty (result v128)
+      (i32x4.trunc_sat_f64x2_s_zero)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.trunc_sat_f64x2_u_zero-arg-empty (result v128)
+      (i32x4.trunc_sat_f64x2_u_zero)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_i64x2_arith.wast b/test/core/simd/simd_i64x2_arith.wast
new file mode 100644
index 000000000..00963a0d0
--- /dev/null
+++ b/test/core/simd/simd_i64x2_arith.wast
@@ -0,0 +1,652 @@
+;; Tests for i64x2 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i64x2.add") (param v128 v128) (result v128) (i64x2.add (local.get 0) (local.get 1)))
+  (func (export "i64x2.sub") (param v128 v128) (result v128) (i64x2.sub (local.get 0) (local.get 1)))
+  (func (export "i64x2.mul") (param v128 v128) (result v128) (i64x2.mul (local.get 0) (local.get 1)))
+  (func (export "i64x2.neg") (param v128) (result v128) (i64x2.neg (local.get 0)))
+)
+
+
+;; i64x2.add
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 2 2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -1 -1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 4611686018427387903 4611686018427387903)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 4611686018427387904 4611686018427387904)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -4611686018427387903 -4611686018427387903)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -4611686018427387904 -4611686018427387904)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -4611686018427387905 -4611686018427387905)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 9223372036854775805 9223372036854775805)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775806 9223372036854775806))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 9223372036854775806 9223372036854775806)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 9223372036854775808 9223372036854775808)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775806 -9223372036854775806)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775807 -9223372036854775807)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 9223372036854775807 9223372036854775807)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 9223372036854775806 9223372036854775806))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 18446744073709551615 18446744073709551615))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x3fffffffffffffff 0x3fffffffffffffff)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x4000000000000000 0x4000000000000000)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -0x3fffffffffffffff -0x3fffffffffffffff)
+                                   (v128.const i64x2 -0x40000000fffffff -0x40000000fffffff))
+                                   (v128.const i64x2 -4899916394847535102 -4899916394847535102))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000000 -0x400000000000000))
+                                   (v128.const i64x2 -4899916394579099648 -4899916394579099648))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000001 -0x400000000000001))
+                                   (v128.const i64x2 -4899916394579099649 -4899916394579099649))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x7ffffffffffffff 0x7ffffffffffffff))
+                                   (v128.const i64x2 -8646911284551352322 -8646911284551352322))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 -0x01 -0x01))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0x80 0 0 0 0 0 0 0 0x80))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i16x8 0 0 0 0x8000 0 0 0 0x8000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i32x4 0 0x80000000 0 0x80000000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 +0.0 +0.0))
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 -0.0 -0.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 1.0 1.0))
+                                   (v128.const i64x2 0xbff0000000000000 0xbff0000000000000))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 -1.0 -1.0))
+                                   (v128.const i64x2 0x3ff0000000000000 0x3ff0000000000000))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const f64x2 +inf +inf))
+                                   (v128.const i64x2 0x7ff0000000000001 0x7ff0000000000001))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const i64x2 0xfff0000000000001 0xfff0000000000001))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const i64x2 0x7ff8000000000001 0x7ff8000000000001))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 0xffffffffffffffff))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 2))
+                                   (v128.const i64x2 0 3))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)
+                                   (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789))
+                                   (v128.const i64x2 02_469_135_780_246_913_578 02_469_135_780_246_913_578))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef)
+                                   (v128.const i64x2 0x0_90AB_cdef_1234_5678 0x0_90AB_cdef_1234_5678))
+                                   (v128.const i64x2 0x0_a2e0_2467_a2e0_2467 0x0_a2e0_2467_a2e0_2467))
+
+;; i64x2.sub
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 2 2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -1 -1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 4611686018427387903 4611686018427387903)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 4611686018427387904 4611686018427387904)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -4611686018427387903 -4611686018427387903)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -4611686018427387904 -4611686018427387904)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -4611686018427387905 -4611686018427387905)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 9223372036854775805 9223372036854775805)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775804 9223372036854775804))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 9223372036854775806 9223372036854775806)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775805 9223372036854775805))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 9223372036854775808 9223372036854775808)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775806 -9223372036854775806)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775805 -9223372036854775805))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775807 -9223372036854775807)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775806 -9223372036854775806))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 9223372036854775807 9223372036854775807)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 18446744073709551615 18446744073709551615))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x3fffffffffffffff 0x3fffffffffffffff)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x4000000000000000 0x4000000000000000)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -0x3fffffffffffffff -0x3fffffffffffffff)
+                                   (v128.const i64x2 -0x40000000fffffff -0x40000000fffffff))
+                                   (v128.const i64x2 -4323455642007240704 -4323455642007240704))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000000 -0x400000000000000))
+                                   (v128.const i64x2 -4323455642275676160 -4323455642275676160))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000001 -0x400000000000001))
+                                   (v128.const i64x2 -4323455642275676159 -4323455642275676159))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x7ffffffffffffff 0x7ffffffffffffff))
+                                   (v128.const i64x2 8646911284551352320 8646911284551352320))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 9223372036854775806 9223372036854775806))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 -0x01 -0x01))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0x80 0 0 0 0 0 0 0 0x80))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i64x2 2 2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i16x8 0 0 0 0x8000 0 0 0 0x8000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i64x2 2 2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i32x4 0 0x80000000 0 0x80000000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i64x2 2 2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 +0.0 +0.0))
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 -0.0 -0.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 1.0 1.0))
+                                   (v128.const i64x2 0x4010000000000000 0x4010000000000000))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 -1.0 -1.0))
+                                   (v128.const i64x2 0xc010000000000000 0xc010000000000000))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 +inf +inf))
+                                   (v128.const i64x2 0x8010000000000001 0x8010000000000001))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const i64x2 0x0010000000000001 0x0010000000000001))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const i64x2 0x8008000000000001 0x8008000000000001))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 0xffffffffffffffff))
+                                   (v128.const i64x2 0 0x02))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 2))
+                                   (v128.const i64x2 0 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 03_214_567_890_123_456_789 03_214_567_890_123_456_789)
+                                   (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789))
+                                   (v128.const i64x2 01_980_000_000_000_000_000 01_980_000_000_000_000_000))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x0_90AB_cdef_8765_4321 0x0_90AB_cdef_8765_4321)
+                                   (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef))
+                                   (v128.const i64x2 0x0_7e77_7776_f6b9_7532 0x0_7e77_7776_f6b9_7532))
+
+;; i64x2.mul
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -1 -1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 4611686018427387903 4611686018427387903)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 4611686018427387904 4611686018427387904)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -4611686018427387903 -4611686018427387903)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -4611686018427387904 -4611686018427387904)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -4611686018427387905 -4611686018427387905)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 9223372036854775805 9223372036854775805)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775805 9223372036854775805))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 9223372036854775806 9223372036854775806)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775806 9223372036854775806))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 9223372036854775808 9223372036854775808)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775806 -9223372036854775806)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 9223372036854775806 9223372036854775806))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775807 -9223372036854775807)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 9223372036854775807 9223372036854775807)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 18446744073709551615 18446744073709551615))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x3fffffffffffffff 0x3fffffffffffffff)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x4000000000000000 0x4000000000000000)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -0x3fffffffffffffff -0x3fffffffffffffff)
+                                   (v128.const i64x2 -0x40000000fffffff -0x40000000fffffff))
+                                   (v128.const i64x2 -4899916394847535103 -4899916394847535103))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000000 -0x400000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000001 -0x400000000000001))
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x7ffffffffffffff 0x7ffffffffffffff))
+                                   (v128.const i64x2 8646911284551352321 8646911284551352321))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 -0x01 -0x01))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i8x16 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i16x8 0 0 0 0x02 0 0 0 0x02))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i32x4 0 0x02 0 0x02))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x80000000 0x80000000)
+                                   (v128.const f64x2 +0.0 +0.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x80000000 0x80000000)
+                                   (v128.const f64x2 -0.0 -0.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x80000000 0x80000000)
+                                   (v128.const f64x2 1.0 1.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x80000000 0x80000000)
+                                   (v128.const f64x2 -1.0 -1.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 +inf +inf))
+                                   (v128.const i64x2 0x7ff0000000000000 0x7ff0000000000000))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const i64x2 0xfff0000000000000 0xfff0000000000000))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const i64x2 0x7ff8000000000000 0x7ff8000000000000))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 0xffffffffffffffff))
+                                   (v128.const i64x2 0 0xffffffffffffffff))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 2))
+                                   (v128.const i64x2 0 0x02))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)
+                                   (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789))
+                                   (v128.const i64x2 09_710_478_858_155_731_897 09_710_478_858_155_731_897))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef)
+                                   (v128.const i64x2 0x0_90AB_cdef_8765_4321 0x0_90AB_cdef_8765_4321))
+                                   (v128.const i64x2 0x0_602f_05e9_e556_18cf 0x0_602f_05e9_e556_18cf))
+
+;; i64x2.neg
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 0 0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 9223372036854775806 9223372036854775806))
+                                   (v128.const i64x2 -9223372036854775806 -9223372036854775806))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 18446744073709551615 18446744073709551615))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -0x01 -0x01))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -0x8000000000000000 -0x8000000000000000))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -0x7fffffffffffffff -0x7fffffffffffffff))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff))
+                                   (v128.const i64x2 1 1))
+
+;; type check
+(assert_invalid (module (func (result v128) (i64x2.neg (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.add (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.sub (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.mul (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i64x2.neg-arg-empty (result v128)
+      (i64x2.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.add-1st-arg-empty (result v128)
+      (i64x2.add (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.add-arg-empty (result v128)
+      (i64x2.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.sub-1st-arg-empty (result v128)
+      (i64x2.sub (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.sub-arg-empty (result v128)
+      (i64x2.sub)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.mul-1st-arg-empty (result v128)
+      (i64x2.mul (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.mul-arg-empty (result v128)
+      (i64x2.mul)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (i64x2.add (i64x2.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-add") (param v128 v128 v128) (result v128)
+    (i64x2.mul (i64x2.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-sub") (param v128 v128 v128) (result v128)
+    (i64x2.mul (i64x2.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (i64x2.sub (i64x2.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (i64x2.add (i64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "mul-neg") (param v128 v128) (result v128)
+    (i64x2.mul (i64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (i64x2.sub (i64x2.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 2)
+                                 (v128.const i64x2 0 2))
+                                 (v128.const i64x2 0 1))
+(assert_return (invoke "mul-add" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 1)
+                                 (v128.const i64x2 2 2))
+                                 (v128.const i64x2 0 4))
+(assert_return (invoke "mul-sub" (v128.const i64x2 0 2)
+                                 (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 1))
+                                 (v128.const i64x2 0 1))
+(assert_return (invoke "sub-add" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 2)
+                                 (v128.const i64x2 0 2))
+                                 (v128.const i64x2 0 1))
+(assert_return (invoke "add-neg" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 1))
+                                 (v128.const i64x2 0 0))
+(assert_return (invoke "mul-neg" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 2 2))
+                                 (v128.const i64x2 0 -2))
+(assert_return (invoke "sub-neg" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 1))
+                                 (v128.const i64x2 0 -2))
\ No newline at end of file
diff --git a/test/core/simd/simd_i64x2_arith2.wast b/test/core/simd/simd_i64x2_arith2.wast
new file mode 100644
index 000000000..14398d8a4
--- /dev/null
+++ b/test/core/simd/simd_i64x2_arith2.wast
@@ -0,0 +1,78 @@
+;; Tests for i64x2 [abs] operations.
+
+(module
+  (func (export "i64x2.abs") (param v128) (result v128) (i64x2.abs (local.get 0)))
+  (func (export "i64x2.abs_with_const_0") (result v128) (i64x2.abs (v128.const i64x2 -9223372036854775808 9223372036854775807)))
+)
+
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 1 1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 18446744073709551615 18446744073709551615))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff))
+                                   (v128.const i64x2 0x1 0x1))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 9223372036854775808 9223372036854775808))
+                                   (v128.const i64x2 9223372036854775808 9223372036854775808))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 9223372036854775808 9223372036854775808))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0x8000000000000000 -0x8000000000000000))
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 01_2_3 01_2_3))
+                                   (v128.const i64x2 01_2_3 01_2_3))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -01_2_3 -01_2_3))
+                                   (v128.const i64x2 123 123))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 0x80 0x80))
+                                   (v128.const i64x2 0x80 0x80))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0x80 -0x80))
+                                   (v128.const i64x2 0x80 0x80))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 0x0_8_0 0x0_8_0))
+                                   (v128.const i64x2 0x0_8_0 0x0_8_0))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0x0_8_0 -0x0_8_0))
+                                   (v128.const i64x2 0x80 0x80))
+
+;; Const vs const
+(assert_return (invoke "i64x2.abs_with_const_0") (v128.const i64x2 9223372036854775808 9223372036854775807))
+
+;; Param vs const
+
+;; Test different lanes go through different if-then clauses
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -9223372036854775808 9223372036854775807))
+                                   (v128.const i64x2 9223372036854775808 9223372036854775807))
+
+;; Test opposite signs of zero
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0 -0))
+                                   (v128.const i64x2 -0 -0))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 +0 0))
+                                   (v128.const i64x2 +0 0))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0 -0))
+                                   (v128.const i64x2 -0 -0))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 +0 +0))
+                                   (v128.const i64x2 +0 +0))
+
+;; Unknown operators
+
+;; Type check
+(assert_invalid (module (func (result v128) (i64x2.abs (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i64x2.abs-arg-empty (result v128)
+      (i64x2.abs)
+    )
+  )
+  "type mismatch"
+)
+
+;; Combination
+(module
+  (func (export "i64x2.abs-i64x2.abs") (param v128) (result v128) (i64x2.abs (i64x2.abs (local.get 0))))
+)
+
+(assert_return (invoke "i64x2.abs-i64x2.abs" (v128.const i64x2 -1 -1))
+                                             (v128.const i64x2 1 1))
diff --git a/test/core/simd/simd_i64x2_cmp.wast b/test/core/simd/simd_i64x2_cmp.wast
new file mode 100644
index 000000000..50e58b64b
--- /dev/null
+++ b/test/core/simd/simd_i64x2_cmp.wast
@@ -0,0 +1,420 @@
+
+;; Test all the i64x2 comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (i64x2.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (i64x2.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x v128) (param $y v128) (result v128) (i64x2.lt_s (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x v128) (param $y v128) (result v128) (i64x2.le_s (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x v128) (param $y v128) (result v128) (i64x2.gt_s (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x v128) (param $y v128) (result v128) (i64x2.ge_s (local.get $x) (local.get $y)))
+)
+
+
+;; eq
+
+;; i64x2.eq  (i64x2) (i64x2)
+(assert_return (invoke "eq" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                            (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                            (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                            (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                            (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                            (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                            (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0x03020100 0x11100904)
+                            (v128.const i64x2 0x03020100 0x11100904))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                            (v128.const i64x2 0x0FFFFFFFFFFFFFFF 0x0FFFFFFFFFFFFFFF))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "eq" (v128.const i64x2 0x1 0x1)
+                            (v128.const i64x2 0x2 0x2))
+                            (v128.const i64x2 0 0))
+
+;; ne
+
+;; i64x2.ne  (i64x2) (i64x2)
+
+;; hex vs hex
+(assert_return (invoke "ne" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                            (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                            (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                            (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                            (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                            (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                            (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0x03020100 0x11100904)
+                            (v128.const i64x2 0x03020100 0x11100904))
+                            (v128.const i64x2 0 0))
+
+;; lt_s
+
+;; i64x2.lt_s  (i64x2) (i64x2)
+
+;; hex vs hex
+(assert_return (invoke "lt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                              (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                              (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                              (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B)
+                              (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B))
+                              (v128.const i64x2 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 9259542123273814144 9259542123273814144))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 -9187201950435737472 -9187201950435737472))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x8382818000FFFEFD 0x7F020100FFFEFD80)
+                              (v128.const i64x2 -8970465120996032771 9151878496576798080))
+                              (v128.const i64x2 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_s" (v128.const i64x2 -1 -1)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0 0)
+                              (v128.const i64x2 0 0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 18446744073709551615 0)
+                              (v128.const i64x2 18446744073709551615 0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0 18446744073709551615)
+                              (v128.const i64x2 0 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 -9223372036854775807 18446744073709551615)
+                              (v128.const i64x2 9223372036854775809 -1))
+                              (v128.const i64x2 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_s" (v128.const i64x2 0xc060000000000000 0xc05fc00000000000)
+                              (v128.const f64x2 -128.0 -127.0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x3ff0000000000000 0x405fc00000000000)
+                              (v128.const f64x2 1.0 127.0))
+                              (v128.const i64x2 0 0))
+
+;; le_s
+
+;; i64x2.le_s  (i64x2) (i64x2)
+
+;; hex vs hex
+(assert_return (invoke "le_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                              (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                              (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                              (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B)
+                              (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B))
+                              (v128.const i64x2 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 9259542123273814144 9259542123273814144))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 -9187201950435737472 -9187201950435737472))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x8382818000FFFEFD 0x7F020100FFFEFD80)
+                              (v128.const i64x2 -8970465120996032771 9151878496576798080))
+                              (v128.const i64x2 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_s" (v128.const i64x2 -1 -1)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0 0)
+                              (v128.const i64x2 0 -1))
+                              (v128.const i64x2 -1 0))
+(assert_return (invoke "le_s" (v128.const i64x2 0 0)
+                              (v128.const i64x2 0 0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 18446744073709551615 0)
+                              (v128.const i64x2 18446744073709551615 0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0 18446744073709551615)
+                              (v128.const i64x2 0 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 -9223372036854775807 18446744073709551615)
+                              (v128.const i64x2 9223372036854775809 -1))
+                              (v128.const i64x2 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_s" (v128.const i64x2 0xc060000000000000 0xc05fc00000000000)
+                              (v128.const f64x2 -128.0 -127.0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x3ff0000000000000 0x405fc00000000000)
+                              (v128.const f64x2 1.0 127.0))
+                              (v128.const i64x2 -1 -1))
+
+;; gt_s
+
+;; i64x2.gt_s  (i64x2) (i64x2)
+
+;; hex vs hex
+(assert_return (invoke "gt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                              (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                              (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                              (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B)
+                              (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B))
+                              (v128.const i64x2 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 9259542123273814144 9259542123273814144))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 -9187201950435737472 -9187201950435737472))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x8382818000FFFEFD 0x7F020100FFFEFD80)
+                              (v128.const i64x2 -8970465120996032771 9151878496576798080))
+                              (v128.const i64x2 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_s" (v128.const i64x2 -1 -1)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0 0)
+                              (v128.const i64x2 0 0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 18446744073709551615 0)
+                              (v128.const i64x2 18446744073709551615 0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0 18446744073709551615)
+                              (v128.const i64x2 0 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 -9223372036854775807 18446744073709551615)
+                              (v128.const i64x2 9223372036854775809 -1))
+                              (v128.const i64x2 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_s" (v128.const i64x2 0xc060000000000000 0xc05fc00000000000)
+                              (v128.const f64x2 -128.0 -127.0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x3ff0000000000000 0x405fc00000000000)
+                              (v128.const f64x2 1.0 127.0))
+                              (v128.const i64x2 0 0))
+
+;; ge_s
+
+;; i64x2.ge_s  (i64x2) (i64x2)
+
+;; hex vs hex
+(assert_return (invoke "ge_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                              (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                              (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                              (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B)
+                              (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B))
+                              (v128.const i64x2 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 9259542123273814144 9259542123273814144))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 -9187201950435737472 -9187201950435737472))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x8382818000FFFEFD 0x7F020100FFFEFD80)
+                              (v128.const i64x2 -8970465120996032771 9151878496576798080))
+                              (v128.const i64x2 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_s" (v128.const i64x2 -1 -1)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 -1 -1)
+                              (v128.const i64x2 0 -1))
+                              (v128.const i64x2 0 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0 0)
+                              (v128.const i64x2 0 0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 18446744073709551615 0)
+                              (v128.const i64x2 18446744073709551615 0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0 18446744073709551615)
+                              (v128.const i64x2 0 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 -9223372036854775807 18446744073709551615)
+                              (v128.const i64x2 9223372036854775809 -1))
+                              (v128.const i64x2 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_s" (v128.const i64x2 0xc060000000000000 0xc05fc00000000000)
+                              (v128.const f64x2 -128.0 -127.0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x3ff0000000000000 0x405fc00000000000)
+                              (v128.const f64x2 1.0 127.0))
+                              (v128.const i64x2 -1 -1))
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (i64x2.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i64x2.eq-1st-arg-empty (result v128)
+      (i64x2.eq (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.eq-arg-empty (result v128)
+      (i64x2.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.ne-1st-arg-empty (result v128)
+      (i64x2.ne (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.ne-arg-empty (result v128)
+      (i64x2.ne)
+    )
+  )
+  "type mismatch"
+)
\ No newline at end of file
diff --git a/test/core/simd/simd_i64x2_extmul_i32x4.wast b/test/core/simd/simd_i64x2_extmul_i32x4.wast
new file mode 100644
index 000000000..9259279c9
--- /dev/null
+++ b/test/core/simd/simd_i64x2_extmul_i32x4.wast
@@ -0,0 +1,404 @@
+;; Tests for i64x2 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i64x2.extmul_low_i32x4_s") (param v128 v128) (result v128) (i64x2.extmul_low_i32x4_s (local.get 0) (local.get 1)))
+  (func (export "i64x2.extmul_high_i32x4_s") (param v128 v128) (result v128) (i64x2.extmul_high_i32x4_s (local.get 0) (local.get 1)))
+  (func (export "i64x2.extmul_low_i32x4_u") (param v128 v128) (result v128) (i64x2.extmul_low_i32x4_u (local.get 0) (local.get 1)))
+  (func (export "i64x2.extmul_high_i32x4_u") (param v128 v128) (result v128) (i64x2.extmul_high_i32x4_u (local.get 0) (local.get 1)))
+)
+
+
+;; i64x2.extmul_low_i32x4_s
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -1 -1 -1 -1)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                  (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                  (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 1152921505680588800 1152921505680588800))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 2147483645 2147483645))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                                  (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 4611686014132420609 4611686014132420609))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                                  (v128.const i64x2 4611686016279904256 4611686016279904256))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 -2147483647 -2147483647))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                                  (v128.const i64x2 1 1))
+
+;; i64x2.extmul_high_i32x4_s
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -1 -1 -1 -1)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                   (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                   (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 1152921505680588800 1152921505680588800))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 2147483645 2147483645))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 4611686014132420609 4611686014132420609))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                                   (v128.const i64x2 4611686016279904256 4611686016279904256))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 -2147483647 -2147483647))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                                   (v128.const i64x2 1 1))
+
+;; i64x2.extmul_low_i32x4_u
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 -8589934591 -8589934591))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                  (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                  (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 -8070450529026703360 -8070450529026703360))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 -8070450532247928832 -8070450532247928832))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 -8070450535469154304 -8070450535469154304))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 2147483645 2147483645))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 -9223372030412324866 -9223372030412324866))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 -9223372034707292161 -9223372034707292161))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 9223372034707292160 9223372034707292160))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                                  (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 4611686014132420609 4611686014132420609))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                                  (v128.const i64x2 4611686020574871552 4611686020574871552))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 -8589934591 -8589934591))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 9223372030412324865 9223372030412324865))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 9223372034707292160 9223372034707292160))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                                  (v128.const i64x2 -8589934591 -8589934591))
+
+;; i64x2.extmul_high_i32x4_u
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 -8589934591 -8589934591))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                   (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                   (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 -8070450529026703360 -8070450529026703360))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 -8070450532247928832 -8070450532247928832))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 -8070450535469154304 -8070450535469154304))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 2147483645 2147483645))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 -9223372030412324866 -9223372030412324866))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 -9223372034707292161 -9223372034707292161))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 9223372034707292160 9223372034707292160))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 4611686014132420609 4611686014132420609))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                                   (v128.const i64x2 4611686020574871552 4611686020574871552))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 -8589934591 -8589934591))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 9223372030412324865 9223372030412324865))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 9223372034707292160 9223372034707292160))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                                   (v128.const i64x2 -8589934591 -8589934591))
+
+;; type check
+(assert_invalid (module (func (result v128) (i64x2.extmul_low_i32x4_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extmul_high_i32x4_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extmul_low_i32x4_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extmul_high_i32x4_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i64x2.extmul_low_i32x4_s-1st-arg-empty (result v128)
+      (i64x2.extmul_low_i32x4_s (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_low_i32x4_s-arg-empty (result v128)
+      (i64x2.extmul_low_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_high_i32x4_s-1st-arg-empty (result v128)
+      (i64x2.extmul_high_i32x4_s (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_high_i32x4_s-arg-empty (result v128)
+      (i64x2.extmul_high_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_low_i32x4_u-1st-arg-empty (result v128)
+      (i64x2.extmul_low_i32x4_u (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_low_i32x4_u-arg-empty (result v128)
+      (i64x2.extmul_low_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_high_i32x4_u-1st-arg-empty (result v128)
+      (i64x2.extmul_high_i32x4_u (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_high_i32x4_u-arg-empty (result v128)
+      (i64x2.extmul_high_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_i8x16_arith.wast b/test/core/simd/simd_i8x16_arith.wast
new file mode 100644
index 000000000..1e56b4c00
--- /dev/null
+++ b/test/core/simd/simd_i8x16_arith.wast
@@ -0,0 +1,426 @@
+;; Tests for i8x16 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i8x16.add") (param v128 v128) (result v128) (i8x16.add (local.get 0) (local.get 1)))
+  (func (export "i8x16.sub") (param v128 v128) (result v128) (i8x16.sub (local.get 0) (local.get 1)))
+  (func (export "i8x16.neg") (param v128) (result v128) (i8x16.neg (local.get 0)))
+)
+
+
+;; i8x16.add
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                   (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                   (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                   (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                   (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                   (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                   (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                   (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                   (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i8x16 0x80 0x80 0 0xbf 0x80 0x80 0 0xbf 0x80 0x80 0 0xbf 0x80 0x80 0 0xbf))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i8x16 0x80 0x80 0 0x3f 0x80 0x80 0 0x3f 0x80 0x80 0 0x3f 0x80 0x80 0 0x3f))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i8x16 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i8x16 0x01 0x01 0x81 0 0x01 0x01 0x81 0 0x01 0x01 0x81 0 0x01 0x01 0x81 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i8x16 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                   (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                   (v128.const i8x16 0 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45))
+
+;; i8x16.sub
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                   (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                   (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                   (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                   (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                   (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                   (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                   (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i8x16 0x80 0x80 0 0x41 0x80 0x80 0 0x41 0x80 0x80 0 0x41 0x80 0x80 0 0x41))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i8x16 0x80 0x80 0 0xc1 0x80 0x80 0 0xc1 0x80 0x80 0 0xc1 0x80 0x80 0 0xc1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i8x16 0x01 0x01 0x81 0x82 0x01 0x01 0x81 0x82 0x01 0x01 0x81 0x82 0x01 0x01 0x81 0x82))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i8x16 0x01 0x01 0x81 0x02 0x01 0x01 0x81 0x02 0x01 0x01 0x81 0x02 0x01 0x01 0x81 0x02))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i8x16 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                   (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                   (v128.const i8x16 0 0x02 0x04 0x06 0x08 0x0a 0x0c 0x0e 0x10 0x12 0x14 0x16 0x18 0x1a 0x1c 0x1e))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                   (v128.const i8x16 0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15))
+
+;; i8x16.neg
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+                                   (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+
+;; type check
+(assert_invalid (module (func (result v128) (i8x16.neg (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.add (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.sub (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.neg-arg-empty (result v128)
+      (i8x16.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.add-1st-arg-empty (result v128)
+      (i8x16.add (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.add-arg-empty (result v128)
+      (i8x16.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub-1st-arg-empty (result v128)
+      (i8x16.sub (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub-arg-empty (result v128)
+      (i8x16.sub)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (i8x16.add (i8x16.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (i8x16.sub (i8x16.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (i8x16.add (i8x16.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (i8x16.sub (i8x16.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                 (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30)
+                                 (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "sub-add" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                 (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30)
+                                 (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "add-neg" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+                                 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "sub-neg" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+                                 (v128.const i8x16 0 -2 -4 -6 -8 -10 -12 -14 -16 -18 -20 -22 -24 -26 -28 -30))
\ No newline at end of file
diff --git a/test/core/simd/simd_i8x16_arith2.wast b/test/core/simd/simd_i8x16_arith2.wast
new file mode 100644
index 000000000..991ec14bb
--- /dev/null
+++ b/test/core/simd/simd_i8x16_arith2.wast
@@ -0,0 +1,713 @@
+;; Tests for i8x16 [min_s, min_u, max_s, max_u, avgr_u, abs] operations.
+
+(module
+  (func (export "i8x16.min_s") (param v128 v128) (result v128) (i8x16.min_s (local.get 0) (local.get 1)))
+  (func (export "i8x16.min_u") (param v128 v128) (result v128) (i8x16.min_u (local.get 0) (local.get 1)))
+  (func (export "i8x16.max_s") (param v128 v128) (result v128) (i8x16.max_s (local.get 0) (local.get 1)))
+  (func (export "i8x16.max_u") (param v128 v128) (result v128) (i8x16.max_u (local.get 0) (local.get 1)))
+  (func (export "i8x16.avgr_u") (param v128 v128) (result v128) (i8x16.avgr_u (local.get 0) (local.get 1)))
+  (func (export "i8x16.abs") (param v128) (result v128) (i8x16.abs (local.get 0)))
+  (func (export "i8x16.popcnt") (param v128) (result v128) (i8x16.popcnt (local.get 0)))
+  (func (export "i8x16.min_s_with_const_0") (result v128) (i8x16.min_s (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)))
+  (func (export "i8x16.min_s_with_const_1") (result v128) (i8x16.min_s (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)))
+  (func (export "i8x16.min_u_with_const_2") (result v128) (i8x16.min_u (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)))
+  (func (export "i8x16.min_u_with_const_3") (result v128) (i8x16.min_u (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)))
+  (func (export "i8x16.max_s_with_const_4") (result v128) (i8x16.max_s (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)))
+  (func (export "i8x16.max_s_with_const_5") (result v128) (i8x16.max_s (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)))
+  (func (export "i8x16.max_u_with_const_6") (result v128) (i8x16.max_u (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)))
+  (func (export "i8x16.max_u_with_const_7") (result v128) (i8x16.max_u (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)))
+  (func (export "i8x16.avgr_u_with_const_8") (result v128) (i8x16.avgr_u (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)))
+  (func (export "i8x16.avgr_u_with_const_9") (result v128) (i8x16.avgr_u (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)))
+  (func (export "i8x16.abs_with_const_10") (result v128) (i8x16.abs (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.popcnt_with_const_11") (result v128) (i8x16.popcnt (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.min_s_with_const_12") (param v128) (result v128) (i8x16.min_s (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.min_s_with_const_13") (param v128) (result v128) (i8x16.min_s (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3)))
+  (func (export "i8x16.min_u_with_const_14") (param v128) (result v128) (i8x16.min_u (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.min_u_with_const_15") (param v128) (result v128) (i8x16.min_u (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3)))
+  (func (export "i8x16.max_s_with_const_16") (param v128) (result v128) (i8x16.max_s (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.max_s_with_const_17") (param v128) (result v128) (i8x16.max_s (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3)))
+  (func (export "i8x16.max_u_with_const_18") (param v128) (result v128) (i8x16.max_u (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.max_u_with_const_19") (param v128) (result v128) (i8x16.max_u (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3)))
+  (func (export "i8x16.avgr_u_with_const_20") (param v128) (result v128) (i8x16.avgr_u (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.avgr_u_with_const_21") (param v128) (result v128) (i8x16.avgr_u (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3)))
+)
+
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)
+                                     (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)
+                                     (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                     (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)
+                                     (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                     (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)
+                                     (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                      (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                      (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)
+                                      (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1))
+                                      (v128.const i8x16 0 0 0 0 128 128 128 128 128 128 128 128 255 255 255 255))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                      (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                      (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                      (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                      (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                      (v128.const i8x16 192 192 192 192 192 192 192 192 192 192 192 192 192 192 192 192))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                      (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                      (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                      (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                      (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)
+                                      (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                      (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                      (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                      (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                   (v128.const i8x16 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                   (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                   (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3))
+                                   (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                      (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                      (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                      (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                      (v128.const i8x16 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3))
+                                      (v128.const i8x16 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+
+;; Const vs const
+(assert_return (invoke "i8x16.min_s_with_const_0") (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_s_with_const_1") (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i8x16.min_u_with_const_2") (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_u_with_const_3") (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i8x16.max_s_with_const_4") (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_s_with_const_5") (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3))
+(assert_return (invoke "i8x16.max_u_with_const_6") (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_u_with_const_7") (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3))
+(assert_return (invoke "i8x16.avgr_u_with_const_8") (v128.const i8x16 192 192 192 192 96 96 96 96 96 96 96 96 192 192 192 192))
+(assert_return (invoke "i8x16.avgr_u_with_const_9") (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.abs_with_const_10") (v128.const i8x16 128 128 128 128 127 127 127 127 64 64 64 64 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt_with_const_11") (v128.const i8x16 1 1 1 1 7 7 7 7 1 1 1 1 8 8 8 8))
+
+;; Param vs const
+(assert_return (invoke "i8x16.min_s_with_const_12" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                                   (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_s_with_const_13" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i8x16.min_u_with_const_14" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                                   (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_u_with_const_15" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i8x16.max_s_with_const_16" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                                   (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_s_with_const_17" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))
+                                                   (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3))
+(assert_return (invoke "i8x16.max_u_with_const_18" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                                   (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_u_with_const_19" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))
+                                                   (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3))
+(assert_return (invoke "i8x16.avgr_u_with_const_20" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                                    (v128.const i8x16 192 192 192 192 96 96 96 96 96 96 96 96 192 192 192 192))
+(assert_return (invoke "i8x16.avgr_u_with_const_21" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))
+                                                    (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+
+;; Test different lanes go through different if-then clauses
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)
+                                     (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                     (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128)
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128))
+                                     (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 128 128 128 128))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)
+                                     (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                     (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128)
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128))
+                                     (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 128 128 128 128))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)
+                                     (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                     (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128)
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128))
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 2 2 2 2 128 128 128 128))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)
+                                     (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                     (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128)
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128))
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 2 2 2 2 128 128 128 128))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)
+                                      (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                      (v128.const i8x16 192 192 192 192 96 96 96 96 96 96 96 96 192 192 192 192))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128)
+                                      (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128))
+                                      (v128.const i8x16 0 0 0 0 2 2 2 2 2 2 2 2 128 128 128 128))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255))
+                                   (v128.const i8x16 128 128 128 128 127 127 127 127 64 64 64 64 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255))
+                                      (v128.const i8x16 1 1 1 1 7 7 7 7 1 1 1 1 8 8 8 8))
+
+;; Test opposite signs of zero
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)
+                                     (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)
+                                     (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)
+                                     (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)
+                                     (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)
+                                      (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)
+                                      (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                   (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                   (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+                                   (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                   (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; Unknown operators
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.avgr (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.avgr_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+
+;; Type check
+(assert_invalid (module (func (result v128) (i8x16.min_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.min_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.max_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.max_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.avgr_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.abs (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.popcnt (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.min_s-1st-arg-empty (result v128)
+      (i8x16.min_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.min_s-arg-empty (result v128)
+      (i8x16.min_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.min_u-1st-arg-empty (result v128)
+      (i8x16.min_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.min_u-arg-empty (result v128)
+      (i8x16.min_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.max_s-1st-arg-empty (result v128)
+      (i8x16.max_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.max_s-arg-empty (result v128)
+      (i8x16.max_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.max_u-1st-arg-empty (result v128)
+      (i8x16.max_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.max_u-arg-empty (result v128)
+      (i8x16.max_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.avgr_u-1st-arg-empty (result v128)
+      (i8x16.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.avgr_u-arg-empty (result v128)
+      (i8x16.avgr_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.abs-arg-empty (result v128)
+      (i8x16.abs)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.popcnt-arg-empty (result v128)
+      (i8x16.popcnt)
+    )
+  )
+  "type mismatch"
+)
+
+;; Combination
+(module
+  (func (export "i8x16.min_s-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_s-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_s-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_s-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_s-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_s-i8x16.abs") (param v128 v128) (result v128) (i8x16.min_s (i8x16.abs (local.get 0))(local.get 1)))
+  (func (export "i8x16.abs-i8x16.min_s") (param v128 v128) (result v128) (i8x16.abs (i8x16.min_s (local.get 0) (local.get 1))))
+  (func (export "i8x16.min_s-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.min_s (i8x16.popcnt (local.get 0))(local.get 1)))
+  (func (export "i8x16.popcnt-i8x16.min_s") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.min_s (local.get 0) (local.get 1))))
+  (func (export "i8x16.min_u-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_u-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_u-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_u-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_u-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_u-i8x16.abs") (param v128 v128) (result v128) (i8x16.min_u (i8x16.abs (local.get 0))(local.get 1)))
+  (func (export "i8x16.abs-i8x16.min_u") (param v128 v128) (result v128) (i8x16.abs (i8x16.min_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.min_u-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.min_u (i8x16.popcnt (local.get 0))(local.get 1)))
+  (func (export "i8x16.popcnt-i8x16.min_u") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.min_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.max_s-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_s-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_s-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_s-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_s-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_s-i8x16.abs") (param v128 v128) (result v128) (i8x16.max_s (i8x16.abs (local.get 0))(local.get 1)))
+  (func (export "i8x16.abs-i8x16.max_s") (param v128 v128) (result v128) (i8x16.abs (i8x16.max_s (local.get 0) (local.get 1))))
+  (func (export "i8x16.max_s-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.max_s (i8x16.popcnt (local.get 0))(local.get 1)))
+  (func (export "i8x16.popcnt-i8x16.max_s") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.max_s (local.get 0) (local.get 1))))
+  (func (export "i8x16.max_u-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_u-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_u-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_u-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_u-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_u-i8x16.abs") (param v128 v128) (result v128) (i8x16.max_u (i8x16.abs (local.get 0))(local.get 1)))
+  (func (export "i8x16.abs-i8x16.max_u") (param v128 v128) (result v128) (i8x16.abs (i8x16.max_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.max_u-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.max_u (i8x16.popcnt (local.get 0))(local.get 1)))
+  (func (export "i8x16.popcnt-i8x16.max_u") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.max_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.avgr_u-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.avgr_u-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.avgr_u-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.avgr_u-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.avgr_u-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.avgr_u-i8x16.abs") (param v128 v128) (result v128) (i8x16.avgr_u (i8x16.abs (local.get 0))(local.get 1)))
+  (func (export "i8x16.abs-i8x16.avgr_u") (param v128 v128) (result v128) (i8x16.abs (i8x16.avgr_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.avgr_u-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.avgr_u (i8x16.popcnt (local.get 0))(local.get 1)))
+  (func (export "i8x16.popcnt-i8x16.avgr_u") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.avgr_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.abs-i8x16.popcnt") (param v128) (result v128) (i8x16.abs (i8x16.popcnt (local.get 0))))
+  (func (export "i8x16.abs-i8x16.abs") (param v128) (result v128) (i8x16.abs (i8x16.abs (local.get 0))))
+  (func (export "i8x16.popcnt-i8x16.popcnt") (param v128) (result v128) (i8x16.popcnt (i8x16.popcnt (local.get 0))))
+  (func (export "i8x16.popcnt-i8x16.abs") (param v128) (result v128) (i8x16.popcnt (i8x16.abs (local.get 0))))
+)
+
+(assert_return (invoke "i8x16.min_s-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_s-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_s-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_s-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_s-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_s-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.abs-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                               (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_s-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.popcnt-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.min_u-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_u-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_u-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_u-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.abs-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                               (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.popcnt-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_s-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_s-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_s-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_s-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_s-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_s-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                               (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                               (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_s-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.popcnt-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_u-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_u-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_u-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_u-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_u-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_u-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                               (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                               (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.max_u-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.popcnt-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.avgr_u-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.avgr_u-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.avgr_u-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.avgr_u-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.avgr_u-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.avgr_u-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.avgr_u-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4))
+(assert_return (invoke "i8x16.popcnt-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.abs-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
diff --git a/test/core/simd/simd_i8x16_cmp.wast b/test/core/simd/simd_i8x16_cmp.wast
new file mode 100644
index 000000000..8683accea
--- /dev/null
+++ b/test/core/simd/simd_i8x16_cmp.wast
@@ -0,0 +1,1847 @@
+
+;; Test all the i8x16 comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (i8x16.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (i8x16.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x v128) (param $y v128) (result v128) (i8x16.lt_s (local.get $x) (local.get $y)))
+  (func (export "lt_u") (param $x v128) (param $y v128) (result v128) (i8x16.lt_u (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x v128) (param $y v128) (result v128) (i8x16.le_s (local.get $x) (local.get $y)))
+  (func (export "le_u") (param $x v128) (param $y v128) (result v128) (i8x16.le_u (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x v128) (param $y v128) (result v128) (i8x16.gt_s (local.get $x) (local.get $y)))
+  (func (export "gt_u") (param $x v128) (param $y v128) (result v128) (i8x16.gt_u (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x v128) (param $y v128) (result v128) (i8x16.ge_s (local.get $x) (local.get $y)))
+  (func (export "ge_u") (param $x v128) (param $y v128) (result v128) (i8x16.ge_u (local.get $x) (local.get $y)))
+)
+
+
+;; eq
+
+;; i8x16.eq  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                            (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                            (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                            (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                            (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                            (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "eq" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "eq" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                            (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                            (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                            (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                            (v128.const i8x16 0 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                            (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                            (v128.const i8x16 0 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 0))
+
+;; i8x16.eq  (i8x16) (i16x8)
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                            (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                            (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                            (v128.const i8x16 -1 0 -1 0 -1 -1 -1 -1 -1 0 -1 0 -1 0 -1 0))
+(assert_return (invoke "eq" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                            (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; i8x16.eq  (i8x16) (i32x4)
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                            (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                            (v128.const i32x4 -128 0 1 255))
+                            (v128.const i8x16 -1 0 0 0 -1 -1 -1 -1 -1 0 0 0 -1 0 0 0))
+(assert_return (invoke "eq" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                            (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; ne
+
+;; i8x16.ne  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                            (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                            (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                            (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                            (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                            (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "ne" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "ne" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                            (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                            (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                            (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 0 0 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                            (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 0 0 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.ne (i8x16) (i16x8)
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                            (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                            (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                            (v128.const i8x16 0 -1 0 -1 0 0 0 0 0 -1 0 -1 0 -1 0 -1))
+(assert_return (invoke "ne" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                            (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.ne  (i8x16) (i32x4)
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                            (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                            (v128.const i32x4 -128 0 1 255))
+                            (v128.const i8x16 0 -1 -1 -1 0 0 0 0 0 -1 -1 -1 0 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                            (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; lt_s
+
+;; i8x16.lt_s  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 0 -1 0 -1 0 0 0 -1 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 -1 -1 -1 0 0 0 0 0 -1 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 -1 -1 -1 0 0 0 0 0 -1 0 0 0))
+
+;; i8x16.lt_s  (i8x16) (i16x8)
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 0 -1 0 -1 0 0 0 0 0 0 0 0 0 -1 0 -1))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; i8x16.lt_s  (i8x16) (i32x4)
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 0 -1 -1 -1 0 0 0 0 0 0 0 0 0 -1 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; lt_u
+
+;; i8x16.lt_u  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 0 -1 0 -1 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 0 0 0 -1 -1 -1 -1 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 0 0 0 -1 -1 -1 -1 0 0 0))
+
+;; i8x16.lt_u  (i8x16) (i16x8)
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 0 -1 0 -1 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.lt_u  (i8x16) (i32x4)
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 0 -1 -1 -1 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; le_s
+
+;; i8x16.le_s  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 0 -1 0 -1 0 0 0 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 -1 -1 -1 -1 -1 0 0 0 -1 0 0 0))
+(assert_return (invoke "le_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 -1 -1 -1 -1 -1 0 0 0 -1 0 0 0))
+
+;; i8x16.le_s  (i8x16) (i16x8)
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 -1 0 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; i8x16.le_s  (i8x16) (i32x4)
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; le_u
+
+;; i8x16.le_u  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 0 -1 0 -1 0 0 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 0 -1 -1 -1 -1 -1 -1 0 0 0))
+(assert_return (invoke "le_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 0 -1 -1 -1 -1 -1 -1 0 0 0))
+
+;; i8x16.le_u  (i8x16) (i16x8)
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 -1 0 -1 0 -1 0))
+(assert_return (invoke "le_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.le_u  (i8x16) (i32x4)
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 -1 0 0 0))
+(assert_return (invoke "le_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; gt_s
+
+;; i8x16.gt_s  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 -1 0 -1 0 -1 -1 -1 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 0 0 0 0 0 -1 -1 -1 0 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 0 0 0 0 0 -1 -1 -1 0 -1 -1 -1))
+
+;; i8x16.gt_s  (i8x16) (i16x8)
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 -1 0 -1 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.gt_s  (i8x16) (i32x4)
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; gt_u
+
+;; i8x16.gt_u  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 -1 0 -1 0 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 -1 0 0 0 0 0 0 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 -1 0 0 0 0 0 0 -1 -1 -1))
+
+;; i8x16.gt_u  (i8x16) (i16x8)
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 -1 0 -1 0 -1 0 -1))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; i8x16.gt_u  (i8x16) (i32x4)
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 -1 -1 -1 0 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; ge_s
+
+;; i8x16.ge_s  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 -1 0 -1 0 -1 -1 -1 0 0 0))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 0 0 0 -1 -1 -1 -1 -1 0 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 0 0 0 -1 -1 -1 -1 -1 0 -1 -1 -1))
+
+;; i8x16.ge_s  (i8x16) (i16x8)
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 -1 0 -1 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 -1 0))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.ge_s  (i8x16) (i32x4)
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 -1 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; ge_u
+
+;; i8x16.ge_u  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 -1 0 -1 0 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 -1 -1 -1 0 0 0 0 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 -1 -1 -1 0 0 0 0 -1 -1 -1))
+
+;; i8x16.ge_u (i8x16) (i16x8)
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 -1 0 -1 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; i8x16.ge_u (i8x16) (i32x4)
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 -1 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (i8x16.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.ge_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.gt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.le_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.lt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+
+
+;; combination
+
+(module (memory 1)
+  (func (export "eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "lt_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.lt_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "le_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.le_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "gt_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.gt_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ge_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.ge_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-eq")
+    (drop
+      (i8x16.eq
+        (i8x16.eq
+          (i8x16.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.eq
+          (i8x16.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ne")
+    (drop
+      (i8x16.ne
+        (i8x16.ne
+          (i8x16.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.ne
+          (i8x16.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-lt_s")
+    (drop
+      (i8x16.lt_s
+        (i8x16.lt_s
+          (i8x16.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.lt_s
+          (i8x16.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-le_u")
+    (drop
+      (i8x16.le_u
+        (i8x16.le_u
+          (i8x16.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.le_u
+          (i8x16.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-gt_u")
+    (drop
+      (i8x16.gt_u
+        (i8x16.gt_u
+          (i8x16.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.gt_u
+          (i8x16.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ge_s")
+    (drop
+      (i8x16.ge_s
+        (i8x16.ge_s
+          (i8x16.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.ge_s
+          (i8x16.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (i8x16.ge_u
+        (i8x16.eq
+          (i8x16.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.ne
+          (i8x16.gt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.lt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "eq-in-block"))
+(assert_return (invoke "ne-in-block"))
+(assert_return (invoke "lt_s-in-block"))
+(assert_return (invoke "le_u-in-block"))
+(assert_return (invoke "gt_u-in-block"))
+(assert_return (invoke "ge_s-in-block"))
+(assert_return (invoke "nested-eq"))
+(assert_return (invoke "nested-ne"))
+(assert_return (invoke "nested-lt_s"))
+(assert_return (invoke "nested-le_u"))
+(assert_return (invoke "nested-gt_u"))
+(assert_return (invoke "nested-ge_s"))
+(assert_return (invoke "as-param"))
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.eq-1st-arg-empty (result v128)
+      (i8x16.eq (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.eq-arg-empty (result v128)
+      (i8x16.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ne-1st-arg-empty (result v128)
+      (i8x16.ne (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ne-arg-empty (result v128)
+      (i8x16.ne)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.lt_s-1st-arg-empty (result v128)
+      (i8x16.lt_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.lt_s-arg-empty (result v128)
+      (i8x16.lt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.lt_u-1st-arg-empty (result v128)
+      (i8x16.lt_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.lt_u-arg-empty (result v128)
+      (i8x16.lt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.le_s-1st-arg-empty (result v128)
+      (i8x16.le_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.le_s-arg-empty (result v128)
+      (i8x16.le_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.le_u-1st-arg-empty (result v128)
+      (i8x16.le_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.le_u-arg-empty (result v128)
+      (i8x16.le_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.gt_s-1st-arg-empty (result v128)
+      (i8x16.gt_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.gt_s-arg-empty (result v128)
+      (i8x16.gt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.gt_u-1st-arg-empty (result v128)
+      (i8x16.gt_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.gt_u-arg-empty (result v128)
+      (i8x16.gt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ge_s-1st-arg-empty (result v128)
+      (i8x16.ge_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ge_s-arg-empty (result v128)
+      (i8x16.ge_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ge_u-1st-arg-empty (result v128)
+      (i8x16.ge_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ge_u-arg-empty (result v128)
+      (i8x16.ge_u)
+    )
+  )
+  "type mismatch"
+)
\ No newline at end of file
diff --git a/test/core/simd/simd_i8x16_sat_arith.wast b/test/core/simd/simd_i8x16_sat_arith.wast
new file mode 100644
index 000000000..a799a8b73
--- /dev/null
+++ b/test/core/simd/simd_i8x16_sat_arith.wast
@@ -0,0 +1,718 @@
+;; Tests for i8x16 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i8x16.add_sat_s") (param v128 v128) (result v128) (i8x16.add_sat_s (local.get 0) (local.get 1)))
+  (func (export "i8x16.add_sat_u") (param v128 v128) (result v128) (i8x16.add_sat_u (local.get 0) (local.get 1)))
+  (func (export "i8x16.sub_sat_s") (param v128 v128) (result v128) (i8x16.sub_sat_s (local.get 0) (local.get 1)))
+  (func (export "i8x16.sub_sat_u") (param v128 v128) (result v128) (i8x16.sub_sat_u (local.get 0) (local.get 1)))
+)
+
+
+;; i8x16.add_sat_s
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i8x16 0x01 0x01 0x81 0x7f 0x01 0x01 0x81 0x7f 0x01 0x01 0x81 0x7f 0x01 0x01 0x81 0x7f))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i8x16 0x01 0x01 0x81 0 0x01 0x01 0x81 0 0x01 0x01 0x81 0 0x01 0x01 0x81 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i8x16 0x01 0x01 0xc1 0x7f 0x01 0x01 0xc1 0x7f 0x01 0x01 0xc1 0x7f 0x01 0x01 0xc1 0x7f))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i8x16 0x01 0x01 0xc1 0 0x01 0x01 0xc1 0 0x01 0x01 0xc1 0 0x01 0x01 0xc1 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                         (v128.const i8x16 0 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45))
+
+;; i8x16.add_sat_u
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 129 129 129 129 129 129 129 129 129 129 129 129 129 129 129 129))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                         (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i8x16 0x80 0x80 0x80 0xff 0x80 0x80 0x80 0xff 0x80 0x80 0x80 0xff 0x80 0x80 0x80 0xff))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i8x16 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i8x16 0x01 0x01 0x81 0xff 0x01 0x01 0x81 0xff 0x01 0x01 0x81 0xff 0x01 0x01 0x81 0xff))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i8x16 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i8x16 0x01 0x01 0xc1 0xff 0x01 0x01 0xc1 0xff 0x01 0x01 0xc1 0xff 0x01 0x01 0xc1 0xff))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                         (v128.const i8x16 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                         (v128.const i8x16 0 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45))
+
+;; i8x16.sub_sat_s
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i8x16 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i8x16 0x01 0x01 0x7f 0x82 0x01 0x01 0x7f 0x82 0x01 0x01 0x7f 0x82 0x01 0x01 0x7f 0x82))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i8x16 0x01 0x01 0x7f 0x02 0x01 0x01 0x7f 0x02 0x01 0x01 0x7f 0x02 0x01 0x01 0x7f 0x02))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i8x16 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i8x16 0x01 0x01 0x41 0x02 0x01 0x01 0x41 0x02 0x01 0x01 0x41 0x02 0x01 0x01 0x41 0x02))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                         (v128.const i8x16 0 0x02 0x04 0x06 0x08 0x0a 0x0c 0x0e 0x10 0x12 0x14 0x16 0x18 0x1a 0x1c 0x1e))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                         (v128.const i8x16 0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15))
+
+;; i8x16.sub_sat_u
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i8x16 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i8x16 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i8x16 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i8x16 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i8x16 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; Malformed cases: non-existent op names
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.add_sat (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.sub_sat (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.mul_sat (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.div_sat (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.add_sat_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.add_sat_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.sub_sat_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.sub_sat_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (f32x4.add_sat_s (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (f32x4.add_sat_u (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (f32x4.sub_sat_s (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (f32x4.sub_sat_u (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0)))")
+    "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (i8x16.add_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.add_sat_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.sub_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.sub_sat_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.add_sat_s-1st-arg-empty (result v128)
+      (i8x16.add_sat_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.add_sat_s-arg-empty (result v128)
+      (i8x16.add_sat_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.add_sat_u-1st-arg-empty (result v128)
+      (i8x16.add_sat_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.add_sat_u-arg-empty (result v128)
+      (i8x16.add_sat_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub_sat_s-1st-arg-empty (result v128)
+      (i8x16.sub_sat_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub_sat_s-arg-empty (result v128)
+      (i8x16.sub_sat_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub_sat_u-1st-arg-empty (result v128)
+      (i8x16.sub_sat_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub_sat_u-arg-empty (result v128)
+      (i8x16.sub_sat_u)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "sat-add_s-sub_s") (param v128 v128 v128) (result v128)
+    (i8x16.add_sat_s (i8x16.sub_sat_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_s-sub_u") (param v128 v128 v128) (result v128)
+    (i8x16.add_sat_s (i8x16.sub_sat_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_u-sub_s") (param v128 v128 v128) (result v128)
+    (i8x16.add_sat_u (i8x16.sub_sat_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_u-sub_u") (param v128 v128 v128) (result v128)
+    (i8x16.add_sat_u (i8x16.sub_sat_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_s-neg") (param v128 v128) (result v128)
+    (i8x16.add_sat_s (i8x16.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-add_u-neg") (param v128 v128) (result v128)
+    (i8x16.add_sat_u (i8x16.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-sub_s-neg") (param v128 v128) (result v128)
+    (i8x16.sub_sat_s (i8x16.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-sub_u-neg") (param v128 v128) (result v128)
+    (i8x16.sub_sat_u (i8x16.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "sat-add_s-sub_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "sat-add_s-sub_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "sat-add_u-sub_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254))
+(assert_return (invoke "sat-add_u-sub_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "sat-add_s-neg" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                       (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                       (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "sat-add_u-neg" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                       (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                       (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "sat-sub_s-neg" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                       (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                       (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "sat-sub_u-neg" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                       (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                       (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
\ No newline at end of file
diff --git a/test/core/simd/simd_int_to_int_extend.wast b/test/core/simd/simd_int_to_int_extend.wast
new file mode 100644
index 000000000..be8d554ca
--- /dev/null
+++ b/test/core/simd/simd_int_to_int_extend.wast
@@ -0,0 +1,599 @@
+;; Tests for int-to-int extension operations.
+
+(module
+  (func (export "i16x8.extend_high_i8x16_s") (param v128) (result v128) (i16x8.extend_high_i8x16_s (local.get 0)))
+  (func (export "i16x8.extend_high_i8x16_u") (param v128) (result v128) (i16x8.extend_high_i8x16_u (local.get 0)))
+  (func (export "i16x8.extend_low_i8x16_s") (param v128) (result v128) (i16x8.extend_low_i8x16_s (local.get 0)))
+  (func (export "i16x8.extend_low_i8x16_u") (param v128) (result v128) (i16x8.extend_low_i8x16_u (local.get 0)))
+  (func (export "i32x4.extend_high_i16x8_s") (param v128) (result v128) (i32x4.extend_high_i16x8_s (local.get 0)))
+  (func (export "i32x4.extend_high_i16x8_u") (param v128) (result v128) (i32x4.extend_high_i16x8_u (local.get 0)))
+  (func (export "i32x4.extend_low_i16x8_s") (param v128) (result v128) (i32x4.extend_low_i16x8_s (local.get 0)))
+  (func (export "i32x4.extend_low_i16x8_u") (param v128) (result v128) (i32x4.extend_low_i16x8_u (local.get 0)))
+  (func (export "i64x2.extend_high_i32x4_s") (param v128) (result v128) (i64x2.extend_high_i32x4_s (local.get 0)))
+  (func (export "i64x2.extend_high_i32x4_u") (param v128) (result v128) (i64x2.extend_high_i32x4_u (local.get 0)))
+  (func (export "i64x2.extend_low_i32x4_s") (param v128) (result v128) (i64x2.extend_low_i32x4_s (local.get 0)))
+  (func (export "i64x2.extend_low_i32x4_u") (param v128) (result v128) (i64x2.extend_low_i32x4_u (local.get 0)))
+)
+
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 126 126 126 126 126 126 126 126))
+                                                   (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                   (v128.const i16x8 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 126 126 126 126 126 126 126 126))
+                                                   (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                   (v128.const i16x8 129 129 129 129 129 129 129 129))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 126 126 126 126 126 126 126 126))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                  (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 126 126 126 126 126 126 126 126))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 129 129 129 129 129 129 129 129))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 0 0 0 0 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 1 1 1 1 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 1 1 1 1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32766 32766 32766 32766))
+                                                   (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32767 -32767 -32767 -32767))
+                                                   (v128.const i32x4 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 -32768 -32768 -32768 -32768))
+
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 0 0 0 0 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 1 1 1 1 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 1 1 1 1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32766 32766 32766 32766))
+                                                   (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 -1 -1 -1 -1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32767 -32767 -32767 -32767))
+                                                   (v128.const i32x4 32769 32769 32769 32769))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -1 -1 -1 -1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 0 0 0 0 1 1 1 1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 1 1 1 1 0 0 0 0))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 1 1 1 1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 1 1 1 1))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32767 32767 32767 32767))
+                                                  (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32766 32766 32766 32766))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 32767 32767 32767 32767))
+                                                  (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 32767 32767 32767 32767))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32767 -32767 -32767 -32767))
+                                                  (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 0 0 0 0 1 1 1 1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 1 1 1 1 0 0 0 0))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 1 1 1 1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 1 1 1 1))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32767 32767 32767 32767))
+                                                  (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32766 32766 32766 32766))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 32767 32767 32767 32767))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 32767 32767 32767 32767))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 32769 32769 32769 32769))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32767 -32767 -32767 -32767))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 0 0 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 0 0 -1 -1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 1 1 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -1 -1 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 1 1 -1 -1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -1 -1 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483646 2147483646 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483646 2147483646))
+                                                   (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 -2147483648 -2147483648))
+                                                   (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 -1 -1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -1 -1 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483647 -2147483647 -2147483648 -2147483648))
+                                                   (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483647 -2147483647))
+                                                   (v128.const i64x2 -2147483647 -2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -1 -1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -1 -1 -2147483648 -2147483648))
+                                                   (v128.const i64x2 -2147483648 -2147483648))
+
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 0 0 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 0 0 -1 -1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 1 1 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -1 -1 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 1 1 -1 -1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -1 -1 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483646 2147483646 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483646 2147483646))
+                                                   (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 -2147483648 -2147483648))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 -1 -1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -1 -1 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483647 -2147483647 -2147483648 -2147483648))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483647 -2147483647))
+                                                   (v128.const i64x2 2147483649 2147483649))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -1 -1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -1 -1 -2147483648 -2147483648))
+                                                   (v128.const i64x2 2147483648 2147483648))
+
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 0 0 1 1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 0 0 -1 -1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 1 1 0 0))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -1 -1 0 0))
+                                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 1 1 -1 -1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -1 -1 1 1))
+                                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483646 2147483646 2147483647 2147483647))
+                                                  (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483646 2147483646))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 -2147483648 -2147483648))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 2147483647 2147483647))
+                                                  (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 -1 -1))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -1 -1 2147483647 2147483647))
+                                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483647 -2147483647 -2147483648 -2147483648))
+                                                  (v128.const i64x2 -2147483647 -2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483647 -2147483647))
+                                                  (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -1 -1))
+                                                  (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -1 -1 -2147483648 -2147483648))
+                                                  (v128.const i64x2 -1 -1))
+
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 0 0 1 1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 0 0 -1 -1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 1 1 0 0))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -1 -1 0 0))
+                                                  (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 1 1 -1 -1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -1 -1 1 1))
+                                                  (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483646 2147483646 2147483647 2147483647))
+                                                  (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483646 2147483646))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 -2147483648 -2147483648))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 2147483647 2147483647))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 -1 -1))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -1 -1 2147483647 2147483647))
+                                                  (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483647 -2147483647 -2147483648 -2147483648))
+                                                  (v128.const i64x2 2147483649 2147483649))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483647 -2147483647))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -1 -1))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -1 -1 -2147483648 -2147483648))
+                                                  (v128.const i64x2 4294967295 4294967295))
+
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.extend_high_i8x16_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extend_high_i8x16_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extend_low_i8x16_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extend_low_i8x16_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extend_high_i16x8_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extend_high_i16x8_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extend_low_i16x8_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extend_low_i16x8_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extend_high_i32x4_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extend_high_i32x4_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extend_low_i32x4_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extend_low_i32x4_u (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.extend_high_i8x16_s-arg-empty (result v128)
+      (i16x8.extend_high_i8x16_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extend_high_i8x16_u-arg-empty (result v128)
+      (i16x8.extend_high_i8x16_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extend_low_i8x16_s-arg-empty (result v128)
+      (i16x8.extend_low_i8x16_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extend_low_i8x16_u-arg-empty (result v128)
+      (i16x8.extend_low_i8x16_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extend_high_i16x8_s-arg-empty (result v128)
+      (i32x4.extend_high_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extend_high_i16x8_u-arg-empty (result v128)
+      (i32x4.extend_high_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extend_low_i16x8_s-arg-empty (result v128)
+      (i32x4.extend_low_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extend_low_i16x8_u-arg-empty (result v128)
+      (i32x4.extend_low_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extend_high_i32x4_s-arg-empty (result v128)
+      (i64x2.extend_high_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extend_high_i32x4_u-arg-empty (result v128)
+      (i64x2.extend_high_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extend_low_i32x4_s-arg-empty (result v128)
+      (i64x2.extend_low_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extend_low_i32x4_u-arg-empty (result v128)
+      (i64x2.extend_low_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/test/core/simd/simd_lane.wast b/test/core/simd/simd_lane.wast
new file mode 100644
index 000000000..9d4b5fd72
--- /dev/null
+++ b/test/core/simd/simd_lane.wast
@@ -0,0 +1,1265 @@
+;; Tests for the extract_lane, replace_lane, swizzle and shuffle group instructions
+
+
+(module
+  (func (export "i8x16_extract_lane_s-first") (param v128) (result i32)
+    (i8x16.extract_lane_s 0 (local.get 0)))
+  (func (export "i8x16_extract_lane_s-last") (param v128) (result i32)
+    (i8x16.extract_lane_s 15 (local.get 0)))
+  (func (export "i8x16_extract_lane_u-first") (param v128) (result i32)
+    (i8x16.extract_lane_u 0 (local.get 0)))
+  (func (export "i8x16_extract_lane_u-last") (param v128) (result i32)
+    (i8x16.extract_lane_u 15 (local.get 0)))
+  (func (export "i16x8_extract_lane_s-first") (param v128) (result i32)
+    (i16x8.extract_lane_s 0 (local.get 0)))
+  (func (export "i16x8_extract_lane_s-last") (param v128) (result i32)
+    (i16x8.extract_lane_s 7 (local.get 0)))
+  (func (export "i16x8_extract_lane_u-first") (param v128) (result i32)
+    (i16x8.extract_lane_u 0 (local.get 0)))
+  (func (export "i16x8_extract_lane_u-last") (param v128) (result i32)
+    (i16x8.extract_lane_u 7 (local.get 0)))
+  (func (export "i32x4_extract_lane-first") (param v128) (result i32)
+    (i32x4.extract_lane 0 (local.get 0)))
+  (func (export "i32x4_extract_lane-last") (param v128) (result i32)
+    (i32x4.extract_lane 3 (local.get 0)))
+  (func (export "f32x4_extract_lane-first") (param v128) (result f32)
+    (f32x4.extract_lane 0 (local.get 0)))
+  (func (export "f32x4_extract_lane-last") (param v128) (result f32)
+    (f32x4.extract_lane 3 (local.get 0)))
+  (func (export "i8x16_replace_lane-first") (param v128 i32) (result v128)
+    (i8x16.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "i8x16_replace_lane-last") (param v128 i32) (result v128)
+    (i8x16.replace_lane 15 (local.get 0) (local.get 1)))
+  (func (export "i16x8_replace_lane-first") (param v128 i32) (result v128)
+    (i16x8.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "i16x8_replace_lane-last") (param v128 i32) (result v128)
+    (i16x8.replace_lane 7 (local.get 0) (local.get 1)))
+  (func (export "i32x4_replace_lane-first") (param v128 i32) (result v128)
+    (i32x4.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "i32x4_replace_lane-last") (param v128 i32) (result v128)
+    (i32x4.replace_lane 3 (local.get 0) (local.get 1)))
+  (func (export "f32x4_replace_lane-first") (param v128 f32) (result v128)
+    (f32x4.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "f32x4_replace_lane-last") (param v128 f32) (result v128)
+    (f32x4.replace_lane 3 (local.get 0) (local.get 1)))
+  (func (export "i64x2_extract_lane-first") (param v128) (result i64)
+    (i64x2.extract_lane 0 (local.get 0)))
+  (func (export "i64x2_extract_lane-last") (param v128) (result i64)
+    (i64x2.extract_lane 1 (local.get 0)))
+  (func (export "f64x2_extract_lane-first") (param v128) (result f64)
+    (f64x2.extract_lane 0 (local.get 0)))
+  (func (export "f64x2_extract_lane-last") (param v128) (result f64)
+    (f64x2.extract_lane 1 (local.get 0)))
+  (func (export "i64x2_replace_lane-first") (param v128 i64) (result v128)
+    (i64x2.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "i64x2_replace_lane-last") (param v128 i64) (result v128)
+    (i64x2.replace_lane 1 (local.get 0) (local.get 1)))
+  (func (export "f64x2_replace_lane-first") (param v128 f64) (result v128)
+    (f64x2.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "f64x2_replace_lane-last") (param v128 f64) (result v128)
+    (f64x2.replace_lane 1 (local.get 0) (local.get 1)))
+
+  ;; Swizzle and shuffle
+  (func (export "v8x16_swizzle") (param v128 v128) (result v128)
+    (i8x16.swizzle (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-1") (param v128 v128) (result v128)
+    (i8x16.shuffle  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-2") (param v128 v128) (result v128)
+    (i8x16.shuffle 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-3") (param v128 v128) (result v128)
+    (i8x16.shuffle 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-4") (param v128 v128) (result v128)
+    (i8x16.shuffle 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-5") (param v128 v128) (result v128)
+    (i8x16.shuffle  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-6") (param v128 v128) (result v128)
+    (i8x16.shuffle 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-7") (param v128 v128) (result v128)
+    (i8x16.shuffle  0  0  0  0  0  0  0  0 16 16 16 16 16 16 16 16 (local.get 0) (local.get 1)))
+)
+
+(assert_return (invoke "i8x16_extract_lane_s-first" (v128.const i8x16 127 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 127))
+(assert_return (invoke "i8x16_extract_lane_s-first" (v128.const i8x16 0x7f 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 127))
+(assert_return (invoke "i8x16_extract_lane_s-first" (v128.const i8x16 255 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const -1))
+(assert_return (invoke "i8x16_extract_lane_s-first" (v128.const i8x16 0xff 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const -1))
+(assert_return (invoke "i8x16_extract_lane_u-first" (v128.const i8x16 255 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 255))
+(assert_return (invoke "i8x16_extract_lane_u-first" (v128.const i8x16 0xff 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 255))
+(assert_return (invoke "i8x16_extract_lane_s-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -128)) (i32.const -128))
+(assert_return (invoke "i8x16_extract_lane_s-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0x80)) (i32.const -128))
+(assert_return (invoke "i8x16_extract_lane_u-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1)) (i32.const 255))
+(assert_return (invoke "i8x16_extract_lane_u-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0xff)) (i32.const 255))
+(assert_return (invoke "i8x16_extract_lane_u-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -128)) (i32.const 128))
+(assert_return (invoke "i8x16_extract_lane_u-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0x80)) (i32.const 128))
+
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 32767 0 0 0 0 0 0 0)) (i32.const 32767))
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 0x7fff 0 0 0 0 0 0 0)) (i32.const 32767))
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 65535 0 0 0 0 0 0 0)) (i32.const -1))
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 0xffff 0 0 0 0 0 0 0)) (i32.const -1))
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 012_345 0 0 0 0 0 0 0)) (i32.const 12345))
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 -0x0_1234 0 0 0 0 0 0 0)) (i32.const -0x1234))
+(assert_return (invoke "i16x8_extract_lane_u-first" (v128.const i16x8 65535 0 0 0 0 0 0 0)) (i32.const 65535))
+(assert_return (invoke "i16x8_extract_lane_u-first" (v128.const i16x8 0xffff 0 0 0 0 0 0 0)) (i32.const 65535))
+(assert_return (invoke "i16x8_extract_lane_u-first" (v128.const i16x8 012_345 0 0 0 0 0 0 0)) (i32.const 12345))
+(assert_return (invoke "i16x8_extract_lane_u-first" (v128.const i16x8 -0x0_1234 0 0 0 0 0 0 0)) (i32.const 60876))
+(assert_return (invoke "i16x8_extract_lane_s-last" (v128.const i16x8 0 0 0 0 0 0 0 -32768)) (i32.const -32768))
+(assert_return (invoke "i16x8_extract_lane_s-last" (v128.const i16x8 0 0 0 0 0 0 0 0x8000)) (i32.const -32768))
+(assert_return (invoke "i16x8_extract_lane_s-last" (v128.const i16x8 0 0 0 0 0 0 0 06_789)) (i32.const 6789))
+(assert_return (invoke "i16x8_extract_lane_s-last" (v128.const i16x8 0 0 0 0 0 0 0 -0x0_6789)) (i32.const -0x6789))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 -1)) (i32.const 65535))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 0xffff)) (i32.const 65535))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 -32768)) (i32.const 32768))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 0x8000)) (i32.const 32768))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 06_789)) (i32.const 6789))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 -0x0_6789)) (i32.const 39031))
+
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 2147483647 0 0 0)) (i32.const 2147483647))
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 0x7fffffff 0 0 0)) (i32.const 2147483647))
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 4294967295 0 0 0)) (i32.const -1))
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 0xffffffff 0 0 0)) (i32.const -1))
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 01_234_567_890 0 0 0)) (i32.const 1234567890))
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 -0x0_1234_5678 0 0 0)) (i32.const -0x12345678))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 -2147483648)) (i32.const -2147483648))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 0x80000000)) (i32.const -2147483648))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 -1)) (i32.const -1))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 0xffffffff)) (i32.const -1))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 0_987_654_321)) (i32.const 987654321))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 -0x0_1234_5678)) (i32.const -0x12345678))
+
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 9223372036854775807 0)) (i64.const 9223372036854775807))
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 0x7ffffffffffffffe 0)) (i64.const 0x7ffffffffffffffe))
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 18446744073709551615 0)) (i64.const -1))
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 0xffffffffffffffff 0)) (i64.const -1))
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 01_234_567_890_123_456_789 0)) (i64.const 1234567890123456789))
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 0x0_1234_5678_90AB_cdef 0)) (i64.const 0x1234567890abcdef))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 9223372036854775808)) (i64.const -9223372036854775808))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 0x8000000000000000)) (i64.const -0x8000000000000000))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 0x8000000000000000)) (i64.const 0x8000000000000000))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0x7f)) (i64.const 9223372036854775807))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0x8000)) (i64.const -9223372036854775808))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i32x4 0 0 0xffffffff 0x7fffffff)) (i64.const 9223372036854775807))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const f64x2 -inf +inf)) (i64.const 0x7ff0000000000000))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 01_234_567_890_123_456_789)) (i64.const 1234567890123456789))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 0x0_1234_5678_90AB_cdef)) (i64.const 0x1234567890abcdef))
+
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 -5.0 0.0 0.0 0.0)) (f32.const -5.0))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 1e38 0.0 0.0 0.0)) (f32.const 1e38))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 0x1.fffffep127 0.0 0.0 0.0)) (f32.const 0x1.fffffep127))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 0x1p127 0.0 0.0 0.0)) (f32.const 0x1p127))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 inf 0.0 0.0 0.0)) (f32.const inf))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 nan inf 0.0 0.0)) (f32.const nan))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 0123456789.0123456789e+019 0.0 0.0 0.0)) (f32.const 123456789.0123456789e+019))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0.0 0.0 0.0)) (f32.const 0x123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 -1e38)) (f32.const -1e38))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 -0x1.fffffep127)) (f32.const -0x1.fffffep127))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 -0x1p127)) (f32.const -0x1p127))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 -inf)) (f32.const -inf))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 -inf nan)) (f32.const nan))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 0123456789.)) (f32.const 123456789.0))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 0x0123456789ABCDEF.)) (f32.const 0x123456789ABCDEF.0p0))
+
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -1.5 0.0)) (f64.const -1.5))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 1.5 0.0)) (f64.const 1.5))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -1.7976931348623157e-308 0x0p+0)) (f64.const -1.7976931348623157e-308))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 1.7976931348623157e-308 0x0p-0)) (f64.const 1.7976931348623157e-308))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -0x1.fffffffffffffp-1023 0x0p+0)) (f64.const -0x1.fffffffffffffp-1023))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 0x1.fffffffffffffp-1023 0x0p-0)) (f64.const 0x1.fffffffffffffp-1023))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -inf 0.0)) (f64.const -inf))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 inf 0.0)) (f64.const inf))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -nan -0.0)) (f64.const -nan))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 nan 0.0)) (f64.const nan))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 0123456789.0123456789e+019 0.0)) (f64.const 123456789.0123456789e+019))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0.0)) (f64.const 0x123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 2.25)) (f64.const 2.25))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 -2.25)) (f64.const -2.25))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0x0p-0 -1.7976931348623157e+308)) (f64.const -1.7976931348623157e+308))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0x0p+0 1.7976931348623157e+308)) (f64.const 1.7976931348623157e+308))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0x0p-0 -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0x0p+0 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 -0.0 -inf)) (f64.const -inf))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 inf)) (f64.const inf))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 -0.0 -nan)) (f64.const -nan))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 nan)) (f64.const nan))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 0123456789.)) (f64.const 123456789.0))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 0x0123456789ABCDEFabcdef.)) (f64.const 0x123456789ABCDEFabcdef.0))
+
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (f64.const 0.0))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0x80)) (f64.const -0.0))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0x4000)) (f64.const 2.0))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0xc000)) (f64.const -2.0))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i32x4 0 0 0xffffffff 0x7fefffff)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i32x4 0 0 0 0x00100000)) (f64.const 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i32x4 0 0 0xffffffff 0x000fffff)) (f64.const 0x1.ffffffffffffep-1023))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i32x4 0 0 1 0)) (f64.const 0x0.0000000000002p-1023))
+
+(assert_return (invoke "i8x16_replace_lane-first" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 127)) (v128.const i8x16 127 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16_replace_lane-first" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 128)) (v128.const i8x16 -128 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16_replace_lane-first" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 255)) (v128.const i8x16 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16_replace_lane-first" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 256)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16_replace_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const -128)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -128))
+(assert_return (invoke "i8x16_replace_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const -129)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127))
+(assert_return (invoke "i8x16_replace_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 32767)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0xff))
+(assert_return (invoke "i8x16_replace_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const -32768)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 32767)) (v128.const i16x8 32767 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 32768)) (v128.const i16x8 -32768 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 65535)) (v128.const i16x8 -1 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 65536)) (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 012345)) (v128.const i16x8 012_345 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const -0x01234)) (v128.const i16x8 -0x0_1234 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const -32768)) (v128.const i16x8 0 0 0 0 0 0 0 -32768))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const -32769)) (v128.const i16x8 0 0 0 0 0 0 0 32767))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 0x7fffffff)) (v128.const i16x8 0 0 0 0 0 0 0 0xffff))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 0x80000000)) (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 054321)) (v128.const i16x8 0 0 0 0 0 0 0 054_321))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const -0x04321)) (v128.const i16x8 0 0 0 0 0 0 0 -0x0_4321))
+
+(assert_return (invoke "i32x4_replace_lane-first" (v128.const i32x4 0 0 0 0) (i32.const 2147483647)) (v128.const i32x4 2147483647 0 0 0))
+(assert_return (invoke "i32x4_replace_lane-first" (v128.const i32x4 0 0 0 0) (i32.const 4294967295)) (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "i32x4_replace_lane-first" (v128.const i32x4 0 0 0 0) (i32.const 01234567890)) (v128.const i32x4 01_234_567_890 0 0 0))
+(assert_return (invoke "i32x4_replace_lane-first" (v128.const i32x4 0 0 0 0) (i32.const -0x012345678)) (v128.const i32x4 -0x0_1234_5678 0 0 0))
+(assert_return (invoke "i32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (i32.const 2147483648)) (v128.const i32x4 0 0 0 2147483648))
+(assert_return (invoke "i32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (i32.const -2147483648)) (v128.const i32x4 0 0 0 -2147483648))
+(assert_return (invoke "i32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (i32.const 01234567890)) (v128.const i32x4 0 0 0 01_234_567_890))
+(assert_return (invoke "i32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (i32.const -0x012345678)) (v128.const i32x4 0 0 0 -0x0_1234_5678))
+
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 53.0)) (v128.const f32x4 53.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const i32x4 0 0 0 0 ) (f32.const 53.0)) (v128.const f32x4 53.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const nan)) (v128.const f32x4 nan 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const inf)) (v128.const f32x4 inf 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 nan 0.0 0.0 0.0) (f32.const 3.14)) (v128.const f32x4 3.14 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 inf 0.0 0.0 0.0) (f32.const 1e38)) (v128.const f32x4 1e38 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 inf 0.0 0.0 0.0) (f32.const 0x1.fffffep127)) (v128.const f32x4 0x1.fffffep127 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 inf 0.0 0.0 0.0) (f32.const 0x1p127)) (v128.const f32x4 0x1p127 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0123456789)) (v128.const f32x4 0123456789 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0123456789.)) (v128.const f32x4 0123456789. 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0x0123456789ABCDEF)) (v128.const f32x4 0x0123456789ABCDEF 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0x0123456789ABCDEF.)) (v128.const f32x4 0x0123456789ABCDEF. 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const -53.0)) (v128.const f32x4 0.0 0.0 0.0 -53.0))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (f32.const -53.0)) (v128.const f32x4 0.0 0.0 0.0 -53.0))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const nan)) (v128.const f32x4 0.0 0.0 0.0 nan))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const -inf)) (v128.const f32x4 0.0 0.0 0.0 -inf))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 nan) (f32.const 3.14)) (v128.const f32x4 0.0 0.0 0.0 3.14))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 -inf) (f32.const -1e38)) (v128.const f32x4 0.0 0.0 0.0 -1e38))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 -inf) (f32.const -0x1.fffffep127)) (v128.const f32x4 0.0 0.0 0.0 -0x1.fffffep127))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 -inf) (f32.const -0x1p127)) (v128.const f32x4 0.0 0.0 0.0 -0x1p127))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0123456789e019)) (v128.const f32x4 0.0 0.0 0.0 0123456789e019))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0123456789.e+019)) (v128.const f32x4 0.0 0.0 0.0 0123456789.e+019))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0x0123456789ABCDEFp019)) (v128.const f32x4 0.0 0.0 0.0 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0x0123456789ABCDEF.p-019)) (v128.const f32x4 0.0 0.0 0.0 0x0123456789ABCDEF.p-019))
+
+(assert_return (invoke "i64x2_replace_lane-first" (v128.const i64x2 0 0) (i64.const 9223372036854775807)) (v128.const i64x2 9223372036854775807 0))
+(assert_return (invoke "i64x2_replace_lane-first" (v128.const i64x2 0 0) (i64.const 18446744073709551615)) (v128.const i64x2 -1 0))
+(assert_return (invoke "i64x2_replace_lane-first" (v128.const i64x2 0 0) (i64.const 01234567890123456789)) (v128.const i64x2 01_234_567_890_123_456_789 0))
+(assert_return (invoke "i64x2_replace_lane-first" (v128.const i64x2 0 0) (i64.const 0x01234567890abcdef)) (v128.const i64x2 0x0_1234_5678_90AB_cdef 0))
+(assert_return (invoke "i64x2_replace_lane-last" (v128.const i64x2 0 0) (i64.const 9223372036854775808)) (v128.const i64x2 0 9223372036854775808))
+(assert_return (invoke "i64x2_replace_lane-last" (v128.const i64x2 0 0) (i64.const 9223372036854775808)) (v128.const i64x2 0 -9223372036854775808))
+(assert_return (invoke "i64x2_replace_lane-last" (v128.const i64x2 0 0) (i64.const 01234567890123456789)) (v128.const i64x2 0 01_234_567_890_123_456_789))
+(assert_return (invoke "i64x2_replace_lane-last" (v128.const i64x2 0 0) (i64.const 0x01234567890abcdef)) (v128.const i64x2 0 0x0_1234_5678_90AB_cdef))
+
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 1.0 1.0) (f64.const 0x0p+0)) (v128.const f64x2 0.0 1.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 -1.0 -1.0) (f64.const -0x0p-0)) (v128.const f64x2 -0.0 -1.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 1.25)) (v128.const f64x2 1.25 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const -1.25)) (v128.const f64x2 -1.25 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 -nan 0.0) (f64.const -1.7976931348623157e+308)) (v128.const f64x2 -1.7976931348623157e+308 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 nan 0.0) (f64.const 1.7976931348623157e+308)) (v128.const f64x2 1.7976931348623157e+308 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 -inf 0.0) (f64.const -0x1.fffffffffffffp-1023)) (v128.const f64x2 -0x1.fffffffffffffp-1023 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 inf 0.0) (f64.const 0x1.fffffffffffffp-1023)) (v128.const f64x2 0x1.fffffffffffffp-1023 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const -nan)) (v128.const f64x2 -nan 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const nan)) (v128.const f64x2 nan 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const -inf)) (v128.const f64x2 -inf 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const inf)) (v128.const f64x2 inf 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 0123456789)) (v128.const f64x2 0123456789 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 0123456789.)) (v128.const f64x2 0123456789. 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 0x0123456789ABCDEFabcdef)) (v128.const f64x2 0x0123456789ABCDEFabcdef 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 0x0123456789ABCDEFabcdef.)) (v128.const f64x2 0x0123456789ABCDEFabcdef. 0.0))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 2.0 2.0) (f64.const 0.0)) (v128.const f64x2 2.0 0.0))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 -2.0 -2.0) (f64.const -0.0)) (v128.const f64x2 -2.0 -0.0))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 2.25)) (v128.const f64x2 0.0 2.25))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const -2.25)) (v128.const f64x2 0.0 -2.25))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 -nan) (f64.const -1.7976931348623157e+308)) (v128.const f64x2 0.0 -1.7976931348623157e+308))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 nan) (f64.const 1.7976931348623157e+308)) (v128.const f64x2 0.0 1.7976931348623157e+308))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 -inf) (f64.const -0x1.fffffffffffffp-1023)) (v128.const f64x2 0.0 -0x1.fffffffffffffp-1023))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 inf) (f64.const 0x1.fffffffffffffp-1023)) (v128.const f64x2 0.0 0x1.fffffffffffffp-1023))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const -nan)) (v128.const f64x2 0.0 -nan))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const nan)) (v128.const f64x2 0.0 nan))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const -inf)) (v128.const f64x2 0.0 -inf))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const inf)) (v128.const f64x2 0.0 inf))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 0123456789e019)) (v128.const f64x2 0.0 0123456789e019))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 0123456789e+019)) (v128.const f64x2 0.0 0123456789e+019))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 0123456789.e019)) (v128.const f64x2 0.0 0123456789.e019))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 0123456789.e-019)) (v128.const f64x2 0.0 0123456789.e-019))
+
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+  (v128.const i8x16  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15))
+  (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16  -8  -7  -6  -5  -4  -3  -2 -1 16 17 18 19 20 21 22 23))
+  (v128.const i8x16   0   0   0   0   0   0   0  0  0  0  0  0  0  0  0  0))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115)
+  (v128.const i8x16  15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0))
+  (v128.const i8x16 115 114 113 112 111 110 109 108 107 106 105 104 103 102 101 100))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115)
+  (v128.const i8x16  -1   1  -2   2  -3   3  -4   4  -5   5  -6   6  -7   7  -8   8))
+  (v128.const i8x16   0 101   0 102   0 103   0 104   0 105   0 106   0 107   0 108))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115)
+  (v128.const i8x16   9  16  10  17  11  18  12  19  13  20  14  21  15  22  16  23))
+  (v128.const i8x16 109   0 110   0 111   0 112   0 113   0 114   0 115   0   0   0))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 0x64 0x65 0x66 0x67 0x68 0x69 0x6a 0x6b 0x6c 0x6d 0x6e 0x6f 0x70 0x71 0x72 0x73)
+  (v128.const i8x16    9   16   10   17  11    18   12   19  13    20   14   21   15   22   16   23))
+  (v128.const i8x16 0x6d    0 0x6e    0 0x6f    0 0x70    0 0x71    0 0x72    0 0x73    0    0    0))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i16x8 0x6465 0x6667 0x6869 0x6a6b 0x6c6d 0x6e6f 0x7071 0x7273)
+  (v128.const i8x16 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15))
+  (v128.const i16x8 0x6465 0x6667 0x6869 0x6a6b 0x6c6d 0x6e6f 0x7071 0x7273))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i32x4 0x64656667 0x68696a6b 0x6c6d6e6f 0x70717273)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0))
+  (v128.const i32x4 0x73727170 0x6f6e6d6c 0x6b6a6968 0x67666564))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const f32x4 nan -nan inf -inf)
+  (v128.const i8x16 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15))
+  (v128.const i32x4 0x7fc00000 0xffc00000 0x7f800000 0xff800000))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i32x4 0x67666564 0x6b6a6968 0x6f6e6d5c 0x73727170)
+  (v128.const f32x4 0.0 -0.0 inf -inf))
+  (v128.const i32x4 0x64646464 0x00646464 0x00006464 0x00006464))
+
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+  (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31))
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "v8x16_shuffle-2"
+  (v128.const i8x16   0   1   2   3   4   5   6  7  8  9 10 11 12 13 14 15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1))
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1))
+(assert_return (invoke "v8x16_shuffle-3"
+  (v128.const i8x16   0   1   2   3   4   5   6  7  8   9  10  11  12  13  14  15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8  -7  -6  -5  -4  -3  -2  -1))
+  (v128.const i8x16  -1  -2  -3  -4  -5  -6  -7 -8 -9 -10 -11 -12 -13 -14 -15 -16))
+(assert_return (invoke "v8x16_shuffle-4"
+  (v128.const i8x16   0   1   2   3   4   5   6  7  8  9 10 11 12 13 14 15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1))
+  (v128.const i8x16  15  14  13  12  11  10   9  8  7  6  5  4  3  2  1  0))
+(assert_return (invoke "v8x16_shuffle-5"
+  (v128.const i8x16   0   1   2   3   4   5   6  7  8  9 10 11 12 13 14 15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1))
+  (v128.const i8x16   0   0   0   0   0   0   0  0  0  0  0  0  0  0  0  0))
+(assert_return (invoke "v8x16_shuffle-6"
+  (v128.const i8x16   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10  -9  -8  -7  -6  -5  -4  -3  -2  -1))
+  (v128.const i8x16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16))
+(assert_return (invoke "v8x16_shuffle-7"
+  (v128.const i8x16   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10  -9  -8  -7  -6  -5  -4  -3  -2  -1))
+  (v128.const i8x16   0   0   0   0   0   0   0   0 -16 -16 -16 -16 -16 -16 -16 -16))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i8x16 0x64 0x65 0x66 0x67 0x68 0x69 0x6a 0x6b 0x6c 0x6d 0x6e 0x6f 0x70 0x71 0x72 0x73)
+  (v128.const i8x16 0xf0 0xf1 0xf2 0xf3 0xf4 0xf5 0xf6 0xf7 0xf8 0xf9 0xfa 0xfb 0xfc 0xfd 0xfe 0xff))
+  (v128.const i8x16 0x64 0x65 0x66 0x67 0x68 0x69 0x6a 0x6b 0x6c 0x6d 0x6e 0x6f 0x70 0x71 0x72 0x73))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0b0a 0x0d0c 0x0f0e)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10  -9  -8  -7  -6  -5  -4  -3  -2  -1))
+  (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0b0a 0x0d0c 0x0f0e))
+(assert_return (invoke "v8x16_shuffle-2"
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+  (v128.const i32x4 0xf3f2f1f0 0xf7f6f5f4 0xfbfaf9f8 0xfffefdfc))
+  (v128.const i32x4 0xf3f2f1f0 0xf7f6f5f4 0xfbfaf9f8 0xfffefdfc))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i32x4 0x10203 0x4050607 0x8090a0b 0xc0d0e0f)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+  (v128.const i32x4 0x10203 0x4050607 0x8090a0b 0xc0d0e0f))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const f32x4 1.0 nan inf -inf)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+  (v128.const i32x4 0x3f800000 0x7fc00000 0x7f800000 0xff800000))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i32x4 0x10203 0x4050607 0x8090a0b 0xc0d0e0f)
+  (v128.const f32x4 -0.0 nan inf -inf))
+  (v128.const i32x4 0x10203 0x4050607 0x8090a0b 0xc0d0e0f))
+
+;; More literals
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i32x4 1_234_567_890 0x1234_5678 01_234_567_890 0x0_1234_5678)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+  (v128.const i32x4 0x4996_02d2 0x1234_5678 0x4996_02d2 0x1234_5678))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i64x2 1_234_567_890_123_456_789_0 0x1234_5678_90AB_cdef)
+  (v128.const i64x2 01_234_567_890_123_456_789_0 0x0_1234_5678_90AB_cdef))
+  (v128.const i32x4 0xeb1f_0ad2 0xab54_a98c 0x90ab_cdef 0x1234_5678))
+
+;; Syntax errors for negative values
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_s  -1 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_u  -1 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_s  -1 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_u  -1 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane  -1 (v128.const i32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result f32) (f32x4.extract_lane  -1 (v128.const f32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i8x16.replace_lane  -1 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i16x8.replace_lane  -1 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i32x4.replace_lane  -1 (v128.const i32x4 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (f32x4.replace_lane  -1 (v128.const f32x4 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result i64) (i64x2.extract_lane  -1 (v128.const i64x2 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result f64) (f64x2.extract_lane  -1 (v128.const f64x2 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i64x2.replace_lane  -1 (v128.const i64x2 0 0) (i64.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (f64x2.replace_lane  -1 (v128.const f64x2 0 0) (f64.const 1)))") "unexpected token")
+
+;; Malformed lane index value
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_s 256 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_u 256 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_s 256 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_u 256 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane 256 (v128.const i32x4 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result f32) (f32x4.extract_lane 256 (v128.const f32x4 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (i8x16.replace_lane 256 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (i16x8.replace_lane 256 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (i32x4.replace_lane 256 (v128.const i32x4 0 0 0 0) (i32.const 1)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (f32x4.replace_lane 256 (v128.const f32x4 0 0 0 0) (i32.const 1)))") "malformed lane index")
+(assert_malformed (module quote "(func (result i64) (i64x2.extract_lane 256 (v128.const i64x2 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result f64) (f64x2.extract_lane 256 (v128.const f64x2 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (i64x2.replace_lane 256 (v128.const i64x2 0 0) (i64.const 1)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (f64x2.replace_lane 256 (v128.const f64x2 0 0) (f64.const 1)))") "malformed lane index")
+
+;; Invalid lane index value
+
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_s 16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_s 255 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_u 16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_u 255 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_s 8 (v128.const i16x8 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_s 255 (v128.const i16x8 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_u 8 (v128.const i16x8 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_u 255 (v128.const i16x8 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i32x4.extract_lane 4 (v128.const i32x4 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i32x4.extract_lane 255 (v128.const i32x4 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result f32) (f32x4.extract_lane 4 (v128.const f32x4 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result f32) (f32x4.extract_lane 255 (v128.const f32x4 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i8x16.replace_lane 16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i8x16.replace_lane 255 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i16x8.replace_lane 16 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i16x8.replace_lane 255 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 4 (v128.const i32x4 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 255 (v128.const i32x4 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 4 (v128.const f32x4 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 255 (v128.const f32x4 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result i64) (i64x2.extract_lane 2 (v128.const i64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i64) (i64x2.extract_lane 255 (v128.const i64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result f64) (f64x2.extract_lane 2 (v128.const f64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result f64) (f64x2.extract_lane 255 (v128.const f64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i64x2.replace_lane 2 (v128.const i64x2 0 0) (i64.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i64x2.replace_lane 255 (v128.const i64x2 0 0) (i64.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f64x2.replace_lane 2 (v128.const f64x2 0 0) (f64.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f64x2.replace_lane 255 (v128.const f64x2 0 0) (f64.const 1.0)))) "invalid lane index")
+
+;; Lane index is determined by the instruction's interpretation only.
+
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_s 8 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_u 8 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i32x4.extract_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (f32x4.extract_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i16x8.replace_lane 8 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result i64) (i64x2.extract_lane 2 (v128.const i64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result f64) (f64x2.extract_lane 2 (v128.const f64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i64x2.replace_lane 2 (v128.const i64x2 0 0) (i64.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f64x2.replace_lane 2 (v128.const f64x2 0 0) (f64.const 1.0)))) "invalid lane index")
+
+;; Invalid parameters: required v128 but pass other types
+
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_s 0 (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_u 0 (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_s 0 (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_u 0 (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32x4.extract_lane 0 (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32x4.extract_lane 0 (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.replace_lane 0 (i32.const 0) (i32.const 1)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.replace_lane 0 (i64.const 0) (i32.const 1)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 0 (i32.const 0) (i32.const 1)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 0 (f32.const 0.0) (i32.const 1)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64x2.extract_lane 0 (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64x2.extract_lane 0 (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 0 (i32.const 0) (i32.const 1)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 0 (f32.const 0.0) (i32.const 1)))) "type mismatch")
+
+;; Invalid types for the replaced value
+
+(assert_invalid (module (func (result v128) (i8x16.replace_lane 0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (f32.const 1.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.replace_lane 0 (v128.const i16x8 0 0 0 0 0 0 0 0) (f64.const 1.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 0 (v128.const i32x4 0 0 0 0) (f32.const 1.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 0 (v128.const f32x4 0 0 0 0) (i32.const 1)))) "type mismatch")
+
+(assert_invalid (module (func (result v128) (i64x2.replace_lane 0 (v128.const i64x2 0 0) (f64.const 1.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.replace_lane 0 (v128.const f64x2 0 0) (i64.const 1)))) "type mismatch")
+
+;; Invalid types for swizzle and shuffle values
+(assert_invalid (module (func (result v128)
+  (i8x16.swizzle (i32.const 1) (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)))) "type mismatch")
+(assert_invalid (module (func (result v128)
+  (i8x16.swizzle (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) (i32.const 2)))) "type mismatch")
+(assert_invalid (module (func (result v128)
+  (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (f32.const 3.0)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)))) "type mismatch")
+(assert_invalid (module (func (result v128)
+  (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) (f32.const 4.0)))) "type mismatch")
+
+;; i8x16.shuffle: the 1st argument must be 16-byte literals in 0..32
+(assert_malformed (module quote "(func (param v128) (result v128)"
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 (local.get 0) (local.get 0)))")
+  "invalid lane length")
+(assert_malformed (module quote "(func (param v128) (result v128)"
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 (local.get 0) (local.get 0)))")
+  "invalid lane length")
+(assert_malformed (module quote "(func (result v128)"
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 -1"
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)"
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128)"
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 256"
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)"
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_invalid (module (func (result v128)
+  (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 255
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))) "invalid lane index")
+
+;; Possible wrong instruction names that'd be used
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane 0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane 0 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane_s 0 (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane_u 0 (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(func (result i32) (i64x2.extract_lane_s 0 (v128.const i64x2 0 0)))") "unknown operator")
+(assert_malformed (module quote "(func (result i32) (i64x2.extract_lane_u 0 (v128.const i64x2 0 0)))") "unknown operator")
+
+
+;; Old shuffle instruction names will not work
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle1 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)))")
+  "unknown operator")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle2_imm  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)))")
+  "unknown operator")
+;; i8x16 not v8x16
+(assert_malformed (module quote "(func (result v128) "
+  "(v8x16.swizzle (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)))")
+  "unknown operator")
+(assert_malformed (module quote "(func (result v128) "
+  "(v8x16.shuffle  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)))")
+  "unknown operator")
+
+
+;; Malformed lane index
+
+;; Pass params as the lane index
+
+(assert_malformed (module quote "(func (param i32) (result i32) (i8x16.extract_lane_s (local.get 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result i32) (i8x16.extract_lane_u (local.get 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result i32) (i16x8.extract_lane_s (local.get 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result i32) (i16x8.extract_lane_u (local.get 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result i32) (i32x4.extract_lane (local.get 0) (v128.const i32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result f32) (f32x4.extract_lane (local.get 0) (v128.const f32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (i8x16.replace_lane (local.get 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (i16x8.replace_lane (local.get 0) (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (i32x4.replace_lane (local.get 0) (v128.const i32x4 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (f32x4.replace_lane (local.get 0) (v128.const f32x4 0 0 0 0) (f32.const 1.0)))") "unexpected token")
+
+(assert_malformed (module quote "(func (param i32) (result i64) (i64x2.extract_lane (local.get 0) (v128.const i64x2 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result f64) (f64x2.extract_lane (local.get 0) (v128.const f64x2 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (i64x2.replace_lane (local.get 0) (v128.const i64x2 0 0) (i64.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (f64x2.replace_lane (local.get 0) (v128.const f64x2 0 0) (f64.const 1.0)))") "unexpected token")
+
+;; Pass non-literal as the lane index
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_s 1.5 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_u nan (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_s inf (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_u -inf (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane nan (v128.const i32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result f32) (f32x4.extract_lane nan (v128.const f32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i8x16.replace_lane -2.5 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i16x8.replace_lane nan (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i32x4.replace_lane inf (v128.const i32x4 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (f32x4.replace_lane -inf (v128.const f32x4 0 0 0 0) (f32.const 1.1)))") "unexpected token")
+
+;; i8x16.shuffle expects a 16-byte literals as first argument
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "invalid lane length")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15.0) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle 0.5 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle -inf 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 inf) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle nan 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+
+
+;; Combination with each other
+
+(module
+  ;; as *.replace_lane's operand
+  (func (export "i8x16_extract_lane_s") (param v128 v128) (result v128)
+    (i8x16.replace_lane 0 (local.get 0) (i8x16.extract_lane_s 0 (local.get 1))))
+  (func (export "i8x16_extract_lane_u") (param v128 v128) (result v128)
+    (i8x16.replace_lane 0 (local.get 0) (i8x16.extract_lane_u 0 (local.get 1))))
+  (func (export "i16x8_extract_lane_s") (param v128 v128) (result v128)
+    (i16x8.replace_lane 0 (local.get 0) (i16x8.extract_lane_s 0 (local.get 1))))
+  (func (export "i16x8_extract_lane_u") (param v128 v128) (result v128)
+    (i16x8.replace_lane 0 (local.get 0) (i16x8.extract_lane_u 0 (local.get 1))))
+  (func (export "i32x4_extract_lane") (param v128 v128) (result v128)
+    (i32x4.replace_lane 0 (local.get 0) (i32x4.extract_lane 0 (local.get 1))))
+  (func (export "f32x4_extract_lane") (param v128 v128) (result v128)
+    (i32x4.replace_lane 0 (local.get 0) (i32x4.extract_lane 0 (local.get 1))))
+  (func (export "i64x2_extract_lane") (param v128 v128) (result v128)
+    (i64x2.replace_lane 0 (local.get 0) (i64x2.extract_lane 0 (local.get 1))))
+  (func (export "f64x2_extract_lane") (param v128 v128) (result v128)
+    (f64x2.replace_lane 0 (local.get 0) (f64x2.extract_lane 0 (local.get 1))))
+
+  ;; as *.extract_lane's operand
+  (func (export "i8x16_replace_lane-s") (param v128 i32) (result i32)
+    (i8x16.extract_lane_s 15 (i8x16.replace_lane 15 (local.get 0) (local.get 1))))
+  (func (export "i8x16_replace_lane-u") (param v128 i32) (result i32)
+    (i8x16.extract_lane_u 15 (i8x16.replace_lane 15 (local.get 0) (local.get 1))))
+  (func (export "i16x8_replace_lane-s") (param v128 i32) (result i32)
+    (i16x8.extract_lane_s 7 (i16x8.replace_lane 7 (local.get 0) (local.get 1))))
+  (func (export "i16x8_replace_lane-u") (param v128 i32) (result i32)
+    (i16x8.extract_lane_u 7 (i16x8.replace_lane 7 (local.get 0) (local.get 1))))
+  (func (export "i32x4_replace_lane") (param v128 i32) (result i32)
+    (i32x4.extract_lane 3 (i32x4.replace_lane 3 (local.get 0) (local.get 1))))
+  (func (export "f32x4_replace_lane") (param v128 f32) (result f32)
+    (f32x4.extract_lane 3 (f32x4.replace_lane 3 (local.get 0) (local.get 1))))
+  (func (export "i64x2_replace_lane") (param v128 i64) (result i64)
+    (i64x2.extract_lane 1 (i64x2.replace_lane 1 (local.get 0) (local.get 1))))
+  (func (export "f64x2_replace_lane") (param v128 f64) (result f64)
+    (f64x2.extract_lane 1 (f64x2.replace_lane 1 (local.get 0) (local.get 1))))
+
+  ;; i8x16.replace outputs as shuffle operand
+  (func (export "as-v8x16_swizzle-operand") (param v128 i32 v128) (result v128)
+    (i8x16.swizzle (i8x16.replace_lane 0 (local.get 0) (local.get 1)) (local.get 2)))
+  (func (export "as-v8x16_shuffle-operands") (param v128 i32 v128 i32) (result v128)
+    (i8x16.shuffle 16 1 18 3 20 5 22 7 24 9 26 11 28 13 30 15
+      (i8x16.replace_lane 0 (local.get 0) (local.get 1))
+      (i8x16.replace_lane 15 (local.get 2) (local.get 3))))
+)
+
+(assert_return (invoke "i8x16_extract_lane_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) (v128.const i8x16 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16_extract_lane_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) (v128.const i8x16 255 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_extract_lane_s" (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) (v128.const i16x8 -1 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_extract_lane_u" (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) (v128.const i16x8 65535 0 0 0 0 0 0 0))
+(assert_return (invoke "i32x4_extract_lane" (v128.const i32x4 0 0 0 0) (v128.const i32x4 0x10000 -1 -1 -1)) (v128.const i32x4 65536 0 0 0))
+(assert_return (invoke "f32x4_extract_lane" (v128.const f32x4 0 0 0 0) (v128.const f32x4 1e38 nan nan nan)) (v128.const f32x4 1e38 0 0 0))
+(assert_return (invoke "i8x16_replace_lane-s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 255)) (i32.const -1))
+(assert_return (invoke "i8x16_replace_lane-u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 255)) (i32.const 255))
+(assert_return (invoke "i16x8_replace_lane-s" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 65535)) (i32.const -1))
+(assert_return (invoke "i16x8_replace_lane-u" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 65535)) (i32.const 65535))
+(assert_return (invoke "i32x4_replace_lane" (v128.const i32x4 0 0 0 0) (i32.const -1)) (i32.const -1))
+(assert_return (invoke "f32x4_replace_lane" (v128.const f32x4 0 0 0 0) (f32.const 1.25)) (f32.const 1.25))
+
+(assert_return (invoke "i64x2_extract_lane" (v128.const i64x2 0 0) (v128.const i64x2 0xffffffffffffffff -1)) (v128.const i64x2 0xffffffffffffffff 0))
+(assert_return (invoke "f64x2_extract_lane" (v128.const f64x2 0 0) (v128.const f64x2 1e308 nan)) (v128.const f64x2 1e308 0))
+(assert_return (invoke "i64x2_replace_lane" (v128.const i64x2 0 0) (i64.const -1)) (i64.const -1))
+(assert_return (invoke "f64x2_replace_lane" (v128.const f64x2 0 0) (f64.const 2.5)) (f64.const 2.5))
+
+(assert_return (invoke "as-v8x16_swizzle-operand"
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) (i32.const 255)
+  (v128.const i8x16 -1 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1))
+  (v128.const i8x16 0 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1))
+(assert_return (invoke "as-v8x16_shuffle-operands"
+  (v128.const i8x16 0 255 0 255 15 255 0 255 255 255 0 255 127 255 0 255) (i32.const 1)
+  (v128.const i8x16 0x55 0 0x55 0 0x55 0 0x55 0 0x55 0 0x55 0 0x55 1 0x55 -1) (i32.const 0))
+  (v128.const i8x16 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff))
+
+;; Combination with other SIMD instructions
+
+(module
+  ;; Constructing SIMD values
+  (func (export "as-i8x16_splat-operand") (param v128) (result v128)
+    (i8x16.splat (i8x16.extract_lane_s 0 (local.get 0))))
+  (func (export "as-i16x8_splat-operand") (param v128) (result v128)
+    (i16x8.splat (i16x8.extract_lane_u 0 (local.get 0))))
+  (func (export "as-i32x4_splat-operand") (param v128) (result v128)
+    (i32x4.splat (i32x4.extract_lane 0 (local.get 0))))
+  (func (export "as-f32x4_splat-operand") (param v128) (result v128)
+    (f32x4.splat (f32x4.extract_lane 0 (local.get 0))))
+  (func (export "as-i64x2_splat-operand") (param v128) (result v128)
+    (i64x2.splat (i64x2.extract_lane 0 (local.get 0))))
+  (func (export "as-f64x2_splat-operand") (param v128) (result v128)
+    (f64x2.splat (f64x2.extract_lane 0 (local.get 0))))
+
+  ;; Integer arithmetic
+  (func (export "as-i8x16_add-operands") (param v128 i32 v128 i32) (result v128)
+    (i8x16.add (i8x16.replace_lane 0 (local.get 0) (local.get 1)) (i8x16.replace_lane 15 (local.get 2) (local.get 3))))
+  (func (export "as-i16x8_add-operands") (param v128 i32 v128 i32) (result v128)
+    (i16x8.add (i16x8.replace_lane 0 (local.get 0) (local.get 1)) (i16x8.replace_lane 7 (local.get 2) (local.get 3))))
+  (func (export "as-i32x4_add-operands") (param v128 i32 v128 i32) (result v128)
+    (i32x4.add (i32x4.replace_lane 0 (local.get 0) (local.get 1)) (i32x4.replace_lane 3 (local.get 2) (local.get 3))))
+  (func (export "as-i64x2_add-operands") (param v128 i64 v128 i64) (result v128)
+    (i64x2.add (i64x2.replace_lane 0 (local.get 0) (local.get 1)) (i64x2.replace_lane 1 (local.get 2) (local.get 3))))
+
+  (func (export "swizzle-as-i8x16_add-operands") (param v128 v128 v128 v128) (result v128)
+    (i8x16.add (i8x16.swizzle (local.get 0) (local.get 1)) (i8x16.swizzle (local.get 2) (local.get 3))))
+  (func (export "shuffle-as-i8x16_sub-operands") (param v128 v128 v128 v128) (result v128)
+    (i8x16.sub (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (local.get 0) (local.get 1))
+      (i8x16.shuffle 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 (local.get 2) (local.get 3))))
+
+  ;; Boolean horizontal reductions
+  (func (export "as-i8x16_any_true-operand") (param v128 i32) (result i32)
+    (v128.any_true (i8x16.replace_lane 0 (local.get 0) (local.get 1))))
+  (func (export "as-i16x8_any_true-operand") (param v128 i32) (result i32)
+    (v128.any_true (i16x8.replace_lane 0 (local.get 0) (local.get 1))))
+  (func (export "as-i32x4_any_true-operand1") (param v128 i32) (result i32)
+    (v128.any_true (i32x4.replace_lane 0 (local.get 0) (local.get 1))))
+  (func (export "as-i32x4_any_true-operand2") (param v128 i64) (result i32)
+    (v128.any_true (i64x2.replace_lane 0 (local.get 0) (local.get 1))))
+
+  (func (export "swizzle-as-i8x16_all_true-operands") (param v128 v128) (result i32)
+    (i8x16.all_true (i8x16.swizzle (local.get 0) (local.get 1))))
+  (func (export "shuffle-as-i8x16_any_true-operands") (param v128 v128) (result i32)
+    (v128.any_true (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (local.get 0) (local.get 1))))
+)
+
+(assert_return (invoke "as-i8x16_splat-operand" (v128.const i8x16 0xff 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "as-i16x8_splat-operand" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0)) (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "as-i32x4_splat-operand" (v128.const i32x4 0x10000 0 0 0)) (v128.const i32x4 65536 65536 65536 65536))
+(assert_return (invoke "as-f32x4_splat-operand" (v128.const f32x4 3.14 nan nan nan)) (v128.const f32x4 3.14 3.14 3.14 3.14))
+(assert_return (invoke "as-i64x2_splat-operand" (v128.const i64x2 -1 0)) (v128.const i64x2 -1 -1))
+(assert_return (invoke "as-f64x2_splat-operand" (v128.const f64x2 inf nan)) (v128.const f64x2 inf inf))
+(assert_return (invoke "as-i8x16_add-operands"
+  (v128.const i8x16 0xff 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16) (i32.const 1)
+  (v128.const i8x16 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 0xff) (i32.const 1))
+  (v128.const i8x16 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17))
+(assert_return (invoke "as-i16x8_add-operands"
+  (v128.const i16x8 -1 4 9 16 25 36 49 64) (i32.const 1)
+  (v128.const i16x8 64 49 36 25 16 9 4 -1) (i32.const 1))
+  (v128.const i16x8 65 53 45 41 41 45 53 65))
+(assert_return (invoke "as-i32x4_add-operands"
+  (v128.const i32x4 -1 8 27 64) (i32.const 1) (v128.const i32x4 64 27 8 -1) (i32.const 1)) (v128.const i32x4 65 35 35 65))
+(assert_return (invoke "as-i64x2_add-operands"
+  (v128.const i64x2 -1 8) (i64.const 1) (v128.const i64x2 64 27) (i64.const 1)) (v128.const i64x2 65 9))
+
+(assert_return (invoke "swizzle-as-i8x16_add-operands"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0))
+  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "shuffle-as-i8x16_sub-operands"
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0))
+  (v128.const i8x16 -15 -13 -11 -9 -7 -5 -3 -1 1 3 5 7 9 11 13 15))
+
+(assert_return (invoke "as-i8x16_any_true-operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-i16x8_any_true-operand" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-i32x4_any_true-operand1" (v128.const i32x4 1 0 0 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-i32x4_any_true-operand2" (v128.const i64x2 1 0) (i64.const 0)) (i32.const 0))
+
+(assert_return (invoke "swizzle-as-i8x16_all_true-operands"
+  (v128.const i8x16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) (i32.const 1))
+(assert_return (invoke "swizzle-as-i8x16_all_true-operands"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 16)) (i32.const 0))
+(assert_return (invoke "shuffle-as-i8x16_any_true-operands"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) (i32.const 1))
+
+;; Load and store
+
+(module
+  (memory 1)
+  (func (export "as-v128_store-operand-1") (param v128 i32) (result v128)
+    (v128.store (i32.const 0) (i8x16.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-2") (param v128 i32) (result v128)
+    (v128.store (i32.const 0) (i16x8.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-3") (param v128 i32) (result v128)
+    (v128.store (i32.const 0) (i32x4.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-4") (param v128 f32) (result v128)
+    (v128.store (i32.const 0) (f32x4.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-5") (param v128 i64) (result v128)
+    (v128.store (i32.const 0) (i64x2.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-6") (param v128 f64) (result v128)
+    (v128.store (i32.const 0) (f64x2.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+)
+
+(assert_return (invoke "as-v128_store-operand-1" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)) (v128.const i8x16 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "as-v128_store-operand-2" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 256)) (v128.const i16x8 0x100 0 0 0 0 0 0 0))
+(assert_return (invoke "as-v128_store-operand-3" (v128.const i32x4 0 0 0 0) (i32.const 0xffffffff)) (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "as-v128_store-operand-4" (v128.const f32x4 0 0 0 0) (f32.const 3.14)) (v128.const f32x4 3.14 0 0 0))
+(assert_return (invoke "as-v128_store-operand-5" (v128.const i64x2 0 0) (i64.const 0xffffffffffffffff)) (v128.const i64x2 -1 0))
+(assert_return (invoke "as-v128_store-operand-6" (v128.const f64x2 0 0) (f64.const 3.14)) (v128.const f64x2 3.14 0))
+
+;; As the argument of wasm core ops
+
+(module
+  (global $g (mut v128) (v128.const f32x4 0.0 0.0 0.0 0.0))
+  (global $h (mut v128) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+  (func (export "as-if-condition-value") (param v128) (result i32)
+    (if (result i32) (i8x16.extract_lane_s 0 (local.get 0)) (then (i32.const 0xff)) (else (i32.const 0))))
+  (func (export "as-return-value-1") (param v128 i32) (result v128)
+    (return (i16x8.replace_lane 0 (local.get 0) (local.get 1))))
+  (func (export "as-local_set-value") (param v128) (result i32) (local i32)
+    (local.set 1 (i32x4.extract_lane 0 (local.get 0)))
+    (return (local.get 1)))
+  (func (export "as-global_set-value-1") (param v128 f32) (result v128)
+    (global.set $g (f32x4.replace_lane 0 (local.get 0) (local.get 1)))
+    (return (global.get $g)))
+
+   (func (export "as-return-value-2") (param v128 v128) (result v128)
+    (return (i8x16.swizzle (local.get 0) (local.get 1))))
+  (func (export "as-global_set-value-2") (param v128 v128) (result v128)
+    (global.set $h (i8x16.shuffle 0 1 2 3 4 5 6 7 24 25 26 27 28 29 30 31 (local.get 0) (local.get 1)))
+    (return (global.get $h)))
+
+  (func (export "as-local_set-value-1") (param v128) (result i64) (local i64)
+    (local.set 1 (i64x2.extract_lane 0 (local.get 0)))
+    (return (local.get 1)))
+  (func (export "as-global_set-value-3") (param v128 f64) (result v128)
+    (global.set $g (f64x2.replace_lane 0 (local.get 0) (local.get 1)))
+    (return (global.get $g)))
+)
+
+(assert_return (invoke "as-if-condition-value" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 0))
+(assert_return (invoke "as-return-value-1" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)) (v128.const i16x8 1 0 0 0 0 0 0 0))
+(assert_return (invoke "as-local_set-value" (v128.const i32x4 -1 -1 -1 -1)) (i32.const -1))
+(assert_return (invoke "as-global_set-value-1" (v128.const f32x4 0 0 0 0)(f32.const 3.14)) (v128.const f32x4 3.14 0 0 0))
+
+(assert_return (invoke "as-return-value-2"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0))
+  (v128.const i8x16 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15 -16))
+(assert_return (invoke "as-global_set-value-2"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1))
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 8 7 6 5 4 3 2 1))
+
+(assert_return (invoke "as-local_set-value-1" (v128.const i64x2 -1 -1)) (i64.const -1))
+(assert_return (invoke "as-global_set-value-3" (v128.const f64x2 0 0)(f64.const 3.14)) (v128.const f64x2 3.14 0))
+
+;; Non-nat lane index
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_u +0x0f (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result f32) (f32x4.extract_lane +03 (v128.const f32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i64) (i64x2.extract_lane +1 (v128.const i64x2 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i8x16.replace_lane +015 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i16x8.replace_lane +0x7 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i32x4.replace_lane +3 (v128.const i32x4 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (f64x2.replace_lane +0x01 (v128.const f64x2 0 0) (f64.const 1.0)))") "unexpected token")
+
+;; Lane index literal
+
+(module (func (result i32) (i8x16.extract_lane_s 0x0f (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))))
+(module (func (result i32) (i16x8.extract_lane_s 0x07 (v128.const i16x8 0 0 0 0 0 0 0 0))))
+(module (func (result i32) (i16x8.extract_lane_u 0x0_7 (v128.const i16x8 0 0 0 0 0 0 0 0))))
+(module (func (result i32) (i32x4.extract_lane 03 (v128.const i32x4 0 0 0 0))))
+(module (func (result f64) (f64x2.extract_lane 0x1 (v128.const f64x2 0 0))))
+(module (func (result v128) (f32x4.replace_lane 0x3 (v128.const f32x4 0 0 0 0) (f32.const 1.0))))
+(module (func (result v128) (i64x2.replace_lane 01 (v128.const i64x2 0 0) (i64.const 1))))
+
+;; 1.0 is malformed lane index
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_s 1.0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+
+;; Test operation with empty argument
+
+(assert_malformed
+  (module quote
+    "(func $i8x16.extract_lane_s-1st-arg-empty (result i32)"
+    "  (i8x16.extract_lane_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i8x16.extract_lane_s-2nd-arg-empty (result i32)
+      (i8x16.extract_lane_s 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i8x16.extract_lane_s-arg-empty (result i32)"
+    "  (i8x16.extract_lane_s)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i16x8.extract_lane_u-1st-arg-empty (result i32)"
+    "  (i16x8.extract_lane_u (v128.const i16x8 0 0 0 0 0 0 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extract_lane_u-2nd-arg-empty (result i32)
+      (i16x8.extract_lane_u 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i16x8.extract_lane_u-arg-empty (result i32)"
+    "  (i16x8.extract_lane_u)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i32x4.extract_lane-1st-arg-empty (result i32)"
+    "  (i32x4.extract_lane (v128.const i32x4 0 0 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extract_lane-2nd-arg-empty (result i32)
+      (i32x4.extract_lane 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i32x4.extract_lane-arg-empty (result i32)"
+    "  (i32x4.extract_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i64x2.extract_lane-1st-arg-empty (result i64)"
+    "  (i64x2.extract_lane (v128.const i64x2 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extract_lane-2nd-arg-empty (result i64)
+      (i64x2.extract_lane 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i64x2.extract_lane-arg-empty (result i64)"
+    "  (i64x2.extract_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $f32x4.extract_lane-1st-arg-empty (result f32)"
+    "  (f32x4.extract_lane (v128.const f32x4 0 0 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $f32x4.extract_lane-2nd-arg-empty (result f32)
+      (f32x4.extract_lane 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $f32x4.extract_lane-arg-empty (result f32)"
+    "  (f32x4.extract_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $f64x2.extract_lane-1st-arg-empty (result f64)"
+    "  (f64x2.extract_lane (v128.const f64x2 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $f64x2.extract_lane-2nd-arg-empty (result f64)
+      (f64x2.extract_lane 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $f64x2.extract_lane-arg-empty (result f64)"
+    "  (f64x2.extract_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i8x16.replace_lane-1st-arg-empty (result v128)"
+    "  (i8x16.replace_lane (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i8x16.replace_lane-2nd-arg-empty (result v128)
+      (i8x16.replace_lane 0 (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.replace_lane-3rd-arg-empty (result v128)
+      (i8x16.replace_lane 0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i8x16.replace_lane-arg-empty (result v128)"
+    "  (i8x16.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i16x8.replace_lane-1st-arg-empty (result v128)"
+    "  (i16x8.replace_lane (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i16x8.replace_lane-2nd-arg-empty (result v128)
+      (i16x8.replace_lane 0 (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.replace_lane-3rd-arg-empty (result v128)
+      (i16x8.replace_lane 0 (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i16x8.replace_lane-arg-empty (result v128)"
+    "  (i16x8.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i32x4.replace_lane-1st-arg-empty (result v128)"
+    "  (i32x4.replace_lane (v128.const i32x4 0 0 0 0) (i32.const 1))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i32x4.replace_lane-2nd-arg-empty (result v128)
+      (i32x4.replace_lane 0 (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.replace_lane-3rd-arg-empty (result v128)
+      (i32x4.replace_lane 0 (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i32x4.replace_lane-arg-empty (result v128)"
+    "  (i32x4.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $f32x4.replace_lane-1st-arg-empty (result v128)"
+    "  (f32x4.replace_lane (v128.const f32x4 0 0 0 0) (f32.const 1.0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $f32x4.replace_lane-2nd-arg-empty (result v128)
+      (f32x4.replace_lane 0 (f32.const 1.0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.replace_lane-3rd-arg-empty (result v128)
+      (f32x4.replace_lane 0 (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $f32x4.replace_lane-arg-empty (result v128)"
+    "  (f32x4.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i64x2.replace_lane-1st-arg-empty (result v128)"
+    "  (i64x2.replace_lane (v128.const i64x2 0 0) (i64.const 1))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i64x2.replace_lane-2nd-arg-empty (result v128)
+      (i64x2.replace_lane 0 (i64.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.replace_lane-3rd-arg-empty (result v128)
+      (i64x2.replace_lane 0 (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i64x2.replace_lane-arg-empty (result v128)"
+    "  (i64x2.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $f64x2.replace_lane-1st-arg-empty (result v128)"
+    "  (f64x2.replace_lane (v128.const f64x2 0 0) (f64.const 1.0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $f64x2.replace_lane-2nd-arg-empty (result v128)
+      (f64x2.replace_lane 0 (f64.const 1.0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.replace_lane-3rd-arg-empty (result v128)
+      (f64x2.replace_lane 0 (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $f64x2.replace_lane-arg-empty (result v128)"
+    "  (f64x2.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i8x16.shuffle-1st-arg-empty (result v128)"
+    "  (i8x16.shuffle"
+    "    (v128.const i8x16 0 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15)"
+    "    (v128.const i8x16 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15 16)"
+    "  )"
+    ")"
+  )
+  "invalid lane length"
+)
+(assert_invalid
+  (module
+    (func $i8x16.shuffle-2nd-arg-empty (result v128)
+      (i8x16.shuffle 0 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15
+        (v128.const i8x16 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15 16)
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i8x16.shuffle-arg-empty (result v128)"
+    "  (i8x16.shuffle)"
+    ")"
+  )
+  "invalid lane length"
+)
diff --git a/test/core/simd/simd_load.wast b/test/core/simd/simd_load.wast
new file mode 100644
index 000000000..4b2edc160
--- /dev/null
+++ b/test/core/simd/simd_load.wast
@@ -0,0 +1,188 @@
+;; v128.load operater with normal argument (e.g. (i8x16, i16x8 i32x4))
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "v128.load") (result v128)
+    (v128.load (i32.const 0))
+  )
+)
+
+(assert_return (invoke "v128.load") (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f))
+(assert_return (invoke "v128.load") (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0b0a 0x0d0c 0x0f0e))
+(assert_return (invoke "v128.load") (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c))
+
+
+;; v128.load operater as the argument of other SIMD instructions
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "as-i8x16_extract_lane_s-value/0") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-i8x16_extract_lane_s-value/0") (i32.const 0x00))
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "as-i8x16.eq-operand") (result v128)
+    (i8x16.eq (v128.load offset=0 (i32.const 0)) (v128.load offset=16 (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-i8x16.eq-operand") (v128.const i32x4 0xffffffff 0x00000000 0x00000000 0x00000000))
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "as-v128.not-operand") (result v128)
+    (v128.not (v128.load (i32.const 0)))
+  )
+  (func (export "as-i8x16.all_true-operand") (result i32)
+    (i8x16.all_true (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-v128.not-operand") (v128.const i32x4 0xfcfdfeff 0xf8f9fafb 0xf4f5f6f7 0xf0f1f2f3))
+(assert_return (invoke "as-i8x16.all_true-operand") (i32.const 0))
+
+(module (memory 1)
+  (data (offset (i32.const 0))  "\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA")
+  (data (offset (i32.const 16)) "\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB")
+  (data (offset (i32.const 32)) "\F0\F0\F0\F0\FF\FF\FF\FF\00\00\00\00\FF\00\FF\00")
+  (func (export "as-v128.bitselect-operand") (result v128)
+    (v128.bitselect (v128.load (i32.const 0)) (v128.load (i32.const 16)) (v128.load (i32.const 32)))
+  )
+)
+(assert_return (invoke "as-v128.bitselect-operand") (v128.const i32x4 0xabababab 0xaaaaaaaa 0xbbbbbbbb 0xbbaabbaa))
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA")
+  (func (export "as-i8x16.shl-operand") (result v128)
+    (i8x16.shl (v128.load (i32.const 0)) (i32.const 1))
+  )
+)
+(assert_return (invoke "as-i8x16.shl-operand") (v128.const i32x4 0x54545454 0x54545454 0x54545454 0x54545454)) ;; 1010 1000 << 1010 1010
+
+(module (memory 1)
+  (data (offset (i32.const 0))  "\02\00\00\00\02\00\00\00\02\00\00\00\02\00\00\00")
+  (data (offset (i32.const 16)) "\03\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00")
+  (func (export "as-add/sub-operand") (result v128)
+    ;; 2 2 2 2 + 3 3 3 3 = 5 5 5 5
+    ;; 5 5 5 5 - 3 3 3 3 = 2 2 2 2
+    (i8x16.sub
+      (i8x16.add (v128.load (i32.const 0)) (v128.load (i32.const 16)))
+      (v128.load (i32.const 16))
+    )
+  )
+)
+(assert_return (invoke "as-add/sub-operand") (v128.const i32x4 2 2 2 2))
+
+(module (memory 1)
+  (data (offset (i32.const 0))  "\00\00\00\43\00\00\80\3f\66\66\e6\3f\00\00\80\bf")  ;; 128 1.0 1.8 -1
+  (data (offset (i32.const 16)) "\00\00\00\40\00\00\00\40\00\00\00\40\00\00\00\40")  ;; 2.0 2.0 2.0 2.0
+  (func (export "as-f32x4.mul-operand") (result v128)
+    (f32x4.mul (v128.load (i32.const 0)) (v128.load (i32.const 16)))
+  )
+)
+(assert_return (invoke "as-f32x4.mul-operand") (v128.const f32x4 256 2 3.6 -2))
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff")  ;; 1111 ...
+  (func (export "as-f32x4.abs-operand") (result v128)
+    (f32x4.abs (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-f32x4.abs-operand") (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)) ;; 1111 -> 0111
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA")
+  (data (offset (i32.const 16)) "\02\00\00\00\02\00\00\00\02\00\00\00\02\00\00\00")
+  (func (export "as-f32x4.min-operand") (result v128)
+    (f32x4.min (v128.load (i32.const 0)) (v128.load offset=16 (i32.const 1)))
+  )
+)
+(assert_return (invoke "as-f32x4.min-operand") (v128.const i32x4 0xaaaaaaaa 0xaaaaaaaa 0xaaaaaaaa 0xaaaaaaaa)) ;; signed 1010 < 0010
+
+(module (memory 1)
+  (data (offset (i32.const 0))  "\00\00\00\43\00\00\80\3f\66\66\e6\3f\00\00\80\bf")  ;; 128 1.0 1.8 -1
+  (func (export "as-i32x4.trunc_sat_f32x4_s-operand") (result v128)
+    (i32x4.trunc_sat_f32x4_s (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-i32x4.trunc_sat_f32x4_s-operand") (v128.const i32x4 128 1 1 -1)) ;; 128 1.0 1.8 -1 -> 128 1 1 -1
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\02\00\00\00\02\00\00\00\02\00\00\00\02\00\00\00")
+  (func (export "as-f32x4.convert_i32x4_u-operand") (result v128)
+    (f32x4.convert_i32x4_u (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-f32x4.convert_i32x4_u-operand") (v128.const f32x4 2 2 2 2))
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\64\65\66\67\68\69\6a\6b\6c\6d\6e\6f\70\71\72\73")  ;; 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
+  (data (offset (i32.const 16)) "\0f\0e\0d\0c\0b\0a\09\08\07\06\05\04\03\02\01\00")  ;;  15  14  13  12  11  10  09  08  07  06  05  04  03  02  01  00
+  (func (export "as-i8x16.swizzle-operand") (result v128)
+    (i8x16.swizzle (v128.load (i32.const 0)) (v128.load offset=15 (i32.const 1)))
+  )
+)
+(assert_return(invoke "as-i8x16.swizzle-operand") (v128.const i8x16 115 114 113 112 111 110 109 108 107 106 105 104 103 102 101 100))
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load (i32.const 0))))
+  )
+)
+(assert_return (invoke "as-br-value") (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c))
+
+
+;; Unknown operator(e.g. v128.load8, v128.load16, v128.load32)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (local v128) (drop (v128.load8 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (local v128) (drop (v128.load16 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (local v128) (drop (v128.load32 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+
+
+;; Type mismatched (e.g. v128.load(f32.const 0), type address empty)
+
+(assert_invalid
+  (module (memory 1) (func (local v128) (drop (v128.load (f32.const 0)))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (local v128) (block (br_if 0 (v128.load (i32.const 0))))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (local v128) (v128.load (i32.const 0))))
+  "type mismatch"
+)
+
+
+;; Type address empty
+
+(assert_invalid
+  (module (memory 1) (func (drop (v128.load (local.get 2)))))
+  "unknown local 2"
+)
+(assert_invalid
+  (module (memory 1) (func (drop (v128.load))))
+  "type mismatch"
+)
\ No newline at end of file
diff --git a/test/core/simd/simd_load16_lane.wast b/test/core/simd/simd_load16_lane.wast
new file mode 100644
index 000000000..8c72a5733
--- /dev/null
+++ b/test/core/simd/simd_load16_lane.wast
@@ -0,0 +1,211 @@
+;; Tests for load lane operations.
+
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F")
+  (func (export "v128.load16_lane_0")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_3")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 4 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_5")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 5 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_6")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 6 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_7")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 7 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_0_offset_0")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=0 0 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_1_offset_1")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=1 1 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_2_offset_2")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=2 2 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_3_offset_3")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=3 3 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_4_offset_4")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=4 4 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_5_offset_5")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=5 5 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_6_offset_6")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=6 6 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_7_offset_7")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=7 7 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_0_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_0_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_1_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_1_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_2_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_2_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_3_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_3_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_4_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 4 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_4_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 4 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_5_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 5 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_5_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 5 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_6_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 6 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_6_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 6 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_7_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 7 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_7_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 7 (local.get $address) (local.get $x)))
+)
+
+(assert_return (invoke "v128.load16_lane_0" (i32.const 0)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 256 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_1" (i32.const 1)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 513 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_2" (i32.const 2)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 770 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_3" (i32.const 3)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 0 1027 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_4" (i32.const 4)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 0 0 1284 0 0 0))
+(assert_return (invoke "v128.load16_lane_5" (i32.const 5)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 0 0 0 1541 0 0))
+(assert_return (invoke "v128.load16_lane_6" (i32.const 6)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 0 0 0 0 1798 0))
+(assert_return (invoke "v128.load16_lane_7" (i32.const 7)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 0 0 0 0 0 2055))
+(assert_return (invoke "v128.load16_lane_0_offset_0" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 256 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_1_offset_1" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 513 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_2_offset_2" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 770 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_3_offset_3" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 0 1027 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_4_offset_4" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 0 0 1284 0 0 0))
+(assert_return (invoke "v128.load16_lane_5_offset_5" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 0 0 0 1541 0 0))
+(assert_return (invoke "v128.load16_lane_6_offset_6" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 0 0 0 0 1798 0))
+(assert_return (invoke "v128.load16_lane_7_offset_7" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 0 0 0 0 0 2055))
+(assert_return (invoke "v128.load16_lane_0_align_1" (i32.const 0)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 256 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_0_align_2" (i32.const 0)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 256 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_1_align_1" (i32.const 1)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 513 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_1_align_2" (i32.const 1)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 513 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_2_align_1" (i32.const 2)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 770 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_2_align_2" (i32.const 2)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 770 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_3_align_1" (i32.const 3)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 1027 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_3_align_2" (i32.const 3)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 1027 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_4_align_1" (i32.const 4)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 1284 0 0 0))
+(assert_return (invoke "v128.load16_lane_4_align_2" (i32.const 4)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 1284 0 0 0))
+(assert_return (invoke "v128.load16_lane_5_align_1" (i32.const 5)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 1541 0 0))
+(assert_return (invoke "v128.load16_lane_5_align_2" (i32.const 5)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 1541 0 0))
+(assert_return (invoke "v128.load16_lane_6_align_1" (i32.const 6)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 0 1798 0))
+(assert_return (invoke "v128.load16_lane_6_align_2" (i32.const 6)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 0 1798 0))
+(assert_return (invoke "v128.load16_lane_7_align_1" (i32.const 7)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 2055))
+(assert_return (invoke "v128.load16_lane_7_align_2" (i32.const 7)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 2055))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load16_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load16_lane 8 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.load16_lane align=4 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/test/core/simd/simd_load32_lane.wast b/test/core/simd/simd_load32_lane.wast
new file mode 100644
index 000000000..e67690ff9
--- /dev/null
+++ b/test/core/simd/simd_load32_lane.wast
@@ -0,0 +1,143 @@
+;; Tests for load lane operations.
+
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F")
+  (func (export "v128.load32_lane_0")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_3")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_0_offset_0")
+    (param $x v128) (result v128)
+    (v128.load32_lane offset=0 0 (i32.const 0) (local.get $x)))
+  (func (export "v128.load32_lane_1_offset_1")
+    (param $x v128) (result v128)
+    (v128.load32_lane offset=1 1 (i32.const 0) (local.get $x)))
+  (func (export "v128.load32_lane_2_offset_2")
+    (param $x v128) (result v128)
+    (v128.load32_lane offset=2 2 (i32.const 0) (local.get $x)))
+  (func (export "v128.load32_lane_3_offset_3")
+    (param $x v128) (result v128)
+    (v128.load32_lane offset=3 3 (i32.const 0) (local.get $x)))
+  (func (export "v128.load32_lane_0_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=1 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_0_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=2 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_0_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=4 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_1_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=1 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_1_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=2 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_1_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=4 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_2_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=1 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_2_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=2 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_2_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=4 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_3_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=1 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_3_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=2 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_3_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=4 3 (local.get $address) (local.get $x)))
+)
+
+(assert_return (invoke "v128.load32_lane_0" (i32.const 0)
+                                            (v128.const i32x4 0 0 0 0))
+                                            (v128.const i32x4 50462976 0 0 0))
+(assert_return (invoke "v128.load32_lane_1" (i32.const 1)
+                                            (v128.const i32x4 0 0 0 0))
+                                            (v128.const i32x4 0 67305985 0 0))
+(assert_return (invoke "v128.load32_lane_2" (i32.const 2)
+                                            (v128.const i32x4 0 0 0 0))
+                                            (v128.const i32x4 0 0 84148994 0))
+(assert_return (invoke "v128.load32_lane_3" (i32.const 3)
+                                            (v128.const i32x4 0 0 0 0))
+                                            (v128.const i32x4 0 0 0 100992003))
+(assert_return (invoke "v128.load32_lane_0_offset_0" (v128.const i32x4 0 0 0 0))
+                                                     (v128.const i32x4 50462976 0 0 0))
+(assert_return (invoke "v128.load32_lane_1_offset_1" (v128.const i32x4 0 0 0 0))
+                                                     (v128.const i32x4 0 67305985 0 0))
+(assert_return (invoke "v128.load32_lane_2_offset_2" (v128.const i32x4 0 0 0 0))
+                                                     (v128.const i32x4 0 0 84148994 0))
+(assert_return (invoke "v128.load32_lane_3_offset_3" (v128.const i32x4 0 0 0 0))
+                                                     (v128.const i32x4 0 0 0 100992003))
+(assert_return (invoke "v128.load32_lane_0_align_1" (i32.const 0)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 50462976 0 0 0))
+(assert_return (invoke "v128.load32_lane_0_align_2" (i32.const 0)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 50462976 0 0 0))
+(assert_return (invoke "v128.load32_lane_0_align_4" (i32.const 0)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 50462976 0 0 0))
+(assert_return (invoke "v128.load32_lane_1_align_1" (i32.const 1)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 67305985 0 0))
+(assert_return (invoke "v128.load32_lane_1_align_2" (i32.const 1)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 67305985 0 0))
+(assert_return (invoke "v128.load32_lane_1_align_4" (i32.const 1)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 67305985 0 0))
+(assert_return (invoke "v128.load32_lane_2_align_1" (i32.const 2)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 84148994 0))
+(assert_return (invoke "v128.load32_lane_2_align_2" (i32.const 2)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 84148994 0))
+(assert_return (invoke "v128.load32_lane_2_align_4" (i32.const 2)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 84148994 0))
+(assert_return (invoke "v128.load32_lane_3_align_1" (i32.const 3)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 0 100992003))
+(assert_return (invoke "v128.load32_lane_3_align_2" (i32.const 3)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 0 100992003))
+(assert_return (invoke "v128.load32_lane_3_align_4" (i32.const 3)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 0 100992003))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load32_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load32_lane 4 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.load32_lane align=8 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/test/core/simd/simd_load64_lane.wast b/test/core/simd/simd_load64_lane.wast
new file mode 100644
index 000000000..5883a6eae
--- /dev/null
+++ b/test/core/simd/simd_load64_lane.wast
@@ -0,0 +1,97 @@
+;; Tests for load lane operations.
+
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F")
+  (func (export "v128.load64_lane_0")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_0_offset_0")
+    (param $x v128) (result v128)
+    (v128.load64_lane offset=0 0 (i32.const 0) (local.get $x)))
+  (func (export "v128.load64_lane_1_offset_1")
+    (param $x v128) (result v128)
+    (v128.load64_lane offset=1 1 (i32.const 0) (local.get $x)))
+  (func (export "v128.load64_lane_0_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=1 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_0_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=2 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_0_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=4 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_0_align_8")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=8 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_1_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=1 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_1_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=2 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_1_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=4 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_1_align_8")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=8 1 (local.get $address) (local.get $x)))
+)
+
+(assert_return (invoke "v128.load64_lane_0" (i32.const 0)
+                                            (v128.const i64x2 0 0))
+                                            (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_1" (i32.const 1)
+                                            (v128.const i64x2 0 0))
+                                            (v128.const i64x2 0 578437695752307201))
+(assert_return (invoke "v128.load64_lane_0_offset_0" (v128.const i64x2 0 0))
+                                                     (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_1_offset_1" (v128.const i64x2 0 0))
+                                                     (v128.const i64x2 0 578437695752307201))
+(assert_return (invoke "v128.load64_lane_0_align_1" (i32.const 0)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_0_align_2" (i32.const 0)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_0_align_4" (i32.const 0)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_0_align_8" (i32.const 0)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_1_align_1" (i32.const 1)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 0 578437695752307201))
+(assert_return (invoke "v128.load64_lane_1_align_2" (i32.const 1)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 0 578437695752307201))
+(assert_return (invoke "v128.load64_lane_1_align_4" (i32.const 1)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 0 578437695752307201))
+(assert_return (invoke "v128.load64_lane_1_align_8" (i32.const 1)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 0 578437695752307201))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load64_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load64_lane 2 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.load64_lane align=16 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/test/core/simd/simd_load8_lane.wast b/test/core/simd/simd_load8_lane.wast
new file mode 100644
index 000000000..d0706f535
--- /dev/null
+++ b/test/core/simd/simd_load8_lane.wast
@@ -0,0 +1,299 @@
+;; Tests for load lane operations.
+
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F")
+  (func (export "v128.load8_lane_0")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_3")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 4 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_5")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 5 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_6")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 6 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_7")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 7 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_8")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 8 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_9")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 9 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_10")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 10 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_11")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 11 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_12")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 12 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_13")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 13 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_14")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 14 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_15")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 15 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_0_offset_0")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=0 0 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_1_offset_1")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=1 1 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_2_offset_2")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=2 2 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_3_offset_3")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=3 3 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_4_offset_4")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=4 4 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_5_offset_5")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=5 5 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_6_offset_6")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=6 6 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_7_offset_7")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=7 7 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_8_offset_8")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=8 8 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_9_offset_9")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=9 9 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_10_offset_10")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=10 10 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_11_offset_11")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=11 11 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_12_offset_12")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=12 12 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_13_offset_13")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=13 13 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_14_offset_14")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=14 14 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_15_offset_15")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=15 15 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_0_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_1_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_2_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_3_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_4_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 4 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_5_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 5 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_6_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 6 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_7_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 7 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_8_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 8 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_9_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 9 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_10_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 10 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_11_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 11 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_12_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 12 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_13_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 13 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_14_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 14 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_15_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 15 (local.get $address) (local.get $x)))
+)
+
+(assert_return (invoke "v128.load8_lane_0" (i32.const 0)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_1" (i32.const 1)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_2" (i32.const 2)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_3" (i32.const 3)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_4" (i32.const 4)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_5" (i32.const 5)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_6" (i32.const 6)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_7" (i32.const 7)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_8" (i32.const 8)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_9" (i32.const 9)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_10" (i32.const 10)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_11" (i32.const 11)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_12" (i32.const 12)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+(assert_return (invoke "v128.load8_lane_13" (i32.const 13)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+(assert_return (invoke "v128.load8_lane_14" (i32.const 14)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+(assert_return (invoke "v128.load8_lane_15" (i32.const 15)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+(assert_return (invoke "v128.load8_lane_0_offset_0" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_1_offset_1" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_2_offset_2" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_3_offset_3" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_4_offset_4" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_5_offset_5" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_6_offset_6" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_7_offset_7" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_8_offset_8" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_9_offset_9" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_10_offset_10" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_11_offset_11" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_12_offset_12" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+(assert_return (invoke "v128.load8_lane_13_offset_13" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+(assert_return (invoke "v128.load8_lane_14_offset_14" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+(assert_return (invoke "v128.load8_lane_15_offset_15" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+(assert_return (invoke "v128.load8_lane_0_align_1" (i32.const 0)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_1_align_1" (i32.const 1)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_2_align_1" (i32.const 2)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_3_align_1" (i32.const 3)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_4_align_1" (i32.const 4)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_5_align_1" (i32.const 5)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_6_align_1" (i32.const 6)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_7_align_1" (i32.const 7)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_8_align_1" (i32.const 8)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_9_align_1" (i32.const 9)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_10_align_1" (i32.const 10)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_11_align_1" (i32.const 11)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_12_align_1" (i32.const 12)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+(assert_return (invoke "v128.load8_lane_13_align_1" (i32.const 13)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+(assert_return (invoke "v128.load8_lane_14_align_1" (i32.const 14)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+(assert_return (invoke "v128.load8_lane_15_align_1" (i32.const 15)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load8_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load8_lane 16 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.load8_lane align=2 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/test/core/simd/simd_load_extend.wast b/test/core/simd/simd_load_extend.wast
new file mode 100644
index 000000000..b9982bbfd
--- /dev/null
+++ b/test/core/simd/simd_load_extend.wast
@@ -0,0 +1,384 @@
+;; Load and Extend test cases
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+  (data (i32.const 65520) "\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+
+  (func (export "v128.load8x8_s") (param $0 i32) (result v128)
+    (v128.load8x8_s (local.get $0))
+  )
+  (func (export "v128.load8x8_u") (param $0 i32) (result v128)
+    (v128.load8x8_u (local.get $0))
+  )
+  (func (export "v128.load16x4_s") (param $0 i32) (result v128)
+    (v128.load16x4_s (local.get $0))
+  )
+  (func (export "v128.load16x4_u") (param $0 i32) (result v128)
+    (v128.load16x4_u (local.get $0))
+  )
+  (func (export "v128.load32x2_s") (param $0 i32) (result v128)
+    (v128.load32x2_s (local.get $0))
+  )
+  (func (export "v128.load32x2_u") (param $0 i32) (result v128)
+    (v128.load32x2_u (local.get $0))
+  )
+
+  ;; load by a constant amount
+  (func (export "v128.load8x8_s_const0") (result v128)
+    (v128.load8x8_s (i32.const 0))
+  )
+  (func (export "v128.load8x8_u_const8") (result v128)
+    (v128.load8x8_u (i32.const 8))
+  )
+  (func (export "v128.load16x4_s_const10") (result v128)
+    (v128.load16x4_s (i32.const 10))
+  )
+  (func (export "v128.load16x4_u_const20") (result v128)
+    (v128.load16x4_u (i32.const 20))
+  )
+  (func (export "v128.load32x2_s_const65520") (result v128)
+    (v128.load32x2_s (i32.const 65520))
+  )
+  (func (export "v128.load32x2_u_const65526") (result v128)
+    (v128.load32x2_u (i32.const 65526))
+  )
+
+  ;; load data with different offset/align arguments
+  ;; i16x8
+  (func (export "v128.load8x8_s_offset0") (param $0 i32) (result v128)
+    (v128.load8x8_s offset=0 (local.get $0))
+  )
+  (func (export "v128.load8x8_s_align1") (param $0 i32) (result v128)
+    (v128.load8x8_s align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_s_offset0_align1") (param $0 i32) (result v128)
+    (v128.load8x8_s offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_s_offset1_align1") (param $0 i32) (result v128)
+    (v128.load8x8_s offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_s_offset10_align4") (param $0 i32) (result v128)
+    (v128.load8x8_s offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load8x8_s_offset20_align8") (param $0 i32) (result v128)
+    (v128.load8x8_s offset=20 align=8 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_offset0") (param $0 i32) (result v128)
+    (v128.load8x8_u offset=0 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_align1") (param $0 i32) (result v128)
+    (v128.load8x8_u align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_offset0_align1") (param $0 i32) (result v128)
+    (v128.load8x8_u offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_offset1_align1") (param $0 i32) (result v128)
+    (v128.load8x8_u offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_offset10_align4") (param $0 i32) (result v128)
+    (v128.load8x8_u offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_offset20_align8") (param $0 i32) (result v128)
+    (v128.load8x8_u offset=20 align=8 (local.get $0))
+  )
+  ;; i32x4
+  (func (export "v128.load16x4_s_offset0") (param $0 i32) (result v128)
+    (v128.load16x4_s offset=0 (local.get $0))
+  )
+  (func (export "v128.load16x4_s_align1") (param $0 i32) (result v128)
+    (v128.load16x4_s align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_s_offset0_align1") (param $0 i32) (result v128)
+    (v128.load16x4_s offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_s_offset1_align1") (param $0 i32) (result v128)
+    (v128.load16x4_s offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_s_offset10_align4") (param $0 i32) (result v128)
+    (v128.load16x4_s offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load16x4_s_offset20_align8") (param $0 i32) (result v128)
+    (v128.load16x4_s offset=20 align=8 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_offset0") (param $0 i32) (result v128)
+    (v128.load16x4_u offset=0 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_align1") (param $0 i32) (result v128)
+    (v128.load16x4_u align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_offset0_align1") (param $0 i32) (result v128)
+    (v128.load16x4_u offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_offset1_align1") (param $0 i32) (result v128)
+    (v128.load16x4_u offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_offset10_align4") (param $0 i32) (result v128)
+    (v128.load16x4_u offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_offset20_align8") (param $0 i32) (result v128)
+    (v128.load16x4_u offset=20 align=8 (local.get $0))
+  )
+  ;; i64x2
+  (func (export "v128.load32x2_s_offset0") (param $0 i32) (result v128)
+    (v128.load32x2_s offset=0 (local.get $0))
+  )
+  (func (export "v128.load32x2_s_align1") (param $0 i32) (result v128)
+    (v128.load32x2_s align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_s_offset0_align1") (param $0 i32) (result v128)
+    (v128.load32x2_s offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_s_offset1_align1") (param $0 i32) (result v128)
+    (v128.load32x2_s offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_s_offset10_align4") (param $0 i32) (result v128)
+    (v128.load32x2_s offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load32x2_s_offset20_align8") (param $0 i32) (result v128)
+    (v128.load32x2_s offset=20 align=8 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_offset0") (param $0 i32) (result v128)
+    (v128.load32x2_u offset=0 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_align1") (param $0 i32) (result v128)
+    (v128.load32x2_u align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_offset0_align1") (param $0 i32) (result v128)
+    (v128.load32x2_u offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_offset1_align1") (param $0 i32) (result v128)
+    (v128.load32x2_u offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_offset10_align4") (param $0 i32) (result v128)
+    (v128.load32x2_u offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_offset20_align8") (param $0 i32) (result v128)
+    (v128.load32x2_u offset=20 align=8 (local.get $0))
+  )
+)
+
+
+;; normal
+(assert_return (invoke "v128.load8x8_s" (i32.const 0)) (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load8x8_u" (i32.const 0)) (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load16x4_s" (i32.const 0)) (v128.const i32x4 0x00000100 0x00000302 0x00000504 0x00000706))
+(assert_return (invoke "v128.load16x4_u" (i32.const 0)) (v128.const i32x4 0x00000100 0x00000302 0x00000504 0x00000706))
+(assert_return (invoke "v128.load32x2_s" (i32.const 0)) (v128.const i64x2 0x0000000003020100 0x0000000007060504))
+(assert_return (invoke "v128.load32x2_u" (i32.const 0)) (v128.const i64x2 0x0000000003020100 0x0000000007060504))
+(assert_return (invoke "v128.load8x8_s" (i32.const 10)) (v128.const i16x8 0x000A 0x000B 0x000C 0x000D 0x000E 0x000F 0xFF80 0xFF81))
+(assert_return (invoke "v128.load8x8_u" (i32.const 10)) (v128.const i16x8 0x000A 0x000B 0x000C 0x000D 0x000E 0x000F 0x0080 0x0081))
+(assert_return (invoke "v128.load16x4_s" (i32.const 10)) (v128.const i32x4 0x00000B0A 0x00000D0C 0x00000F0E 0xFFFF8180))
+(assert_return (invoke "v128.load16x4_u" (i32.const 10)) (v128.const i32x4 0x00000B0A 0x00000D0C 0x00000F0E 0x00008180))
+(assert_return (invoke "v128.load32x2_s" (i32.const 10)) (v128.const i64x2 0x000000000D0C0B0A 0xFFFFFFFF81800F0E))
+(assert_return (invoke "v128.load32x2_u" (i32.const 10)) (v128.const i64x2 0x000000000D0C0B0A 0x0000000081800F0E))
+(assert_return (invoke "v128.load8x8_s" (i32.const 20)) (v128.const i16x8 0xff84 0xff85 0xff86 0xff87 0xff88 0xff89 0x0000 0x0000))
+(assert_return (invoke "v128.load8x8_u" (i32.const 20)) (v128.const i16x8 0x0084 0x0085 0x0086 0x0087 0x0088 0x0089 0x0000 0x0000))
+(assert_return (invoke "v128.load16x4_s" (i32.const 20)) (v128.const i32x4 0xffff8584 0xffff8786 0xffff8988 0x00000000))
+(assert_return (invoke "v128.load16x4_u" (i32.const 20)) (v128.const i32x4 0x00008584 0x00008786 0x00008988 0x00000000))
+(assert_return (invoke "v128.load32x2_s" (i32.const 20)) (v128.const i64x2 0xFFFFFFFF87868584 0x0000000000008988))
+(assert_return (invoke "v128.load32x2_u" (i32.const 20)) (v128.const i64x2 0x0000000087868584 0x0000000000008988))
+
+;; load by a constant amount
+(assert_return (invoke "v128.load8x8_s_const0") (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load8x8_u_const8") (v128.const i16x8 0x0008 0x0009 0x000A 0x000B 0x000C 0x000D 0x000E 0x000F))
+(assert_return (invoke "v128.load16x4_s_const10") (v128.const i32x4 0x00000B0A 0x00000D0C 0x00000F0E 0xFFFF8180))
+(assert_return (invoke "v128.load16x4_u_const20") (v128.const i32x4 0x00008584 0x00008786 0x00008988 0x00000000))
+(assert_return (invoke "v128.load32x2_s_const65520") (v128.const i64x2 0x000000000D0C0B0A 0xFFFFFFFF81800F0E))
+(assert_return (invoke "v128.load32x2_u_const65526") (v128.const i64x2 0x0000000083828180 0x0000000087868584))
+
+;; load data with different offset/align arguments
+;; i16x8
+(assert_return (invoke "v128.load8x8_s_offset0" (i32.const 0)) (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load8x8_s_align1" (i32.const 1)) (v128.const i16x8 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008))
+(assert_return (invoke "v128.load8x8_s_offset0_align1" (i32.const 2)) (v128.const i16x8 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008 0x0009))
+(assert_return (invoke "v128.load8x8_s_offset10_align4" (i32.const 3)) (v128.const i16x8 0x000D 0x000E 0x000F 0xFF80 0xFF81 0xFF82 0xFF83 0xFF84))
+(assert_return (invoke "v128.load8x8_s_offset20_align8" (i32.const 4)) (v128.const i16x8 0xFF88 0xFF89 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+(assert_return (invoke "v128.load8x8_u_offset0" (i32.const 0)) (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load8x8_u_align1" (i32.const 1)) (v128.const i16x8 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008))
+(assert_return (invoke "v128.load8x8_u_offset0_align1" (i32.const 2)) (v128.const i16x8 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008 0x0009))
+(assert_return (invoke "v128.load8x8_u_offset10_align4" (i32.const 3)) (v128.const i16x8 0x000D 0x000E 0x000F 0x0080 0x0081 0x0082 0x0083 0x0084))
+(assert_return (invoke "v128.load8x8_u_offset20_align8" (i32.const 4)) (v128.const i16x8 0x0088 0x0089 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+;; i32x4
+(assert_return (invoke "v128.load16x4_s_offset0" (i32.const 0)) (v128.const i32x4 0x00000100 0x00000302 0x00000504 0x00000706))
+(assert_return (invoke "v128.load16x4_s_align1" (i32.const 1)) (v128.const i32x4 0x00000201 0x00000403 0x00000605 0x00000807))
+(assert_return (invoke "v128.load16x4_s_offset0_align1" (i32.const 2)) (v128.const i32x4 0x00000302 0x00000504 0x00000706 0x00000908))
+(assert_return (invoke "v128.load16x4_s_offset10_align4" (i32.const 3)) (v128.const i32x4 0x00000E0D 0xFFFF800F 0xFFFF8281 0xFFFF8483))
+(assert_return (invoke "v128.load16x4_s_offset20_align8" (i32.const 4)) (v128.const i32x4 0xFFFF8988 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load16x4_u_offset0" (i32.const 0)) (v128.const i32x4 0x00000100 0x00000302 0x00000504 0x00000706))
+(assert_return (invoke "v128.load16x4_u_align1" (i32.const 1)) (v128.const i32x4 0x00000201 0x00000403 0x00000605 0x00000807))
+(assert_return (invoke "v128.load16x4_u_offset0_align1" (i32.const 2)) (v128.const i32x4 0x00000302 0x00000504 0x00000706 0x00000908))
+(assert_return (invoke "v128.load16x4_u_offset10_align4" (i32.const 3)) (v128.const i32x4 0x00000E0D 0x0000800F 0x00008281 0x00008483))
+(assert_return (invoke "v128.load16x4_u_offset20_align8" (i32.const 4)) (v128.const i32x4 0x00008988 0x00000000 0x00000000 0x00000000))
+;; i64x2
+(assert_return (invoke "v128.load32x2_s_offset0" (i32.const 0)) (v128.const i64x2 0x0000000003020100 0x0000000007060504))
+(assert_return (invoke "v128.load32x2_s_align1" (i32.const 1)) (v128.const i64x2 0x0000000004030201 0x0000000008070605))
+(assert_return (invoke "v128.load32x2_s_offset0_align1" (i32.const 2)) (v128.const i64x2 0x0000000005040302 0x0000000009080706))
+(assert_return (invoke "v128.load32x2_s_offset10_align4" (i32.const 3)) (v128.const i64x2 0xFFFFFFFF800F0E0D 0xFFFFFFFF84838281))
+(assert_return (invoke "v128.load32x2_s_offset20_align8" (i32.const 4)) (v128.const i64x2 0x0000000000008988 0x0000000000000000))
+(assert_return (invoke "v128.load32x2_u_offset0" (i32.const 0)) (v128.const i64x2 0x0000000003020100 0x0000000007060504))
+(assert_return (invoke "v128.load32x2_u_align1" (i32.const 1)) (v128.const i64x2 0x0000000004030201 0x0000000008070605))
+(assert_return (invoke "v128.load32x2_u_offset0_align1" (i32.const 2)) (v128.const i64x2 0x0000000005040302 0x0000000009080706))
+(assert_return (invoke "v128.load32x2_u_offset10_align4" (i32.const 3)) (v128.const i64x2 0x00000000800F0E0D 0x0000000084838281))
+(assert_return (invoke "v128.load32x2_u_offset20_align8" (i32.const 4)) (v128.const i64x2 0x0000000000008988 0x0000000000000000))
+
+;; out of bounds memory access
+(assert_trap (invoke "v128.load8x8_s" (i32.const -1))  "out of bounds memory access")
+(assert_trap (invoke "v128.load8x8_u" (i32.const -1))  "out of bounds memory access")
+(assert_trap (invoke "v128.load16x4_s" (i32.const 65536))  "out of bounds memory access")
+(assert_trap (invoke "v128.load16x4_u" (i32.const 65536))  "out of bounds memory access")
+(assert_trap (invoke "v128.load32x2_s" (i32.const 65529))  "out of bounds memory access")
+(assert_trap (invoke "v128.load32x2_u" (i32.const 65529))  "out of bounds memory access")
+
+(assert_trap (invoke "v128.load8x8_s_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load8x8_u_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load16x4_s_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load16x4_u_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load32x2_s_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load32x2_u_offset1_align1" (i32.const -1)) "out of bounds memory access")
+
+;; type check
+(assert_invalid (module (memory 0) (func (result v128) (v128.load8x8_s (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load8x8_u (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load16x4_s (f64.const 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load16x4_u (f64.const 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load32x2_s (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load32x2_u (v128.const i32x4 0 0 0 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load8x8_s-arg-empty (result v128)
+      (v128.load8x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load8x8_u-arg-empty (result v128)
+      (v128.load8x8_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load16x4_s-arg-empty (result v128)
+      (v128.load16x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load16x4_u-arg-empty (result v128)
+      (v128.load16x4_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load32x2_s-arg-empty (result v128)
+      (v128.load32x2_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load32x2_u-arg-empty (result v128)
+      (v128.load32x2_u)
+    )
+  )
+  "type mismatch"
+)
+
+;; Unknown operator
+
+(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_u (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load32x2_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load32x2_u (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load64x1_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load64x1_u (i32.const 0))))") "unknown operator")
+
+;; combination
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+  (func (export "v128.load8x8_s-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load8x8_s (i32.const 0))))
+  )
+  (func (export "v128.load8x8_u-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load8x8_u (i32.const 1))))
+  )
+  (func (export "v128.load16x4_s-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load16x4_s (i32.const 2))))
+  )
+  (func (export "v128.load16x4_u-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load16x4_u (i32.const 3))))
+  )
+  (func (export "v128.load32x2_s-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load32x2_s (i32.const 4))))
+  )
+  (func (export "v128.load32x2_u-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load32x2_u (i32.const 5))))
+  )
+  (func (export "v128.load8x8_s-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load8x8_s (i32.const 6))))
+  )
+  (func (export "v128.load8x8_u-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load8x8_u (i32.const 7))))
+  )
+  (func (export "v128.load16x4_s-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load16x4_s (i32.const 8))))
+  )
+  (func (export "v128.load16x4_u-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load16x4_u (i32.const 9))))
+  )
+  (func (export "v128.load32x2_s-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load32x2_s (i32.const 10))))
+  )
+  (func (export "v128.load32x2_u-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load32x2_u (i32.const 11))))
+  )
+  (func (export "v128.load8x8_s-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load8x8_s (i32.const 12)))
+  )
+  (func (export "v128.load8x8_u-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load8x8_u (i32.const 13)))
+  )
+  (func (export "v128.load16x4_s-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load16x4_s (i32.const 14)))
+  )
+  (func (export "v128.load16x4_u-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load16x4_u (i32.const 15)))
+  )
+  (func (export "v128.load32x2_s-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load32x2_s (i32.const 16)))
+  )
+  (func (export "v128.load32x2_u-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load32x2_u (i32.const 17)))
+  )
+)
+(assert_return (invoke "v128.load8x8_s-in-block") (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load8x8_u-in-block") (v128.const i16x8 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008))
+(assert_return (invoke "v128.load16x4_s-in-block") (v128.const i32x4 0x00000302 0x00000504 0x00000706 0x00000908))
+(assert_return (invoke "v128.load16x4_u-in-block") (v128.const i32x4 0x00000403 0x00000605 0x00000807 0x00000A09))
+(assert_return (invoke "v128.load32x2_s-in-block") (v128.const i64x2 0x0000000007060504 0x000000000B0A0908))
+(assert_return (invoke "v128.load32x2_u-in-block") (v128.const i64x2 0x0000000008070605 0x000000000C0B0A09))
+(assert_return (invoke "v128.load8x8_s-as-br-value") (v128.const i16x8 0x0006 0x0007 0x0008 0x0009 0x000A 0x000B 0x000C 0x000D))
+(assert_return (invoke "v128.load8x8_u-as-br-value") (v128.const i16x8 0x0007 0x0008 0x0009 0x000A 0x000B 0x000C 0x000D 0x000E))
+(assert_return (invoke "v128.load16x4_s-as-br-value") (v128.const i32x4 0x00000908 0x00000B0A 0x00000D0C 0x00000F0E))
+(assert_return (invoke "v128.load16x4_u-as-br-value") (v128.const i32x4 0x00000A09 0x00000C0B 0x00000E0D 0x0000800F))
+(assert_return (invoke "v128.load32x2_s-as-br-value") (v128.const i64x2 0x000000000D0C0B0A 0xFFFFFFFF81800F0E))
+(assert_return (invoke "v128.load32x2_u-as-br-value") (v128.const i64x2 0x000000000E0D0C0B 0x000000008281800F))
+(assert_return (invoke "v128.load8x8_s-extract_lane_s-operand") (i32.const 12))
+(assert_return (invoke "v128.load8x8_u-extract_lane_s-operand") (i32.const 13))
+(assert_return (invoke "v128.load16x4_s-extract_lane_s-operand") (i32.const 14))
+(assert_return (invoke "v128.load16x4_u-extract_lane_s-operand") (i32.const 15))
+(assert_return (invoke "v128.load32x2_s-extract_lane_s-operand") (i32.const -128))
+(assert_return (invoke "v128.load32x2_u-extract_lane_s-operand") (i32.const -127))
diff --git a/test/core/simd/simd_load_splat.wast b/test/core/simd/simd_load_splat.wast
new file mode 100644
index 000000000..d9642f8bd
--- /dev/null
+++ b/test/core/simd/simd_load_splat.wast
@@ -0,0 +1,261 @@
+;; Tests for the load_splat instructions
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F")
+  (data (i32.const 65520) "\10\11\12\13\14\15\16\17\18\19\1A\1B\1C\1D\1E\1F")
+
+  (func (export "v128.load8_splat") (param $address i32) (result v128) (v128.load8_splat (local.get $address)))
+  (func (export "v128.load16_splat") (param $address i32) (result v128) (v128.load16_splat (local.get $address)))
+  (func (export "v128.load32_splat") (param $address i32) (result v128) (v128.load32_splat (local.get $address)))
+  (func (export "v128.load64_splat") (param $address i32) (result v128) (v128.load64_splat (local.get $address)))
+
+  ;; Load data with different offset/align arguments
+  (func (export "v8x16.offset0") (param $address i32) (result v128) (v128.load8_splat offset=0 (local.get $address)))
+  (func (export "v8x16.align1") (param $address i32) (result v128) (v128.load8_splat align=1 (local.get $address)))
+  (func (export "v8x16.offset1_align1") (param $address i32) (result v128) (v128.load8_splat offset=1 align=1 (local.get $address)))
+  (func (export "v8x16.offset2_align1") (param $address i32) (result v128) (v128.load8_splat offset=2 align=1 (local.get $address)))
+  (func (export "v8x16.offset15_align1") (param $address i32) (result v128) (v128.load8_splat offset=15 align=1 (local.get $address)))
+
+  (func (export "v16x8.offset0") (param $address i32) (result v128) (v128.load16_splat offset=0 (local.get $address)))
+  (func (export "v16x8.align1") (param $address i32) (result v128) (v128.load16_splat align=1 (local.get $address)))
+  (func (export "v16x8.offset1_align1") (param $address i32) (result v128) (v128.load16_splat offset=1 align=1 (local.get $address)))
+  (func (export "v16x8.offset2_align1") (param $address i32) (result v128) (v128.load16_splat offset=2 align=1 (local.get $address)))
+  (func (export "v16x8.offset15_align2") (param $address i32) (result v128) (v128.load16_splat offset=15 align=2 (local.get $address)))
+
+  (func (export "v32x4.offset0") (param $address i32) (result v128) (v128.load32_splat offset=0 (local.get $address)))
+  (func (export "v32x4.align1") (param $address i32) (result v128) (v128.load32_splat align=1 (local.get $address)))
+  (func (export "v32x4.offset1_align1") (param $address i32) (result v128) (v128.load32_splat offset=1 align=1 (local.get $address)))
+  (func (export "v32x4.offset2_align2") (param $address i32) (result v128) (v128.load32_splat offset=2 align=2 (local.get $address)))
+  (func (export "v32x4.offset15_align4") (param $address i32) (result v128) (v128.load32_splat offset=15 align=4 (local.get $address)))
+
+  (func (export "v64x2.offset0") (param $address i32) (result v128) (v128.load64_splat offset=0 (local.get $address)))
+  (func (export "v64x2.align1") (param $address i32) (result v128) (v128.load64_splat align=1 (local.get $address)))
+  (func (export "v64x2.offset1_align2") (param $address i32) (result v128) (v128.load64_splat offset=1 align=2 (local.get $address)))
+  (func (export "v64x2.offset2_align4") (param $address i32) (result v128) (v128.load64_splat offset=2 align=4 (local.get $address)))
+  (func (export "v64x2.offset15_align8") (param $address i32) (result v128) (v128.load64_splat offset=15 align=8 (local.get $address)))
+
+  (func (export "v8x16.offset65536") (param $address i32) (result v128) (v128.load8_splat offset=65536 (local.get $address)))
+  (func (export "v16x8.offset65535") (param $address i32) (result v128) (v128.load16_splat offset=65535 (local.get $address)))
+  (func (export "v32x4.offset65533") (param $address i32) (result v128) (v128.load32_splat offset=65533 (local.get $address)))
+  (func (export "v64x2.offset65529") (param $address i32) (result v128) (v128.load64_splat offset=65529 (local.get $address)))
+)
+(assert_return (invoke "v128.load8_splat" (i32.const 0)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_splat" (i32.const 1)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "v128.load8_splat" (i32.const 2)) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "v128.load8_splat" (i32.const 3)) (v128.const i8x16 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3))
+(assert_return (invoke "v128.load8_splat" (i32.const 65535)) (v128.const i8x16 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31))
+(assert_return (invoke "v128.load16_splat" (i32.const 4)) (v128.const i16x8 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504))
+(assert_return (invoke "v128.load16_splat" (i32.const 5)) (v128.const i16x8 0x0605 0x0605 0x0605 0x0605 0x0605 0x0605 0x0605 0x0605))
+(assert_return (invoke "v128.load16_splat" (i32.const 6)) (v128.const i16x8 0x0706 0x0706 0x0706 0x0706 0x0706 0x0706 0x0706 0x0706))
+(assert_return (invoke "v128.load16_splat" (i32.const 7)) (v128.const i16x8 0x0807 0x0807 0x0807 0x0807 0x0807 0x0807 0x0807 0x0807))
+(assert_return (invoke "v128.load16_splat" (i32.const 65534)) (v128.const i16x8 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E))
+(assert_return (invoke "v128.load32_splat" (i32.const 8)) (v128.const i32x4 0x0B0A0908 0x0B0A0908 0x0B0A0908 0x0B0A0908))
+(assert_return (invoke "v128.load32_splat" (i32.const 9)) (v128.const i32x4 0x0C0B0A09 0x0C0B0A09 0x0C0B0A09 0x0C0B0A09))
+(assert_return (invoke "v128.load32_splat" (i32.const 10)) (v128.const i32x4 0x0D0C0B0A 0x0D0C0B0A 0x0D0C0B0A 0x0D0C0B0A))
+(assert_return (invoke "v128.load32_splat" (i32.const 11)) (v128.const i32x4 0x0E0D0C0B 0x0E0D0C0B 0x0E0D0C0B 0x0E0D0C0B))
+(assert_return (invoke "v128.load32_splat" (i32.const 65532)) (v128.const i32x4 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C))
+(assert_return (invoke "v128.load64_splat" (i32.const 12)) (v128.const i64x2 0x000000000F0E0D0C 0x000000000F0E0D0C))
+(assert_return (invoke "v128.load64_splat" (i32.const 13)) (v128.const i64x2 0x00000000000F0E0D 0x00000000000F0E0D))
+(assert_return (invoke "v128.load64_splat" (i32.const 14)) (v128.const i64x2 0x0000000000000F0E 0x0000000000000F0E))
+(assert_return (invoke "v128.load64_splat" (i32.const 15)) (v128.const i64x2 0x000000000000000F 0x000000000000000F))
+(assert_return (invoke "v128.load64_splat" (i32.const 65528)) (v128.const i64x2 0x1F1E1D1C1B1A1918 0x1F1E1D1C1B1A1918))
+
+;; v8x16
+(assert_return (invoke "v8x16.offset0" (i32.const 0)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v8x16.align1" (i32.const 0)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v8x16.offset1_align1" (i32.const 0)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "v8x16.offset2_align1" (i32.const 0)) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "v8x16.offset15_align1" (i32.const 0)) (v128.const i8x16 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15))
+(assert_return (invoke "v8x16.offset0" (i32.const 1)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "v8x16.align1" (i32.const 1)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "v8x16.offset1_align1" (i32.const 1)) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "v8x16.offset2_align1" (i32.const 1)) (v128.const i8x16 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3))
+(assert_return (invoke "v8x16.offset15_align1" (i32.const 1)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v8x16.offset0" (i32.const 65535)) (v128.const i8x16 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31))
+(assert_return (invoke "v8x16.align1" (i32.const 65535)) (v128.const i8x16 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31))
+;; v16x8
+(assert_return (invoke "v16x8.offset0" (i32.const 0)) (v128.const i16x8 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100))
+(assert_return (invoke "v16x8.align1" (i32.const 0)) (v128.const i16x8 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100))
+(assert_return (invoke "v16x8.offset1_align1" (i32.const 0)) (v128.const i16x8 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201))
+(assert_return (invoke "v16x8.offset2_align1" (i32.const 0)) (v128.const i16x8 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302))
+(assert_return (invoke "v16x8.offset15_align2" (i32.const 0)) (v128.const i16x8 0x000F 0x000F 0x000F 0x000F 0x000F 0x000F 0x000F 0x000F))
+(assert_return (invoke "v16x8.offset0" (i32.const 1)) (v128.const i16x8 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201))
+(assert_return (invoke "v16x8.align1" (i32.const 1)) (v128.const i16x8 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201))
+(assert_return (invoke "v16x8.offset1_align1" (i32.const 1)) (v128.const i16x8 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302))
+(assert_return (invoke "v16x8.offset2_align1" (i32.const 1)) (v128.const i16x8 0x0403 0x0403 0x0403 0x0403 0x0403 0x0403 0x0403 0x0403))
+(assert_return (invoke "v16x8.offset15_align2" (i32.const 1)) (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+(assert_return (invoke "v16x8.offset0" (i32.const 65534)) (v128.const i16x8 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E))
+(assert_return (invoke "v16x8.align1" (i32.const 65534)) (v128.const i16x8 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E))
+;; v32x4
+(assert_return (invoke "v32x4.offset0" (i32.const 0)) (v128.const i32x4 0x03020100 0x03020100 0x03020100 0x03020100))
+(assert_return (invoke "v32x4.align1" (i32.const 0)) (v128.const i32x4 0x03020100 0x03020100 0x03020100 0x03020100))
+(assert_return (invoke "v32x4.offset1_align1" (i32.const 0)) (v128.const i32x4 0x04030201 0x04030201 0x04030201 0x04030201))
+(assert_return (invoke "v32x4.offset2_align2" (i32.const 0)) (v128.const i32x4 0x05040302 0x05040302 0x05040302 0x05040302))
+(assert_return (invoke "v32x4.offset15_align4" (i32.const 0)) (v128.const i32x4 0x0000000F 0x0000000F 0x0000000F 0x0000000F))
+(assert_return (invoke "v32x4.offset0" (i32.const 1)) (v128.const i32x4 0x04030201 0x04030201 0x04030201 0x04030201))
+(assert_return (invoke "v32x4.align1" (i32.const 1)) (v128.const i32x4 0x04030201 0x04030201 0x04030201 0x04030201))
+(assert_return (invoke "v32x4.offset1_align1" (i32.const 1)) (v128.const i32x4 0x05040302 0x05040302 0x05040302 0x05040302))
+(assert_return (invoke "v32x4.offset2_align2" (i32.const 1)) (v128.const i32x4 0x06050403 0x06050403 0x06050403 0x06050403))
+(assert_return (invoke "v32x4.offset15_align4" (i32.const 1)) (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v32x4.offset0" (i32.const 65532)) (v128.const i32x4 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C))
+(assert_return (invoke "v32x4.align1" (i32.const 65532)) (v128.const i32x4 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C))
+;; v64x2
+(assert_return (invoke "v64x2.offset0" (i32.const 0)) (v128.const i64x2 0x0706050403020100 0x0706050403020100))
+(assert_return (invoke "v64x2.align1" (i32.const 0)) (v128.const i64x2 0x0706050403020100 0x0706050403020100))
+(assert_return (invoke "v64x2.offset1_align2" (i32.const 0)) (v128.const i64x2 0x0807060504030201 0x0807060504030201))
+(assert_return (invoke "v64x2.offset2_align4" (i32.const 0)) (v128.const i64x2 0x0908070605040302 0x0908070605040302))
+(assert_return (invoke "v64x2.offset15_align8" (i32.const 0)) (v128.const i64x2 0x000000000000000F 0x000000000000000F))
+(assert_return (invoke "v64x2.offset0" (i32.const 1)) (v128.const i64x2 0x0807060504030201 0x0807060504030201))
+(assert_return (invoke "v64x2.align1" (i32.const 1)) (v128.const i64x2 0x0807060504030201 0x0807060504030201))
+(assert_return (invoke "v64x2.offset1_align2" (i32.const 1)) (v128.const i64x2 0x0908070605040302 0x0908070605040302))
+(assert_return (invoke "v64x2.offset2_align4" (i32.const 1)) (v128.const i64x2 0x0A09080706050403 0x0A09080706050403))
+(assert_return (invoke "v64x2.offset15_align8" (i32.const 1)) (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+(assert_return (invoke "v64x2.offset0" (i32.const 65528)) (v128.const i64x2 0x1F1E1D1C1B1A1918 0x1F1E1D1C1B1A1918))
+(assert_return (invoke "v64x2.align1" (i32.const 65528)) (v128.const i64x2 0x1F1E1D1C1B1A1918 0x1F1E1D1C1B1A1918))
+
+
+;; Out of bounds memory access
+(assert_trap (invoke "v128.load8_splat" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load16_splat" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load32_splat" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load64_splat" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load8_splat" (i32.const 65536)) "out of bounds memory access")
+(assert_trap (invoke "v128.load16_splat" (i32.const 65535)) "out of bounds memory access")
+(assert_trap (invoke "v128.load32_splat" (i32.const 65533)) "out of bounds memory access")
+(assert_trap (invoke "v128.load64_splat" (i32.const 65529)) "out of bounds memory access")
+
+(assert_trap (invoke "v8x16.offset1_align1" (i32.const 65535)) "out of bounds memory access")
+(assert_trap (invoke "v8x16.offset2_align1" (i32.const 65535)) "out of bounds memory access")
+(assert_trap (invoke "v8x16.offset15_align1" (i32.const 65535)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset1_align1" (i32.const 65534)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset2_align1" (i32.const 65534)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset15_align2" (i32.const 65534)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset1_align1" (i32.const 65532)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset2_align2" (i32.const 65532)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset15_align4" (i32.const 65532)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset1_align2" (i32.const 65528)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset2_align4" (i32.const 65528)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset15_align8" (i32.const 65528)) "out of bounds memory access")
+
+(assert_trap (invoke "v8x16.offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset1_align2" (i32.const -1)) "out of bounds memory access")
+
+(assert_trap (invoke "v8x16.offset65536" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset65535" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset65533" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset65529" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "v8x16.offset65536" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset65535" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset65533" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset65529" (i32.const 1)) "out of bounds memory access")
+
+
+;; Combination
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A")
+
+  (func (export "v128.load8_splat-in-block") (result v128)
+      (block (result v128) (block (result v128) (v128.load8_splat (i32.const 0))))
+  )
+  (func (export "v128.load16_splat-in-block") (result v128)
+      (block (result v128) (block (result v128) (v128.load16_splat (i32.const 1))))
+  )
+  (func (export "v128.load32_splat-in-block") (result v128)
+      (block (result v128) (block (result v128) (v128.load32_splat (i32.const 2))))
+  )
+  (func (export "v128.load64_splat-in-block") (result v128)
+      (block (result v128) (block (result v128) (v128.load64_splat (i32.const 9))))
+  )
+  (func (export "v128.load8_splat-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load8_splat (i32.const 3))))
+  )
+  (func (export "v128.load16_splat-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load16_splat (i32.const 4))))
+  )
+  (func (export "v128.load32_splat-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load32_splat (i32.const 5))))
+  )
+  (func (export "v128.load64_splat-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load64_splat (i32.const 10))))
+  )
+  (func (export "v128.load8_splat-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load8_splat (i32.const 6)))
+  )
+  (func (export "v128.load16_splat-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load16_splat (i32.const 7)))
+  )
+  (func (export "v128.load32_splat-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load32_splat (i32.const 8)))
+  )
+  (func (export "v128.load64_splat-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load64_splat (i32.const 11)))
+  )
+)
+(assert_return (invoke "v128.load8_splat-in-block") (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_splat-in-block") (v128.const i16x8 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201))
+(assert_return (invoke "v128.load32_splat-in-block") (v128.const i32x4 0x05040302 0x05040302 0x05040302 0x05040302))
+(assert_return (invoke "v128.load64_splat-in-block") (v128.const i64x2 0x0000000000000A09 0x0000000000000A09))
+(assert_return (invoke "v128.load8_splat-as-br-value") (v128.const i8x16 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3))
+(assert_return (invoke "v128.load16_splat-as-br-value") (v128.const i16x8 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504))
+(assert_return (invoke "v128.load32_splat-as-br-value") (v128.const i32x4 0x08070605 0x08070605 0x08070605 0x08070605))
+(assert_return (invoke "v128.load64_splat-as-br-value") (v128.const i64x2 0x000000000000000A 0x000000000000000A))
+(assert_return (invoke "v128.load8_splat-extract_lane_s-operand") (i32.const 6))
+(assert_return (invoke "v128.load16_splat-extract_lane_s-operand") (i32.const 7))
+(assert_return (invoke "v128.load32_splat-extract_lane_s-operand") (i32.const 8))
+(assert_return (invoke "v128.load64_splat-extract_lane_s-operand") (i32.const 0))
+
+
+;; Type check
+
+(assert_invalid (module (memory 0) (func (result v128) (v128.load8_splat (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load16_splat (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load32_splat (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load64_splat (v128.const i32x4 0 0 0 0)))) "type mismatch")
+
+
+;; Unknown operator
+
+(assert_malformed (module quote "(memory 1) (func (drop (i8x16.load_splat (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load_splat (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load_splat (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load_splat (i32.const 0))))") "unknown operator")
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load8_splat-arg-empty (result v128)
+      (v128.load8_splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load16_splat-arg-empty (result v128)
+      (v128.load16_splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load32_splat-arg-empty (result v128)
+      (v128.load32_splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load64_splat-arg-empty (result v128)
+      (v128.load64_splat)
+    )
+  )
+  "type mismatch"
+)
diff --git a/test/core/simd/simd_load_zero.wast b/test/core/simd/simd_load_zero.wast
new file mode 100644
index 000000000..6276a6863
--- /dev/null
+++ b/test/core/simd/simd_load_zero.wast
@@ -0,0 +1,154 @@
+;; Load and Zero extend test cases
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+  (data (i32.const 65520) "\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+
+  (func (export "v128.load32_zero") (param $0 i32) (result v128)
+    (v128.load32_zero (local.get $0))
+  )
+  (func (export "v128.load64_zero") (param $0 i32) (result v128)
+    (v128.load64_zero (local.get $0))
+  )
+
+  ;; load by a constant amount
+  (func (export "v128.load32_zero_const0") (result v128)
+    (v128.load32_zero (i32.const 0))
+  )
+  (func (export "v128.load64_zero_const8") (result v128)
+    (v128.load64_zero (i32.const 8))
+  )
+
+  ;; load data with different offset/align arguments
+  ;; i16x8
+  (func (export "v128.load32_zero_offset0") (param $0 i32) (result v128)
+    (v128.load32_zero offset=0 (local.get $0))
+  )
+  (func (export "v128.load32_zero_align1") (param $0 i32) (result v128)
+    (v128.load32_zero align=1 (local.get $0))
+  )
+  (func (export "v128.load32_zero_offset0_align1") (param $0 i32) (result v128)
+    (v128.load32_zero offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load32_zero_offset1_align1") (param $0 i32) (result v128)
+    (v128.load32_zero offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load32_zero_offset10_align4") (param $0 i32) (result v128)
+    (v128.load32_zero offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load64_zero_offset0") (param $0 i32) (result v128)
+    (v128.load64_zero offset=0 (local.get $0))
+  )
+  (func (export "v128.load64_zero_align1") (param $0 i32) (result v128)
+    (v128.load64_zero align=1 (local.get $0))
+  )
+  (func (export "v128.load64_zero_offset0_align1") (param $0 i32) (result v128)
+    (v128.load64_zero offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load64_zero_offset1_align1") (param $0 i32) (result v128)
+    (v128.load64_zero offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load64_zero_offset10_align4") (param $0 i32) (result v128)
+    (v128.load64_zero offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load64_zero_offset20_align8") (param $0 i32) (result v128)
+    (v128.load64_zero offset=20 align=8 (local.get $0))
+  )
+)
+
+
+;; normal
+(assert_return (invoke "v128.load32_zero" (i32.const 0)) (v128.const i32x4 0x03020100 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero" (i32.const 0)) (v128.const i64x2 0x0706050403020100 0x0000000000000000))
+(assert_return (invoke "v128.load32_zero" (i32.const 10)) (v128.const i32x4 0x0D0C0B0A 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero" (i32.const 10)) (v128.const i64x2 0x81800F0E0D0C0B0A 0x0000000000000000))
+(assert_return (invoke "v128.load32_zero" (i32.const 20)) (v128.const i32x4 0x87868584 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero" (i32.const 20)) (v128.const i64x2 0x0000898887868584 0x0000000000000000))
+
+;; load by a constant amount
+(assert_return (invoke "v128.load32_zero_const0") (v128.const i32x4 0x03020100 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero_const8") (v128.const i64x2 0x0F0E0D0C0B0A0908 0x0000000000000000))
+
+;; load data with different offset/align arguments
+;; load32_zero
+(assert_return (invoke "v128.load32_zero_offset0" (i32.const 0)) (v128.const i32x4 0x03020100 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load32_zero_align1" (i32.const 1)) (v128.const i32x4 0x04030201 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load32_zero_offset0_align1" (i32.const 2)) (v128.const i32x4 0x05040302 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load32_zero_offset10_align4" (i32.const 3)) (v128.const i32x4 0x800F0E0D 0x00000000 0x00000000 0x00000000))
+
+;; load64_zero
+(assert_return (invoke "v128.load64_zero_offset0" (i32.const 0)) (v128.const i64x2 0x0706050403020100 0x0000000000000000))
+(assert_return (invoke "v128.load64_zero_align1" (i32.const 1)) (v128.const i64x2 0x0807060504030201 0x0000000000000000))
+(assert_return (invoke "v128.load64_zero_offset0_align1" (i32.const 2)) (v128.const i64x2 0x0908070605040302 0x0000000000000000))
+(assert_return (invoke "v128.load64_zero_offset10_align4" (i32.const 3)) (v128.const i64x2 0x84838281800F0E0D 0x0000000000000000))
+(assert_return (invoke "v128.load64_zero_offset20_align8" (i32.const 4)) (v128.const i64x2 0x0000000000008988 0x0000000000000000))
+
+;; out of bounds memory access
+(assert_trap (invoke "v128.load32_zero" (i32.const -1))  "out of bounds memory access")
+(assert_trap (invoke "v128.load64_zero" (i32.const -1))  "out of bounds memory access")
+
+(assert_trap (invoke "v128.load32_zero_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load64_zero_offset1_align1" (i32.const -1)) "out of bounds memory access")
+
+;; type check
+(assert_invalid (module (memory 0) (func (result v128) (v128.load32_zero (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load64_zero (f32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load32_zero-arg-empty (result v128)
+      (v128.load32_zero)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load64_zero-arg-empty (result v128)
+      (v128.load64_zero)
+    )
+  )
+  "type mismatch"
+)
+
+;; Unknown operator
+
+(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_u (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load32x2_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load32x2_u (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load64x1_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load64x1_u (i32.const 0))))") "unknown operator")
+
+;; combination
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+  (func (export "v128.load32_zero-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load32_zero (i32.const 0))))
+  )
+  (func (export "v128.load64_zero-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load64_zero (i32.const 1))))
+  )
+  (func (export "v128.load32_zero-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load32_zero (i32.const 6))))
+  )
+  (func (export "v128.load64_zero-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load64_zero (i32.const 7))))
+  )
+  (func (export "v128.load32_zero-extract_lane_s-operand") (result i32)
+    (i32x4.extract_lane 0 (v128.load32_zero (i32.const 12)))
+  )
+  (func (export "v128.load64_zero-extract_lane_s-operand") (result i64)
+    (i64x2.extract_lane 0 (v128.load64_zero (i32.const 13)))
+  )
+)
+(assert_return (invoke "v128.load32_zero-in-block") (v128.const i32x4 0x03020100 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero-in-block") (v128.const i64x2 0x0807060504030201 0x0000000000000000))
+(assert_return (invoke "v128.load32_zero-as-br-value") (v128.const i32x4 0x09080706 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero-as-br-value") (v128.const i64x2 0x0E0D0C0B0A090807 0x0000000000000000))
+(assert_return (invoke "v128.load32_zero-extract_lane_s-operand") (i32.const 0x0F0E0D0C))
+(assert_return (invoke "v128.load64_zero-extract_lane_s-operand") (i64.const 0x84838281800F0E0D))
diff --git a/test/core/simd/simd_splat.wast b/test/core/simd/simd_splat.wast
new file mode 100644
index 000000000..4be04ef17
--- /dev/null
+++ b/test/core/simd/simd_splat.wast
@@ -0,0 +1,430 @@
+;; Tests for the *_splat instructions
+
+(module
+  (func (export "i8x16.splat") (param i32) (result v128) (i8x16.splat (local.get 0)))
+  (func (export "i16x8.splat") (param i32) (result v128) (i16x8.splat (local.get 0)))
+  (func (export "i32x4.splat") (param i32) (result v128) (i32x4.splat (local.get 0)))
+  (func (export "f32x4.splat") (param f32) (result v128) (f32x4.splat (local.get 0)))
+  (func (export "i64x2.splat") (param i64) (result v128) (i64x2.splat (local.get 0)))
+  (func (export "f64x2.splat") (param f64) (result v128) (f64x2.splat (local.get 0)))
+)
+
+(assert_return (invoke "i8x16.splat" (i32.const 0)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.splat" (i32.const 5)) (v128.const i8x16 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5))
+(assert_return (invoke "i8x16.splat" (i32.const -5)) (v128.const i8x16 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5))
+(assert_return (invoke "i8x16.splat" (i32.const 257)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.splat" (i32.const 0xff)) (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.splat" (i32.const -128)) (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.splat" (i32.const 127)) (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.splat" (i32.const -129)) (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.splat" (i32.const 128)) (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.splat" (i32.const 0xff7f)) (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.splat" (i32.const 0x80)) (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.splat" (i32.const 0xAB)) (v128.const i32x4 0xABABABAB 0xABABABAB 0xABABABAB 0xABABABAB))
+
+(assert_return (invoke "i16x8.splat" (i32.const 0)) (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.splat" (i32.const 5)) (v128.const i16x8 5 5 5 5 5 5 5 5))
+(assert_return (invoke "i16x8.splat" (i32.const -5)) (v128.const i16x8 -5 -5 -5 -5 -5 -5 -5 -5))
+(assert_return (invoke "i16x8.splat" (i32.const 65537)) (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.splat" (i32.const 0xffff)) (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.splat" (i32.const -32768)) (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.splat" (i32.const 32767)) (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.splat" (i32.const -32769)) (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.splat" (i32.const 32768)) (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.splat" (i32.const 0xffff7fff)) (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.splat" (i32.const 0x8000)) (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.splat" (i32.const 0xABCD)) (v128.const i32x4 0xABCDABCD 0xABCDABCD 0xABCDABCD 0xABCDABCD))
+(assert_return (invoke "i16x8.splat" (i32.const 012345)) (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+(assert_return (invoke "i16x8.splat" (i32.const 0x01234)) (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+
+(assert_return (invoke "i32x4.splat" (i32.const 0)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.splat" (i32.const 5)) (v128.const i32x4 5 5 5 5))
+(assert_return (invoke "i32x4.splat" (i32.const -5)) (v128.const i32x4 -5 -5 -5 -5))
+(assert_return (invoke "i32x4.splat" (i32.const 0xffffffff)) (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.splat" (i32.const 4294967295)) (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.splat" (i32.const -2147483648)) (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.splat" (i32.const 2147483647)) (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff))
+(assert_return (invoke "i32x4.splat" (i32.const 2147483648)) (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.splat" (i32.const 01234567890)) (v128.const i32x4 012_3456_7890 012_3456_7890 012_3456_7890 012_3456_7890))
+(assert_return (invoke "i32x4.splat" (i32.const 0x012345678)) (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+
+(assert_return (invoke "f32x4.splat" (f32.const 0.0)) (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.splat" (f32.const 1.1)) (v128.const f32x4 1.1 1.1 1.1 1.1))
+(assert_return (invoke "f32x4.splat" (f32.const -1.1)) (v128.const f32x4 -1.1 -1.1 -1.1 -1.1))
+(assert_return (invoke "f32x4.splat" (f32.const 1e38)) (v128.const f32x4 1e38 1e38 1e38 1e38))
+(assert_return (invoke "f32x4.splat" (f32.const -1e38)) (v128.const f32x4 -1e38 -1e38 -1e38 -1e38))
+(assert_return (invoke "f32x4.splat" (f32.const 0x1.fffffep127)) (v128.const f32x4 0x1.fffffep127 0x1.fffffep127 0x1.fffffep127 0x1.fffffep127))
+(assert_return (invoke "f32x4.splat" (f32.const -0x1.fffffep127)) (v128.const f32x4 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127))
+(assert_return (invoke "f32x4.splat" (f32.const 0x1p127)) (v128.const f32x4 0x1p127 0x1p127 0x1p127 0x1p127))
+(assert_return (invoke "f32x4.splat" (f32.const -0x1p127)) (v128.const f32x4 -0x1p127 -0x1p127 -0x1p127 -0x1p127))
+(assert_return (invoke "f32x4.splat" (f32.const inf)) (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.splat" (f32.const -inf)) (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.splat" (f32.const nan)) (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.splat" (f32.const nan:0x1)) (v128.const f32x4 nan:0x1 nan:0x1 nan:0x1 nan:0x1))
+(assert_return (invoke "f32x4.splat" (f32.const nan:0x7f_ffff)) (v128.const f32x4 nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff))
+(assert_return (invoke "f32x4.splat" (f32.const 0123456789)) (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.splat" (f32.const 0123456789.)) (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.splat" (f32.const 0x0123456789ABCDEF)) (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.splat" (f32.const 0x0123456789ABCDEF.)) (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.splat" (f32.const 0123456789e019)) (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.splat" (f32.const 0123456789.e+019)) (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.splat" (f32.const 0x0123456789ABCDEFp019)) (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.splat" (f32.const 0x0123456789ABCDEF.p-019)) (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+
+(assert_return (invoke "i64x2.splat" (i64.const 0)) (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.splat" (i64.const -0)) (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.splat" (i64.const 1)) (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.splat" (i64.const -1)) (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.splat" (i64.const -9223372036854775808)) (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.splat" (i64.const -9223372036854775808)) (v128.const i64x2 9223372036854775808 9223372036854775808))
+(assert_return (invoke "i64x2.splat" (i64.const 9223372036854775807)) (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.splat" (i64.const 18446744073709551615)) (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.splat" (i64.const 0x7fffffffffffffff)) (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff))
+(assert_return (invoke "i64x2.splat" (i64.const 0xffffffffffffffff)) (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.splat" (i64.const -0x8000000000000000)) (v128.const i64x2 -0x8000000000000000 -0x8000000000000000))
+(assert_return (invoke "i64x2.splat" (i64.const -0x8000000000000000)) (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+(assert_return (invoke "i64x2.splat" (i64.const 01234567890123456789)) (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789))
+(assert_return (invoke "i64x2.splat" (i64.const 0x01234567890ABcdef)) (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef))
+
+(assert_return (invoke "f64x2.splat" (f64.const 0.0)) (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.splat" (f64.const -0.0)) (v128.const f64x2 -0.0 -0.0))
+(assert_return (invoke "f64x2.splat" (f64.const 1.1)) (v128.const f64x2 1.1 1.1))
+(assert_return (invoke "f64x2.splat" (f64.const -1.1)) (v128.const f64x2 -1.1 -1.1))
+(assert_return (invoke "f64x2.splat" (f64.const 0x0.0000000000001p-1022)) (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.splat" (f64.const -0x0.0000000000001p-1022)) (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.splat" (f64.const 0x1p-1022)) (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.splat" (f64.const -0x1p-1022)) (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.splat" (f64.const 0x1p-1)) (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.splat" (f64.const -0x1p-1)) (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.splat" (f64.const 0x1p+0)) (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.splat" (f64.const -0x1p+0)) (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.splat" (f64.const 0x1.921fb54442d18p+2)) (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.splat" (f64.const -0x1.921fb54442d18p+2)) (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.splat" (f64.const 0x1.fffffffffffffp+1023)) (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.splat" (f64.const -0x1.fffffffffffffp+1023)) (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.splat" (f64.const inf)) (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.splat" (f64.const -inf)) (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.splat" (f64.const nan)) (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.splat" (f64.const -nan)) (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.splat" (f64.const nan:0x4000000000000)) (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.splat" (f64.const -nan:0x4000000000000)) (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.splat" (f64.const 0123456789)) (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.splat" (f64.const 0123456789.)) (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.splat" (f64.const 0x0123456789ABCDEFabcdef)) (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.splat" (f64.const 0x0123456789ABCDEFabcdef.)) (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.splat" (f64.const 0123456789e019)) (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.splat" (f64.const 0123456789e+019)) (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.splat" (f64.const 0x0123456789ABCDEFabcdef.p019)) (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.splat" (f64.const 0x0123456789ABCDEFabcdef.p-019)) (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+
+;; Unknown operator
+
+(assert_malformed (module quote "(func (result v128) (v128.splat (i32.const 0)))") "unknown operator")
+
+
+;; Type mismatched
+
+(assert_invalid (module (func (result v128) i8x16.splat (i64.const 0))) "type mismatch")
+(assert_invalid (module (func (result v128) i8x16.splat (f32.const 0.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i8x16.splat (f64.const 0.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i16x8.splat (i64.const 1))) "type mismatch")
+(assert_invalid (module (func (result v128) i16x8.splat (f32.const 1.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i16x8.splat (f64.const 1.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i32x4.splat (i64.const 2))) "type mismatch")
+(assert_invalid (module (func (result v128) i32x4.splat (f32.const 2.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i32x4.splat (f64.const 2.0))) "type mismatch")
+(assert_invalid (module (func (result v128) f32x4.splat (i32.const 4))) "type mismatch")
+(assert_invalid (module (func (result v128) f32x4.splat (i64.const 4))) "type mismatch")
+(assert_invalid (module (func (result v128) f32x4.splat (f64.const 4.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i64x2.splat (i32.const 0))) "type mismatch")
+(assert_invalid (module (func (result v128) i64x2.splat (f64.const 0.0))) "type mismatch")
+(assert_invalid (module (func (result v128) f64x2.splat (i32.const 0))) "type mismatch")
+(assert_invalid (module (func (result v128) f64x2.splat (f32.const 0.0))) "type mismatch")
+
+
+;; V128 splat operators as the argument of other SIMD instructions
+
+;; v128.store and v128.load
+(module (memory 1)
+  (func (export "as-v128_store-operand-1") (param i32) (result v128)
+    (v128.store (i32.const 0) (i8x16.splat (local.get 0)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-2") (param i32) (result v128)
+    (v128.store (i32.const 0) (i16x8.splat (local.get 0)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-3") (param i32) (result v128)
+    (v128.store (i32.const 0) (i32x4.splat (local.get 0)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-4") (param i64) (result v128)
+    (v128.store (i32.const 0) (i64x2.splat (local.get 0)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-5") (param f64) (result v128)
+    (v128.store (i32.const 0) (f64x2.splat (local.get 0)))
+    (v128.load (i32.const 0)))
+)
+
+(assert_return (invoke "as-v128_store-operand-1" (i32.const 1)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "as-v128_store-operand-2" (i32.const 256)) (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+(assert_return (invoke "as-v128_store-operand-3" (i32.const 0xffffffff)) (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "as-v128_store-operand-4" (i64.const 1)) (v128.const i64x2 1 1))
+(assert_return (invoke "as-v128_store-operand-5" (f64.const -0x1p+0)) (v128.const f64x2 -0x1p+0 -0x1p+0))
+
+(module
+  ;; Accessing lane
+  (func (export "as-i8x16_extract_lane_s-operand-first") (param i32) (result i32)
+    (i8x16.extract_lane_s 0 (i8x16.splat (local.get 0))))
+  (func (export "as-i8x16_extract_lane_s-operand-last") (param i32) (result i32)
+    (i8x16.extract_lane_s 15 (i8x16.splat (local.get 0))))
+  (func (export "as-i16x8_extract_lane_s-operand-first") (param i32) (result i32)
+    (i16x8.extract_lane_s 0 (i16x8.splat (local.get 0))))
+  (func (export "as-i16x8_extract_lane_s-operand-last") (param i32) (result i32)
+    (i16x8.extract_lane_s 7 (i16x8.splat (local.get 0))))
+  (func (export "as-i32x4_extract_lane_s-operand-first") (param i32) (result i32)
+    (i32x4.extract_lane 0 (i32x4.splat (local.get 0))))
+  (func (export "as-i32x4_extract_lane_s-operand-last") (param i32) (result i32)
+    (i32x4.extract_lane 3 (i32x4.splat (local.get 0))))
+  (func (export "as-f32x4_extract_lane_s-operand-first") (param f32) (result f32)
+    (f32x4.extract_lane 0 (f32x4.splat (local.get 0))))
+  (func (export "as-f32x4_extract_lane_s-operand-last") (param f32) (result f32)
+    (f32x4.extract_lane 3 (f32x4.splat (local.get 0))))
+  (func (export "as-v8x16_swizzle-operands") (param i32) (param i32) (result v128)
+    (i8x16.swizzle (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1))))
+  (func (export "as-i64x2_extract_lane-operand-first") (param i64) (result i64)
+    (i64x2.extract_lane 0 (i64x2.splat (local.get 0))))
+  (func (export "as-i64x2_extract_lane-operand-last") (param i64) (result i64)
+    (i64x2.extract_lane 1 (i64x2.splat (local.get 0))))
+  (func (export "as-f64x2_extract_lane-operand-first") (param f64) (result f64)
+    (f64x2.extract_lane 0 (f64x2.splat (local.get 0))))
+  (func (export "as-f64x2_extract_lane-operand-last") (param f64) (result f64)
+    (f64x2.extract_lane 1 (f64x2.splat (local.get 0))))
+
+  ;; Integer arithmetic
+  (func (export "as-i8x16_add_sub-operands") (param i32 i32 i32) (result v128)
+    (i8x16.add (i8x16.splat (local.get 0))
+      (i8x16.sub (i8x16.splat (local.get 1)) (i8x16.splat (local.get 2)))))
+  (func (export "as-i16x8_add_sub_mul-operands") (param i32 i32 i32 i32) (result v128)
+    (i16x8.add (i16x8.splat (local.get 0))
+      (i16x8.sub (i16x8.splat (local.get 1))
+        (i16x8.mul (i16x8.splat (local.get 2)) (i16x8.splat (local.get 3))))))
+  (func (export "as-i32x4_add_sub_mul-operands") (param i32 i32 i32 i32) (result v128)
+    (i32x4.add (i32x4.splat (local.get 0))
+      (i32x4.sub (i32x4.splat (local.get 1))
+        (i32x4.mul (i32x4.splat (local.get 2)) (i32x4.splat (local.get 3))))))
+
+  (func (export "as-i64x2_add_sub_mul-operands") (param i64 i64 i64 i64) (result v128)
+    (i64x2.add (i64x2.splat (local.get 0))
+      (i64x2.sub (i64x2.splat (local.get 1))
+        (i64x2.mul (i64x2.splat (local.get 2)) (i64x2.splat (local.get 3))))))
+  (func (export "as-f64x2_add_sub_mul-operands") (param f64 f64 f64 f64) (result v128)
+    (f64x2.add (f64x2.splat (local.get 0))
+      (f64x2.sub (f64x2.splat (local.get 1))
+        (f64x2.mul (f64x2.splat (local.get 2)) (f64x2.splat (local.get 3))))))
+
+  ;; Saturating integer arithmetic
+  (func (export "as-i8x16_add_sat_s-operands") (param i32 i32) (result v128)
+    (i8x16.add_sat_s (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1))))
+  (func (export "as-i16x8_add_sat_s-operands") (param i32 i32) (result v128)
+    (i16x8.add_sat_s (i16x8.splat (local.get 0)) (i16x8.splat (local.get 1))))
+  (func (export "as-i8x16_sub_sat_u-operands") (param i32 i32) (result v128)
+    (i8x16.sub_sat_u (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1))))
+  (func (export "as-i16x8_sub_sat_u-operands") (param i32 i32) (result v128)
+    (i16x8.sub_sat_u (i16x8.splat (local.get 0)) (i16x8.splat (local.get 1))))
+
+  ;; Bit shifts
+  (func (export "as-i8x16_shr_s-operand") (param i32 i32) (result v128)
+    (i8x16.shr_s (i8x16.splat (local.get 0)) (local.get 1)))
+  (func (export "as-i16x8_shr_s-operand") (param i32 i32) (result v128)
+    (i16x8.shr_s (i16x8.splat (local.get 0)) (local.get 1)))
+  (func (export "as-i32x4_shr_s-operand") (param i32 i32) (result v128)
+    (i32x4.shr_s (i32x4.splat (local.get 0)) (local.get 1)))
+
+  ;; Bitwise operantions
+  (func (export "as-v128_and-operands") (param i32 i32) (result v128)
+    (v128.and (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1))))
+  (func (export "as-v128_or-operands") (param i32 i32) (result v128)
+    (v128.or (i16x8.splat (local.get 0)) (i16x8.splat (local.get 1))))
+  (func (export "as-v128_xor-operands") (param i32 i32) (result v128)
+    (v128.xor (i32x4.splat (local.get 0)) (i32x4.splat (local.get 1))))
+
+  ;; Boolean horizontal reductions
+  (func (export "as-i8x16_all_true-operand") (param i32) (result i32)
+    (i8x16.all_true (i8x16.splat (local.get 0))))
+  (func (export "as-i16x8_all_true-operand") (param i32) (result i32)
+    (i16x8.all_true (i16x8.splat (local.get 0))))
+  (func (export "as-i32x4_all_true-operand1") (param i32) (result i32)
+    (i32x4.all_true (i32x4.splat (local.get 0))))
+  (func (export "as-i32x4_all_true-operand2") (param i64) (result i32)
+    (i32x4.all_true (i64x2.splat (local.get 0))))
+
+  ;; Comparisons
+  (func (export "as-i8x16_eq-operands") (param i32 i32) (result v128)
+    (i8x16.eq (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1))))
+  (func (export "as-i16x8_eq-operands") (param i32 i32) (result v128)
+    (i16x8.eq (i16x8.splat (local.get 0)) (i16x8.splat (local.get 1))))
+  (func (export "as-i32x4_eq-operands1") (param i32 i32) (result v128)
+    (i32x4.eq (i32x4.splat (local.get 0)) (i32x4.splat (local.get 1))))
+  (func (export "as-i32x4_eq-operands2") (param i64 i64) (result v128)
+    (i32x4.eq (i64x2.splat (local.get 0)) (i64x2.splat (local.get 1))))
+  (func (export "as-f32x4_eq-operands") (param f32 f32) (result v128)
+    (f32x4.eq (f32x4.splat (local.get 0)) (f32x4.splat (local.get 1))))
+  (func (export "as-f64x2_eq-operands") (param f64 f64) (result v128)
+    (f64x2.eq (f64x2.splat (local.get 0)) (f64x2.splat (local.get 1))))
+
+  ;; Floating-point sign bit operations
+  (func (export "as-f32x4_abs-operand") (param f32) (result v128)
+    (f32x4.abs (f32x4.splat (local.get 0))))
+
+  ;; Floating-point min
+  (func (export "as-f32x4_min-operands") (param f32 f32) (result v128)
+    (f32x4.min (f32x4.splat (local.get 0)) (f32x4.splat (local.get 1))))
+
+  ;; Floating-point arithmetic
+  (func (export "as-f32x4_div-operands") (param f32 f32) (result v128)
+    (f32x4.div (f32x4.splat (local.get 0)) (f32x4.splat (local.get 1))))
+
+  ;; Conversions
+  (func (export "as-f32x4_convert_s_i32x4-operand") (param i32) (result v128)
+    (f32x4.convert_i32x4_s (i32x4.splat (local.get 0))))
+  (func (export "as-i32x4_trunc_s_f32x4_sat-operand") (param f32) (result v128)
+    (i32x4.trunc_sat_f32x4_s (f32x4.splat (local.get 0))))
+)
+
+(assert_return (invoke "as-i8x16_extract_lane_s-operand-first" (i32.const 42)) (i32.const 42))
+(assert_return (invoke "as-i8x16_extract_lane_s-operand-last" (i32.const -42)) (i32.const -42))
+(assert_return (invoke "as-i16x8_extract_lane_s-operand-first" (i32.const 0xffff7fff)) (i32.const 32767))
+(assert_return (invoke "as-i16x8_extract_lane_s-operand-last" (i32.const 0x8000)) (i32.const -32768))
+(assert_return (invoke "as-i32x4_extract_lane_s-operand-first" (i32.const 0x7fffffff)) (i32.const 2147483647))
+(assert_return (invoke "as-i32x4_extract_lane_s-operand-last" (i32.const 0x80000000)) (i32.const -2147483648))
+(assert_return (invoke "as-f32x4_extract_lane_s-operand-first" (f32.const 1.5)) (f32.const 1.5))
+(assert_return (invoke "as-f32x4_extract_lane_s-operand-last" (f32.const -0.25)) (f32.const -0.25))
+(assert_return (invoke "as-v8x16_swizzle-operands" (i32.const 1) (i32.const -1)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "as-i64x2_extract_lane-operand-last" (i64.const -42)) (i64.const -42))
+(assert_return (invoke "as-i64x2_extract_lane-operand-first" (i64.const 42)) (i64.const 42))
+(assert_return (invoke "as-f64x2_extract_lane-operand-first" (f64.const 1.5)) (f64.const 1.5))
+(assert_return (invoke "as-f64x2_extract_lane-operand-last" (f64.const -0x1p+0)) (f64.const -0x1p+0))
+
+(assert_return (invoke "as-i8x16_add_sub-operands" (i32.const 3) (i32.const 2) (i32.const 1)) (v128.const i8x16 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4))
+(assert_return (invoke "as-i16x8_add_sub_mul-operands" (i32.const 257) (i32.const 128) (i32.const 16) (i32.const 16)) (v128.const i16x8 129 129 129 129 129 129 129 129))
+(assert_return (invoke "as-i32x4_add_sub_mul-operands" (i32.const 65535) (i32.const 65537) (i32.const 256) (i32.const 256)) (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+(assert_return (invoke "as-i64x2_add_sub_mul-operands" (i64.const 0x7fffffff) (i64.const 0x1_0000_0001) (i64.const 65536) (i64.const 65536)) (v128.const i64x2 0x8000_0000 0x8000_0000))
+(assert_return (invoke "as-f64x2_add_sub_mul-operands" (f64.const 0x1p-1) (f64.const 0.75) (f64.const 0x1p-1) (f64.const 0.5)) (v128.const f64x2 0x1p+0 0x1p+0))
+
+(assert_return (invoke "as-i8x16_add_sat_s-operands" (i32.const 0x7f) (i32.const 1)) (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "as-i16x8_add_sat_s-operands" (i32.const 0x7fff) (i32.const 1)) (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "as-i8x16_sub_sat_u-operands" (i32.const 0x7f) (i32.const 0xff)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "as-i16x8_sub_sat_u-operands" (i32.const 0x7fff) (i32.const 0xffff)) (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+(assert_return (invoke "as-i8x16_shr_s-operand" (i32.const 0xf0) (i32.const 3)) (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "as-i16x8_shr_s-operand" (i32.const 0x100) (i32.const 4)) (v128.const i16x8 16 16 16 16 16 16 16 16))
+(assert_return (invoke "as-i32x4_shr_s-operand" (i32.const -1) (i32.const 16)) (v128.const i32x4 -1 -1 -1 -1))
+
+(assert_return (invoke "as-v128_and-operands" (i32.const 0x11) (i32.const 0xff)) (v128.const i8x16 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17))
+(assert_return (invoke "as-v128_or-operands" (i32.const 0) (i32.const 0xffff)) (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "as-v128_xor-operands" (i32.const 0xf0f0f0f0) (i32.const 0xffffffff)) (v128.const i32x4 0xf0f0f0f 0xf0f0f0f 0xf0f0f0f 0xf0f0f0f))
+
+(assert_return (invoke "as-i8x16_all_true-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-i16x8_all_true-operand" (i32.const 0xffff)) (i32.const 1))
+(assert_return (invoke "as-i32x4_all_true-operand1" (i32.const 0xf0f0f0f0)) (i32.const 1))
+(assert_return (invoke "as-i32x4_all_true-operand2" (i64.const -1)) (i32.const 1))
+
+(assert_return (invoke "as-i8x16_eq-operands" (i32.const 1) (i32.const 2)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "as-i16x8_eq-operands" (i32.const -1) (i32.const 65535)) (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "as-i32x4_eq-operands1" (i32.const -1) (i32.const 0xffffffff)) (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+(assert_return (invoke "as-f32x4_eq-operands" (f32.const +0.0) (f32.const -0.0)) (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+(assert_return (invoke "as-i32x4_eq-operands2" (i64.const 1) (i64.const 2)) (v128.const i64x2 0xffffffff00000000 0xffffffff00000000))
+(assert_return (invoke "as-f64x2_eq-operands" (f64.const +0.0) (f64.const -0.0)) (v128.const i64x2 -1 -1))
+
+(assert_return (invoke "as-f32x4_abs-operand" (f32.const -1.125)) (v128.const f32x4 1.125 1.125 1.125 1.125))
+(assert_return (invoke "as-f32x4_min-operands" (f32.const 0.25) (f32.const 1e-38)) (v128.const f32x4 1e-38 1e-38 1e-38 1e-38))
+(assert_return (invoke "as-f32x4_div-operands" (f32.const 1.0) (f32.const 8.0)) (v128.const f32x4 0.125 0.125 0.125 0.125))
+
+(assert_return (invoke "as-f32x4_convert_s_i32x4-operand" (i32.const 12345)) (v128.const f32x4 12345.0 12345.0 12345.0 12345.0))
+(assert_return (invoke "as-i32x4_trunc_s_f32x4_sat-operand" (f32.const 1.1)) (v128.const i32x4 1 1 1 1))
+
+
+;; As the argument of control constructs and WASM instructions
+
+(module
+  (global $g (mut v128) (v128.const f32x4 0.0 0.0 0.0 0.0))
+  (func (export "as-br-value1") (param i32) (result v128)
+    (block (result v128) (br 0 (i8x16.splat (local.get 0)))))
+  (func (export "as-return-value1") (param i32) (result v128)
+    (return (i16x8.splat (local.get 0))))
+  (func (export "as-local_set-value1") (param i32) (result v128) (local v128)
+    (local.set 1 (i32x4.splat (local.get 0)))
+    (return (local.get 1)))
+  (func (export "as-global_set-value1") (param f32) (result v128)
+    (global.set $g (f32x4.splat (local.get 0)))
+    (return (global.get $g)))
+  (func (export "as-br-value2") (param i64) (result v128)
+    (block (result v128) (br 0 (i64x2.splat (local.get 0)))))
+  (func (export "as-return-value2") (param i64) (result v128)
+    (return (i64x2.splat (local.get 0))))
+  (func (export "as-local_set-value2") (param i64) (result v128) (local v128)
+    (local.set 1 (i64x2.splat (local.get 0)))
+    (return (local.get 1)))
+  (func (export "as-global_set-value2") (param f64) (result v128)
+    (global.set $g (f64x2.splat (local.get 0)))
+    (return (global.get $g)))
+)
+
+(assert_return (invoke "as-br-value1" (i32.const 0xAB)) (v128.const i8x16 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB))
+(assert_return (invoke "as-return-value1" (i32.const 0xABCD)) (v128.const i16x8 0xABCD 0xABCD 0xABCD 0xABCD 0xABCD 0xABCD 0xABCD 0xABCD))
+(assert_return (invoke "as-local_set-value1" (i32.const 0x10000)) (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+(assert_return (invoke "as-global_set-value1" (f32.const 1.0)) (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "as-br-value2" (i64.const 0xABCD)) (v128.const i64x2 0xABCD 0xABCD))
+(assert_return (invoke "as-return-value2" (i64.const 0xABCD)) (v128.const i64x2 0xABCD 0xABCD))
+(assert_return (invoke "as-local_set-value2" (i64.const 0x10000)) (v128.const i64x2 0x10000 0x10000))
+(assert_return (invoke "as-global_set-value2" (f64.const 1.0)) (v128.const f64x2 1.0 1.0))
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.splat-arg-empty (result v128)
+      (i8x16.splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.splat-arg-empty (result v128)
+      (i16x8.splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.splat-arg-empty (result v128)
+      (i32x4.splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.splat-arg-empty (result v128)
+      (f32x4.splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.splat-arg-empty (result v128)
+      (i64x2.splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.splat-arg-empty (result v128)
+      (f64x2.splat)
+    )
+  )
+  "type mismatch"
+)
diff --git a/test/core/simd/simd_store.wast b/test/core/simd/simd_store.wast
new file mode 100644
index 000000000..50349c41b
--- /dev/null
+++ b/test/core/simd/simd_store.wast
@@ -0,0 +1,166 @@
+;; v128.store operater with normal argument (e.g. (i8x16, i16x8, i32x4, f32x4))
+
+(module
+  (memory 1)
+  (func (export "v128.store_i8x16") (result v128)
+    (v128.store (i32.const 0) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i16x8") (result v128)
+    (v128.store (i32.const 0) (v128.const i16x8 0 1 2 3 4 5 6 7))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i16x8_2") (result v128)
+    (v128.store (i32.const 0) (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i16x8_3") (result v128)
+    (v128.store (i32.const 0) (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i32x4") (result v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i32x4_2") (result v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i32x4_3") (result v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+    (v128.load (i32.const 0))
+  )
+
+  (func (export "v128.store_f32x4") (result v128)
+    (v128.store (i32.const 0) (v128.const f32x4 0 1 2 3))
+    (v128.load (i32.const 0))
+  )
+)
+
+(assert_return (invoke "v128.store_i8x16") (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "v128.store_i16x8") (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "v128.store_i16x8_2") (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+(assert_return (invoke "v128.store_i16x8_3") (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+(assert_return (invoke "v128.store_i32x4") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "v128.store_i32x4_2") (v128.const i32x4 123456789 123456789 123456789 123456789))
+(assert_return (invoke "v128.store_i32x4_3") (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+(assert_return (invoke "v128.store_f32x4") (v128.const f32x4 0 1 2 3))
+
+
+;; v128.store operator as the argument of control constructs and instructions
+
+(module
+  (memory 1)
+  (func (export "as-block-value")
+    (block (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+  )
+  (func (export "as-loop-value")
+    (loop (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+  )
+  (func (export "as-br-value")
+    (block (br 0 (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  )
+  (func (export "as-br_if-value")
+    (block
+      (br_if 0 (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)) (i32.const 1))
+    )
+  )
+  (func (export "as-br_if-value-cond")
+    (block
+      (br_if 0 (i32.const 6) (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+    )
+  )
+  (func (export "as-br_table-value")
+    (block
+      (br_table 0 (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)) (i32.const 1))
+    )
+  )
+  (func (export "as-return-value")
+    (return (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+  )
+  (func (export "as-if-then")
+    (if (i32.const 1) (then (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  )
+  (func (export "as-if-else")
+    (if (i32.const 0) (then) (else (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  )
+)
+
+(assert_return (invoke "as-block-value"))
+(assert_return (invoke "as-loop-value"))
+(assert_return (invoke "as-br-value"))
+(assert_return (invoke "as-br_if-value"))
+(assert_return (invoke "as-br_if-value-cond"))
+(assert_return (invoke "as-br_table-value"))
+(assert_return (invoke "as-return-value"))
+(assert_return (invoke "as-if-then"))
+(assert_return (invoke "as-if-else"))
+
+
+;; Unknown operator(e.g. v128.store8, v128.store16, v128.store32)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store8 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store16 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store32 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+
+
+;; Type mismatched (e.g. v128.load(f32.const 0), type address empty)
+
+(assert_invalid
+  (module (memory 1) (func (v128.store (f32.const 0) (v128.const i32x4 0 0 0 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (local v128) (block (br_if 0 (v128.store)))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  "type mismatch"
+)
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module (memory 0)
+    (func $v128.store-1st-arg-empty
+      (v128.store (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.store-2nd-arg-empty
+      (v128.store (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.store-arg-empty
+      (v128.store)
+    )
+  )
+  "type mismatch"
+)
diff --git a/test/core/simd/simd_store16_lane.wast b/test/core/simd/simd_store16_lane.wast
new file mode 100644
index 000000000..d8ea35c3f
--- /dev/null
+++ b/test/core/simd/simd_store16_lane.wast
@@ -0,0 +1,299 @@
+;; Tests for store lane operations.
+
+
+(module
+  (memory 1)
+  (global $zero (mut v128) (v128.const i32x4 0 0 0 0))
+  (func (export "v128.store16_lane_0")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_3")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 4 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_5")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 5 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_6")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 6 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_7")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 7 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_0_offset_0")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=0 0 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=0 (i32.const 0)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_1_offset_1")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=1 1 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=1 (i32.const 0)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_2_offset_2")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=2 2 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=2 (i32.const 0)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_3_offset_3")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=3 3 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=3 (i32.const 0)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_4_offset_4")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=4 4 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=4 (i32.const 0)))
+    (v128.store offset=4 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_5_offset_5")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=5 5 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=5 (i32.const 0)))
+    (v128.store offset=5 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_6_offset_6")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=6 6 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=6 (i32.const 0)))
+    (v128.store offset=6 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_7_offset_7")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=7 7 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=7 (i32.const 0)))
+    (v128.store offset=7 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_0_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_0_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_1_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_1_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_2_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_2_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_3_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_3_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_4_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 4 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=4 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_4_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 4 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=4 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_5_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 5 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=5 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_5_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 5 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=5 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_6_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 6 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=6 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_6_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 6 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=6 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_7_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 7 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=7 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_7_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 7 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=7 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+)
+
+(assert_return (invoke "v128.store16_lane_0" (i32.const 0)
+                                             (v128.const i16x8 256 0 0 0 0 0 0 0))
+                                             (i64.const 256))
+(assert_return (invoke "v128.store16_lane_1" (i32.const 1)
+                                             (v128.const i16x8 0 513 0 0 0 0 0 0))
+                                             (i64.const 513))
+(assert_return (invoke "v128.store16_lane_2" (i32.const 2)
+                                             (v128.const i16x8 0 0 770 0 0 0 0 0))
+                                             (i64.const 770))
+(assert_return (invoke "v128.store16_lane_3" (i32.const 3)
+                                             (v128.const i16x8 0 0 0 1027 0 0 0 0))
+                                             (i64.const 1027))
+(assert_return (invoke "v128.store16_lane_4" (i32.const 4)
+                                             (v128.const i16x8 0 0 0 0 1284 0 0 0))
+                                             (i64.const 1284))
+(assert_return (invoke "v128.store16_lane_5" (i32.const 5)
+                                             (v128.const i16x8 0 0 0 0 0 1541 0 0))
+                                             (i64.const 1541))
+(assert_return (invoke "v128.store16_lane_6" (i32.const 6)
+                                             (v128.const i16x8 0 0 0 0 0 0 1798 0))
+                                             (i64.const 1798))
+(assert_return (invoke "v128.store16_lane_7" (i32.const 7)
+                                             (v128.const i16x8 0 0 0 0 0 0 0 2055))
+                                             (i64.const 2055))
+(assert_return (invoke "v128.store16_lane_0_offset_0" (v128.const i16x8 256 0 0 0 0 0 0 0))
+                                                      (i64.const 256))
+(assert_return (invoke "v128.store16_lane_1_offset_1" (v128.const i16x8 0 513 0 0 0 0 0 0))
+                                                      (i64.const 513))
+(assert_return (invoke "v128.store16_lane_2_offset_2" (v128.const i16x8 0 0 770 0 0 0 0 0))
+                                                      (i64.const 770))
+(assert_return (invoke "v128.store16_lane_3_offset_3" (v128.const i16x8 0 0 0 1027 0 0 0 0))
+                                                      (i64.const 1027))
+(assert_return (invoke "v128.store16_lane_4_offset_4" (v128.const i16x8 0 0 0 0 1284 0 0 0))
+                                                      (i64.const 1284))
+(assert_return (invoke "v128.store16_lane_5_offset_5" (v128.const i16x8 0 0 0 0 0 1541 0 0))
+                                                      (i64.const 1541))
+(assert_return (invoke "v128.store16_lane_6_offset_6" (v128.const i16x8 0 0 0 0 0 0 1798 0))
+                                                      (i64.const 1798))
+(assert_return (invoke "v128.store16_lane_7_offset_7" (v128.const i16x8 0 0 0 0 0 0 0 2055))
+                                                      (i64.const 2055))
+(assert_return (invoke "v128.store16_lane_0_align_1" (i32.const 0)
+                                                     (v128.const i16x8 256 0 0 0 0 0 0 0))
+                                                     (i64.const 256))
+(assert_return (invoke "v128.store16_lane_0_align_2" (i32.const 0)
+                                                     (v128.const i16x8 256 0 0 0 0 0 0 0))
+                                                     (i64.const 256))
+(assert_return (invoke "v128.store16_lane_1_align_1" (i32.const 1)
+                                                     (v128.const i16x8 0 513 0 0 0 0 0 0))
+                                                     (i64.const 513))
+(assert_return (invoke "v128.store16_lane_1_align_2" (i32.const 1)
+                                                     (v128.const i16x8 0 513 0 0 0 0 0 0))
+                                                     (i64.const 513))
+(assert_return (invoke "v128.store16_lane_2_align_1" (i32.const 2)
+                                                     (v128.const i16x8 0 0 770 0 0 0 0 0))
+                                                     (i64.const 770))
+(assert_return (invoke "v128.store16_lane_2_align_2" (i32.const 2)
+                                                     (v128.const i16x8 0 0 770 0 0 0 0 0))
+                                                     (i64.const 770))
+(assert_return (invoke "v128.store16_lane_3_align_1" (i32.const 3)
+                                                     (v128.const i16x8 0 0 0 1027 0 0 0 0))
+                                                     (i64.const 1027))
+(assert_return (invoke "v128.store16_lane_3_align_2" (i32.const 3)
+                                                     (v128.const i16x8 0 0 0 1027 0 0 0 0))
+                                                     (i64.const 1027))
+(assert_return (invoke "v128.store16_lane_4_align_1" (i32.const 4)
+                                                     (v128.const i16x8 0 0 0 0 1284 0 0 0))
+                                                     (i64.const 1284))
+(assert_return (invoke "v128.store16_lane_4_align_2" (i32.const 4)
+                                                     (v128.const i16x8 0 0 0 0 1284 0 0 0))
+                                                     (i64.const 1284))
+(assert_return (invoke "v128.store16_lane_5_align_1" (i32.const 5)
+                                                     (v128.const i16x8 0 0 0 0 0 1541 0 0))
+                                                     (i64.const 1541))
+(assert_return (invoke "v128.store16_lane_5_align_2" (i32.const 5)
+                                                     (v128.const i16x8 0 0 0 0 0 1541 0 0))
+                                                     (i64.const 1541))
+(assert_return (invoke "v128.store16_lane_6_align_1" (i32.const 6)
+                                                     (v128.const i16x8 0 0 0 0 0 0 1798 0))
+                                                     (i64.const 1798))
+(assert_return (invoke "v128.store16_lane_6_align_2" (i32.const 6)
+                                                     (v128.const i16x8 0 0 0 0 0 0 1798 0))
+                                                     (i64.const 1798))
+(assert_return (invoke "v128.store16_lane_7_align_1" (i32.const 7)
+                                                     (v128.const i16x8 0 0 0 0 0 0 0 2055))
+                                                     (i64.const 2055))
+(assert_return (invoke "v128.store16_lane_7_align_2" (i32.const 7)
+                                                     (v128.const i16x8 0 0 0 0 0 0 0 2055))
+                                                     (i64.const 2055))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store16_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store16_lane 8 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.store16_lane align=4 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/test/core/simd/simd_store32_lane.wast b/test/core/simd/simd_store32_lane.wast
new file mode 100644
index 000000000..847bab9e6
--- /dev/null
+++ b/test/core/simd/simd_store32_lane.wast
@@ -0,0 +1,199 @@
+;; Tests for store lane operations.
+
+
+(module
+  (memory 1)
+  (global $zero (mut v128) (v128.const i32x4 0 0 0 0))
+  (func (export "v128.store32_lane_0")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store32_lane_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store32_lane_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store32_lane_3")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store32_lane_0_offset_0")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane offset=0 0 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=0 (i32.const 0)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_1_offset_1")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane offset=1 1 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=1 (i32.const 0)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_2_offset_2")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane offset=2 2 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=2 (i32.const 0)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_3_offset_3")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane offset=3 3 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=3 (i32.const 0)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_0_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=1 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_0_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=2 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_0_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=4 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_1_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=1 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_1_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=2 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_1_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=4 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_2_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=1 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_2_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=2 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_2_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=4 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_3_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=1 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_3_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=2 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_3_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=4 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+)
+
+(assert_return (invoke "v128.store32_lane_0" (i32.const 0)
+                                             (v128.const i32x4 50462976 0 0 0))
+                                             (i64.const 50462976))
+(assert_return (invoke "v128.store32_lane_1" (i32.const 1)
+                                             (v128.const i32x4 0 67305985 0 0))
+                                             (i64.const 67305985))
+(assert_return (invoke "v128.store32_lane_2" (i32.const 2)
+                                             (v128.const i32x4 0 0 84148994 0))
+                                             (i64.const 84148994))
+(assert_return (invoke "v128.store32_lane_3" (i32.const 3)
+                                             (v128.const i32x4 0 0 0 100992003))
+                                             (i64.const 100992003))
+(assert_return (invoke "v128.store32_lane_0_offset_0" (v128.const i32x4 50462976 0 0 0))
+                                                      (i64.const 50462976))
+(assert_return (invoke "v128.store32_lane_1_offset_1" (v128.const i32x4 0 67305985 0 0))
+                                                      (i64.const 67305985))
+(assert_return (invoke "v128.store32_lane_2_offset_2" (v128.const i32x4 0 0 84148994 0))
+                                                      (i64.const 84148994))
+(assert_return (invoke "v128.store32_lane_3_offset_3" (v128.const i32x4 0 0 0 100992003))
+                                                      (i64.const 100992003))
+(assert_return (invoke "v128.store32_lane_0_align_1" (i32.const 0)
+                                                     (v128.const i32x4 50462976 0 0 0))
+                                                     (i64.const 50462976))
+(assert_return (invoke "v128.store32_lane_0_align_2" (i32.const 0)
+                                                     (v128.const i32x4 50462976 0 0 0))
+                                                     (i64.const 50462976))
+(assert_return (invoke "v128.store32_lane_0_align_4" (i32.const 0)
+                                                     (v128.const i32x4 50462976 0 0 0))
+                                                     (i64.const 50462976))
+(assert_return (invoke "v128.store32_lane_1_align_1" (i32.const 1)
+                                                     (v128.const i32x4 0 67305985 0 0))
+                                                     (i64.const 67305985))
+(assert_return (invoke "v128.store32_lane_1_align_2" (i32.const 1)
+                                                     (v128.const i32x4 0 67305985 0 0))
+                                                     (i64.const 67305985))
+(assert_return (invoke "v128.store32_lane_1_align_4" (i32.const 1)
+                                                     (v128.const i32x4 0 67305985 0 0))
+                                                     (i64.const 67305985))
+(assert_return (invoke "v128.store32_lane_2_align_1" (i32.const 2)
+                                                     (v128.const i32x4 0 0 84148994 0))
+                                                     (i64.const 84148994))
+(assert_return (invoke "v128.store32_lane_2_align_2" (i32.const 2)
+                                                     (v128.const i32x4 0 0 84148994 0))
+                                                     (i64.const 84148994))
+(assert_return (invoke "v128.store32_lane_2_align_4" (i32.const 2)
+                                                     (v128.const i32x4 0 0 84148994 0))
+                                                     (i64.const 84148994))
+(assert_return (invoke "v128.store32_lane_3_align_1" (i32.const 3)
+                                                     (v128.const i32x4 0 0 0 100992003))
+                                                     (i64.const 100992003))
+(assert_return (invoke "v128.store32_lane_3_align_2" (i32.const 3)
+                                                     (v128.const i32x4 0 0 0 100992003))
+                                                     (i64.const 100992003))
+(assert_return (invoke "v128.store32_lane_3_align_4" (i32.const 3)
+                                                     (v128.const i32x4 0 0 0 100992003))
+                                                     (i64.const 100992003))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store32_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store32_lane 4 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.store32_lane align=8 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/test/core/simd/simd_store64_lane.wast b/test/core/simd/simd_store64_lane.wast
new file mode 100644
index 000000000..2ed1dcd68
--- /dev/null
+++ b/test/core/simd/simd_store64_lane.wast
@@ -0,0 +1,131 @@
+;; Tests for store lane operations.
+
+
+(module
+  (memory 1)
+  (global $zero (mut v128) (v128.const i32x4 0 0 0 0))
+  (func (export "v128.store64_lane_0")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store64_lane_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store64_lane_0_offset_0")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane offset=0 0 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=0 (i32.const 0)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_1_offset_1")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane offset=1 1 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=1 (i32.const 0)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_0_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=1 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_0_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=2 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_0_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=4 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_0_align_8")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=8 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_1_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=1 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_1_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=2 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_1_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=4 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_1_align_8")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=8 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+)
+
+(assert_return (invoke "v128.store64_lane_0" (i32.const 0)
+                                             (v128.const i64x2 506097522914230528 0))
+                                             (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_1" (i32.const 1)
+                                             (v128.const i64x2 0 578437695752307201))
+                                             (i64.const 578437695752307201))
+(assert_return (invoke "v128.store64_lane_0_offset_0" (v128.const i64x2 506097522914230528 0))
+                                                      (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_1_offset_1" (v128.const i64x2 0 578437695752307201))
+                                                      (i64.const 578437695752307201))
+(assert_return (invoke "v128.store64_lane_0_align_1" (i32.const 0)
+                                                     (v128.const i64x2 506097522914230528 0))
+                                                     (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_0_align_2" (i32.const 0)
+                                                     (v128.const i64x2 506097522914230528 0))
+                                                     (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_0_align_4" (i32.const 0)
+                                                     (v128.const i64x2 506097522914230528 0))
+                                                     (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_0_align_8" (i32.const 0)
+                                                     (v128.const i64x2 506097522914230528 0))
+                                                     (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_1_align_1" (i32.const 1)
+                                                     (v128.const i64x2 0 578437695752307201))
+                                                     (i64.const 578437695752307201))
+(assert_return (invoke "v128.store64_lane_1_align_2" (i32.const 1)
+                                                     (v128.const i64x2 0 578437695752307201))
+                                                     (i64.const 578437695752307201))
+(assert_return (invoke "v128.store64_lane_1_align_4" (i32.const 1)
+                                                     (v128.const i64x2 0 578437695752307201))
+                                                     (i64.const 578437695752307201))
+(assert_return (invoke "v128.store64_lane_1_align_8" (i32.const 1)
+                                                     (v128.const i64x2 0 578437695752307201))
+                                                     (i64.const 578437695752307201))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store64_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store64_lane 2 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.store64_lane align=16 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/test/core/simd/simd_store8_lane.wast b/test/core/simd/simd_store8_lane.wast
new file mode 100644
index 000000000..b4e4a583f
--- /dev/null
+++ b/test/core/simd/simd_store8_lane.wast
@@ -0,0 +1,427 @@
+;; Tests for store lane operations.
+
+
+(module
+  (memory 1)
+  (global $zero (mut v128) (v128.const i32x4 0 0 0 0))
+  (func (export "v128.store8_lane_0")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_3")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 4 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_5")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 5 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_6")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 6 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_7")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 7 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_8")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 8 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_9")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 9 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_10")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 10 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_11")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 11 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_12")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 12 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_13")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 13 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_14")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 14 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_15")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 15 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_0_offset_0")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=0 0 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=0 (i32.const 0)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_1_offset_1")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=1 1 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=1 (i32.const 0)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_2_offset_2")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=2 2 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=2 (i32.const 0)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_3_offset_3")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=3 3 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=3 (i32.const 0)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_4_offset_4")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=4 4 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=4 (i32.const 0)))
+    (v128.store offset=4 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_5_offset_5")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=5 5 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=5 (i32.const 0)))
+    (v128.store offset=5 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_6_offset_6")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=6 6 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=6 (i32.const 0)))
+    (v128.store offset=6 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_7_offset_7")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=7 7 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=7 (i32.const 0)))
+    (v128.store offset=7 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_8_offset_8")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=8 8 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=8 (i32.const 0)))
+    (v128.store offset=8 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_9_offset_9")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=9 9 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=9 (i32.const 0)))
+    (v128.store offset=9 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_10_offset_10")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=10 10 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=10 (i32.const 0)))
+    (v128.store offset=10 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_11_offset_11")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=11 11 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=11 (i32.const 0)))
+    (v128.store offset=11 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_12_offset_12")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=12 12 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=12 (i32.const 0)))
+    (v128.store offset=12 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_13_offset_13")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=13 13 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=13 (i32.const 0)))
+    (v128.store offset=13 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_14_offset_14")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=14 14 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=14 (i32.const 0)))
+    (v128.store offset=14 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_15_offset_15")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=15 15 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=15 (i32.const 0)))
+    (v128.store offset=15 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_0_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_1_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_2_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_3_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_4_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 4 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=4 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_5_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 5 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=5 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_6_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 6 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=6 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_7_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 7 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=7 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_8_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 8 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=8 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_9_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 9 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=9 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_10_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 10 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=10 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_11_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 11 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=11 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_12_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 12 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=12 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_13_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 13 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=13 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_14_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 14 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=14 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_15_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 15 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=15 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+)
+
+(assert_return (invoke "v128.store8_lane_0" (i32.const 0)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 0))
+(assert_return (invoke "v128.store8_lane_1" (i32.const 1)
+                                            (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 1))
+(assert_return (invoke "v128.store8_lane_2" (i32.const 2)
+                                            (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 2))
+(assert_return (invoke "v128.store8_lane_3" (i32.const 3)
+                                            (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 3))
+(assert_return (invoke "v128.store8_lane_4" (i32.const 4)
+                                            (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 4))
+(assert_return (invoke "v128.store8_lane_5" (i32.const 5)
+                                            (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 5))
+(assert_return (invoke "v128.store8_lane_6" (i32.const 6)
+                                            (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 6))
+(assert_return (invoke "v128.store8_lane_7" (i32.const 7)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+                                            (i64.const 7))
+(assert_return (invoke "v128.store8_lane_8" (i32.const 8)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+                                            (i64.const 8))
+(assert_return (invoke "v128.store8_lane_9" (i32.const 9)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+                                            (i64.const 9))
+(assert_return (invoke "v128.store8_lane_10" (i32.const 10)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+                                             (i64.const 10))
+(assert_return (invoke "v128.store8_lane_11" (i32.const 11)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+                                             (i64.const 11))
+(assert_return (invoke "v128.store8_lane_12" (i32.const 12)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+                                             (i64.const 12))
+(assert_return (invoke "v128.store8_lane_13" (i32.const 13)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+                                             (i64.const 13))
+(assert_return (invoke "v128.store8_lane_14" (i32.const 14)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+                                             (i64.const 14))
+(assert_return (invoke "v128.store8_lane_15" (i32.const 15)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+                                             (i64.const 15))
+(assert_return (invoke "v128.store8_lane_0_offset_0" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 0))
+(assert_return (invoke "v128.store8_lane_1_offset_1" (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 1))
+(assert_return (invoke "v128.store8_lane_2_offset_2" (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 2))
+(assert_return (invoke "v128.store8_lane_3_offset_3" (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 3))
+(assert_return (invoke "v128.store8_lane_4_offset_4" (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 4))
+(assert_return (invoke "v128.store8_lane_5_offset_5" (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 5))
+(assert_return (invoke "v128.store8_lane_6_offset_6" (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 6))
+(assert_return (invoke "v128.store8_lane_7_offset_7" (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+                                                     (i64.const 7))
+(assert_return (invoke "v128.store8_lane_8_offset_8" (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+                                                     (i64.const 8))
+(assert_return (invoke "v128.store8_lane_9_offset_9" (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+                                                     (i64.const 9))
+(assert_return (invoke "v128.store8_lane_10_offset_10" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+                                                       (i64.const 10))
+(assert_return (invoke "v128.store8_lane_11_offset_11" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+                                                       (i64.const 11))
+(assert_return (invoke "v128.store8_lane_12_offset_12" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+                                                       (i64.const 12))
+(assert_return (invoke "v128.store8_lane_13_offset_13" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+                                                       (i64.const 13))
+(assert_return (invoke "v128.store8_lane_14_offset_14" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+                                                       (i64.const 14))
+(assert_return (invoke "v128.store8_lane_15_offset_15" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+                                                       (i64.const 15))
+(assert_return (invoke "v128.store8_lane_0_align_1" (i32.const 0)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 0))
+(assert_return (invoke "v128.store8_lane_1_align_1" (i32.const 1)
+                                                    (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 1))
+(assert_return (invoke "v128.store8_lane_2_align_1" (i32.const 2)
+                                                    (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 2))
+(assert_return (invoke "v128.store8_lane_3_align_1" (i32.const 3)
+                                                    (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 3))
+(assert_return (invoke "v128.store8_lane_4_align_1" (i32.const 4)
+                                                    (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 4))
+(assert_return (invoke "v128.store8_lane_5_align_1" (i32.const 5)
+                                                    (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 5))
+(assert_return (invoke "v128.store8_lane_6_align_1" (i32.const 6)
+                                                    (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 6))
+(assert_return (invoke "v128.store8_lane_7_align_1" (i32.const 7)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+                                                    (i64.const 7))
+(assert_return (invoke "v128.store8_lane_8_align_1" (i32.const 8)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+                                                    (i64.const 8))
+(assert_return (invoke "v128.store8_lane_9_align_1" (i32.const 9)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+                                                    (i64.const 9))
+(assert_return (invoke "v128.store8_lane_10_align_1" (i32.const 10)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+                                                     (i64.const 10))
+(assert_return (invoke "v128.store8_lane_11_align_1" (i32.const 11)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+                                                     (i64.const 11))
+(assert_return (invoke "v128.store8_lane_12_align_1" (i32.const 12)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+                                                     (i64.const 12))
+(assert_return (invoke "v128.store8_lane_13_align_1" (i32.const 13)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+                                                     (i64.const 13))
+(assert_return (invoke "v128.store8_lane_14_align_1" (i32.const 14)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+                                                     (i64.const 14))
+(assert_return (invoke "v128.store8_lane_15_align_1" (i32.const 15)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+                                                     (i64.const 15))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store8_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store8_lane 16 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.store8_lane align=2 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
diff --git a/test/core/type.wast b/test/core/type.wast
index b94063e6a..aad40dd16 100644
--- a/test/core/type.wast
+++ b/test/core/type.wast
@@ -42,7 +42,7 @@
 
 (assert_malformed
   (module quote "(type (func (result i32) (param i32)))")
-  "result before parameter"
+  "unexpected token"
 )
 (assert_malformed
   (module quote "(type (func (result $x i32)))")
diff --git a/test/js-api/assertions.js b/test/js-api/assertions.js
index f00303f6a..162f5a9a6 100644
--- a/test/js-api/assertions.js
+++ b/test/js-api/assertions.js
@@ -17,8 +17,13 @@ function assert_function_length(fn, length, description) {
 }
 
 function assert_exported_function(fn, { name, length }, description) {
-  assert_equals(Object.getPrototypeOf(fn), Function.prototype,
-                `${description}: prototype`);
+  if (WebAssembly.Function === undefined) {
+    assert_equals(Object.getPrototypeOf(fn), Function.prototype,
+                  `${description}: prototype`);
+  } else {
+    assert_equals(Object.getPrototypeOf(fn), WebAssembly.Function.prototype,
+                  `${description}: prototype`);
+  }
 
   assert_function_name(fn, name, description);
   assert_function_length(fn, length, description);
diff --git a/test/js-api/constructor/toStringTag.any.js b/test/js-api/constructor/toStringTag.any.js
new file mode 100644
index 000000000..9c0d346bc
--- /dev/null
+++ b/test/js-api/constructor/toStringTag.any.js
@@ -0,0 +1,42 @@
+// META: global=window,dedicatedworker,jsshell
+
+"use strict";
+// https://heycam.github.io/webidl/#es-namespaces
+// https://webassembly.github.io/spec/js-api/#namespacedef-webassembly
+
+test(() => {
+  assert_own_property(WebAssembly, Symbol.toStringTag);
+
+  const propDesc = Object.getOwnPropertyDescriptor(WebAssembly, Symbol.toStringTag);
+  assert_equals(propDesc.value, "WebAssembly", "value");
+  assert_equals(propDesc.writable, false, "writable");
+  assert_equals(propDesc.enumerable, false, "enumerable");
+  assert_equals(propDesc.configurable, true, "configurable");
+}, "@@toStringTag exists on the namespace object with the appropriate descriptor");
+
+test(() => {
+  assert_equals(WebAssembly.toString(), "[object WebAssembly]");
+  assert_equals(Object.prototype.toString.call(WebAssembly), "[object WebAssembly]");
+}, "Object.prototype.toString applied to the namespace object");
+
+test(t => {
+  assert_own_property(WebAssembly, Symbol.toStringTag, "Precondition: @@toStringTag on the namespace object");
+  t.add_cleanup(() => {
+    Object.defineProperty(WebAssembly, Symbol.toStringTag, { value: "WebAssembly" });
+  });
+
+  Object.defineProperty(WebAssembly, Symbol.toStringTag, { value: "Test" });
+  assert_equals(WebAssembly.toString(), "[object Test]");
+  assert_equals(Object.prototype.toString.call(WebAssembly), "[object Test]");
+}, "Object.prototype.toString applied after modifying the namespace object's @@toStringTag");
+
+test(t => {
+  assert_own_property(WebAssembly, Symbol.toStringTag, "Precondition: @@toStringTag on the namespace object");
+  t.add_cleanup(() => {
+    Object.defineProperty(WebAssembly, Symbol.toStringTag, { value: "WebAssembly" });
+  });
+
+  assert_true(delete WebAssembly[Symbol.toStringTag]);
+  assert_equals(WebAssembly.toString(), "[object Object]");
+  assert_equals(Object.prototype.toString.call(WebAssembly), "[object Object]");
+}, "Object.prototype.toString applied after deleting @@toStringTag");
diff --git a/test/js-api/functions/helper.js b/test/js-api/functions/helper.js
new file mode 100644
index 000000000..487791c69
--- /dev/null
+++ b/test/js-api/functions/helper.js
@@ -0,0 +1,12 @@
+function call_later(f) {
+  const builder = new WasmModuleBuilder();
+  const functionIndex = builder.addImport("module", "imported", kSig_v_v);
+  builder.addStart(functionIndex);
+  const buffer = builder.toBuffer();
+
+  WebAssembly.instantiate(buffer, {
+    "module": {
+      "imported": f,
+    }
+  });
+}
diff --git a/test/js-api/global/constructor.any.js b/test/js-api/global/constructor.any.js
index f536f5d7b..7c2c02c79 100644
--- a/test/js-api/global/constructor.any.js
+++ b/test/js-api/global/constructor.any.js
@@ -164,3 +164,8 @@ test(() => {
   const global = new WebAssembly.Global(argument, 0, {});
   assert_Global(global, 0);
 }, "Stray argument");
+
+test(() => {
+  const argument = { "value": "v128" };
+  assert_throws_js(TypeError, () =>new WebAssembly.Global(argument));
+}, "Construct v128 global");
diff --git a/test/js-api/instanceTestFactory.js b/test/js-api/instanceTestFactory.js
index 86f593f46..ac468947e 100644
--- a/test/js-api/instanceTestFactory.js
+++ b/test/js-api/instanceTestFactory.js
@@ -126,6 +126,134 @@ const instanceTestFactory = [
     }
   ],
 
+  [
+    "imports with empty module names",
+    function() {
+      const builder = new WasmModuleBuilder();
+
+      builder.addImport("", "fn", kSig_v_v);
+      builder.addImportedGlobal("", "global", kWasmI32);
+      builder.addImportedMemory("", "memory", 0, 128);
+      builder.addImportedTable("", "table", 0, 128);
+
+      const buffer = builder.toBuffer();
+      const imports = {
+        "": {
+          "fn": function() {},
+          "global": 0,
+          "memory": new WebAssembly.Memory({ "initial": 64, maximum: 128 }),
+          "table": new WebAssembly.Table({ "element": "anyfunc", "initial": 64, maximum: 128 }),
+        },
+      };
+
+      return {
+        buffer,
+        args: [imports],
+        exports: {},
+        verify: () => {},
+      };
+    }
+  ],
+
+  [
+    "imports with empty names",
+    function() {
+      const builder = new WasmModuleBuilder();
+
+      builder.addImport("a", "", kSig_v_v);
+      builder.addImportedGlobal("b", "", kWasmI32);
+      builder.addImportedMemory("c", "", 0, 128);
+      builder.addImportedTable("d", "", 0, 128);
+
+      const buffer = builder.toBuffer();
+      const imports = {
+        "a": { "": function() {} },
+        "b": { "": 0 },
+        "c": { "": new WebAssembly.Memory({ "initial": 64, maximum: 128 }) },
+        "d": { "": new WebAssembly.Table({ "element": "anyfunc", "initial": 64, maximum: 128 }) },
+      };
+
+      return {
+        buffer,
+        args: [imports],
+        exports: {},
+        verify: () => {},
+      };
+    }
+  ],
+
+  [
+    "exports with empty name: function",
+    function() {
+      const builder = new WasmModuleBuilder();
+
+      builder
+        .addFunction("", kSig_v_d)
+        .addBody([])
+        .exportFunc();
+
+      const buffer = builder.toBuffer();
+
+      const exports = {
+        "": { "kind": "function", "name": "0", "length": 1 },
+      };
+
+      return {
+        buffer,
+        args: [],
+        exports,
+        verify: () => {},
+      };
+    }
+  ],
+
+  [
+    "exports with empty name: table",
+    function() {
+      const builder = new WasmModuleBuilder();
+
+      builder.setTableBounds(1);
+      builder.addExportOfKind("", kExternalTable, 0);
+
+      const buffer = builder.toBuffer();
+
+      const exports = {
+        "": { "kind": "table", "length": 1 },
+      };
+
+      return {
+        buffer,
+        args: [],
+        exports,
+        verify: () => {},
+      };
+    }
+  ],
+
+  [
+    "exports with empty name: global",
+    function() {
+      const builder = new WasmModuleBuilder();
+
+      builder.addGlobal(kWasmI32, true)
+        .exportAs("")
+        .init = 7;
+
+      const buffer = builder.toBuffer();
+
+      const exports = {
+        "": { "kind": "global", "value": 7 },
+      };
+
+      return {
+        buffer,
+        args: [],
+        exports,
+        verify: () => {},
+      };
+    }
+  ],
+
   [
     "No imports",
     function() {
diff --git a/test/js-api/memory/constructor.any.js b/test/js-api/memory/constructor.any.js
index 6524c8acc..0a0be11e3 100644
--- a/test/js-api/memory/constructor.any.js
+++ b/test/js-api/memory/constructor.any.js
@@ -72,7 +72,16 @@ test(() => {
       assert_unreached(`Should not call [[HasProperty]] with ${x}`);
     },
     get(o, x) {
-      return 0;
+      // Due to the requirement not to supply both minimum and initial, we need to ignore one of them.
+      switch (x) {
+        case "shared":
+          return false;
+        case "initial":
+        case "maximum":
+          return 0;
+        default:
+          return undefined;
+      }
     },
   });
   new WebAssembly.Memory(proxy);
diff --git a/test/js-api/module/exports.any.js b/test/js-api/module/exports.any.js
index 60b2c04f4..40a3935a4 100644
--- a/test/js-api/module/exports.any.js
+++ b/test/js-api/module/exports.any.js
@@ -75,6 +75,12 @@ test(() => {
   }
 }, "Branding");
 
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  const exports = WebAssembly.Module.exports(module);
+  assert_true(Array.isArray(exports));
+}, "Return type");
+
 test(() => {
   const module = new WebAssembly.Module(emptyModuleBinary);
   const exports = WebAssembly.Module.exports(module);
@@ -124,6 +130,54 @@ test(() => {
   assert_exports(exports, expected);
 }, "exports");
 
+test(() => {
+  const builder = new WasmModuleBuilder();
+
+  builder
+    .addFunction("", kSig_v_v)
+    .addBody([])
+    .exportFunc();
+
+  const buffer = builder.toBuffer()
+  const module = new WebAssembly.Module(buffer);
+  const exports = WebAssembly.Module.exports(module);
+  const expected = [
+    { "kind": "function", "name": "" },
+  ];
+  assert_exports(exports, expected);
+}, "exports with empty name: function");
+
+test(() => {
+  const builder = new WasmModuleBuilder();
+
+  builder.setTableBounds(1);
+  builder.addExportOfKind("", kExternalTable, 0);
+
+  const buffer = builder.toBuffer()
+  const module = new WebAssembly.Module(buffer);
+  const exports = WebAssembly.Module.exports(module);
+  const expected = [
+    { "kind": "table", "name": "" },
+  ];
+  assert_exports(exports, expected);
+}, "exports with empty name: table");
+
+test(() => {
+  const builder = new WasmModuleBuilder();
+
+  builder.addGlobal(kWasmI32, true)
+    .exportAs("")
+    .init = 7;
+
+  const buffer = builder.toBuffer()
+  const module = new WebAssembly.Module(buffer);
+  const exports = WebAssembly.Module.exports(module);
+  const expected = [
+    { "kind": "global", "name": "" },
+  ];
+  assert_exports(exports, expected);
+}, "exports with empty name: global");
+
 test(() => {
   const module = new WebAssembly.Module(emptyModuleBinary);
   const exports = WebAssembly.Module.exports(module, {});
diff --git a/test/js-api/module/imports.any.js b/test/js-api/module/imports.any.js
index d6754c9ef..ec550ce6c 100644
--- a/test/js-api/module/imports.any.js
+++ b/test/js-api/module/imports.any.js
@@ -118,6 +118,66 @@ test(() => {
   assert_imports(imports, expected);
 }, "imports");
 
+test(() => {
+  const builder = new WasmModuleBuilder();
+
+  builder.addImport("", "fn", kSig_v_v);
+  builder.addImportedGlobal("", "global", kWasmI32);
+  builder.addImportedMemory("", "memory", 0, 128);
+  builder.addImportedTable("", "table", 0, 128);
+
+  const buffer = builder.toBuffer()
+  const module = new WebAssembly.Module(buffer);
+  const imports = WebAssembly.Module.imports(module);
+  const expected = [
+    { "module": "", "kind": "function", "name": "fn" },
+    { "module": "", "kind": "global", "name": "global" },
+    { "module": "", "kind": "memory", "name": "memory" },
+    { "module": "", "kind": "table", "name": "table" },
+  ];
+  assert_imports(imports, expected);
+}, "imports with empty module name");
+
+test(() => {
+  const builder = new WasmModuleBuilder();
+
+  builder.addImport("a", "", kSig_v_v);
+  builder.addImportedGlobal("b", "", kWasmI32);
+  builder.addImportedMemory("c", "", 0, 128);
+  builder.addImportedTable("d", "", 0, 128);
+
+  const buffer = builder.toBuffer()
+  const module = new WebAssembly.Module(buffer);
+  const imports = WebAssembly.Module.imports(module);
+  const expected = [
+    { "module": "a", "kind": "function", "name": "" },
+    { "module": "b", "kind": "global", "name": "" },
+    { "module": "c", "kind": "memory", "name": "" },
+    { "module": "d", "kind": "table", "name": "" },
+  ];
+  assert_imports(imports, expected);
+}, "imports with empty names");
+
+test(() => {
+  const builder = new WasmModuleBuilder();
+
+  builder.addImport("", "", kSig_v_v);
+  builder.addImportedGlobal("", "", kWasmI32);
+  builder.addImportedMemory("", "", 0, 128);
+  builder.addImportedTable("", "", 0, 128);
+
+  const buffer = builder.toBuffer()
+  const module = new WebAssembly.Module(buffer);
+  const imports = WebAssembly.Module.imports(module);
+  const expected = [
+    { "module": "", "kind": "function", "name": "" },
+    { "module": "", "kind": "global", "name": "" },
+    { "module": "", "kind": "memory", "name": "" },
+    { "module": "", "kind": "table", "name": "" },
+  ];
+  assert_imports(imports, expected);
+}, "imports with empty module names and names");
+
 test(() => {
   const module = new WebAssembly.Module(emptyModuleBinary);
   const imports = WebAssembly.Module.imports(module, {});
diff --git a/test/js-api/table/assertions.js b/test/js-api/table/assertions.js
index b1aeaf1a6..19cc5c3b9 100644
--- a/test/js-api/table/assertions.js
+++ b/test/js-api/table/assertions.js
@@ -11,3 +11,14 @@ function assert_equal_to_array(table, expected, message) {
   assert_throws_js(RangeError, () => table.get(expected.length + 1),
                    `${message}: table.get(${expected.length + 1} of ${expected.length})`);
 }
+
+function assert_Table(actual, expected) {
+  assert_equals(Object.getPrototypeOf(actual), WebAssembly.Table.prototype,
+                "prototype");
+  assert_true(Object.isExtensible(actual), "extensible");
+
+  assert_equals(actual.length, expected.length, "length");
+  for (let i = 0; i < expected.length; ++i) {
+    assert_equals(actual.get(i), null, `actual.get(${i})`);
+  }
+}
diff --git a/test/js-api/table/constructor.any.js b/test/js-api/table/constructor.any.js
index e9e77a132..cf501fbc2 100644
--- a/test/js-api/table/constructor.any.js
+++ b/test/js-api/table/constructor.any.js
@@ -1,16 +1,7 @@
 // META: global=window,dedicatedworker,jsshell
+// META: script=/wasm/jsapi/wasm-module-builder.js
 // META: script=/wasm/jsapi/assertions.js
-
-function assert_Table(actual, expected) {
-  assert_equals(Object.getPrototypeOf(actual), WebAssembly.Table.prototype,
-                "prototype");
-  assert_true(Object.isExtensible(actual), "extensible");
-
-  assert_equals(actual.length, expected.length, "length");
-  for (let i = 0; i < expected.length; ++i) {
-    assert_equals(actual.get(i), null, `actual.get(${i})`);
-  }
-}
+// META: script=/wasm/jsapi/table/assertions.js
 
 test(() => {
   assert_function_name(WebAssembly.Table, "Table", "WebAssembly.Table");
@@ -177,3 +168,41 @@ test(() => {
     "maximum valueOf",
   ]);
 }, "Order of evaluation for descriptor");
+
+test(() => {
+  const testObject = {};
+  const argument = { "element": "externref", "initial": 3 };
+  const table = new WebAssembly.Table(argument, testObject);
+  assert_equals(table.length, 3);
+  assert_equals(table.get(0), testObject);
+  assert_equals(table.get(1), testObject);
+  assert_equals(table.get(2), testObject);
+}, "initialize externref table with default value");
+
+test(() => {
+  const argument = { "element": "i32", "initial": 3 };
+  assert_throws_js(TypeError, () => new WebAssembly.Table(argument));
+}, "initialize table with a wrong element value");
+
+test(() => {
+  const builder = new WasmModuleBuilder();
+  builder
+    .addFunction("fn", kSig_v_v)
+    .addBody([])
+    .exportFunc();
+  const bin = builder.toBuffer();
+  const fn = new WebAssembly.Instance(new WebAssembly.Module(bin)).exports.fn;
+  const argument = { "element": "anyfunc", "initial": 3 };
+  const table = new WebAssembly.Table(argument, fn);
+  assert_equals(table.length, 3);
+  assert_equals(table.get(0), fn);
+  assert_equals(table.get(1), fn);
+  assert_equals(table.get(2), fn);
+}, "initialize anyfunc table with default value");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 3 };
+  assert_throws_js(TypeError, () => new WebAssembly.Table(argument, {}));
+  assert_throws_js(TypeError, () => new WebAssembly.Table(argument, "cannot be used as a wasm function"));
+  assert_throws_js(TypeError, () => new WebAssembly.Table(argument, 37));
+}, "initialize anyfunc table with a bad default value");
diff --git a/test/js-api/table/get-set.any.js b/test/js-api/table/get-set.any.js
index 2e16346c6..9301057a5 100644
--- a/test/js-api/table/get-set.any.js
+++ b/test/js-api/table/get-set.any.js
@@ -56,7 +56,6 @@ test(() => {
   const argument = { "element": "anyfunc", "initial": 5 };
   const table = new WebAssembly.Table(argument);
   assert_throws_js(TypeError, () => table.set());
-  assert_throws_js(TypeError, () => table.set(0));
 }, "Missing arguments: set");
 
 test(t => {
@@ -223,3 +222,42 @@ test(() => {
   assert_equals(table.get(0, {}), null);
   assert_equals(table.set(0, fn, {}), undefined);
 }, "Stray argument");
+
+test(() => {
+  const builder = new WasmModuleBuilder();
+  builder
+    .addFunction("fn", kSig_v_v)
+    .addBody([])
+    .exportFunc();
+  const bin = builder.toBuffer();
+  const fn = new WebAssembly.Instance(new WebAssembly.Module(bin)).exports.fn;
+
+  const argument = { "element": "anyfunc", "initial": 1 };
+  const table = new WebAssembly.Table(argument, fn);
+
+  assert_equals(table.get(0), fn);
+  table.set(0);
+  assert_equals(table.get(0), null);
+
+  table.set(0, fn);
+  assert_equals(table.get(0), fn);
+
+  assert_throws_js(TypeError, () => table.set(0, {}));
+  assert_throws_js(TypeError, () => table.set(0, 37));
+}, "Arguments for anyfunc table set");
+
+test(() => {
+  const testObject = {};
+  const argument = { "element": "externref", "initial": 1 };
+  const table = new WebAssembly.Table(argument, testObject);
+
+  assert_equals(table.get(0), testObject);
+  table.set(0);
+  assert_equals(table.get(0), undefined);
+
+  table.set(0, testObject);
+  assert_equals(table.get(0), testObject);
+
+  table.set(0, 37);
+  assert_equals(table.get(0), 37);
+}, "Arguments for externref table set");
diff --git a/test/js-api/table/grow.any.js b/test/js-api/table/grow.any.js
index 3b2ee5fa8..520d24bf4 100644
--- a/test/js-api/table/grow.any.js
+++ b/test/js-api/table/grow.any.js
@@ -1,4 +1,5 @@
 // META: global=window,dedicatedworker,jsshell
+// META: script=/wasm/jsapi/wasm-module-builder.js
 // META: script=assertions.js
 
 function nulls(n) {
@@ -94,3 +95,32 @@ test(() => {
   assert_equals(result, 5);
   assert_equal_to_array(table, nulls(8), "after");
 }, "Stray argument");
+
+test(() => {
+  const builder = new WasmModuleBuilder();
+  builder
+    .addFunction("fn", kSig_v_v)
+    .addBody([])
+    .exportFunc();
+  const bin = builder.toBuffer()
+  const argument = { "element": "anyfunc", "initial": 1 };
+  const table = new WebAssembly.Table(argument);
+  const fn = new WebAssembly.Instance(new WebAssembly.Module(bin)).exports.fn;
+  const result = table.grow(2, fn);
+  assert_equals(result, 1);
+  assert_equals(table.get(0), null);
+  assert_equals(table.get(1), fn);
+  assert_equals(table.get(2), fn);
+}, "Grow with exported-function argument");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 1 };
+  const table = new WebAssembly.Table(argument);
+  assert_throws_js(TypeError, () => table.grow(2, {}));
+}, "Grow with non-function argument");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 1 };
+  const table = new WebAssembly.Table(argument);
+  assert_throws_js(TypeError, () => table.grow(2, () => true));
+}, "Grow with JS-function argument");
diff --git a/test/js-api/wasm-module-builder.js b/test/js-api/wasm-module-builder.js
index 25fb1c836..7be72f86d 100644
--- a/test/js-api/wasm-module-builder.js
+++ b/test/js-api/wasm-module-builder.js
@@ -99,7 +99,6 @@ let kWasmF64 = 0x7c;
 let kWasmS128 = 0x7b;
 let kWasmAnyRef = 0x6f;
 let kWasmAnyFunc = 0x70;
-let kWasmExnRef = 0x68;
 
 let kExternalFunction = 0;
 let kExternalTable = 1;
@@ -149,17 +148,14 @@ let kSig_f_d = makeSig([kWasmF64], [kWasmF32]);
 let kSig_d_d = makeSig([kWasmF64], [kWasmF64]);
 let kSig_r_r = makeSig([kWasmAnyRef], [kWasmAnyRef]);
 let kSig_a_a = makeSig([kWasmAnyFunc], [kWasmAnyFunc]);
-let kSig_e_e = makeSig([kWasmExnRef], [kWasmExnRef]);
 let kSig_i_r = makeSig([kWasmAnyRef], [kWasmI32]);
 let kSig_v_r = makeSig([kWasmAnyRef], []);
 let kSig_v_a = makeSig([kWasmAnyFunc], []);
-let kSig_v_e = makeSig([kWasmExnRef], []);
 let kSig_v_rr = makeSig([kWasmAnyRef, kWasmAnyRef], []);
 let kSig_v_aa = makeSig([kWasmAnyFunc, kWasmAnyFunc], []);
 let kSig_r_v = makeSig([], [kWasmAnyRef]);
 let kSig_a_v = makeSig([], [kWasmAnyFunc]);
 let kSig_a_i = makeSig([kWasmI32], [kWasmAnyFunc]);
-let kSig_e_v = makeSig([], [kWasmExnRef]);
 
 function makeSig(params, results) {
   return {params: params, results: results};
@@ -194,6 +190,7 @@ let kExprIf = 0x04;
 let kExprElse = 0x05;
 let kExprTry = 0x06;
 let kExprCatch = 0x07;
+let kExprCatchAll = 0x19;
 let kExprThrow = 0x08;
 let kExprRethrow = 0x09;
 let kExprBrOnExn = 0x0a;
@@ -746,9 +743,8 @@ class WasmModuleBuilder {
   }
 
   addTable(type, initial_size, max_size = undefined) {
-    if (type != kWasmAnyRef && type != kWasmAnyFunc && type != kWasmExnRef) {
-      throw new Error(
-          'Tables must be of type kWasmAnyRef, kWasmAnyFunc, or kWasmExnRef');
+    if (type != kWasmAnyRef && type != kWasmAnyFunc) {
+      throw new Error('Tables must be of type kWasmAnyRef or kWasmAnyFunc');
     }
     let table = new WasmTableBuilder(this, type, initial_size, max_size);
     table.index = this.tables.length + this.num_imported_tables;
@@ -1029,9 +1025,6 @@ class WasmModuleBuilder {
                 section.emit_u8(kExprRefNull);
               }
               break;
-            case kWasmExnRef:
-              section.emit_u8(kExprRefNull);
-              break;
             }
           } else {
             // Emit a global-index initializer.
@@ -1173,9 +1166,6 @@ class WasmModuleBuilder {
             if (l.anyfunc_count > 0) {
               local_decls.push({count: l.anyfunc_count, type: kWasmAnyFunc});
             }
-            if (l.except_count > 0) {
-              local_decls.push({count: l.except_count, type: kWasmExnRef});
-            }
           }
 
           header.emit_u32v(local_decls.length);

From a4a7f684c9ec4d6ffda15c3f67f76a26528927fe Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Fri, 4 Feb 2022 14:27:25 +0100
Subject: [PATCH 084/285] Typo

---
 document/core/binary/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/binary/instructions.rst b/document/core/binary/instructions.rst
index fc1c51296..be2fe4390 100644
--- a/document/core/binary/instructions.rst
+++ b/document/core/binary/instructions.rst
@@ -66,7 +66,7 @@ Control Instructions
      \hex{0F} &\Rightarrow& \RETURN \\ &&|&
      \hex{10}~~x{:}\Bfuncidx &\Rightarrow& \CALL~x \\ &&|&
      \hex{11}~~y{:}\Btypeidx~~x{:}\Btableidx &\Rightarrow& \CALLINDIRECT~x~y \\ &&|&
-     \hex{14}~~x{:}\Bfuncidx &\Rightarrow& \CALLREF \\ &&|&
+     \hex{14} &\Rightarrow& \CALLREF \\ &&|&
      \hex{D4}~~x{:}\Bfuncidx &\Rightarrow& \BRONNULL \\ &&|&
      \hex{D6}~~x{:}\Bfuncidx &\Rightarrow& \BRONNONNULL \\
    \end{array}

From 5a6a7fb29611777f8d46a2c11df49ec600ebe8ea Mon Sep 17 00:00:00 2001
From: Crypt Keeper <64215+codefromthecrypt@users.noreply.github.com>
Date: Tue, 15 Feb 2022 16:12:55 +0800
Subject: [PATCH 085/285] [spec] Clarifying note on text format (#1420)

Signed-off-by: Adrian Cole <adrian@tetrate.io>
Co-authored-by: Andreas Rossberg <rossberg@mpi-sws.org>
---
 document/core/text/modules.rst | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/document/core/text/modules.rst b/document/core/text/modules.rst
index 848f6880b..b85f51328 100644
--- a/document/core/text/modules.rst
+++ b/document/core/text/modules.rst
@@ -250,7 +250,9 @@ Functions can be defined as :ref:`imports <text-import>` or :ref:`exports <text-
        (\iff \Tid^? \neq \epsilon \wedge \Tid' = \Tid^? \vee \Tid^? = \epsilon \wedge \Tid' \idfresh) \\
    \end{array}
 
-The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export.
+.. note::
+   The latter abbreviation can be applied repeatedly, if ":math:`\dots`" contains additional export clauses.
+   Consequently, a function declaration can contain any number of exports, possibly followed by an import.
 
 
 .. index:: table, table type, identifier
@@ -319,7 +321,9 @@ Tables can be defined as :ref:`imports <text-import>` or :ref:`exports <text-exp
        (\iff \Tid^? \neq \epsilon \wedge \Tid' = \Tid^? \vee \Tid^? = \epsilon \wedge \Tid' \idfresh) \\
    \end{array}
 
-The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export or an inline elements segment.
+.. note::
+   The latter abbreviation can be applied repeatedly, if ":math:`\dots`" contains additional export clauses.
+   Consequently, a table declaration can contain any number of exports, possibly followed by an import.
 
 
 .. index:: memory, memory type, identifier
@@ -379,7 +383,9 @@ Memories can be defined as :ref:`imports <text-import>` or :ref:`exports <text-e
        (\iff \Tid^? \neq \epsilon \wedge \Tid' = \Tid^? \vee \Tid^? = \epsilon \wedge \Tid' \idfresh) \\
    \end{array}
 
-The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export or an inline data segment.
+.. note::
+   The latter abbreviation can be applied repeatedly, if ":math:`\dots`" contains additional export clauses.
+   Consequently, a memory declaration can contain any number of exports, possibly followed by an import.
 
 
 .. index:: global, global type, identifier, expression
@@ -423,7 +429,9 @@ Globals can be defined as :ref:`imports <text-import>` or :ref:`exports <text-ex
        (\iff \Tid^? \neq \epsilon \wedge \Tid' = \Tid^? \vee \Tid^? = \epsilon \wedge \Tid' \idfresh) \\
    \end{array}
 
-The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export.
+.. note::
+   The latter abbreviation can be applied repeatedly, if ":math:`\dots`" contains additional export clauses.
+   Consequently, a global declaration can contain any number of exports, possibly followed by an import.
 
 
 .. index:: export, name, index, function index, table index, memory index, global index

From bdee0c7b7b62b9bd7f991a71982840881aff8406 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Tue, 15 Feb 2022 14:09:05 +0100
Subject: [PATCH 086/285] Eps

---
 document/core/conf.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/conf.py b/document/core/conf.py
index 09930022e..3512c164c 100644
--- a/document/core/conf.py
+++ b/document/core/conf.py
@@ -69,7 +69,7 @@
 repo = 'function-references'
 
 # The name of the proposal it represents, if any
-proposal = 'function-references'
+proposal = 'function references'
 
 # The draft version string (clear out for release cuts)
 draft = ' (Draft ' + date.today().strftime("%Y-%m-%d") + ')'

From a906a4d63bf29b8488bd161870e04dc9198dc797 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Tue, 15 Feb 2022 14:15:25 +0100
Subject: [PATCH 087/285] Eps

---
 document/core/conf.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/conf.py b/document/core/conf.py
index edbec9c78..ed128ff77 100644
--- a/document/core/conf.py
+++ b/document/core/conf.py
@@ -69,7 +69,7 @@
 repo = 'tail-call'
 
 # The name of the proposal it represents, if any
-proposal = 'tail-call'
+proposal = 'tail calls'
 
 # The draft version string (clear out for release cuts)
 draft = ' (Draft ' + date.today().strftime("%Y-%m-%d") + ')'

From 5257f137390d4f612213e27f76ea69a54bf3225f Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Tue, 22 Feb 2022 19:44:55 +0100
Subject: [PATCH 088/285] [test] Fix section size in binary test (#1424)

---
 interpreter/binary/decode.ml | 2 +-
 test/core/binary.wast        | 8 ++++----
 test/core/custom.wast        | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 78b466776..7ed4a9235 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -110,7 +110,7 @@ let v128 s = V128.of_bits (get_string (Types.vec_size Types.V128Type) s)
 let len32 s =
   let pos = pos s in
   let n = vu32 s in
-  if I32.le_u n (Int32.of_int (len s)) then Int32.to_int n else
+  if I32.le_u n (Int32.of_int (len s - pos)) then Int32.to_int n else
     error s pos "length out of bounds"
 
 let bool s = (vu1 s = 1)
diff --git a/test/core/binary.wast b/test/core/binary.wast
index e80d3e20b..31bb24a93 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -1311,7 +1311,7 @@
     "\60\00\00"                             ;; 1st type
     ;; "\60\00\00"                          ;; 2nd type (missed)
   )
-  "unexpected end of section or function"
+  "length out of bounds"
 )
 
 ;; 1 type declared, 2 given
@@ -1600,7 +1600,7 @@
     "\02\00\0b"                             ;; function body 0
     "\02\00\0b"                             ;; function body 1
   )
-  "unexpected end of section or function"
+  "length out of bounds"
 )
 
 ;; 1 export declared, 2 given
@@ -1662,7 +1662,7 @@
     "\03\02\01\00"                          ;; func section
     "\04\04\01"                             ;; table section
     "\70\00\01"                             ;; table 0
-    "\09\07\02"                             ;; elem with inconsistent segment count (2 declared, 1 given)
+    "\09\0a\02"                             ;; elem with inconsistent segment count (2 declared, 1 given)
     "\00\41\00\0b\01\00"                    ;; elem 0
     "\00\41\00"                             ;; elem 1 (partial)
     ;; "\0b\01\00"                          ;; elem 1 (missing part)
@@ -1774,7 +1774,7 @@
     "\01\04\01"                             ;; type section
     "\60\00\00"                             ;; type 0
     "\03\02\01\00"                          ;; func section
-    "\0a\12\01"                             ;; code section
+    "\0a\13\01"                             ;; code section
     "\11\00"                                ;; func 0
     "\02\40"                                ;; block 0
     "\41\01"                                ;; condition of if 0
diff --git a/test/core/custom.wast b/test/core/custom.wast
index b2394f5e3..12b047650 100644
--- a/test/core/custom.wast
+++ b/test/core/custom.wast
@@ -86,7 +86,7 @@
     "\00asm" "\01\00\00\00"
     "\00\26\10" "a custom section" "this is the payload"
   )
-  "unexpected end"
+  "length out of bounds"
 )
 
 (assert_malformed

From df228524cdfd47e721570b5896fb1c7c27ccd160 Mon Sep 17 00:00:00 2001
From: Zhi An Ng <zhin@google.com>
Date: Tue, 1 Mar 2022 18:21:39 +0000
Subject: [PATCH 089/285] Update document README to install six

---
 document/README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/document/README.md b/document/README.md
index caf75430d..a99cb9ffb 100644
--- a/document/README.md
+++ b/document/README.md
@@ -3,9 +3,9 @@
 This directory contains the source code for the WebAssembly spec documents, as served from the [webassembly.github.io/spec](https://webassembly.github.io/spec) pages.
 It uses [Sphinx](http://www.sphinx-doc.org/) and [Bikeshed](https://github.com/tabatkins/bikeshed).
 
-To install Sphinx:
+To install Sphinx (and required library six):
 ```
-pip install sphinx
+pip install sphinx six
 ```
 
 To install Bikeshed, see the instructions [here](https://tabatkins.github.io/bikeshed/#installing).
@@ -42,7 +42,7 @@ pipenv shell
 Install Python dependencies:
 
 ```
-pipenv install Sphinx==4.0.0
+pipenv install Sphinx==4.0.0 six
 ```
 
 ### Checking out the repository

From 4ba7f3fe981b90b0df01c60fd287b8cf5ab0fddd Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@dfinity.org>
Date: Tue, 8 Mar 2022 07:06:32 +0100
Subject: [PATCH 090/285] Disallow type recursion (#56)

---
 interpreter/valid/valid.ml                |  44 ++-
 proposals/function-references/Overview.md |   8 +
 test/core/type-equivalence.wast           | 333 +---------------------
 3 files changed, 36 insertions(+), 349 deletions(-)

diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index 9a7c40acb..575f03970 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -125,11 +125,6 @@ let check_def_type (c : context) (dt : def_type) at =
   | FuncDefType ft -> check_func_type c ft at
 
 
-let check_type (c : context) (t : type_) =
-  check_def_type c t.it t.at
-
-
-
 
 (* Stack typing *)
 
@@ -795,7 +790,11 @@ let check_start (c : context) (start : idx option) =
       "start function must not have parameters or results"
   ) start
 
-let check_import (im : import) (c : context) : context =
+let check_type (c : context) (ty : type_) : context =
+  check_def_type c ty.it ty.at;
+  {c with types = c.types @ [ty.it]}
+
+let check_import (c : context) (im : import) : context =
   let {module_name = _; item_name = _; idesc} = im.it in
   match idesc.it with
   | FuncImport x ->
@@ -830,31 +829,26 @@ let check_module (m : module_) =
     { types; imports; tables; memories; globals; funcs; start; elems; datas;
       exports } = m.it
   in
-  let c0 =
-    List.fold_right check_import imports
-      { empty_context with
-        refs = Free.module_ ({m.it with funcs = []; start = None} @@ m.at);
-        types = List.map (fun ty -> ty.it) types;
-      }
-  in
-  let c1 =
-    { c0 with
-      funcs = c0.funcs @ List.map (fun f -> func_type c0 f.it.ftype) funcs;
-      tables = c0.tables @ List.map (fun tab -> tab.it.ttype) tables;
-      memories = c0.memories @ List.map (fun mem -> mem.it.mtype) memories;
+  let c0 = List.fold_left check_type empty_context types in
+  let c1 = List.fold_left check_import c0 imports in
+  let c2 =
+    { c1 with
+      funcs = c1.funcs @ List.map (fun f -> func_type c1 f.it.ftype) funcs;
+      tables = c1.tables @ List.map (fun tab -> tab.it.ttype) tables;
+      memories = c1.memories @ List.map (fun mem -> mem.it.mtype) memories;
       elems = List.map (fun elem -> elem.it.etype) elems;
       datas = List.map (fun _data -> ()) datas;
+      refs = Free.module_ ({m.it with funcs = []; start = None} @@ m.at);
     }
   in
   let c =
-    { c1 with globals = c1.globals @ List.map (fun g -> g.it.gtype) globals }
+    { c2 with globals = c1.globals @ List.map (fun g -> g.it.gtype) globals }
   in
-  List.iter (check_type c1) types;
-  List.iter (check_global c1) globals;
-  List.iter (check_table c1) tables;
-  List.iter (check_memory c1) memories;
-  List.iter (check_elem c1) elems;
-  List.iter (check_data c1) datas;
+  List.iter (check_global c2) globals;
+  List.iter (check_table c2) tables;
+  List.iter (check_memory c2) memories;
+  List.iter (check_elem c2) elems;
+  List.iter (check_data c2) datas;
   List.iter (check_func c) funcs;
   check_start c start;
   ignore (List.fold_left (check_export c) NameSet.empty exports);
diff --git a/proposals/function-references/Overview.md b/proposals/function-references/Overview.md
index 801553ab5..da019d1f4 100644
--- a/proposals/function-references/Overview.md
+++ b/proposals/function-references/Overview.md
@@ -150,6 +150,14 @@ A *reference type* denotes the type of a reference to some data. It may either i
   - the opcodes for `funcref` and `externref` continue to exist as shorthands as described above
 
 
+#### Type Definitions
+
+* Type definitions are validated in sequence and without allowing recursion
+  - `functype* ok`
+    - iff `functype* = epsilon`
+    - or `functype* = functype'* functype''`and `functype'* ok` and `functype'' ok` using only type indices up to `|functype'*|-1`
+
+
 #### Subtyping
 
 The following rules, now defined in terms of heap types, replace and extend the rules for [basic reference types](https://github.com/WebAssembly/reference-types/proposals/reference-types/Overview.md#subtyping).
diff --git a/test/core/type-equivalence.wast b/test/core/type-equivalence.wast
index e43871a36..4e295061f 100644
--- a/test/core/type-equivalence.wast
+++ b/test/core/type-equivalence.wast
@@ -27,76 +27,19 @@
 
 ;; Recursive types.
 
-(module
-  (type $t1 (func (param i32 (ref $t1))))
-  (type $t2 (func (param i32 (ref $t2))))
-
-  (func $f1 (param $r (ref $t1)) (call $f2 (local.get $r)))
-  (func $f2 (param $r (ref $t2)) (call $f1 (local.get $r)))
-)
-
-
-;; Isomorphic recursive types.
-
-(module
-  (type $t1 (func (param i32 (ref $t1))))
-  (type $t2 (func (param i32 (ref $t3))))
-  (type $t3 (func (param i32 (ref $t2))))
-
-  (func $f1 (param $r (ref $t1))
-    (call $f2 (local.get $r))
-    (call $f3 (local.get $r))
-  )
-  (func $f2 (param $r (ref $t2))
-    (call $f1 (local.get $r))
-    (call $f3 (local.get $r))
-  )
-  (func $f3 (param $r (ref $t3))
-    (call $f1 (local.get $r))
-    (call $f2 (local.get $r))
-  )
-)
-
-(module
-  (type $t1 (func (param i32 (ref $t3))))
-  (type $t2 (func (param i32 (ref $t1))))
-  (type $t3 (func (param i32 (ref $t2))))
-
-  (func $f1 (param $r (ref $t1))
-    (call $f2 (local.get $r))
-    (call $f3 (local.get $r))
-  )
-  (func $f2 (param $r (ref $t2))
-    (call $f1 (local.get $r))
-    (call $f3 (local.get $r))
-  )
-  (func $f3 (param $r (ref $t3))
-    (call $f1 (local.get $r))
-    (call $f2 (local.get $r))
+(assert_invalid
+  (module
+    (type $t (func (result (ref $t))))
   )
+  "unknown type"
 )
 
-(module
-  (type $t1 (func (param i32 (ref $u1))))
-  (type $u1 (func (param f32 (ref $t1))))
-
-  (type $t2 (func (param i32 (ref $u3))))
-  (type $u2 (func (param f32 (ref $t3))))
-  (type $t3 (func (param i32 (ref $u2))))
-  (type $u3 (func (param f32 (ref $t2))))
-
-  (func $f1 (param $r (ref $t1))
-    (call $f2 (local.get $r))
-    (call $f3 (local.get $r))
-  )
-  (func $f2 (param $r (ref $t2))
-    (call $f1 (local.get $r))
-    (call $f3 (local.get $r))
-  )
-  (func $f3 (param $r (ref $t3))
-    (call $f1 (local.get $r))
-    (call $f2 (local.get $r))
+(assert_invalid
+  (module
+    (type $t1 (func (param (ref $t2))))
+    (type $t2 (func (param (ref $t1))))
   )
+  "unknown type"
 )
 
 
@@ -149,166 +92,6 @@
 (assert_return (invoke "run"))
 
 
-;; Recursive types.
-
-(module
-  (type $t1 (func (param i32 (ref $t1))))
-  (type $t2 (func (param i32 (ref $t2))))
-
-  (func $f1 (type $t1))
-  (func $f2 (type $t2))
-  (table funcref (elem $f1 $f2))
-
-  (func (export "run")
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 1))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 0))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 0))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 1))
-  )
-)
-(assert_return (invoke "run"))
-
-
-;; Isomorphic recursive types.
-
-(module
-  (type $t1 (func (param i32 (ref $t1))))
-  (type $t2 (func (param i32 (ref $t3))))
-  (type $t3 (func (param i32 (ref $t2))))
-
-  (func $f1 (type $t1))
-  (func $f2 (type $t2))
-  (func $f3 (type $t3))
-  (table funcref (elem $f1 $f2 $f3))
-
-  (func (export "run")
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 1))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 2))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 1))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 2))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 1))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 2))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 0))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 2))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 0))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 2))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 0))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 2))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 0))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 1))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 2))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 0))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 1))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 2))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 0))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 1))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 2))
-  )
-)
-(assert_return (invoke "run"))
-
-(module
-  (type $t1 (func (param i32 (ref $t3))))
-  (type $t2 (func (param i32 (ref $t1))))
-  (type $t3 (func (param i32 (ref $t2))))
-
-  (func $f1 (type $t1))
-  (func $f2 (type $t2))
-  (func $f3 (type $t3))
-  (table funcref (elem $f1 $f2 $f3))
-
-  (func (export "run")
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 1))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 2))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 1))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 2))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 1))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 2))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 0))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 2))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 0))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 2))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 0))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 2))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 0))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 1))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 2))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 0))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 1))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 2))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 0))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 1))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 2))
-  )
-)
-(assert_return (invoke "run"))
-
-(module
-  (type $t1 (func (param i32 (ref $u1))))
-  (type $u1 (func (param f32 (ref $t1))))
-
-  (type $t2 (func (param i32 (ref $u3))))
-  (type $u2 (func (param f32 (ref $t3))))
-  (type $t3 (func (param i32 (ref $u2))))
-  (type $u3 (func (param f32 (ref $t2))))
-
-  (func $f1 (type $t1))
-  (func $f2 (type $t2))
-  (func $f3 (type $t3))
-  (func $g1 (type $u1))
-  (func $g2 (type $u2))
-  (func $g3 (type $u3))
-  (table funcref (elem $f1 $f2 $f3 $g1 $g2 $g3))
-
-  (func (export "run")
-    (call_indirect (type $t1) (i32.const 1) (ref.func $g1) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $g1) (i32.const 1))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $g1) (i32.const 2))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $g2) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $g2) (i32.const 1))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $g2) (i32.const 2))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $g3) (i32.const 0))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $g3) (i32.const 1))
-    (call_indirect (type $t1) (i32.const 1) (ref.func $g3) (i32.const 2))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $g1) (i32.const 0))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $g1) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $g1) (i32.const 2))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $g2) (i32.const 0))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $g2) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $g2) (i32.const 2))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $g3) (i32.const 0))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $g3) (i32.const 1))
-    (call_indirect (type $t2) (i32.const 1) (ref.func $g3) (i32.const 2))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $g1) (i32.const 0))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $g1) (i32.const 1))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $g1) (i32.const 2))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $g2) (i32.const 0))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $g2) (i32.const 1))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $g2) (i32.const 2))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $g3) (i32.const 0))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $g3) (i32.const 1))
-    (call_indirect (type $t3) (i32.const 1) (ref.func $g3) (i32.const 2))
-  )
-)
-(assert_return (invoke "run"))
-
-
 ;; Semantic types (link time)
 
 ;; Simple types.
@@ -347,101 +130,3 @@
   (func (import "M" "f2") (param (ref $t1)))
   (func (import "M" "f2") (param (ref $t1)))
 )
-
-
-;; Recursive types.
-
-(module
-  (type $t1 (func (param i32 (ref $t1))))
-  (func (export "f") (param (ref $t1)))
-)
-(register "M")
-(module
-  (type $t2 (func (param i32 (ref $t2))))
-  (func (import "M" "f") (param (ref $t2)))
-)
-
-
-;; Isomorphic recursive types.
-
-(module
-  (type $t1 (func (param i32 (ref $t1))))
-  (type $t2 (func (param i32 (ref $t3))))
-  (type $t3 (func (param i32 (ref $t2))))
-  (func (export "f1") (param (ref $t1)))
-  (func (export "f2") (param (ref $t2)))
-  (func (export "f3") (param (ref $t3)))
-)
-(register "M")
-(module
-  (type $t1 (func (param i32 (ref $t1))))
-  (type $t2 (func (param i32 (ref $t3))))
-  (type $t3 (func (param i32 (ref $t2))))
-  (func (import "M" "f1") (param (ref $t1)))
-  (func (import "M" "f1") (param (ref $t2)))
-  (func (import "M" "f1") (param (ref $t3)))
-  (func (import "M" "f2") (param (ref $t1)))
-  (func (import "M" "f2") (param (ref $t2)))
-  (func (import "M" "f2") (param (ref $t3)))
-  (func (import "M" "f3") (param (ref $t1)))
-  (func (import "M" "f3") (param (ref $t2)))
-  (func (import "M" "f3") (param (ref $t3)))
-)
-
-(module
-  (type $t1 (func (param i32 (ref $t3))))
-  (type $t2 (func (param i32 (ref $t1))))
-  (type $t3 (func (param i32 (ref $t2))))
-  (func (export "f1") (param (ref $t1)))
-  (func (export "f2") (param (ref $t2)))
-  (func (export "f3") (param (ref $t3)))
-)
-(register "M")
-(module
-  (type $t1 (func (param i32 (ref $t3))))
-  (type $t2 (func (param i32 (ref $t1))))
-  (type $t3 (func (param i32 (ref $t2))))
-  (func (import "M" "f1") (param (ref $t1)))
-  (func (import "M" "f1") (param (ref $t2)))
-  (func (import "M" "f1") (param (ref $t3)))
-  (func (import "M" "f2") (param (ref $t1)))
-  (func (import "M" "f2") (param (ref $t2)))
-  (func (import "M" "f2") (param (ref $t3)))
-  (func (import "M" "f3") (param (ref $t1)))
-  (func (import "M" "f3") (param (ref $t2)))
-  (func (import "M" "f3") (param (ref $t3)))
-)
-
-(module
-  (type $t1 (func (param i32 (ref $u1))))
-  (type $u1 (func (param f32 (ref $t1))))
-
-  (type $t2 (func (param i32 (ref $u3))))
-  (type $u2 (func (param f32 (ref $t3))))
-  (type $t3 (func (param i32 (ref $u2))))
-  (type $u3 (func (param f32 (ref $t2))))
-
-  (func (export "f1") (param (ref $t1)))
-  (func (export "f2") (param (ref $t2)))
-  (func (export "f3") (param (ref $t3)))
-)
-(register "M")
-(module
-  (type $t1 (func (param i32 (ref $u1))))
-  (type $u1 (func (param f32 (ref $t1))))
-
-  (type $t2 (func (param i32 (ref $u3))))
-  (type $u2 (func (param f32 (ref $t3))))
-  (type $t3 (func (param i32 (ref $u2))))
-  (type $u3 (func (param f32 (ref $t2))))
-
-  (func (import "M" "f1") (param (ref $t1)))
-  (func (import "M" "f1") (param (ref $t2)))
-  (func (import "M" "f1") (param (ref $t3)))
-  (func (import "M" "f2") (param (ref $t1)))
-  (func (import "M" "f2") (param (ref $t2)))
-  (func (import "M" "f2") (param (ref $t3)))
-  (func (import "M" "f3") (param (ref $t1)))
-  (func (import "M" "f3") (param (ref $t2)))
-  (func (import "M" "f3") (param (ref $t3)))
-)

From af438f4ad7f15631ff862cd07f08af2ca67f4c47 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Tue, 8 Mar 2022 07:42:17 +0100
Subject: [PATCH 091/285] Fix import order

---
 interpreter/valid/valid.ml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index 575f03970..1ee93d636 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -799,16 +799,16 @@ let check_import (c : context) (im : import) : context =
   match idesc.it with
   | FuncImport x ->
     let ft = func_type c x in
-    {c with funcs = ft :: c.funcs}
+    {c with funcs = c.funcs @ [ft]}
   | TableImport tt ->
     check_table_type c tt idesc.at;
-    {c with tables = tt :: c.tables}
+    {c with tables = c.tables @ [tt]}
   | MemoryImport mt ->
     check_memory_type c mt idesc.at;
-    {c with memories = mt :: c.memories}
+    {c with memories = c.memories @ [mt]}
   | GlobalImport gt ->
     check_global_type c gt idesc.at;
-    {c with globals = gt :: c.globals}
+    {c with globals = c.globals @ [gt]}
 
 module NameSet = Set.Make(struct type t = Ast.name let compare = compare end)
 

From daee490389920da241f0c0cb85f93bd57c9c8cb0 Mon Sep 17 00:00:00 2001
From: Ng Zhi An <ngzhian@gmail.com>
Date: Fri, 18 Mar 2022 22:38:03 +0000
Subject: [PATCH 092/285] Add --generate-js-only flag to test runner

This will return early right after generating JS from the wast test
files. It will not attempt to run the tests, or do the round trip
conversion from wasm <-> wast.

This is convenient for proposals to add tests without having to
update the reference interpreter with implementation, and generate those
tests to JS to run in other Wasm engines.

Fixes #1430.
---
 test/core/run.py | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/test/core/run.py b/test/core/run.py
index 924b42c69..27c069436 100755
--- a/test/core/run.py
+++ b/test/core/run.py
@@ -17,6 +17,7 @@
 parser = argparse.ArgumentParser()
 parser.add_argument("--wasm", metavar="<wasm-command>", default=os.path.join(os.getcwd(), "wasm"))
 parser.add_argument("--js", metavar="<js-command>")
+parser.add_argument("--generate-js-only", action='store_true')
 parser.add_argument("--out", metavar="<out-dir>", default=outputDir)
 parser.add_argument("file", nargs='*')
 arguments = parser.parse_args()
@@ -28,6 +29,7 @@
 
 wasmCommand = arguments.wasm
 jsCommand = arguments.js
+generateJsOnly = arguments.generate_js_only
 outputDir = arguments.out
 inputFiles = arguments.file if arguments.file else main_test_files + simd_test_files
 
@@ -64,6 +66,14 @@ def _runTestFile(self, inputPath):
     dir, inputFile = os.path.split(inputPath)
     outputPath = os.path.join(outputDir, inputFile)
 
+    # Generate JS first, then return early if we are only generating JS.
+    jsPath = self._auxFile(outputPath.replace(".wast", ".js"))
+    logPath = self._auxFile(jsPath + ".log")
+    self._runCommand(('%s -d "%s" -o "%s"') % (wasmCommand, inputPath, jsPath), logPath)
+
+    if generateJsOnly:
+      return
+
     # Run original file
     expectedExitCode = 1 if ".fail." in inputFile else 0
     logPath = self._auxFile(outputPath + ".log")
@@ -96,9 +106,6 @@ def _runTestFile(self, inputPath):
     self._runCommand(('%s -d "%s" -o "%s"') % (wasmCommand, wasm2Path, wast2Path), logPath)
     self._compareFile(wastPath, wast2Path)
 
-    jsPath = self._auxFile(outputPath.replace(".wast", ".js"))
-    logPath = self._auxFile(jsPath + ".log")
-    self._runCommand(('%s -d "%s" -o "%s"') % (wasmCommand, inputPath, jsPath), logPath)
     if jsCommand != None:
       self._runCommand(('%s "%s"') % (jsCommand, jsPath), logPath)
 

From 244cc87500aa7578c0624869e1bb2e20e29f1e4c Mon Sep 17 00:00:00 2001
From: "Ben L. Titzer" <ben.titzer@gmail.com>
Date: Mon, 21 Mar 2022 12:35:37 -0400
Subject: [PATCH 093/285] Remove use of let from func.bind test

---
 test/core/func_bind.wast | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/test/core/func_bind.wast b/test/core/func_bind.wast
index 18743219f..f009a0432 100644
--- a/test/core/func_bind.wast
+++ b/test/core/func_bind.wast
@@ -19,12 +19,10 @@
   )
 
   (func (export "call2") (param $i i32) (param $j i32) (param $k i32) (result i32)
-    (call $mk-adder (local.get $k))
-    (let (result i32) (local $f (ref $unop))  ;; binds $f to top of stack
-      (i32.mul
-        (call_ref (local.get $i) (local.get $f))
-        (call_ref (local.get $j) (local.get $f))
-      )
+    
+    (i32.mul
+      (call_ref (local.get $i) (call $mk-adder (local.get $k)))
+      (call_ref (local.get $j) (call $mk-adder (local.get $k)))
     )
   )
 

From 44a0a7793e52fca7dc960719c3470ef2c0c90bd9 Mon Sep 17 00:00:00 2001
From: "Ben L. Titzer" <ben.titzer@gmail.com>
Date: Mon, 21 Mar 2022 21:57:51 -0400
Subject: [PATCH 094/285] Add call3

---
 test/core/func_bind.wast | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/test/core/func_bind.wast b/test/core/func_bind.wast
index f009a0432..a0dd71419 100644
--- a/test/core/func_bind.wast
+++ b/test/core/func_bind.wast
@@ -19,7 +19,17 @@
   )
 
   (func (export "call2") (param $i i32) (param $j i32) (param $k i32) (result i32)
-    
+    (local $f (ref null $unop))
+    (local.set $f (call $mk-adder (local.get $k)))
+
+    (i32.mul
+      (call_ref (local.get $i) (local.get $f))
+      (call_ref (local.get $j) (local.get $f))
+    )
+  )
+
+  (func (export "call3") (param $i i32) (param $j i32) (param $k i32) (result i32)
+
     (i32.mul
       (call_ref (local.get $i) (call $mk-adder (local.get $k)))
       (call_ref (local.get $j) (call $mk-adder (local.get $k)))
@@ -48,6 +58,10 @@
 (assert_return (invoke "call2" (i32.const 2) (i32.const 5) (i32.const 1)) (i32.const 18))
 (assert_return (invoke "call2" (i32.const 2) (i32.const 5) (i32.const 7)) (i32.const 108))
 
+(assert_return (invoke "call3" (i32.const 4) (i32.const 9) (i32.const 1)) (i32.const 50))
+(assert_return (invoke "call3" (i32.const 4) (i32.const 7) (i32.const 2)) (i32.const 54))
+(assert_return (invoke "call3" (i32.const 4) (i32.const 5) (i32.const 3)) (i32.const 56))
+
 (assert_trap (invoke "null") "null function")
 
 (module

From 253db39e54e2ae45f80d9c9fc7df7dd8c66a6483 Mon Sep 17 00:00:00 2001
From: Ng Zhi An <ngzhian@gmail.com>
Date: Mon, 4 Apr 2022 04:53:10 -0700
Subject: [PATCH 095/285] [spec] Fix missing mention of vectype (#1436)

Fixed #1435.
---
 document/core/binary/types.rst | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/document/core/binary/types.rst b/document/core/binary/types.rst
index f77da6eae..485057354 100644
--- a/document/core/binary/types.rst
+++ b/document/core/binary/types.rst
@@ -69,12 +69,13 @@ Reference Types
 Value Types
 ~~~~~~~~~~~
 
-:ref:`Value types <syntax-valtype>` are encoded with their respective encoding as a :ref:`number type <binary-numtype>` or :ref:`reference type <binary-reftype>`.
+:ref:`Value types <syntax-valtype>` are encoded with their respective encoding as a :ref:`number type <binary-numtype>`, :ref:`vector type <binary-vectype>`, or :ref:`reference type <binary-reftype>`.
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
    \production{value type} & \Bvaltype &::=&
      t{:}\Bnumtype &\Rightarrow& t \\ &&|&
+     t{:}\Bvectype &\Rightarrow& t \\ &&|&
      t{:}\Breftype &\Rightarrow& t \\
    \end{array}
 

From f7e4ad1edfb7ebcaa693d56f7c639a52ac3d2504 Mon Sep 17 00:00:00 2001
From: Keith Winstein <keithw@cs.stanford.edu>
Date: Mon, 4 Apr 2022 05:23:36 -0700
Subject: [PATCH 096/285] [spec] Fix single-table limitation in module
 instantiation (#1434)

---
 document/core/exec/modules.rst | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index 34f1298ad..a6ed62be7 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -657,19 +657,17 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
 14. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEMS` whose :ref:`mode <syntax-elemmode>` is of the form :math:`\EACTIVE~\{ \ETABLE~\tableidx_i, \EOFFSET~\X{einstr}^\ast_i~\END \}`, do:
 
-    a. Assert: :math:`\tableidx_i` is :math:`0`.
+    a. Let :math:`n` be the length of the vector :math:`\elem_i.\EINIT`.
 
-    b. Let :math:`n` be the length of the vector :math:`\elem_i.\EINIT`.
+    b. :ref:`Execute <exec-instr-seq>` the instruction sequence :math:`\X{einstr}^\ast_i`.
 
-    c. :ref:`Execute <exec-instr-seq>` the instruction sequence :math:`\X{einstr}^\ast_i`.
+    c. :ref:`Execute <exec-const>` the instruction :math:`\I32.\CONST~0`.
 
-    d. :ref:`Execute <exec-const>` the instruction :math:`\I32.\CONST~0`.
-
-    e. :ref:`Execute <exec-const>` the instruction :math:`\I32.\CONST~n`.
+    d. :ref:`Execute <exec-const>` the instruction :math:`\I32.\CONST~n`.
 
-    f. :ref:`Execute <exec-table.init>` the instruction :math:`\TABLEINIT~i`.
+    e. :ref:`Execute <exec-table.init>` the instruction :math:`\TABLEINIT~\tableidx_i~i`.
 
-    g. :ref:`Execute <exec-elem.drop>` the instruction :math:`\ELEMDROP~i`.
+    f. :ref:`Execute <exec-elem.drop>` the instruction :math:`\ELEMDROP~i`.
 
 15. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATAS` whose :ref:`mode <syntax-datamode>` is of the form :math:`\DACTIVE~\{ \DMEM~\memidx_i, \DOFFSET~\X{dinstr}^\ast_i~\END \}`, do:
 

From f6ae547fd357c15ff3b01cdfb6b419d5a1481fcb Mon Sep 17 00:00:00 2001
From: Keith Winstein <keithw@cs.stanford.edu>
Date: Mon, 4 Apr 2022 23:49:31 -0700
Subject: [PATCH 097/285] [spec] Fix missing immediate on table.set (#1441)

---
 document/core/exec/instructions.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index b46397ca4..84dbf86db 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -1191,8 +1191,8 @@ Table Instructions
 
 .. _exec-table.set:
 
-:math:`\TABLESET`
-.................
+:math:`\TABLESET~x`
+...................
 
 1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
 

From d28b65e14f462e7ae8a7f8683a6a285fcca7f28e Mon Sep 17 00:00:00 2001
From: Crypt Keeper <64215+codefromthecrypt@users.noreply.github.com>
Date: Thu, 14 Apr 2022 18:53:59 +0800
Subject: [PATCH 098/285] [docs] Update syntax in examples (#1442)

---
 proposals/multi-value/Overview.md | 28 ++++++++++++++++++----------
 1 file changed, 18 insertions(+), 10 deletions(-)

diff --git a/proposals/multi-value/Overview.md b/proposals/multi-value/Overview.md
index b3c0277fe..42952f0e4 100644
--- a/proposals/multi-value/Overview.md
+++ b/proposals/multi-value/Overview.md
@@ -43,7 +43,7 @@
 A simple swap function.
 ```wasm
 (func $swap (param i32 i32) (result i32 i32)
-	(get_local 1) (get_local 0)
+	(local.get 1) (local.get 0)
 )
 ```
 
@@ -51,10 +51,10 @@ An addition function returning an additional carry bit.
 ```wasm
 (func $add64_u_with_carry (param $i i64) (param $j i64) (param $c i32) (result i64 i32)
 	(local $k i64)
-	(set_local $k
-		(i64.add (i64.add (get_local $i) (get_local $j)) (i64.extend_u/i32 (get_local $c)))
+	(local.set $k
+		(i64.add (i64.add (local.get $i) (local.get $j)) (i64.extend_i32_u (local.get $c)))
 	)
-	(return (get_local $k) (i64.lt_u (get_local $k) (get_local $i)))
+	(return (local.get $k) (i64.lt_u (local.get $k) (local.get $i)))
 )
 ```
 
@@ -71,7 +71,7 @@ An addition function returning an additional carry bit.
 Conditionally manipulating a stack operand without using a local.
 ```wasm
 (func $add64_u_saturated (param i64 i64) (result i64)
-	($i64.add_u_carry (get_local 0) (get_local 1) (i32.const 0))
+	(call $add64_u_with_carry (local.get 0) (local.get 1) (i32.const 0))
 	(if (param i64) (result i64)
 		(then (drop) (i64.const 0xffff_ffff_ffff_ffff))
 	)
@@ -80,14 +80,22 @@ Conditionally manipulating a stack operand without using a local.
 
 An iterative factorial function whose loop doesn't use locals, but uses arguments like phis.
 ```wasm
+(func $pick0 (param i64) (result i64 i64)
+	(local.get 0) (local.get 0)
+)
+
+(func $pick1 (param i64 i64) (result i64 i64 i64)
+	(local.get 0) (local.get 1) (local.get 0)
+)
+
 (func $fac (param i64) (result i64)
-	(i64.const 1) (get_local 0)
+	(i64.const 1) (local.get 0)
 	(loop $l (param i64 i64) (result i64)
-		(pick 1) (pick 1) (i64.mul)
-		(pick 1) (i64.const 1) (i64.sub)
-		(pick 0) (i64.const 0) (i64.gt_u)
+		(call $pick1) (call $pick1) (i64.mul)
+		(call $pick1) (i64.const 1) (i64.sub)
+		(call $pick0) (i64.const 0) (i64.gt_u)
 		(br_if $l)
-		(pick 1) (return)
+		(call $pick1) (return)
 	)
 )
 ```

From 101a69e717e54895b7972eda0e573c6a26f1cbd2 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Thu, 14 Apr 2022 13:00:02 +0200
Subject: [PATCH 099/285] Clarification in proposals README

---
 proposals/README.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/proposals/README.md b/proposals/README.md
index 170c15123..b2aa25965 100644
--- a/proposals/README.md
+++ b/proposals/README.md
@@ -2,3 +2,6 @@
 
 This directory contains overviews for post-MVP proposals that have been finished and merged into the spec.
 Proposals that are not yet finished can be found at https://github.com/WebAssembly/proposals.
+
+**Note:** The design documents in this folder are archived here for historical purposes and are no longer actively maintained.
+Consequently, they may be outdated, contain unfixed errors, or provide insufficient context.

From 4ea0e9a95e8cc256bbdc2f8d5fcb8139defefc8f Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Fri, 15 Apr 2022 10:45:12 +0200
Subject: [PATCH 100/285] [interpreter] Tweak start section AST to match spec

---
 interpreter/binary/decode.ml |  6 +++++-
 interpreter/binary/encode.ml |  6 +++++-
 interpreter/exec/eval.ml     |  2 +-
 interpreter/syntax/ast.ml    |  8 +++++++-
 interpreter/syntax/free.ml   |  6 +++---
 interpreter/syntax/free.mli  |  2 +-
 interpreter/text/arrange.ml  |  5 +++--
 interpreter/text/parser.mly  |  2 +-
 interpreter/valid/valid.ml   | 11 +++++------
 9 files changed, 31 insertions(+), 17 deletions(-)

diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 7ed4a9235..392f61b21 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -897,8 +897,12 @@ let export_section s =
 
 (* Start section *)
 
+let start s =
+  let sfunc = at var s in
+  {sfunc}
+
 let start_section s =
-  section `StartSection (opt (at var) true) None s
+  section `StartSection (opt (at start) true) None s
 
 
 (* Code section *)
diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index 254b341b2..aafc3d986 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -780,8 +780,12 @@ struct
     section 7 (vec export) exs (exs <> [])
 
   (* Start section *)
+  let start st =
+    let {sfunc} = st.it in
+    var sfunc
+
   let start_section xo =
-    section 8 (opt var) xo (xo <> None)
+    section 8 (opt start) xo (xo <> None)
 
   (* Code section *)
   let compress ts =
diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index fb7beac05..74e7f1a72 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -772,7 +772,7 @@ let run_data i data =
   | Declarative -> assert false
 
 let run_start start =
-  [Call start @@ start.at]
+  [Call start.it.sfunc @@ start.at]
 
 let init (m : module_) (exts : extern list) : module_inst =
   let
diff --git a/interpreter/syntax/ast.ml b/interpreter/syntax/ast.ml
index b5e3ae6ee..502a29687 100644
--- a/interpreter/syntax/ast.ml
+++ b/interpreter/syntax/ast.ml
@@ -289,6 +289,12 @@ and import' =
   idesc : import_desc;
 }
 
+type start = start' Source.phrase
+and start' =
+{
+  sfunc : var;
+}
+
 type module_ = module_' Source.phrase
 and module_' =
 {
@@ -297,7 +303,7 @@ and module_' =
   tables : table list;
   memories : memory list;
   funcs : func list;
-  start : var option;
+  start : start option;
   elems : elem_segment list;
   datas : data_segment list;
   imports : import list;
diff --git a/interpreter/syntax/free.ml b/interpreter/syntax/free.ml
index 78c09baf3..8e1a37a45 100644
--- a/interpreter/syntax/free.ml
+++ b/interpreter/syntax/free.ml
@@ -58,6 +58,7 @@ let shift s = Set.map (Int32.add (-1l)) (Set.remove 0l s)
 
 let (++) = union
 let list free xs = List.fold_left union empty (List.map free xs)
+let opt free xo = Lib.Option.get (Lib.Option.map free xo) empty
 
 let block_type = function
   | VarBlockType x -> types (var x)
@@ -135,8 +136,7 @@ let import_desc (d : import_desc) =
 let export (e : export) = export_desc e.it.edesc
 let import (i : import) = import_desc i.it.idesc
 
-let start (s : var option) =
-  funcs (Lib.Option.get (Lib.Option.map var s) Set.empty)
+let start (s : start) = funcs (var s.it.sfunc)
 
 let module_ (m : module_) =
   list type_ m.it.types ++
@@ -144,7 +144,7 @@ let module_ (m : module_) =
   list table m.it.tables ++
   list memory m.it.memories ++
   list func m.it.funcs ++
-  start m.it.start ++
+  opt start m.it.start ++
   list elem m.it.elems ++
   list data m.it.datas ++
   list import m.it.imports ++
diff --git a/interpreter/syntax/free.mli b/interpreter/syntax/free.mli
index dc01edc02..32f57b96c 100644
--- a/interpreter/syntax/free.mli
+++ b/interpreter/syntax/free.mli
@@ -29,7 +29,7 @@ val elem : Ast.elem_segment -> t
 val data : Ast.data_segment -> t
 val export : Ast.export -> t
 val import : Ast.import -> t
-val start : Ast.var option -> t
+val start : Ast.start -> t
 
 val module_ : Ast.module_ -> t
 
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index cdcd4f84d..dc56743eb 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -526,8 +526,6 @@ let func_with_index off i f =
 let func f =
   func_with_name "" f
 
-let start x = Node ("start " ^ var x, [])
-
 
 (* Tables & memories *)
 
@@ -619,6 +617,9 @@ let global off i g =
   let {gtype; ginit} = g.it in
   Node ("global $" ^ nat (off + i), global_type gtype :: list instr ginit.it)
 
+let start s =
+  Node ("start " ^ var s.it.sfunc, [])
+
 
 (* Modules *)
 
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index e91c3fe86..1eb6be286 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -995,7 +995,7 @@ type_def :
 
 start :
   | LPAR START var RPAR
-    { fun c -> $3 c func }
+    { let at = at () in fun c -> {sfunc = $3 c func} @@ at }
 
 module_fields :
   | /* empty */
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index 780404e50..cfe7f310f 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -667,11 +667,10 @@ let check_global (c : context) (glob : global) =
 
 (* Modules *)
 
-let check_start (c : context) (start : var option) =
-  Lib.Option.app (fun x ->
-    require (func c x = FuncType ([], [])) x.at
-      "start function must not have parameters or results"
-  ) start
+let check_start (c : context) (start : start) =
+  let {sfunc} = start.it in
+  require (func c sfunc = FuncType ([], [])) start.at
+    "start function must not have parameters or results"
 
 let check_import (im : import) (c : context) : context =
   let {module_name = _; item_name = _; idesc} = im.it in
@@ -732,7 +731,7 @@ let check_module (m : module_) =
   List.iter (check_elem c1) elems;
   List.iter (check_data c1) datas;
   List.iter (check_func c) funcs;
-  check_start c start;
+  Lib.Option.app (check_start c) start;
   ignore (List.fold_left (check_export c) NameSet.empty exports);
   require (List.length c.memories <= 1) m.at
     "multiple memories are not allowed (yet)"

From ce4b6c4d47eb06098cc7ab2e81f24748da822f20 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Sat, 16 Apr 2022 02:44:20 +0200
Subject: [PATCH 101/285] [spec] Bump release to 2 (#1443)

At yesterday's WG meeting, we decided to make a new release, now switching to the Evergreen model. For administrative and technical reasons having to do with W3C procedure, we decided to bump the release number to 2.

From now on, the standard will iterate at version 2 from the W3C's official perspective. We use minor release numbers internally to distinguish different iterations.

(@ericprud, I hope I understood correctly that the Bikeshed "level" also needed to be bumped to 2.)
---
 document/core/appendix/changes.rst | 2 +-
 document/core/conf.py              | 6 +++---
 document/core/index.bs             | 6 +++---
 document/js-api/index.bs           | 4 ++--
 document/web-api/index.bs          | 4 ++--
 interpreter/main/main.ml           | 2 +-
 6 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/document/core/appendix/changes.rst b/document/core/appendix/changes.rst
index 66303ba21..339cb25f9 100644
--- a/document/core/appendix/changes.rst
+++ b/document/core/appendix/changes.rst
@@ -7,7 +7,7 @@ Change History
 Since the original release 1.0 of the WebAssembly specification, a number of proposals for extensions have been integrated.
 The following sections provide an overview of what has changed.
 
-Release 1.1
+Release 2.0
 ~~~~~~~~~~~
 
 .. index:: instruction, integer
diff --git a/document/core/conf.py b/document/core/conf.py
index 1cde497d7..8980bae6f 100644
--- a/document/core/conf.py
+++ b/document/core/conf.py
@@ -26,7 +26,7 @@
 
 # If your documentation needs a minimal Sphinx version, state it here.
 #
-needs_sphinx = '1.4'
+needs_sphinx = '2.3'
 
 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
@@ -60,7 +60,7 @@
 name = 'WebAssembly'
 project = u'WebAssembly'
 title = u'WebAssembly Specification'
-copyright = u'2017, WebAssembly Community Group'
+copyright = u'2022, WebAssembly Community Group'
 author = u'WebAssembly Community Group'
 editor = u'Andreas Rossberg (editor)'
 logo = 'static/webassembly.png'
@@ -79,7 +79,7 @@
 # built documents.
 #
 # The short X.Y version.
-version = u'1.1'
+version = u'2.0'
 # The full version, including alpha/beta/rc tags.
 release = version + ('' if proposal == '' else ' + ') + proposal + draft
 
diff --git a/document/core/index.bs b/document/core/index.bs
index b99aac3e1..ff31b91e3 100644
--- a/document/core/index.bs
+++ b/document/core/index.bs
@@ -3,13 +3,13 @@ Title: WebAssembly Core Specification
 Shortname: wasm-core
 Group: wasm
 Status: ED
-Level: 1
-TR: https://www.w3.org/TR/wasm-core-1/
+Level: 2
+TR: https://www.w3.org/TR/wasm-core-2/
 ED: https://webassembly.github.io/spec/core/bikeshed/
 Editor: Andreas Rossberg (Dfinity Stiftung)
 Repository: WebAssembly/spec
 Markup Shorthands: css no, markdown no, algorithm no, idl no
-Abstract: This document describes version 1.1 of the core WebAssembly standard, a safe, portable, low-level code format designed for efficient execution and compact representation.
+Abstract: This document describes version 2.0 of the core WebAssembly standard, a safe, portable, low-level code format designed for efficient execution and compact representation.
 Prepare For TR: true
 </pre>
 
diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 1c6e2ce90..20c2c6e5c 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -3,8 +3,8 @@ Title: WebAssembly JavaScript Interface
 Shortname: wasm-js-api
 Group: wasm
 Status: ED
-Level: 1
-TR: https://www.w3.org/TR/wasm-js-api-1/
+Level: 2
+TR: https://www.w3.org/TR/wasm-js-api-2/
 ED: https://webassembly.github.io/spec/js-api/
 Editor: Ms2ger, Igalia
 Repository: WebAssembly/spec
diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index d5999b5fc..51f92a5a7 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -3,8 +3,8 @@ Title: WebAssembly Web API
 Shortname: wasm-web-api
 Group: wasm
 Status: ED
-Level: 1
-TR: https://www.w3.org/TR/wasm-web-api-1/
+Level: 2
+TR: https://www.w3.org/TR/wasm-web-api-2/
 ED: https://webassembly.github.io/spec/web-api/
 Editor: Ms2ger, Igalia
 Repository: WebAssembly/spec
diff --git a/interpreter/main/main.ml b/interpreter/main/main.ml
index 91b91018f..898bdef1d 100644
--- a/interpreter/main/main.ml
+++ b/interpreter/main/main.ml
@@ -1,5 +1,5 @@
 let name = "wasm"
-let version = "1.1"
+let version = "2.0"
 
 let configure () =
   Import.register (Utf8.decode "spectest") Spectest.lookup;

From 91767c8640fe49ec6f6ea6c7b504029c65b8f3ca Mon Sep 17 00:00:00 2001
From: "Ben L. Titzer" <ben.titzer@gmail.com>
Date: Mon, 18 Apr 2022 14:03:05 -0400
Subject: [PATCH 102/285] Remove test cases with let

---
 test/core/func.wast |   9 --
 test/core/let.wast  | 302 --------------------------------------------
 2 files changed, 311 deletions(-)
 delete mode 100644 test/core/let.wast

diff --git a/test/core/func.wast b/test/core/func.wast
index a5e0ec757..46a013831 100644
--- a/test/core/func.wast
+++ b/test/core/func.wast
@@ -639,15 +639,6 @@
   )
   "unknown type"
 )
-(assert_invalid
-  (module
-    (type $t (func))
-    (func $f (drop (let (result (ref $t)) (ref.func $g))))
-    (func $g (type 4))
-    (elem declare func $g)
-  )
-  "unknown type"
-)
 
 
 ;; Invalid typing of locals
diff --git a/test/core/let.wast b/test/core/let.wast
deleted file mode 100644
index 451bc5d6f..000000000
--- a/test/core/let.wast
+++ /dev/null
@@ -1,302 +0,0 @@
-(module
-  ;; Auxiliary
-  (type $dummy (func))
-  (elem declare func $dummy)
-  (func $dummy)
-  (func $consume (param i32))
-  (func $produce (result i32) (i32.const 7))
-
-  (func (export "syntax") (param $x1 i32) (param $x2 i64)
-    (local $y1 i64)
-    (local $y2 i32)
-    (local.set $y2 (i32.const 5))
-
-    (let)
-    (let $l)
-    (let (local))
-    (let $l (local))
-
-    (let (result) (local))
-    (let $l (result) (local))
-
-    (let (call $dummy) (call $consume (local.get $x1)))
-    (let $l (call $dummy) (call $consume (local.get $y2)))
-    (let (local) (call $dummy) (call $consume (local.get $y2)))
-    (let $l (local) (call $dummy) (call $consume (local.get $x1)))
-
-    (let (call $dummy) (call $dummy) (br 0))
-    (let $l (call $dummy) (call $dummy) (br $l))
-    (let (local) (call $dummy) (call $dummy) (br 0))
-    (let $l (local) (call $dummy) (call $dummy) (br $l))
-
-    (i32.const 1)
-    (f32.const 2)
-    (let $l (param i32) (result i64) (local f32) (br $l (i64.const 3)))
-    (drop)
-
-    (let (result i32) (call $dummy) (call $produce) (call $dummy))
-    (drop)
-    (let $l (result i32) (call $dummy) (call $produce) (call $dummy))
-    (drop)
-    (let (result i32) (local) (call $dummy) (call $produce) (call $dummy))
-    (drop)
-    (let $l (result i32) (local) (call $dummy) (call $produce) (call $dummy))
-    (drop)
-
-    (i32.const 1)
-    (let (local i32) (call $dummy) (call $consume (local.get 0)))
-    (i32.const 2)
-    (let $l (local i32) (call $dummy) (call $consume (local.get 0)))
-    (i32.const 3)
-    (let (local i32) (call $dummy) (call $consume (local.get 0)))
-    (i32.const 4)
-    (let $l (local i32) (call $dummy) (call $consume (local.get 0)))
-
-    (i32.const 1) (f32.const 2) (i32.const 3) (i64.const 4)
-    (let (local i32 f32) (local) (local $z i32) (local i64)
-      (call $consume (local.get 0))
-      (call $consume (local.get 2))  ;; $z
-      (call $consume (local.get 4))  ;; $x1
-      (call $consume (local.get 7))  ;; $y2
-      (call $consume (local.get $z))
-      (call $consume (local.get $x1))
-      (call $consume (local.get $y2))
-    )
-
-    (f32.const 1) (i32.const 2) (i64.const 3) (i32.const 4)
-    (let (result i32) (local $z1 f32) (local $z2 i32) (local) (local i64 i32)
-      (call $produce)
-      (call $consume (local.get 1))  ;; $z2
-      (call $consume (local.get 3))
-      (call $consume (local.get 4))  ;; $x1
-      (call $consume (local.get 7))  ;; $y2
-      (call $consume (local.get $z2))
-      (call $consume (local.get $x1))
-      (call $consume (local.get $y2))
-    )
-    (drop)
-
-    (ref.func $dummy)
-    (let (local (ref $dummy)))
-  )
-
-  (func $pow (export "pow") (param $x i64) (param $n i32) (result i64)
-    (local $y i64)
-    (local.set $y 
-      (if (result i64) (i32.and (local.get $n) (i32.const 1))
-        (then (local.get $x)) (else (i64.const 1))
-      )
-    )
-    (i64.mul
-      (local.get $y)
-      (if (result i64) (i32.le_u (local.get $n) (i32.const 1))
-        (then (i64.const 1))
-        (else
-          (call $pow
-            (i64.mul (local.get $x) (local.get $x))
-            (i32.shr_u (local.get $n) (i32.const 1))
-          )
-        )
-      )
-    )
-  )
-
-  (func (export "semantics-idx") (param i64 i64) (result i64)
-    (local i64 i64)
-    (local.set 2 (i64.const 5))
-    (local.set 3 (i64.const 7))
-
-    (i64.const 11) (i64.const 13)
-    (let (result i64) (local i64 i64)
-      (i64.const 17) (i64.const 19)
-      (let (result i64) (local i64 i64)
-        (i64.const 0)
-        (i64.add (call $pow (local.get 0) (i32.const 0)))  ;; 17^0 =      1
-        (i64.add (call $pow (local.get 1) (i32.const 1)))  ;; 19^1 =     19
-        (i64.add (call $pow (local.get 2) (i32.const 2)))  ;; 11^2 =    121
-        (i64.add (call $pow (local.get 3) (i32.const 3)))  ;; 13^3 =   2197
-        (i64.add (call $pow (local.get 4) (i32.const 4)))  ;;  2^4 =     16
-        (i64.add (call $pow (local.get 5) (i32.const 5)))  ;;  3^5 =    243
-        (i64.add (call $pow (local.get 6) (i32.const 6)))  ;;  5^6 =  15625
-        (i64.add (call $pow (local.get 7) (i32.const 7)))  ;;  7^7 = 823543
-      )
-    )
-  )
-
-  (func (export "semantics-sym") (param $x1 i64) (param $x2 i64) (result i64)
-    (local $y1 i64)
-    (local $y2 i64)
-    (local.set $y1 (i64.const 5))
-    (local.set $y2 (i64.const 7))
-
-    (i64.const 11) (i64.const 13)
-    (let (result i64) (local $z1 i64) (local $z2 i64)
-      (i64.const 17) (i64.const 19)
-      (let (result i64) (local $u1 i64) (local $u2 i64)
-        (i64.const 0)
-        (i64.add (call $pow (local.get $u1) (i32.const 0)))  ;; 17^0 =      1
-        (i64.add (call $pow (local.get $u2) (i32.const 1)))  ;; 19^1 =     19
-        (i64.add (call $pow (local.get $z1) (i32.const 2)))  ;; 11^2 =    121
-        (i64.add (call $pow (local.get $z2) (i32.const 3)))  ;; 13^3 =   2197
-        (i64.add (call $pow (local.get $x1) (i32.const 4)))  ;;  2^4 =     16
-        (i64.add (call $pow (local.get $x2) (i32.const 5)))  ;;  3^5 =    243
-        (i64.add (call $pow (local.get $y1) (i32.const 6)))  ;;  5^6 =  15625
-        (i64.add (call $pow (local.get $y2) (i32.const 7)))  ;;  7^7 = 823543
-      )
-    )
-  )
-
-  (func (export "mutate") (param $x1 i64) (param $x2 i64) (result i64)
-    (local $y1 i64)
-    (local $y2 i64)
-
-    (i64.const 0) (i64.const 0)
-    (let (result i64) (local $z1 i64) (local $z2 i64)
-      (i64.const 0) (i64.const 0)
-      (let (result i64) (local $u1 i64) (local $u2 i64)
-        (local.set $y1 (i64.const 5))
-        (local.set $y2 (i64.const 7))
-        (local.set $z1 (i64.const 11))
-        (local.set $z2 (i64.const 13))
-        (local.set $u1 (i64.const 17))
-        (local.set $u2 (i64.const 19))
-        (i64.const 0)
-        (i64.add (call $pow (local.get $u1) (i32.const 0)))  ;; 17^0 =      1
-        (i64.add (call $pow (local.get $u2) (i32.const 1)))  ;; 19^1 =     19
-        (i64.add (call $pow (local.get $z1) (i32.const 2)))  ;; 11^2 =    121
-        (i64.add (call $pow (local.get $z2) (i32.const 3)))  ;; 13^3 =   2197
-        (i64.add (call $pow (local.get $x1) (i32.const 4)))  ;;  2^4 =     16
-        (i64.add (call $pow (local.get $x2) (i32.const 5)))  ;;  3^5 =    243
-        (i64.add (call $pow (local.get $y1) (i32.const 6)))  ;;  5^6 =  15625
-        (i64.add (call $pow (local.get $y2) (i32.const 7)))  ;;  7^7 = 823543
-      )
-    )
-  )
-)
-
-(assert_return (invoke "syntax" (i32.const 1) (i64.const 2)))
-
-(assert_return (invoke "pow" (i64.const 17) (i32.const 0)) (i64.const 1))
-(assert_return (invoke "pow" (i64.const 19) (i32.const 1)) (i64.const 19))
-(assert_return (invoke "pow" (i64.const 11) (i32.const 2)) (i64.const 121))
-(assert_return (invoke "pow" (i64.const 13) (i32.const 3)) (i64.const 2197))
-(assert_return (invoke "pow" (i64.const 2) (i32.const 4)) (i64.const 16))
-(assert_return (invoke "pow" (i64.const 3) (i32.const 5)) (i64.const 243))
-(assert_return (invoke "pow" (i64.const 5) (i32.const 6)) (i64.const 15625))
-(assert_return (invoke "pow" (i64.const 7) (i32.const 7)) (i64.const 823543))
-
-(assert_return (invoke "semantics-idx" (i64.const 2) (i64.const 3)) (i64.const 841_765))
-(assert_return (invoke "semantics-sym" (i64.const 2) (i64.const 3)) (i64.const 841_765))
-(assert_return (invoke "mutate" (i64.const 2) (i64.const 3)) (i64.const 841_765))
-
-
-;; Shadowing.
-
-;; Shadowing is fine across nested let blocks (analogous to labels).
-(module
-  (func (export "f1") (param $x i32) (result i32)
-    (i32.const 1)
-    (let (local $x i32) (return (local.get $x)))
-    (unreachable)
-  )
-  (func (export "f2") (result i32)
-    (local $x i32)
-    (i32.const 1)
-    (let (local $x i32) (return (local.get $x)))
-    (unreachable)
-  )
-  (func (export "f3") (result i32)
-    (i32.const 0)
-    (let (local $x i32)
-      (i32.const 1)
-      (let (local $x i32) (return (local.get $x)))
-    )
-    (unreachable)
-  )
-  (func (export "f4") (result i32)
-    (local $x i32)
-    (i32.const 1)
-    (let (local $x i32)
-      (i32.const 2)
-      (let (local $x i32) (return (local.get $x)))
-    )
-    (unreachable)
-  )
-)
-
-(assert_return (invoke "f1" (i32.const 0)) (i32.const 1))
-(assert_return (invoke "f2") (i32.const 1))
-(assert_return (invoke "f3") (i32.const 1))
-(assert_return (invoke "f4") (i32.const 2))
-
-;; Duplicate labels within a single let block are still disallowed.
-(assert_malformed
-  (module quote "(func (let (local $x i32) (local $x i64)))")
-  "duplicate local"
-)
-
-
-;; Syntax
-
-(assert_malformed
-  (module quote "(func (let (local) (param)))")
-  "unexpected token"
-)
-(assert_malformed
-  (module quote
-    "(func"
-    "  (i32.const 0) (i32.const 0)"
-    "  (let (local i32) (param i32) (drop))"
-    ")"
-  )
-  "unexpected token"
-)
-
-(assert_malformed
-  (module quote "(func (let (local) (result)))")
-  "unexpected token"
-)
-(assert_malformed
-  (module quote
-    "(func (result i32)"
-    "  (i32.const 0)"
-    "  (let (local i32) (result i32) (local.get 0))"
-    ")"
-  )
-  "unexpected token"
-)
-(assert_malformed
-  (module quote
-    "(func (result i32)"
-    "  (let (local $x i32) (result i32) (local.get 0))"
-    ")"
-  )
-  "unexpected token"
-)
-
-(assert_malformed
-  (module quote "(func (let (result) (param)))")
-  "unexpected token"
-)
-(assert_malformed
-  (module quote
-    "(func (result i32)"
-    "  (i32.const 0)"
-    "  (let (result i32) (param i32))"
-    ")"
-  )
-  "unexpected token"
-)
-
-(assert_malformed
-  (module quote "(func (let (param) $l))")
-  "unexpected token"
-)
-(assert_malformed
-  (module quote "(func (let (result) $l))")
-  "unexpected token"
-)
-(assert_malformed
-  (module quote "(func (let (local) $l))")
-  "unexpected token"
-)

From 581daf6c30d4b261cad3665f4511bffc569f05cf Mon Sep 17 00:00:00 2001
From: gahaas <ahaas@google.com>
Date: Mon, 25 Apr 2022 12:06:17 +0200
Subject: [PATCH 103/285] Sync wpt test (#1449)

---
 test/js-api/constructor/toStringTag.any.js | 2 +-
 test/js-api/interface.any.js               | 2 +-
 test/js-api/table/constructor.any.js       | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/js-api/constructor/toStringTag.any.js b/test/js-api/constructor/toStringTag.any.js
index 9c0d346bc..c6d2cdaf6 100644
--- a/test/js-api/constructor/toStringTag.any.js
+++ b/test/js-api/constructor/toStringTag.any.js
@@ -1,7 +1,7 @@
 // META: global=window,dedicatedworker,jsshell
 
 "use strict";
-// https://heycam.github.io/webidl/#es-namespaces
+// https://webidl.spec.whatwg.org/#es-namespaces
 // https://webassembly.github.io/spec/js-api/#namespacedef-webassembly
 
 test(() => {
diff --git a/test/js-api/interface.any.js b/test/js-api/interface.any.js
index 4551e6e6e..19d29ead0 100644
--- a/test/js-api/interface.any.js
+++ b/test/js-api/interface.any.js
@@ -143,7 +143,7 @@ test_attributes(WebAssembly.Memory.prototype, "WebAssembly.Memory", [
 test_operations(WebAssembly.Table.prototype, "WebAssembly.Table", [
   ["grow", 1],
   ["get", 1],
-  ["set", 2],
+  ["set", 1],
 ]);
 
 test_attributes(WebAssembly.Table.prototype, "WebAssembly.Table", [
diff --git a/test/js-api/table/constructor.any.js b/test/js-api/table/constructor.any.js
index cf501fbc2..6d38d04e4 100644
--- a/test/js-api/table/constructor.any.js
+++ b/test/js-api/table/constructor.any.js
@@ -89,7 +89,7 @@ test(() => {
 
 test(() => {
   const argument = { "element": "anyfunc", "initial": 0 };
-  const table = new WebAssembly.Table(argument, {});
+  const table = new WebAssembly.Table(argument, null, {});
   assert_Table(table, { "length": 0 });
 }, "Stray argument");
 

From 4a74af44ecfa5630fcaa6b31ad99b4e46d3b1735 Mon Sep 17 00:00:00 2001
From: r00ster <r00ster91@protonmail.com>
Date: Tue, 26 Apr 2022 10:37:18 +0200
Subject: [PATCH 104/285] [spec] Fix typo (#1448)

---
 document/core/appendix/custom.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/appendix/custom.rst b/document/core/appendix/custom.rst
index bea81d61c..c12ebf183 100644
--- a/document/core/appendix/custom.rst
+++ b/document/core/appendix/custom.rst
@@ -36,7 +36,7 @@ Each subsection consists of a
 
 * a one-byte subsection *id*,
 * the |U32| *size* of the contents, in bytes,
-* the actual *contents*, whose structure is depended on the subsection id.
+* the actual *contents*, whose structure is dependent on the subsection id.
 
 .. math::
    \begin{array}{llcll}

From bdcf1c1d83d0891a3d852cdd3a01ed34b9060351 Mon Sep 17 00:00:00 2001
From: Crypt Keeper <64215+codefromthecrypt@users.noreply.github.com>
Date: Wed, 27 Apr 2022 18:15:43 +0800
Subject: [PATCH 105/285] [proposals] Add missing start to example (#1454)

---
 proposals/bulk-memory-operations/Overview.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/proposals/bulk-memory-operations/Overview.md b/proposals/bulk-memory-operations/Overview.md
index 8f9bc6c18..0dfc53264 100644
--- a/proposals/bulk-memory-operations/Overview.md
+++ b/proposals/bulk-memory-operations/Overview.md
@@ -386,6 +386,7 @@ implemented as follows:
     ;; be dropped.
     (data.drop 1))
 )
+(start $start)
 ```
 
 ### Instruction encoding

From 2eb7e6491010261beb52cd3c6647e9a5d26b00da Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Mon, 2 May 2022 10:54:32 +0200
Subject: [PATCH 106/285] [spec] "version 2.0" -> "release 2.0" (#1452)

---
 document/core/index.bs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/index.bs b/document/core/index.bs
index ff31b91e3..d27a96999 100644
--- a/document/core/index.bs
+++ b/document/core/index.bs
@@ -9,7 +9,7 @@ ED: https://webassembly.github.io/spec/core/bikeshed/
 Editor: Andreas Rossberg (Dfinity Stiftung)
 Repository: WebAssembly/spec
 Markup Shorthands: css no, markdown no, algorithm no, idl no
-Abstract: This document describes version 2.0 of the core WebAssembly standard, a safe, portable, low-level code format designed for efficient execution and compact representation.
+Abstract: This document describes release 2.0 of the core WebAssembly standard, a safe, portable, low-level code format designed for efficient execution and compact representation.
 Prepare For TR: true
 </pre>
 

From c4699b1a71e18744453bbf7161b2601a24aec08f Mon Sep 17 00:00:00 2001
From: Timothy McCallum <tpmccallum@users.noreply.github.com>
Date: Mon, 2 May 2022 19:08:28 +1000
Subject: [PATCH 107/285] [spec] Fix typo (#1458)

---
 document/core/exec/runtime.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index 482eea0ad..5bd6de257 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -18,7 +18,7 @@ Runtime Structure
 Values
 ~~~~~~
 
-WebAssembly computations manipulate *values* of either the four basic :ref:`number types <syntax-numtype>`, i.e., :ref:`integers <syntax-int>` and :ref:`floating-point data <syntax-float>` of 32 or 64 bit width each, of :ref:`vectors <syntax-vecnum>` of 128 bit width, or of :ref:`reference type <syntax-reftype>`.
+WebAssembly computations manipulate *values* of either the four basic :ref:`number types <syntax-numtype>`, i.e., :ref:`integers <syntax-int>` and :ref:`floating-point data <syntax-float>` of 32 or 64 bit width each, or :ref:`vectors <syntax-vecnum>` of 128 bit width, or of :ref:`reference type <syntax-reftype>`.
 
 In most places of the semantics, values of different types can occur.
 In order to avoid ambiguities, values are therefore represented with an abstract syntax that makes their type explicit.

From 4bc7d317d3bec0c03482491a78c55851354f5c29 Mon Sep 17 00:00:00 2001
From: "Ben L. Titzer" <ben.titzer@gmail.com>
Date: Wed, 4 May 2022 01:47:33 -0400
Subject: [PATCH 108/285] [test] Add assert_trap for unreached valid case
 (#1460)

---
 test/core/unreached-valid.wast | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/core/unreached-valid.wast b/test/core/unreached-valid.wast
index 00252171a..b7ebabfdb 100644
--- a/test/core/unreached-valid.wast
+++ b/test/core/unreached-valid.wast
@@ -60,3 +60,4 @@
   )
 )
 
+(assert_trap (invoke "meet-bottom") "unreachable")

From 082ae4d45b240b83eef1b80c3b4896a94e2f4c71 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Wed, 4 May 2022 09:18:58 +0200
Subject: [PATCH 109/285] [interpreter] Name the type Utf8.unicode

---
 interpreter/binary/utf8.ml  | 3 +++
 interpreter/binary/utf8.mli | 7 +++++--
 interpreter/syntax/ast.ml   | 2 +-
 3 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/interpreter/binary/utf8.ml b/interpreter/binary/utf8.ml
index 5cf17997e..b92295488 100644
--- a/interpreter/binary/utf8.ml
+++ b/interpreter/binary/utf8.ml
@@ -1,3 +1,6 @@
+type codepoint = int
+type unicode = codepoint list
+
 exception Utf8
 
 let con n = 0x80 lor (n land 0x3f)
diff --git a/interpreter/binary/utf8.mli b/interpreter/binary/utf8.mli
index 3b5994a34..73a95f487 100644
--- a/interpreter/binary/utf8.mli
+++ b/interpreter/binary/utf8.mli
@@ -1,4 +1,7 @@
+type codepoint = int
+type unicode = codepoint list
+
 exception Utf8
 
-val decode : string -> int list (* raises Utf8 *)
-val encode : int list -> string (* raises Utf8 *)
+val decode : string -> unicode (* raises Utf8 *)
+val encode : unicode -> string (* raises Utf8 *)
diff --git a/interpreter/syntax/ast.ml b/interpreter/syntax/ast.ml
index 502a29687..a6eb0d9cc 100644
--- a/interpreter/syntax/ast.ml
+++ b/interpreter/syntax/ast.ml
@@ -130,7 +130,7 @@ type vec_laneop = (vec_type, pack_size) memop * int
 type var = int32 Source.phrase
 type num = Values.num Source.phrase
 type vec = Values.vec Source.phrase
-type name = int list
+type name = Utf8.unicode
 
 type block_type = VarBlockType of var | ValBlockType of value_type option
 

From 1ffb924e94856e89f787fc2000fa4c5dc069a24f Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Thu, 5 May 2022 10:13:04 +0200
Subject: [PATCH 110/285] [spec] Fix binary format of data/elem tags to allow
 LEB (#1461)

---
 document/core/binary/modules.rst | 26 ++++++++--------
 test/core/binary.wast            | 53 +++++++++++++++++++++++++++++---
 2 files changed, 62 insertions(+), 17 deletions(-)

diff --git a/document/core/binary/modules.rst b/document/core/binary/modules.rst
index 9e91f6243..818c19e76 100644
--- a/document/core/binary/modules.rst
+++ b/document/core/binary/modules.rst
@@ -327,28 +327,28 @@ It decodes into a vector of :ref:`element segments <syntax-elem>` that represent
    \production{element section} & \Belemsec &::=&
      \X{seg}^\ast{:}\Bsection_9(\Bvec(\Belem)) &\Rightarrow& \X{seg} \\
    \production{element segment} & \Belem &::=&
-     \hex{00}~~e{:}\Bexpr~~y^\ast{:}\Bvec(\Bfuncidx)
+     0{:}\Bu32~~e{:}\Bexpr~~y^\ast{:}\Bvec(\Bfuncidx)
        &\Rightarrow& \\&&&\quad
        \{ \ETYPE~\FUNCREF, \EINIT~((\REFFUNC~y)~\END)^\ast, \EMODE~\EACTIVE~\{ \ETABLE~0, \EOFFSET~e \} \} \\ &&|&
-     \hex{01}~~\X{et}:\Belemkind~~y^\ast{:}\Bvec(\Bfuncidx)
+     1{:}\Bu32~~\X{et}:\Belemkind~~y^\ast{:}\Bvec(\Bfuncidx)
        &\Rightarrow& \\&&&\quad
        \{ \ETYPE~\X{et}, \EINIT~((\REFFUNC~y)~\END)^\ast, \EMODE~\EPASSIVE \} \\ &&|&
-     \hex{02}~~x{:}\Btableidx~~e{:}\Bexpr~~\X{et}:\Belemkind~~y^\ast{:}\Bvec(\Bfuncidx)
+     2{:}\Bu32~~x{:}\Btableidx~~e{:}\Bexpr~~\X{et}:\Belemkind~~y^\ast{:}\Bvec(\Bfuncidx)
        &\Rightarrow& \\&&&\quad
        \{ \ETYPE~\X{et}, \EINIT~((\REFFUNC~y)~\END)^\ast, \EMODE~\EACTIVE~\{ \ETABLE~x, \EOFFSET~e \} \} \\ &&|&
-     \hex{03}~~\X{et}:\Belemkind~~y^\ast{:}\Bvec(\Bfuncidx)
+     3{:}\Bu32~~\X{et}:\Belemkind~~y^\ast{:}\Bvec(\Bfuncidx)
        &\Rightarrow& \\&&&\quad
        \{ \ETYPE~\X{et}, \EINIT~((\REFFUNC~y)~\END)^\ast, \EMODE~\EDECLARATIVE \} \\ &&|&
-     \hex{04}~~e{:}\Bexpr~~\X{el}^\ast{:}\Bvec(\Bexpr)
+     4{:}\Bu32~~e{:}\Bexpr~~\X{el}^\ast{:}\Bvec(\Bexpr)
        &\Rightarrow& \\&&&\quad
        \{ \ETYPE~\FUNCREF, \EINIT~\X{el}^\ast, \EMODE~\EACTIVE~\{ \ETABLE~0, \EOFFSET~e \} \} \\ &&|&
-     \hex{05}~~\X{et}:\Breftype~~\X{el}^\ast{:}\Bvec(\Bexpr)
+     5{:}\Bu32~~\X{et}:\Breftype~~\X{el}^\ast{:}\Bvec(\Bexpr)
        &\Rightarrow& \\&&&\quad
        \{ \ETYPE~et, \EINIT~\X{el}^\ast, \EMODE~\EPASSIVE \} \\ &&|&
-     \hex{06}~~x{:}\Btableidx~~e{:}\Bexpr~~\X{et}:\Breftype~~\X{el}^\ast{:}\Bvec(\Bexpr)
+     6{:}\Bu32~~x{:}\Btableidx~~e{:}\Bexpr~~\X{et}:\Breftype~~\X{el}^\ast{:}\Bvec(\Bexpr)
        &\Rightarrow& \\&&&\quad
        \{ \ETYPE~et, \EINIT~\X{el}^\ast, \EMODE~\EACTIVE~\{ \ETABLE~x, \EOFFSET~e \} \} \\ &&|&
-     \hex{07}~~\X{et}:\Breftype~~\X{el}^\ast{:}\Bvec(\Bexpr)
+     7{:}\Bu32~~\X{et}:\Breftype~~\X{el}^\ast{:}\Bvec(\Bexpr)
        &\Rightarrow& \\&&&\quad
        \{ \ETYPE~et, \EINIT~\X{el}^\ast, \EMODE~\EDECLARATIVE \} \\
    \production{element kind} & \Belemkind &::=&
@@ -356,7 +356,7 @@ It decodes into a vector of :ref:`element segments <syntax-elem>` that represent
    \end{array}
 
 .. note::
-   The initial byte can be interpreted as a bitfield.
+   The initial integer can be interpreted as a bitfield.
    Bit 0 indicates a passive or declarative segment,
    bit 1 indicates the presence of an explicit table index for an active segment and otherwise distinguishes passive from declarative segments,
    bit 2 indicates the use of element type and element :ref:`expressions <binary-expr>` instead of element kind and element indices.
@@ -440,16 +440,16 @@ It decodes into a vector of :ref:`data segments <syntax-data>` that represent th
    \production{data section} & \Bdatasec &::=&
      \X{seg}^\ast{:}\Bsection_{11}(\Bvec(\Bdata)) &\Rightarrow& \X{seg} \\
    \production{data segment} & \Bdata &::=&
-     \hex{00}~~e{:}\Bexpr~~b^\ast{:}\Bvec(\Bbyte)
+     0{:}\Bu32~~e{:}\Bexpr~~b^\ast{:}\Bvec(\Bbyte)
        &\Rightarrow& \{ \DINIT~b^\ast, \DMODE~\DACTIVE~\{ \DMEM~0, \DOFFSET~e \} \} \\ &&|&
-     \hex{01}~~b^\ast{:}\Bvec(\Bbyte)
+     1{:}\Bu32~~b^\ast{:}\Bvec(\Bbyte)
        &\Rightarrow& \{ \DINIT~b^\ast, \DMODE~\DPASSIVE \} \\ &&|&
-     \hex{02}~~x{:}\Bmemidx~~e{:}\Bexpr~~b^\ast{:}\Bvec(\Bbyte)
+     2{:}\Bu32~~x{:}\Bmemidx~~e{:}\Bexpr~~b^\ast{:}\Bvec(\Bbyte)
        &\Rightarrow& \{ \DINIT~b^\ast, \DMODE~\DACTIVE~\{ \DMEM~x, \DOFFSET~e \} \} \\
    \end{array}
 
 .. note::
-   The initial byte can be interpreted as a bitfield.
+   The initial integer can be interpreted as a bitfield.
    Bit 0 indicates a passive segment,
    bit 1 indicates the presence of an explicit memory index for an active segment.
 
diff --git a/test/core/binary.wast b/test/core/binary.wast
index 31bb24a93..891aad367 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -140,23 +140,68 @@
   "\41\00\0b\00"                       ;; (i32.const 0) with no elements
 )
 
-;; Data segment memory index can have non-minimal length
+;; Data segment tags and memory index can have non-minimal length
 (module binary
   "\00asm" "\01\00\00\00"
   "\05\03\01"                          ;; Memory section with 1 entry
   "\00\00"                             ;; no max, minimum 0
   "\0b\07\01"                          ;; Data section with 1 entry
-  "\80\00"                             ;; Memory index 0, encoded with 2 bytes
+  "\80\00"                             ;; Active segment, encoded with 2 bytes
+  "\41\00\0b\00"                       ;; (i32.const 0) with contents ""
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\03\01"                          ;; Memory section with 1 entry
+  "\00\00"                             ;; no max, minimum 0
+  "\0b\08\01"                          ;; Data section with 1 entry
+  "\82\00"                             ;; Active segment, encoded with 2 bytes
+  "\00"                                ;; explicit memory index
+  "\41\00\0b\00"                       ;; (i32.const 0) with contents ""
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\03\01"                          ;; Memory section with 1 entry
+  "\00\00"                             ;; no max, minimum 0
+  "\0b\09\01"                          ;; Data section with 1 entry
+  "\82\00"                             ;; Active segment, encoded with 2 bytes
+  "\80\00"                             ;; explicit memory index, encoded with 2 bytes
   "\41\00\0b\00"                       ;; (i32.const 0) with contents ""
 )
 
-;; Element segment table index can have non-minimal length
+;; Element segment tags and table index can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\04\04\01"                          ;; Table section with 1 entry
+  "\70\00\00"                          ;; no max, minimum 0, funcref
+  "\09\07\01"                          ;; Element section with 1 entry
+  "\80\00"                             ;; Active segment
+  "\41\00\0b\00"                       ;; (i32.const 0) with no elements
+)
 (module binary
   "\00asm" "\01\00\00\00"
   "\04\04\01"                          ;; Table section with 1 entry
   "\70\00\00"                          ;; no max, minimum 0, funcref
   "\09\09\01"                          ;; Element section with 1 entry
-  "\02\80\00"                          ;; Table index 0, encoded with 2 bytes
+  "\02"                                ;; Active segment
+  "\80\00"                             ;; explicit table index, encoded with 2 bytes
+  "\41\00\0b\00\00"                    ;; (i32.const 0) with no elements
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\04\04\01"                          ;; Table section with 1 entry
+  "\70\00\00"                          ;; no max, minimum 0, funcref
+  "\09\09\01"                          ;; Element section with 1 entry
+  "\82\00"                             ;; Active segment, encoded with 2 bytes
+  "\00"                                ;; explicit table index
+  "\41\00\0b\00\00"                    ;; (i32.const 0) with no elements
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\04\04\01"                          ;; Table section with 1 entry
+  "\70\00\00"                          ;; no max, minimum 0, funcref
+  "\09\0a\01"                          ;; Element section with 1 entry
+  "\82\00"                             ;; Active segment, encoded with 2 bytes
+  "\80\00"                             ;; explicit table index, encoded with 2 bytes
   "\41\00\0b\00\00"                    ;; (i32.const 0) with no elements
 )
 

From 50fdeb55b4346b26ca1ad4bb64ee1d28627cf564 Mon Sep 17 00:00:00 2001
From: Julien Cretin <github@ia0.eu>
Date: Fri, 6 May 2022 12:14:06 +0200
Subject: [PATCH 111/285] [spec] Fix typos in numeric operations (#1467)

---
 document/core/exec/instructions.rst |  2 +-
 document/core/exec/numerics.rst     | 14 +++++++-------
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 84dbf86db..6ab846d28 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -108,7 +108,7 @@ Where the underlying operators are non-deterministic, because they may return on
    (t\K{.}\CONST~c_1)~(t\K{.}\CONST~c_2)~t\K{.}\binop &\stepto& (t\K{.}\CONST~c)
      & (\iff c \in \binop_t(c_1,c_2)) \\
    (t\K{.}\CONST~c_1)~(t\K{.}\CONST~c_2)~t\K{.}\binop &\stepto& \TRAP
-     & (\iff \binop_{t}(c_1,c2) = \{\})
+     & (\iff \binop_{t}(c_1,c_2) = \{\})
    \end{array}
 
 
diff --git a/document/core/exec/numerics.rst b/document/core/exec/numerics.rst
index b60416874..301984447 100644
--- a/document/core/exec/numerics.rst
+++ b/document/core/exec/numerics.rst
@@ -406,7 +406,7 @@ The integer result of predicates -- i.e., :ref:`tests <syntax-testop>` and :ref:
 
 .. math::
    \begin{array}{@{}lcll}
-   \iandnot_N(i_1, i_2) &=& \iand_N(i_1, \inot_N(i2))
+   \iandnot_N(i_1, i_2) &=& \iand_N(i_1, \inot_N(i_2))
    \end{array}
 
 .. _op-ior:
@@ -793,8 +793,8 @@ The integer result of predicates -- i.e., :ref:`tests <syntax-testop>` and :ref:
 
 .. math::
    \begin{array}{@{}lcll}
-   \iminu_N(i_1, i_2) &=& i_1 & (\iff \ilts_N(i_1, i_2) = 1)\\
-   \iminu_N(i_1, i_2) &=& i_2 & (\otherwise)
+   \imins_N(i_1, i_2) &=& i_1 & (\iff \ilts_N(i_1, i_2) = 1)\\
+   \imins_N(i_1, i_2) &=& i_2 & (\otherwise)
    \end{array}
 
 
@@ -807,8 +807,8 @@ The integer result of predicates -- i.e., :ref:`tests <syntax-testop>` and :ref:
 
 .. math::
    \begin{array}{@{}lcll}
-   \iminu_N(i_1, i_2) &=& i_1 & (\iff \igtu_N(i_1, i_2) = 1)\\
-   \iminu_N(i_1, i_2) &=& i_2 & (\otherwise)
+   \imaxu_N(i_1, i_2) &=& i_1 & (\iff \igtu_N(i_1, i_2) = 1)\\
+   \imaxu_N(i_1, i_2) &=& i_2 & (\otherwise)
    \end{array}
 
 
@@ -821,8 +821,8 @@ The integer result of predicates -- i.e., :ref:`tests <syntax-testop>` and :ref:
 
 .. math::
    \begin{array}{@{}lcll}
-   \iminu_N(i_1, i_2) &=& i_1 & (\iff \igts_N(i_1, i_2) = 1)\\
-   \iminu_N(i_1, i_2) &=& i_2 & (\otherwise)
+   \imaxs_N(i_1, i_2) &=& i_1 & (\iff \igts_N(i_1, i_2) = 1)\\
+   \imaxs_N(i_1, i_2) &=& i_2 & (\otherwise)
    \end{array}
 
 

From 49105a7347a96deac21f912fd610cef00ef42946 Mon Sep 17 00:00:00 2001
From: Julien Cretin <cretin@google.com>
Date: Fri, 6 May 2022 12:33:17 +0200
Subject: [PATCH 112/285] [spec] Fix syntax error in element segments
 validation rule (#1465)

---
 document/core/valid/modules.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index 949c977e5..ed17d795c 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -149,7 +149,7 @@ Element segments :math:`\elem` are classified by the :ref:`reference type <synta
 
 * For each :math:`e_i` in :math:`e^\ast`,
 
-  * The expression :math:`e_i` must be :ref:`valid <valid-expr>`.
+  * The expression :math:`e_i` must be :ref:`valid <valid-expr>` with some :ref:`result type <syntax-resulttype>` :math:`[t]`.
 
   * The expression :math:`e_i` must be :ref:`constant <valid-const>`.
 
@@ -160,7 +160,7 @@ Element segments :math:`\elem` are classified by the :ref:`reference type <synta
 
 .. math::
    \frac{
-     (C \vdashexpr e \ok)^\ast
+     (C \vdashexpr e : [t])^\ast
      \qquad
      (C \vdashexprconst e \const)^\ast
      \qquad

From 5e49f4b271629eca04f9044ce912c50a68fd5444 Mon Sep 17 00:00:00 2001
From: Julien Cretin <cretin@google.com>
Date: Fri, 6 May 2022 13:07:11 +0200
Subject: [PATCH 113/285] [spec] Fix typo in global instance syntax (#1466)

---
 document/core/exec/runtime.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index 5bd6de257..5faaab458 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -320,7 +320,7 @@ It records its :ref:`type <syntax-globaltype>` and holds an individual :ref:`val
 .. math::
    \begin{array}{llll}
    \production{(global instance)} & \globalinst &::=&
-     \{ \GITYPE~\valtype, \GIVALUE~\val \} \\
+     \{ \GITYPE~\globaltype, \GIVALUE~\val \} \\
    \end{array}
 
 The value of mutable globals can be mutated through :ref:`variable instructions <syntax-instr-variable>` or by external means provided by the :ref:`embedder <embedder>`.

From 0d42c114c9bca70621190f81dbedd6f4d7dd1665 Mon Sep 17 00:00:00 2001
From: Julien Cretin <cretin@google.com>
Date: Fri, 6 May 2022 13:13:42 +0200
Subject: [PATCH 114/285] [spec] Fix typos in module instantiation (#1468)

---
 document/core/exec/modules.rst | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index a6ed62be7..eb2faa05f 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -713,8 +713,8 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
      &\wedge& \module.\MELEMS = \elem^n \\
      &\wedge& \module.\MDATAS = \data^m \\
      &\wedge& \module.\MSTART = \start^? \\
-     &\wedge& (\expr_{\F{g}} = \global.GINIT)^\ast \\
-     &\wedge& (\expr_{\F{e}}^\ast = \elem.EINIT)^n \\[1ex]
+     &\wedge& (\expr_{\F{g}} = \global.\GINIT)^\ast \\
+     &\wedge& (\expr_{\F{e}}^\ast = \elem.\EINIT)^n \\[1ex]
      &\wedge& S', \moduleinst = \allocmodule(S, \module, \externval^k, \val^\ast, (\reff^\ast)^n) \\
      &\wedge& F = \{ \AMODULE~\moduleinst, \ALOCALS~\epsilon \} \\[1ex]
      &\wedge& (S'; F; \expr_{\F{g}} \stepto^\ast S'; F; \val~\END)^\ast \\
@@ -733,15 +733,15 @@ where:
      \instr^\ast~(\I32.\CONST~0)~(\I32.\CONST~n)~(\TABLEINIT~i)~(\ELEMDROP~i) \\
    \F{runelem}_i(\{\ETYPE~\X{et}, \EINIT~\reff^n, \EMODE~\EDECLARATIVE\}) \quad=\\ \qquad
      (\ELEMDROP~i) \\[1ex]
-   \F{rundata}_i(\{\DINIT~b^n, DMODE~\DPASSIVE\}) \quad=\quad \epsilon \\
-   \F{rundata}_i(\{\DINIT~b^n, DMODE~\DACTIVE \{\DMEM~0, \DOFFSET~\instr^\ast~\END\}\}) \quad=\\ \qquad
+   \F{rundata}_i(\{\DINIT~b^n, \DMODE~\DPASSIVE\}) \quad=\quad \epsilon \\
+   \F{rundata}_i(\{\DINIT~b^n, \DMODE~\DACTIVE \{\DMEM~0, \DOFFSET~\instr^\ast~\END\}\}) \quad=\\ \qquad
      \instr^\ast~(\I32.\CONST~0)~(\I32.\CONST~n)~(\MEMORYINIT~i)~(\DATADROP~i) \\
    \end{array}
 
 .. note::
    Module :ref:`allocation <alloc-module>` and the :ref:`evaluation <exec-expr>` of :ref:`global <syntax-global>` initializers and :ref:`element segments <syntax-elem>` are mutually recursive because the global initialization :ref:`values <syntax-val>` :math:`\val^\ast` and element segment contents :math:`(\reff^\ast)^\ast` are passed to the module allocator while depending on the module instance :math:`\moduleinst` and store :math:`S'` returned by allocation.
    However, this recursion is just a specification device.
-   In practice, the initialization values can :ref:`be determined <exec-initvals>` beforehand by staging module allocation such that first, the module's own :math:`function instances <syntax-funcinst>` are pre-allocated in the store, then the initializer expressions are evaluated, then the rest of the module instance is allocated, and finally the new function instances' :math:`\AMODULE` fields are set to that module instance.
+   In practice, the initialization values can :ref:`be determined <exec-initvals>` beforehand by staging module allocation such that first, the module's own :ref:`function instances <syntax-funcinst>` are pre-allocated in the store, then the initializer expressions are evaluated, then the rest of the module instance is allocated, and finally the new function instances' :math:`\AMODULE` fields are set to that module instance.
    This is possible because :ref:`validation <valid-module>` ensures that initialization expressions cannot actually call a function, only take their reference.
 
    All failure conditions are checked before any observable mutation of the store takes place.

From 6c2b582c6415370b310625eba114e08578a8c93f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ole=20Kr=C3=BCger?= <ole@vprsm.de>
Date: Fri, 6 May 2022 13:28:09 +0200
Subject: [PATCH 115/285] [interpreter] Turn into a Dune package (#1459)

---
 interpreter/.merlin      | 12 ------------
 interpreter/dune         | 33 +++++++++++++++++++++++++++++++++
 interpreter/dune-project |  1 +
 3 files changed, 34 insertions(+), 12 deletions(-)
 delete mode 100644 interpreter/.merlin
 create mode 100644 interpreter/dune
 create mode 100644 interpreter/dune-project

diff --git a/interpreter/.merlin b/interpreter/.merlin
deleted file mode 100644
index 5af0cf09f..000000000
--- a/interpreter/.merlin
+++ /dev/null
@@ -1,12 +0,0 @@
-S binary
-S exec
-S host
-S main
-S runtime
-S script
-S syntax
-S text
-S util
-S valid
-
-B _build/*
diff --git a/interpreter/dune b/interpreter/dune
new file mode 100644
index 000000000..2b5cd3572
--- /dev/null
+++ b/interpreter/dune
@@ -0,0 +1,33 @@
+(include_subdirs unqualified)
+
+(library
+ (name wasm)
+ ; The 'main' module shall not be part of the library, as it would start the
+ ; WASM REPL every time in all the dependencies.
+ ; We also need to exclude the 'wasm' module as it overlaps with the library
+ ; name.
+ (modules :standard \ main wasm))
+
+(executable
+ (name main)
+ (modules main)
+ (libraries wasm)
+ (flags
+  (-open Wasm)))
+
+(subdir
+ text
+ (rule
+  (target lexer.ml)
+  (deps lexer.mll)
+  (action
+   (chdir
+    %{workspace_root}
+    (run %{bin:ocamllex} -ml -q -o %{target} %{deps}))))
+ (ocamlyacc
+  (modules parser)))
+
+(env
+ (dev
+  (flags
+   (-w +a-4-27-42-44-45 -warn-error +a-3))))
diff --git a/interpreter/dune-project b/interpreter/dune-project
new file mode 100644
index 000000000..c994249ac
--- /dev/null
+++ b/interpreter/dune-project
@@ -0,0 +1 @@
+(lang dune 2.9)

From 79ef7af5b824f2eec26cab298a04e12cc995865a Mon Sep 17 00:00:00 2001
From: Julien Cretin <cretin@google.com>
Date: Fri, 6 May 2022 13:29:44 +0200
Subject: [PATCH 116/285] [spec] Fix typos in instruction validation rules
 (#1462)

---
 document/core/valid/instructions.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index d60df9646..131551416 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -793,7 +793,7 @@ Table Instructions
 
 .. math::
    \frac{
-     C.\CTABLES[x] = t
+     C.\CTABLES[x] = \limits~t
    }{
      C \vdashinstr \TABLESET~x : [\I32~t] \to []
    }
@@ -900,7 +900,7 @@ Table Instructions
 
 .. math::
    \frac{
-     C.\CTABLES[x] = \limits_1~t
+     C.\CTABLES[x] = \limits~t
      \qquad
      C.\CELEMS[y] = t
    }{

From 54fa9268d5508482ca0a5696b2b9f1a4587e950f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=A4mes=20M=C3=A9n=C3=A9trey?= <james@menetrey.me>
Date: Fri, 6 May 2022 13:40:20 +0200
Subject: [PATCH 117/285] [bib] Update latex .bib file for webassembly 2.0
 (#1463)

---
 wasm-specs.bib | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/wasm-specs.bib b/wasm-specs.bib
index c116cf114..7c8a40aa7 100644
--- a/wasm-specs.bib
+++ b/wasm-specs.bib
@@ -1,9 +1,20 @@
-@report{WebAssemblyCoreSpecification,
+@report{WebAssemblyCoreSpecification1,
   title = {{WebAssembly Core Specification}},
+  version = {1.0},
   editor = {Rossberg, Andreas},
   date = {2019-12-05},
   institution = {{W3C}},
   url = {https://www.w3.org/TR/wasm-core-1/},
+  langid = {english}
+}
+
+@report{WebAssemblyCoreSpecification2,
+  title = {{WebAssembly Core Specification}},
+  version = {2.0},
+  editor = {Rossberg, Andreas},
+  date = {2022-04-19},
+  institution = {{W3C}},
+  url = {https://www.w3.org/TR/wasm-core-2/},
   langid = {english},
   note = {https://webassembly.github.io/spec/core/_download/WebAssembly.pdf}
 }

From 8d005d4fc144c315a0c43e7c700029a41e9eacc1 Mon Sep 17 00:00:00 2001
From: Julien Cretin <cretin@google.com>
Date: Fri, 6 May 2022 13:49:01 +0200
Subject: [PATCH 118/285] [spec] Add missing default for vector types (#1464)

---
 document/core/exec/runtime.rst | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index 5faaab458..e5c97ed78 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -51,11 +51,12 @@ or *external references* pointing to an uninterpreted form of :ref:`extern addre
 .. _default-val:
 
 Each :ref:`value type <syntax-valtype>` has an associated *default value*;
-it is the respective value :math:`0` for :ref:`number types <syntax-numtype>` and null for :ref:`reference types <syntax-reftype>`.
+it is the respective value :math:`0` for :ref:`number types <syntax-numtype>`, :math:`0` for :ref:`vector types <syntax-vectype>`, and null for :ref:`reference types <syntax-reftype>`.
 
 .. math::
    \begin{array}{lcl@{\qquad}l}
    \default_t &=& t{.}\CONST~0 & (\iff t = \numtype) \\
+   \default_t &=& t{.}\CONST~0 & (\iff t = \vectype) \\
    \default_t &=& \REFNULL~t & (\iff t = \reftype) \\
    \end{array}
 

From 75059dcb8f3d3e5e8d40f4abd1999f73dfb14b70 Mon Sep 17 00:00:00 2001
From: Julien Cretin <cretin@google.com>
Date: Fri, 6 May 2022 16:12:00 +0200
Subject: [PATCH 119/285] [spec] Fix typos in binary and text formats (#1469)

---
 document/core/binary/instructions.rst |  2 +-
 document/core/binary/modules.rst      |  8 ++++----
 document/core/binary/types.rst        |  2 +-
 document/core/binary/values.rst       |  2 +-
 document/core/text/instructions.rst   | 20 ++++++++++----------
 5 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/document/core/binary/instructions.rst b/document/core/binary/instructions.rst
index f295b5e76..abd4ee5c0 100644
--- a/document/core/binary/instructions.rst
+++ b/document/core/binary/instructions.rst
@@ -511,7 +511,7 @@ The |VCONST| instruction is followed by 16 immediate bytes, which are converted
    \begin{array}{llclll}
    \production{instruction} & \Binstr &::=& \dots \\&&|&
      \hex{FD}~~12{:}\Bu32~~(b{:}\Bbyte)^{16} &\Rightarrow& \V128.\VCONST~
-     bytes_{\K{i128}}^{-1}(b_{0}~\dots~b_{15}) \\
+     \bytes_{\K{i128}}^{-1}(b_{0}~\dots~b_{15}) \\
    \end{array}
 
 .. _binary-vternop:
diff --git a/document/core/binary/modules.rst b/document/core/binary/modules.rst
index 818c19e76..f20bd0749 100644
--- a/document/core/binary/modules.rst
+++ b/document/core/binary/modules.rst
@@ -325,7 +325,7 @@ It decodes into a vector of :ref:`element segments <syntax-elem>` that represent
 .. math::
    \begin{array}{llclll}
    \production{element section} & \Belemsec &::=&
-     \X{seg}^\ast{:}\Bsection_9(\Bvec(\Belem)) &\Rightarrow& \X{seg} \\
+     \X{seg}^\ast{:}\Bsection_9(\Bvec(\Belem)) &\Rightarrow& \X{seg}^\ast \\
    \production{element segment} & \Belem &::=&
      0{:}\Bu32~~e{:}\Bexpr~~y^\ast{:}\Bvec(\Bfuncidx)
        &\Rightarrow& \\&&&\quad
@@ -406,7 +406,7 @@ denoting *count* locals of the same value type.
        &\Rightarrow& \X{code} & (\iff \X{size} = ||\Bfunc||) \\
    \production{function} & \Bfunc &::=&
      (t^\ast)^\ast{:}\Bvec(\Blocals)~~e{:}\Bexpr
-       &\Rightarrow& \concat((t^\ast)^\ast), e^\ast
+       &\Rightarrow& \concat((t^\ast)^\ast), e
          & (\iff |\concat((t^\ast)^\ast)| < 2^{32}) \\
    \production{locals} & \Blocals &::=&
      n{:}\Bu32~~t{:}\Bvaltype &\Rightarrow& t^n \\
@@ -438,7 +438,7 @@ It decodes into a vector of :ref:`data segments <syntax-data>` that represent th
 .. math::
    \begin{array}{llclll}
    \production{data section} & \Bdatasec &::=&
-     \X{seg}^\ast{:}\Bsection_{11}(\Bvec(\Bdata)) &\Rightarrow& \X{seg} \\
+     \X{seg}^\ast{:}\Bsection_{11}(\Bvec(\Bdata)) &\Rightarrow& \X{seg}^\ast \\
    \production{data segment} & \Bdata &::=&
      0{:}\Bu32~~e{:}\Bexpr~~b^\ast{:}\Bvec(\Bbyte)
        &\Rightarrow& \{ \DINIT~b^\ast, \DMODE~\DACTIVE~\{ \DMEM~0, \DOFFSET~e \} \} \\ &&|&
@@ -504,7 +504,7 @@ All sections can be empty.
 The lengths of vectors produced by the (possibly empty) :ref:`function <binary-funcsec>` and :ref:`code <binary-codesec>` section must match up.
 
 Similarly, the optional data count must match the length of the :ref:`data segment <binary-datasec>` vector.
-Furthermore, it must be present if any :math:`data index <syntax-dataidx>` occurs in the code section.
+Furthermore, it must be present if any :ref:`data index <syntax-dataidx>` occurs in the code section.
 
 .. math::
    \begin{array}{llcllll}
diff --git a/document/core/binary/types.rst b/document/core/binary/types.rst
index 485057354..4df661839 100644
--- a/document/core/binary/types.rst
+++ b/document/core/binary/types.rst
@@ -91,7 +91,7 @@ Value Types
 Result Types
 ~~~~~~~~~~~~
 
-:ref:`Result types <syntax-resulttype>` are encoded by the respective :ref:`vectors <binary-vec>` of :ref:`value types `<binary-valtype>`.
+:ref:`Result types <syntax-resulttype>` are encoded by the respective :ref:`vectors <binary-vec>` of :ref:`value types <binary-valtype>`.
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
diff --git a/document/core/binary/values.rst b/document/core/binary/values.rst
index c62686248..93699749b 100644
--- a/document/core/binary/values.rst
+++ b/document/core/binary/values.rst
@@ -66,7 +66,7 @@ As an additional constraint, the total number of bytes encoding a value of type
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
    \production{uninterpreted integer} & \BiN &::=&
-     n{:}\BsN &\Rightarrow& i & (\iff n = \signed_{\iN}(i))
+     n{:}\BsN &\Rightarrow& i & (\iff n = \signed_N(i))
    \end{array}
 
 .. note::
diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index 95eb41717..348aa7733 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -239,18 +239,18 @@ Table Instructions
 Abbreviations
 .............
 
-For backwards compatibility, all :math:`table indices <syntax-tableidx>` may be omitted from table instructions, defaulting to :math:`0`.
+For backwards compatibility, all :ref:`table indices <syntax-tableidx>` may be omitted from table instructions, defaulting to :math:`0`.
 
 .. math::
-   \begin{array}{llclll}
+   \begin{array}{llcl}
    \production{instruction} &
-     \text{table.get} &\equiv& \text{table.get}~~\text{0} \\ &&|&
-     \text{table.set} &\equiv& \text{table.set}~~\text{0} \\ &&|&
-     \text{table.size} &\equiv& \text{table.size}~~\text{0} \\ &&|&
-     \text{table.grow} &\equiv& \text{table.grow}~~\text{0} \\ &&|&
-     \text{table.fill} &\equiv& \text{table.fill}~~\text{0} \\ &&|&
-     \text{table.copy} &\equiv& \text{table.copy}~~\text{0}~~\text{0} \\ &&|&
-     \text{table.init}~~x{:}\Telemidx_I &\equiv& \text{table.init}~~\text{0}~~x{:}\Telemidx_I \\ &&|&
+     \text{table.get} &\equiv& \text{table.get}~~\text{0} \\ &
+     \text{table.set} &\equiv& \text{table.set}~~\text{0} \\ &
+     \text{table.size} &\equiv& \text{table.size}~~\text{0} \\ &
+     \text{table.grow} &\equiv& \text{table.grow}~~\text{0} \\ &
+     \text{table.fill} &\equiv& \text{table.fill}~~\text{0} \\ &
+     \text{table.copy} &\equiv& \text{table.copy}~~\text{0}~~\text{0} \\ &
+     \text{table.init}~~x{:}\Telemidx_I &\equiv& \text{table.init}~~\text{0}~~x{:}\Telemidx_I \\
    \end{array}
 
 
@@ -916,7 +916,7 @@ Such a folded instruction can appear anywhere a regular instruction can.
      \text{(}~\text{loop}~~\Tlabel~~\Tblocktype~~\Tinstr^\ast~\text{)}
        &\equiv\quad \text{loop}~~\Tlabel~~\Tblocktype~~\Tinstr^\ast~~\text{end} \\ &
      \text{(}~\text{if}~~\Tlabel~~\Tblocktype~~\Tfoldedinstr^\ast
-       &\hspace{-3ex} \text{(}~\text{then}~~\Tinstr_1^\ast~\text{)}~~\text{(}~\text{else}~~\Tinstr_2^\ast~\text{)}^?~~\text{)}
+       &\hspace{-3ex} \text{(}~\text{then}~~\Tinstr_1^\ast~\text{)}~~(\text{(}~\text{else}~~\Tinstr_2^\ast~\text{)})^?~~\text{)}
        \quad\equiv \\ &\qquad
          \Tfoldedinstr^\ast~~\text{if}~~\Tlabel~~\Tblocktype &\hspace{-1ex} \Tinstr_1^\ast~~\text{else}~~(\Tinstr_2^\ast)^?~\text{end} \\
    \end{array}

From d39195773112a22b245ffbe864bab6d1182ccb06 Mon Sep 17 00:00:00 2001
From: Ivan Panchenko <39594356+ivan-pan@users.noreply.github.com>
Date: Tue, 10 May 2022 09:25:56 +0200
Subject: [PATCH 120/285] [spec] Fix various typos (#1470)

---
 document/core/appendix/embedding.rst  | 16 ++++-----
 document/core/appendix/properties.rst |  4 +--
 document/core/binary/modules.rst      |  2 +-
 document/core/exec/conventions.rst    |  2 +-
 document/core/exec/instructions.rst   | 50 +++++++++++++--------------
 document/core/exec/modules.rst        |  6 ++--
 document/core/exec/numerics.rst       | 20 +++++------
 document/core/intro/overview.rst      |  2 +-
 document/core/syntax/conventions.rst  |  4 +--
 document/core/syntax/instructions.rst |  4 +--
 document/core/text/conventions.rst    |  2 +-
 document/core/text/modules.rst        |  6 ++--
 document/core/valid/conventions.rst   |  2 +-
 document/core/valid/instructions.rst  |  4 +--
 document/core/valid/modules.rst       |  2 +-
 document/js-api/index.bs              |  8 ++---
 document/web-api/index.bs             |  6 ++--
 17 files changed, 70 insertions(+), 70 deletions(-)

diff --git a/document/core/appendix/embedding.rst b/document/core/appendix/embedding.rst
index db83ae26b..b2995f2f1 100644
--- a/document/core/appendix/embedding.rst
+++ b/document/core/appendix/embedding.rst
@@ -50,7 +50,7 @@ Some operations state *pre-conditions* about their arguments or *post-conditions
 It is the embedder's responsibility to meet the pre-conditions.
 If it does, the post conditions are guaranteed by the semantics.
 
-In addition to pre- and post-conditions explicitly stated with each operation, the specification adopts the following conventions for :ref:`runtime objects <syntax-runtime>` (:math:`store`, :math:`\moduleinst`, :math:`\externval`, :ref:`addresses <syntax-addr>`):
+In addition to pre- and post-conditions explicitly stated with each operation, the specification adopts the following conventions for :ref:`runtime objects <syntax-runtime>` (:math:`\store`, :math:`\moduleinst`, :math:`\externval`, :ref:`addresses <syntax-addr>`):
 
 * Every runtime object passed as a parameter must be :ref:`valid <valid-store>` per an implicit pre-condition.
 
@@ -258,7 +258,7 @@ Functions
 :math:`\F{func\_alloc}(\store, \functype, \hostfunc) : (\store, \funcaddr)`
 ...........................................................................
 
-1. Pre-condition: :math:`\functype` is :math:`valid <valid-functype>`.
+1. Pre-condition: :math:`\functype` is :ref:`valid <valid-functype>`.
 
 2. Let :math:`\funcaddr` be the result of :ref:`allocating a host function <alloc-func>` in :math:`\store` with :ref:`function type <syntax-functype>` :math:`\functype` and host function code :math:`\hostfunc`.
 
@@ -326,7 +326,7 @@ Tables
 :math:`\F{table\_alloc}(\store, \tabletype) : (\store, \tableaddr, \reff)`
 ..........................................................................
 
-1. Pre-condition: :math:`\tabletype` is :math:`valid <valid-tabletype>`.
+1. Pre-condition: :math:`\tabletype` is :ref:`valid <valid-tabletype>`.
 
 2. Let :math:`\tableaddr` be the result of :ref:`allocating a table <alloc-table>` in :math:`\store` with :ref:`table type <syntax-tabletype>` :math:`\tabletype` and initialization value :math:`\reff`.
 
@@ -345,7 +345,7 @@ Tables
 
 1. Return :math:`S.\STABLES[a].\TITYPE`.
 
-2. Post-condition: the returned :ref:`table type <syntax-tabletype>` is :math:`valid <valid-tabletype>`.
+2. Post-condition: the returned :ref:`table type <syntax-tabletype>` is :ref:`valid <valid-tabletype>`.
 
 .. math::
    \begin{array}{lclll}
@@ -438,7 +438,7 @@ Memories
 :math:`\F{mem\_alloc}(\store, \memtype) : (\store, \memaddr)`
 ................................................................
 
-1. Pre-condition: :math:`\memtype` is :math:`valid <valid-memtype>`.
+1. Pre-condition: :math:`\memtype` is :ref:`valid <valid-memtype>`.
 
 2. Let :math:`\memaddr` be the result of :ref:`allocating a memory <alloc-mem>` in :math:`\store` with :ref:`memory type <syntax-memtype>` :math:`\memtype`.
 
@@ -457,7 +457,7 @@ Memories
 
 1. Return :math:`S.\SMEMS[a].\MITYPE`.
 
-2. Post-condition: the returned :ref:`memory type <syntax-memtype>` is :math:`valid <valid-memtype>`.
+2. Post-condition: the returned :ref:`memory type <syntax-memtype>` is :ref:`valid <valid-memtype>`.
 
 .. math::
    \begin{array}{lclll}
@@ -551,7 +551,7 @@ Globals
 :math:`\F{global\_alloc}(\store, \globaltype, \val) : (\store, \globaladdr)`
 ............................................................................
 
-1. Pre-condition: :math:`\globaltype` is :math:`valid <valid-globaltype>`.
+1. Pre-condition: :math:`\globaltype` is :ref:`valid <valid-globaltype>`.
 
 2. Let :math:`\globaladdr` be the result of :ref:`allocating a global <alloc-global>` in :math:`\store` with :ref:`global type <syntax-globaltype>` :math:`\globaltype` and initialization value :math:`\val`.
 
@@ -570,7 +570,7 @@ Globals
 
 1. Return :math:`S.\SGLOBALS[a].\GITYPE`.
 
-2. Post-condition: the returned :ref:`global type <syntax-globaltype>` is :math:`valid <valid-globaltype>`.
+2. Post-condition: the returned :ref:`global type <syntax-globaltype>` is :ref:`valid <valid-globaltype>`.
 
 .. math::
    \begin{array}{lclll}
diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index da3658c8f..72251114e 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -483,7 +483,7 @@ Finally, :ref:`frames <syntax-frame>` are classified with *frame contexts*, whic
 
 * Each :ref:`value <syntax-val>` :math:`\val_i` in :math:`\val^\ast` must be :ref:`valid <valid-val>` with some :ref:`value type <syntax-valtype>` :math:`t_i`.
 
-* Let :math:`t^\ast` the concatenation of all :math:`t_i` in order.
+* Let :math:`t^\ast` be the concatenation of all :math:`t_i` in order.
 
 * Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the :ref:`value types <syntax-valtype>` :math:`t^\ast` prepended to the |CLOCALS| vector.
 
@@ -543,7 +543,7 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
 :math:`\REFFUNCADDR~\funcaddr`
 ..............................
 
-* The :ref:`external function value <syntax-externval>` :math:`\EVFUNC~\funcaddr` must be :ref:`valid <valid-externval-func>` with :ref:`external function type <syntax-externtype>` :math:`\ETFUNC \functype`.
+* The :ref:`external function value <syntax-externval>` :math:`\EVFUNC~\funcaddr` must be :ref:`valid <valid-externval-func>` with :ref:`external function type <syntax-externtype>` :math:`\ETFUNC~\functype`.
 
 * Then the instruction is valid with type :math:`[] \to [\FUNCREF]`.
 
diff --git a/document/core/binary/modules.rst b/document/core/binary/modules.rst
index f20bd0749..e9c72b61a 100644
--- a/document/core/binary/modules.rst
+++ b/document/core/binary/modules.rst
@@ -559,7 +559,7 @@ Furthermore, it must be present if any :ref:`data index <syntax-dataidx>` occurs
 where for each :math:`t_i^\ast, e_i` in :math:`\X{code}^n`,
 
 .. math::
-   \func^n[i] = \{ \FTYPE~\typeidx^n[i], \FLOCALS~t_i^\ast, \FBODY~e_i \} ) \\
+   \func^n[i] = \{ \FTYPE~\typeidx^n[i], \FLOCALS~t_i^\ast, \FBODY~e_i \} \\
 
 .. note::
    The version of the WebAssembly binary format may increase in the future
diff --git a/document/core/exec/conventions.rst b/document/core/exec/conventions.rst
index 807239b04..d9b998a92 100644
--- a/document/core/exec/conventions.rst
+++ b/document/core/exec/conventions.rst
@@ -92,7 +92,7 @@ and a sequence of |CONST| instructions can be interpreted as an operand "stack"
       (\I32.\CONST~n_1)~(\I32.\CONST~n_2)~\I32.\ADD \quad\stepto\quad (\I32.\CONST~(n_1 + n_2) \mod 2^{32})
 
    Per this rule, two |CONST| instructions and the |ADD| instruction itself are removed from the instruction stream and replaced with one new |CONST| instruction.
-   This can be interpreted as popping two value off the stack and pushing the result.
+   This can be interpreted as popping two values off the stack and pushing the result.
 
    When no result is produced, an instruction reduces to the empty sequence:
 
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 6ab846d28..194c39851 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -400,7 +400,7 @@ Most vector instructions are defined in terms of generic numeric operators appli
      \begin{array}[t]{@{}r@{~}l@{}}
       (\iff & i^\ast = \lanes_{i8x16}(c_2) \\
       \wedge & c^\ast = \lanes_{i8x16}(c_1)~0^{240} \\
-      \wedge & c' = \lanes^{-1}_{i8x16}(c^\ast[ i^\ast[0] ] \dots c^\ast[ i^\ast[15] ])
+      \wedge & c' = \lanes^{-1}_{i8x16}(c^\ast[ i^\ast[0] ] \dots c^\ast[ i^\ast[15] ]))
      \end{array}
    \end{array}
 
@@ -436,7 +436,7 @@ Most vector instructions are defined in terms of generic numeric operators appli
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
       (\iff & i^\ast = \lanes_{i8x16}(c_1)~\lanes_{i8x16}(c_2) \\
-      \wedge & c = \lanes^{-1}_{i8x16}(i^\ast[x^\ast[0]] \dots i^\ast[x^\ast[15]])
+      \wedge & c = \lanes^{-1}_{i8x16}(i^\ast[x^\ast[0]] \dots i^\ast[x^\ast[15]]))
      \end{array}
    \end{array}
 
@@ -494,7 +494,7 @@ Most vector instructions are defined in terms of generic numeric operators appli
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
       (\iff & t_2 = \unpacked(t_1\K{x}N) \\
-       \wedge & c_2 = \extend^{sx^?}_{t_1,t_2}(\lanes_{t_1\K{x}N}(c_1)[x])
+       \wedge & c_2 = \extend^{sx^?}_{t_1,t_2}(\lanes_{t_1\K{x}N}(c_1)[x]))
      \end{array}
    \end{array}
 
@@ -529,8 +529,8 @@ Most vector instructions are defined in terms of generic numeric operators appli
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
-      (\iff & i^\ast = \lanes_{\shape}(c_2)) \\
-       \wedge & c = \lanes^{-1}_{\shape}(i^\ast \with [x] = c_1)
+      (\iff & i^\ast = \lanes_{\shape}(c_2) \\
+       \wedge & c = \lanes^{-1}_{\shape}(i^\ast \with [x] = c_1))
      \end{array}
    \end{array}
 
@@ -673,7 +673,7 @@ Most vector instructions are defined in terms of generic numeric operators appli
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
      (\iff & i_1^\ast = \lanes_{\shape}(c) \\
-     \wedge & i = \bool(\bigwedge(i_1 \neq 0)^\ast)
+     \wedge & i = \bool(\bigwedge(i_1 \neq 0)^\ast))
      \end{array}
    \end{array}
 
@@ -735,7 +735,7 @@ Most vector instructions are defined in terms of generic numeric operators appli
      \begin{array}[t]{@{}r@{~}l@{}}
      (\iff & d_1^M = \narrow^{\sx}_{|t_1|,|t_2|}( \lanes_{t_1\K{x}M}(c_1)) \\
      \wedge & d_2^M = \narrow^{\sx}_{|t_1|,|t_2|}( \lanes_{t_1\K{x}M}(c_2)) \\
-     \wedge & c = \lanes^{-1}_{t_2\K{x}N}(d_1^M~d_2^M)
+     \wedge & c = \lanes^{-1}_{t_2\K{x}N}(d_1^M~d_2^M))
      \end{array}
    \end{array}
 
@@ -762,7 +762,7 @@ Most vector instructions are defined in terms of generic numeric operators appli
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
-     (\iff & c = \lanes^{-1}_{t_2\K{x}N}(\vcvtop^{\sx}_{|t_1|,|t_2|}(\lanes_{t_1\K{x}M}(c_1)))
+     (\iff & c = \lanes^{-1}_{t_2\K{x}N}(\vcvtop^{\sx}_{|t_1|,|t_2|}(\lanes_{t_1\K{x}M}(c_1))))
      \end{array}
    \end{array}
 
@@ -795,7 +795,7 @@ Most vector instructions are defined in terms of generic numeric operators appli
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
-     (\iff & c = \lanes^{-1}_{t_2\K{x}N}(\vcvtop^{\sx^?}_{|t_1|,|t_2|}(\lanes_{t_1\K{x}M}(c_1)[\half(0, N) \slice N]))
+     (\iff & c = \lanes^{-1}_{t_2\K{x}N}(\vcvtop^{\sx^?}_{|t_1|,|t_2|}(\lanes_{t_1\K{x}M}(c_1)[\half(0, N) \slice N])))
      \end{array}
    \end{array}
 
@@ -830,7 +830,7 @@ where:
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
-     (\iff & c = \lanes^{-1}_{t_2\K{x}N}(\vcvtop^{\sx}_{|t_1|,|t_2|}(\lanes_{t_1\K{x}M}(c_1))~0^M)
+     (\iff & c = \lanes^{-1}_{t_2\K{x}N}(\vcvtop^{\sx}_{|t_1|,|t_2|}(\lanes_{t_1\K{x}M}(c_1))~0^M))
      \end{array}
    \end{array}
 
@@ -840,7 +840,7 @@ where:
 :math:`\K{i32x4.}\DOT\K{\_i16x8\_s}`
 ....................................
 
-1. Assert: due to :ref:`validation <valid-vec-dot>`, two values of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+1. Assert: due to :ref:`validation <valid-vec-dot>`, two values of :ref:`value type <syntax-valtype>` |V128| are on the top of the stack.
 
 2. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
 
@@ -863,7 +863,7 @@ where:
      \begin{array}[t]{@{}r@{~}l@{}}
      (\iff & (i_1~i_2)^\ast = \imul_{32}(\extends_{16,32}(\lanes_{\I16X8}(c_1)), \extends_{16,32}(\lanes_{\I16X8}(c_2))) \\
      \wedge & j^\ast = \iadd_{32}(i_1, i_2)^\ast \\
-     \wedge & c = \lanes^{-1}_{\I32X4}(j^\ast)
+     \wedge & c = \lanes^{-1}_{\I32X4}(j^\ast))
      \end{array}
    \end{array}
 
@@ -873,7 +873,7 @@ where:
 :math:`t_2\K{x}N\K{.}\EXTMUL\K{\_}\half\K{\_}t_1\K{x}M\K{\_}\sx`
 ................................................................
 
-1. Assert: due to :ref:`validation <valid-vec-extmul>`, two values of :ref:`value type <syntax-valtype>` |V128| is on the top of the stack.
+1. Assert: due to :ref:`validation <valid-vec-extmul>`, two values of :ref:`value type <syntax-valtype>` |V128| are on the top of the stack.
 
 2. Pop the value :math:`\V128.\VCONST~c_2` from the stack.
 
@@ -903,7 +903,7 @@ where:
      \begin{array}[t]{@{}r@{~}l@{}}
      (\iff & i^\ast = \lanes_{t_1\K{x}M}(c_1)[\half(0, N) \slice N] \\
      \wedge & j^\ast = \lanes_{t_1\K{x}M}(c_2)[\half(0, N) \slice N] \\
-     \wedge & c = \lanes^{-1}_{t_2\K{x}N}(\imul_{t_2\K{x}N}(\extend^{\sx}_{|t_1|,|t_2|}(i^\ast), \extend^{\sx}_{|t_1|,|t_2|}(j^\ast)))
+     \wedge & c = \lanes^{-1}_{t_2\K{x}N}(\imul_{t_2\K{x}N}(\extend^{\sx}_{|t_1|,|t_2|}(i^\ast), \extend^{\sx}_{|t_1|,|t_2|}(j^\ast))))
      \end{array}
 
 where:
@@ -941,7 +941,7 @@ where:
      \begin{array}[t]{@{}r@{~}l@{}}
      (\iff & (i_1~i_2)^\ast = \extend^{\sx}_{|t_1|,|t_2|}(\lanes_{t_1\K{x}M}(c_1)) \\
      \wedge & j^\ast = \iadd_{N}(i_1, i_2)^\ast \\
-     \wedge & c = \lanes^{-1}_{t_2\K{x}N}(j^\ast)
+     \wedge & c = \lanes^{-1}_{t_2\K{x}N}(j^\ast))
      \end{array}
    \end{array}
 
@@ -1777,9 +1777,9 @@ Memory Instructions
      \begin{array}[t]{@{}r@{~}l@{}}
      (\iff & \X{ea} = i + \memarg.\OFFSET \\
      \wedge & \X{ea} + M \cdot N / 8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
-     \wedge & \bytes_{\iM}(m_k) = S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} + k \cdot M/8 \slice M/8]) \\
+     \wedge & \bytes_{\iM}(m_k) = S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} + k \cdot M/8 \slice M/8] \\
      \wedge & W = M \cdot 2 \\
-     \wedge & c = \lanes^{-1}_{\X{i}W\K{x}N}(\extend^{\sx}_{M,W}(m_0) \dots \extend^{\sx}_{M,W}(m_{N-1}))
+     \wedge & c = \lanes^{-1}_{\X{i}W\K{x}N}(\extend^{\sx}_{M,W}(m_0) \dots \extend^{\sx}_{M,W}(m_{N-1})))
      \end{array}
    \\[1ex]
    \begin{array}{lcl@{\qquad}l}
@@ -1835,8 +1835,8 @@ Memory Instructions
      \begin{array}[t]{@{}r@{~}l@{}}
      (\iff & \X{ea} = i + \memarg.\OFFSET \\
      \wedge & \X{ea} + N/8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
-     \wedge & \bytes_{\iN}(n) = S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8]) \\
-     \wedge & c = \lanes^{-1}_{\iN\K{x}L}(n^L)
+     \wedge & \bytes_{\iN}(n) = S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8] \\
+     \wedge & c = \lanes^{-1}_{\iN\K{x}L}(n^L))
      \end{array}
    \\[1ex]
    \begin{array}{lcl@{\qquad}l}
@@ -1890,8 +1890,8 @@ Memory Instructions
      \begin{array}[t]{@{}r@{~}l@{}}
      (\iff & \X{ea} = i + \memarg.\OFFSET \\
      \wedge & \X{ea} + N/8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
-     \wedge & \bytes_{\iN}(n) = S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8]) \\
-     \wedge & c = \extendu_{N,128}(n)
+     \wedge & \bytes_{\iN}(n) = S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8] \\
+     \wedge & c = \extendu_{N,128}(n))
      \end{array}
    \\[1ex]
    \begin{array}{lcl@{\qquad}l}
@@ -1951,9 +1951,9 @@ Memory Instructions
      \begin{array}[t]{@{}r@{~}l@{}}
      (\iff & \X{ea} = i + \memarg.\OFFSET \\
      \wedge & \X{ea} + N/8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
-     \wedge & \bytes_{\iN}(r) = S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8]) \\
+     \wedge & \bytes_{\iN}(r) = S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8] \\
      \wedge & L = 128/N \\
-     \wedge & c = \lanes^{-1}_{\K{i}N\K{x}L}(\lanes_{\K{i}N\K{x}L}(v) \with [x] = r)
+     \wedge & c = \lanes^{-1}_{\K{i}N\K{x}L}(\lanes_{\K{i}N\K{x}L}(v) \with [x] = r))
      \end{array}
    \\[1ex]
    \begin{array}{lcl@{\qquad}l}
@@ -2030,7 +2030,7 @@ Memory Instructions
      \begin{array}[t]{@{}r@{~}l@{}}
      (\iff & \X{ea} = i + \memarg.\OFFSET \\
      \wedge & \X{ea} + N/8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
-     \wedge & S' = S \with \SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8] = \bytes_{\iN}(\wrap_{|t|,N}(c)) \\[1ex]
+     \wedge & S' = S \with \SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8] = \bytes_{\iN}(\wrap_{|t|,N}(c))) \\[1ex]
      \end{array}
    \\[1ex]
    \begin{array}{lcl@{\qquad}l}
@@ -2087,7 +2087,7 @@ Memory Instructions
      (\iff & \X{ea} = i + \memarg.\OFFSET \\
      \wedge & \X{ea} + N \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
      \wedge & L = 128/N \\
-     \wedge & S' = S \with \SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8] = \bytes_{\iN}(\lanes_{\K{i}N\K{x}L}(c)[x])
+     \wedge & S' = S \with \SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8] = \bytes_{\iN}(\lanes_{\K{i}N\K{x}L}(c)[x]))
      \end{array}
    \\[1ex]
    \begin{array}{lcl@{\qquad}l}
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index eb2faa05f..0e8c9d50a 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -386,7 +386,7 @@ Growing :ref:`tables <syntax-tableinst>`
        \wedge & \X{len} < 2^{32} \\
        \wedge & \limits~t = \tableinst.\TITYPE \\
        \wedge & \limits' = \limits \with \LMIN = \X{len} \\
-       \wedge & \vdashlimits \limits' \ok \\
+       \wedge & \vdashlimits \limits' \ok) \\
        \end{array} \\
    \end{array}
 
@@ -424,7 +424,7 @@ Growing :ref:`memories <syntax-meminst>`
        \wedge & \X{len} \leq 2^{16} \\
        \wedge & \limits = \meminst.\MITYPE \\
        \wedge & \limits' = \limits \with \LMIN = \X{len} \\
-       \wedge & \vdashlimits \limits' \ok \\
+       \wedge & \vdashlimits \limits' \ok) \\
        \end{array} \\
    \end{array}
 
@@ -462,7 +462,7 @@ and list of :ref:`reference <syntax-ref>` vectors for the module's :ref:`element
 
 6. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEMS`, do:
 
-   a. Let :math:`\elemaddr_i` be the :ref:`element address <syntax-elemaddr>` resulting from :ref:`allocating <alloc-elem>` a :ref:`element instance <syntax-eleminst>` of :ref:`reference type <syntax-reftype>` :math:`\elem_i.\ETYPE` with contents :math:`(\reff^\ast)^\ast[i]`.
+   a. Let :math:`\elemaddr_i` be the :ref:`element address <syntax-elemaddr>` resulting from :ref:`allocating <alloc-elem>` an :ref:`element instance <syntax-eleminst>` of :ref:`reference type <syntax-reftype>` :math:`\elem_i.\ETYPE` with contents :math:`(\reff^\ast)^\ast[i]`.
 
 7. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATAS`, do:
 
diff --git a/document/core/exec/numerics.rst b/document/core/exec/numerics.rst
index 301984447..c7050b17d 100644
--- a/document/core/exec/numerics.rst
+++ b/document/core/exec/numerics.rst
@@ -197,7 +197,7 @@ Numeric vectors have the same underlying representation as an |i128|. They can a
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
      (\where & B = |t| / 8 \\
-     \wedge & b^{16} = bytes_{\i128}(c) \\
+     \wedge & b^{16} = \bytes_{\i128}(c) \\
      \wedge & c_i = \bytes_{t}^{-1}(b^{16}[i \cdot B \slice B]))
      \end{array}
    \end{array}
@@ -746,7 +746,7 @@ The integer result of predicates -- i.e., :ref:`tests <syntax-testop>` and :ref:
 
 * Let :math:`j` be the :ref:`signed interpretation <aux-signed>` of :math:`i`.
 
-* If :math:`j` greater than or equal to :math:`0`, then return :math:`i`.
+* If :math:`j` is greater than or equal to :math:`0`, then return :math:`i`.
 
 * Else return the negation of `j`, modulo :math:`2^N`.
 
@@ -1060,13 +1060,13 @@ This non-deterministic result is expressed by the following auxiliary function p
 
 * Else if both :math:`z_1` and :math:`z_2` are infinities of equal sign, then return that infinity.
 
-* Else if one of :math:`z_1` or :math:`z_2` is an infinity, then return that infinity.
+* Else if either :math:`z_1` or :math:`z_2` is an infinity, then return that infinity.
 
 * Else if both :math:`z_1` and :math:`z_2` are zeroes of opposite sign, then return positive zero.
 
 * Else if both :math:`z_1` and :math:`z_2` are zeroes of equal sign, then return that zero.
 
-* Else if one of :math:`z_1` or :math:`z_2` is a zero, then return the other operand.
+* Else if either :math:`z_1` or :math:`z_2` is a zero, then return the other operand.
 
 * Else if both :math:`z_1` and :math:`z_2` are values with the same magnitude but opposite signs, then return positive zero.
 
@@ -1149,9 +1149,9 @@ This non-deterministic result is expressed by the following auxiliary function p
 
 * Else if both :math:`z_1` and :math:`z_2` are infinities of opposite sign, then return negative infinity.
 
-* Else if one of :math:`z_1` or :math:`z_2` is an infinity and the other a value with equal sign, then return positive infinity.
+* Else if either :math:`z_1` or :math:`z_2` is an infinity and the other a value with equal sign, then return positive infinity.
 
-* Else if one of :math:`z_1` or :math:`z_2` is an infinity and the other a value with opposite sign, then return negative infinity.
+* Else if either :math:`z_1` or :math:`z_2` is an infinity and the other a value with opposite sign, then return negative infinity.
 
 * Else if both :math:`z_1` and :math:`z_2` are zeroes of equal sign, then return positive zero.
 
@@ -1235,9 +1235,9 @@ This non-deterministic result is expressed by the following auxiliary function p
 
 * If either :math:`z_1` or :math:`z_2` is a NaN, then return an element of :math:`\nans_N\{z_1, z_2\}`.
 
-* Else if one of :math:`z_1` or :math:`z_2` is a negative infinity, then return negative infinity.
+* Else if either :math:`z_1` or :math:`z_2` is a negative infinity, then return negative infinity.
 
-* Else if one of :math:`z_1` or :math:`z_2` is a positive infinity, then return the other value.
+* Else if either :math:`z_1` or :math:`z_2` is a positive infinity, then return the other value.
 
 * Else if both :math:`z_1` and :math:`z_2` are zeroes of opposite signs, then return negative zero.
 
@@ -1264,9 +1264,9 @@ This non-deterministic result is expressed by the following auxiliary function p
 
 * If either :math:`z_1` or :math:`z_2` is a NaN, then return an element of :math:`\nans_N\{z_1, z_2\}`.
 
-* Else if one of :math:`z_1` or :math:`z_2` is a positive infinity, then return positive infinity.
+* Else if either :math:`z_1` or :math:`z_2` is a positive infinity, then return positive infinity.
 
-* Else if one of :math:`z_1` or :math:`z_2` is a negative infinity, then return the other value.
+* Else if either :math:`z_1` or :math:`z_2` is a negative infinity, then return the other value.
 
 * Else if both :math:`z_1` and :math:`z_2` are zeroes of opposite signs, then return positive zero.
 
diff --git a/document/core/intro/overview.rst b/document/core/intro/overview.rst
index b9e858ccc..5a4760baf 100644
--- a/document/core/intro/overview.rst
+++ b/document/core/intro/overview.rst
@@ -26,7 +26,7 @@ This language is structured around the following concepts.
   In addition to these basic number types, there is a single 128 bit wide
   vector type representing different types of packed data.
   The supported representations are 4 32-bit, or 2 64-bit
-  |IEEE754|_ numbers, or different widths of packed integer values
+  |IEEE754|_ numbers, or different widths of packed integer values,
   specifically 2 64-bit integers, 4 32-bit integers, 8
   16-bit integers, or 16 8-bit integers.
 
diff --git a/document/core/syntax/conventions.rst b/document/core/syntax/conventions.rst
index 979d6bc4e..9e5dca182 100644
--- a/document/core/syntax/conventions.rst
+++ b/document/core/syntax/conventions.rst
@@ -107,9 +107,9 @@ The following notation is adopted for manipulating such records:
 
 The update notation for sequences and records generalizes recursively to nested components accessed by "paths" :math:`\X{pth} ::= ([\dots] \;| \;.\K{field})^+`:
 
-* :math:`s \with [i]\,\X{pth} = A` is short for :math:`s \with [i] = (s[i] \with \X{pth} = A)`.
+* :math:`s \with [i]\,\X{pth} = A` is short for :math:`s \with [i] = (s[i] \with \X{pth} = A)`,
 
-* :math:`r \with \K{field}\,\X{pth} = A` is short for :math:`r \with \K{field} = (r.\K{field} \with \X{pth} = A)`.
+* :math:`r \with \K{field}\,\X{pth} = A` is short for :math:`r \with \K{field} = (r.\K{field} \with \X{pth} = A)`,
 
 where :math:`r \with~.\K{field} = A` is shortened to :math:`r \with \K{field} = A`.
 
diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index 5b869b33f..6ebb400d9 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -428,7 +428,7 @@ Instructions in this group are concerned with accessing :ref:`references <syntax
      \REFFUNC~\funcidx \\
    \end{array}
 
-These instruction produce a null value, check for a null value, or produce a reference to a given function, respectively.
+These instructions produce a null value, check for a null value, or produce a reference to a given function, respectively.
 
 
 .. index:: ! parametric instruction, value type
@@ -586,7 +586,7 @@ All values are read and written in |LittleEndian|_ byte order.
 A :ref:`trap <trap>` results if any of the accessed memory bytes lies outside the address range implied by the memory's current size.
 
 .. note::
-   Future version of WebAssembly might provide memory instructions with 64 bit address ranges.
+   Future versions of WebAssembly might provide memory instructions with 64 bit address ranges.
 
 The |MEMORYSIZE| instruction returns the current size of a memory.
 The |MEMORYGROW| instruction grows memory by a given delta and returns the previous size, or :math:`-1` if enough memory cannot be allocated.
diff --git a/document/core/text/conventions.rst b/document/core/text/conventions.rst
index ddcd8e780..12c8b7dfc 100644
--- a/document/core/text/conventions.rst
+++ b/document/core/text/conventions.rst
@@ -110,7 +110,7 @@ Contexts
 
 The text format allows the use of symbolic :ref:`identifiers <text-id>` in place of :ref:`indices <syntax-index>`.
 To resolve these identifiers into concrete indices,
-some grammar production are indexed by an *identifier context* :math:`I` as a synthesized attribute that records the declared identifiers in each :ref:`index space <syntax-index>`.
+some grammar productions are indexed by an *identifier context* :math:`I` as a synthesized attribute that records the declared identifiers in each :ref:`index space <syntax-index>`.
 In addition, the context records the types defined in the module, so that :ref:`parameter <text-param>` indices can be computed for :ref:`functions <text-func>`.
 
 It is convenient to define identifier contexts as :ref:`records <notation-record>` :math:`I` with abstract syntax as follows:
diff --git a/document/core/text/modules.rst b/document/core/text/modules.rst
index b85f51328..0964dfdaa 100644
--- a/document/core/text/modules.rst
+++ b/document/core/text/modules.rst
@@ -120,7 +120,7 @@ The following auxiliary function extracts optional identifiers from parameters:
    Both productions overlap for the case that the function type is :math:`[] \to []`.
    However, in that case, they also produce the same results, so that the choice is immaterial.
 
-   The :ref:`well-formedness <text-context-wf>` condition on :math:`I'` ensures that the parameters do not contain duplicate identifier.
+   The :ref:`well-formedness <text-context-wf>` condition on :math:`I'` ensures that the parameters do not contain duplicate identifiers.
 
 
 .. _text-typeuse-abbrev:
@@ -356,7 +356,7 @@ Memory definitions can bind a symbolic :ref:`memory identifier <text-id>`.
 Abbreviations
 .............
 
-A :ref:`data segment <text-data>` can be given inline with a memory definition, in which case its offset is :math:`0` the :ref:`limits <text-limits>` of the :ref:`memory type <text-memtype>` are inferred from the length of the data, rounded up to :ref:`page size <page-size>`:
+A :ref:`data segment <text-data>` can be given inline with a memory definition, in which case its offset is :math:`0` and the :ref:`limits <text-limits>` of the :ref:`memory type <text-memtype>` are inferred from the length of the data, rounded up to :ref:`page size <page-size>`:
 
 .. math::
    \begin{array}{llclll}
@@ -365,7 +365,7 @@ A :ref:`data segment <text-data>` can be given inline with a memory definition,
        \text{(}~\text{memory}~~\Tid'~~m~~m~\text{)} \\ & \qquad
        \text{(}~\text{data}~~\text{(}~\text{memory}~~\Tid'~\text{)}~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Tdatastring~\text{)}
        \\ & \qquad\qquad
-       (\iff \Tid^? \neq \epsilon \wedge \Tid' = \Tid^? \vee \Tid^? = \epsilon \wedge \Tid' \idfresh, m = \F{ceil}(n / 64\F{Ki})) \\
+       (\iff \Tid^? \neq \epsilon \wedge \Tid' = \Tid^? \vee \Tid^? = \epsilon \wedge \Tid' \idfresh, m = \F{ceil}(n / 64\,\F{Ki})) \\
    \end{array}
 
 Memories can be defined as :ref:`imports <text-import>` or :ref:`exports <text-export>` inline:
diff --git a/document/core/valid/conventions.rst b/document/core/valid/conventions.rst
index b6a49b0cd..ae219e44a 100644
--- a/document/core/valid/conventions.rst
+++ b/document/core/valid/conventions.rst
@@ -150,7 +150,7 @@ and there is one respective rule for each relevant construct :math:`A` of the ab
         C \vdash \I32.\ADD : [\I32~\I32] \to [\I32]
       }
 
-   The instruction is always valid with type :math:`[\I32~\I32] \to [\I32`]
+   The instruction is always valid with type :math:`[\I32~\I32] \to [\I32]`
    (saying that it consumes two |I32| values and produces one),
    independent of any side conditions.
 
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 131551416..a6d6b007a 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -1033,7 +1033,7 @@ Memory Instructions
      \qquad
      2^{\memarg.\ALIGN} \leq N/8 \cdot M
    }{
-     C \vdashinstr \K{v128.}\K{.}\LOAD{N}\K{x}M\_\sx~\memarg : [\I32] \to [\V128]
+     C \vdashinstr \K{v128.}\LOAD{N}\K{x}M\_\sx~\memarg : [\I32] \to [\V128]
    }
 
 
@@ -1578,7 +1578,7 @@ Expressions :math:`\expr` are classified by :ref:`result types <syntax-resulttyp
 
 * The instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with some :ref:`stack type <syntax-stacktype>` :math:`[] \to [{t'}^\ast]`.
 
-* For each :ref:`operand type <syntax-opdtype>` :math:`t'_i` in :math:`{t'}^\ast` and corresponding :ref:`value type <syntax-valtype>` type :math:`t_i` in :math:`t^\ast`, :math:`t'_i` :ref:`matches <match-opdtype>` :math:`t_i`.
+* For each :ref:`operand type <syntax-opdtype>` :math:`t'_i` in :math:`{t'}^\ast` and corresponding :ref:`value type <syntax-valtype>` :math:`t_i` in :math:`t^\ast`, :math:`t'_i` :ref:`matches <match-opdtype>` :math:`t_i`.
 
 * Then the expression is valid with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`.
 
diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index ed17d795c..5b13ae7fc 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -147,7 +147,7 @@ Element segments :math:`\elem` are classified by the :ref:`reference type <synta
 :math:`\{ \ETYPE~t, \EINIT~e^\ast, \EMODE~\elemmode \}`
 .......................................................
 
-* For each :math:`e_i` in :math:`e^\ast`,
+* For each :math:`e_i` in :math:`e^\ast`:
 
   * The expression :math:`e_i` must be :ref:`valid <valid-expr>` with some :ref:`result type <syntax-resulttype>` :math:`[t]`.
 
diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 20c2c6e5c..40267eb85 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -585,7 +585,7 @@ interface Module {
 </div>
 
 <div algorithm>
-    The <dfn constructor for="Module">Module(|bytes|)</dfn> constructor, when invoked, performs the follwing steps:
+    The <dfn constructor for="Module">Module(|bytes|)</dfn> constructor, when invoked, performs the following steps:
 
     1. Let |stableBytes| be a [=get a copy of the buffer source|copy of the bytes held by the buffer=] |bytes|.
     1. [=Compile a WebAssembly module|Compile the WebAssembly module=] |stableBytes| and store the result as |module|.
@@ -778,7 +778,7 @@ Each {{Table}} object has a \[[Table]] internal slot, which is a [=table address
         1. Let |ref| be [=DefaultValue=](|elementType|).
     1. Otherwise,
         1. Let |ref| be ? [=ToWebAssemblyValue=](|value|, |elementType|).
-    1. Let |type| be the [=table type=] {[=table type|min=] |initial|, [=table type|ma𝗑=] |maximum|} |elementType|.
+    1. Let |type| be the [=table type=] {[=table type|min=] |initial|, [=table type|max=] |maximum|} |elementType|.
     1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let (|store|, |tableaddr|) be [=table_alloc=](|store|, |type|, |ref|). <!-- TODO(littledan): Report allocation failure https://github.com/WebAssembly/spec/issues/584 -->
     1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
@@ -1147,7 +1147,7 @@ WebAssembly defines the following Error classes: <dfn exception>CompileError</df
 <div algorithm="create the WebAssembly namespace object">
 When the [=namespace object=] for the {{WebAssembly}} namespace is [=create a namespace object|created=], the following steps must be run:
 
-1.  Let |namespaceObject| the [=namespace object=].
+1.  Let |namespaceObject| be the [=namespace object=].
 1.  [=list/iterate|For each=] |error| of « "CompileError", "LinkError", "RuntimeError" »,
     1.  Let |constructor| be a new object, implementing the [=NativeError Object Structure=], with <var ignore>NativeError</var> set to |error|.
     1.  ! [$CreateMethodProperty$](|namespaceObject|, |error|,  |constructor|).
@@ -1241,4 +1241,4 @@ In practice, an implementation may run out of resources for valid modules below
 
 <p><em>This section is non-normative.</em></p>
 
-This document defines a host environment for WebAssembly. It enables a WebAssembly instance to [=import=] JavaScript objects and functions from an [=read the imports|import object=], but otherwise provides no access to the embedding environment. Thus a WebAssembly instance is bounds to the same constraints as JavaScript.
+This document defines a host environment for WebAssembly. It enables a WebAssembly instance to [=import=] JavaScript objects and functions from an [=read the imports|import object=], but otherwise provides no access to the embedding environment. Thus a WebAssembly instance is bound to the same constraints as JavaScript.
diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index 51f92a5a7..602222129 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -125,7 +125,7 @@ Note: This algorithm accepts a {{Response}} object, or a
 
         1. If |response| is not [=CORS-same-origin=], [=reject=] |returnValue| with a {{TypeError}} and abort these substeps.
         1. If |response|'s [=response/status=] is not an [=ok status=], [=reject=] |returnValue| with a {{TypeError}} and abort these substeps.
-        1. [=Consume body|consume=] |response|'s body as an {{ArrayBuffer}}, and let |bodyPromise| be the result.
+        1. [=Consume body|Consume=] |response|'s body as an {{ArrayBuffer}}, and let |bodyPromise| be the result.
 
             Note: Although it is specified here that the response is consumed entirely before compilation proceeds, that is purely for ease of specification; implementations are likely to instead perform processing in a streaming fashion. The difference is unobservable, and thus the simpler model is specified. <!-- Using consume is a bit silly as it creates an ArrayBuffer but then we just want the underlying bytes. This is because of how streams is specced in terms of promises and JS objects whereas we want to operate more directly on the underlying concept. We can revisit this if things change in the Streams/Fetch specs. -->
 
@@ -145,7 +145,7 @@ Web user agents must augment the {{Module}} interface with the <code>[<a extende
 
 The [=serialization steps=], given |value|, |serialized|, and |forStorage|, are:
 
-    1. If |forStorage| is true, throw a "<a exception>DataCloneError</a>" {{DOMException}}
+    1. If |forStorage| is true, throw a "<a exception>DataCloneError</a>" {{DOMException}}.
 
     1. Set |serialized|.\[[Bytes]] to the [=sub-serialization=] of |value|.\[[Bytes]].
 
@@ -184,7 +184,7 @@ example) even though the exact format of implementation-dependent stack trace
 strings does not always match, the locations are easily understandable and the
 same across browsers.
 
-To achieve the same goal of a common representations for WebAssembly constructs, the
+To achieve the same goal of a common representation for WebAssembly constructs, the
 following conventions are adopted.
 
 A WebAssembly location is a reference to a particular instruction in the binary, and may be

From be736ea61394e7648d27f8bad9dc8faf5dc2ea86 Mon Sep 17 00:00:00 2001
From: gahaas <ahaas@google.com>
Date: Thu, 12 May 2022 14:31:28 +0200
Subject: [PATCH 121/285] TypeError for Global constructor with v128

At the moment the spec requires a `LinkError` to be thrown when the `WebAssembly.Global` constructor is called for type `v128`. This was introduced in https://github.com/WebAssembly/simd/pull/360, but according to the PR description, actually a `TypeError` should be thrown. The PR refers to https://github.com/WebAssembly/simd/blob/master/proposals/simd/SIMD.md#javascript-api-and-simd-values, and there a `TypeError` is required.
---
 document/js-api/index.bs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 40267eb85..f99f9f578 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -916,7 +916,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. Let |mutable| be |descriptor|["mutable"].
     1. Let |valuetype| be [=ToValueType=](|descriptor|["value"]).
     1. If |valuetype| is [=v128=],
-        1. Throw a {{LinkError}} exception.
+        1. Throw a {{TypeError}} exception.
     1. If |v| is missing,
         1. Let |value| be [=DefaultValue=](|valuetype|).
     1. Otherwise,

From 6e1efd1e0256890ecc7a02a39666f1e17b4da169 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Mon, 16 May 2022 18:36:18 +0200
Subject: [PATCH 122/285] [spec] Fix LEB opcodes in instruction index (#1475)

---
 .../core/appendix/gen-index-instructions.py   |  216 ++--
 document/core/appendix/index-instructions.rst | 1020 ++++++++---------
 2 files changed, 618 insertions(+), 618 deletions(-)

diff --git a/document/core/appendix/gen-index-instructions.py b/document/core/appendix/gen-index-instructions.py
index 477c7cf43..4e04cfff6 100755
--- a/document/core/appendix/gen-index-instructions.py
+++ b/document/core/appendix/gen-index-instructions.py
@@ -459,114 +459,114 @@ def Instruction(name, opcode, type=None, validation=None, execution=None, operat
     Instruction(r'\I16X8.\EXTADDPAIRWISE\K{\_i8x16\_u}', r'\hex{FD}~~\hex{7D}', r'[\V128] \to [\V128]', r'valid-vec-extadd_pairwise', r'exec-vec-extadd_pairwise'),
     Instruction(r'\I32X4.\EXTADDPAIRWISE\K{\_i16x8\_s}', r'\hex{FD}~~\hex{7E}', r'[\V128] \to [\V128]', r'valid-vec-extadd_pairwise', r'exec-vec-extadd_pairwise'),
     Instruction(r'\I32X4.\EXTADDPAIRWISE\K{\_i16x8\_u}', r'\hex{FD}~~\hex{7F}', r'[\V128] \to [\V128]', r'valid-vec-extadd_pairwise', r'exec-vec-extadd_pairwise'),
-    Instruction(r'\I16X8.\VABS', r'\hex{FD}~~\hex{80}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-iabs'),
-    Instruction(r'\I16X8.\VNEG', r'\hex{FD}~~\hex{81}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ineg'),
-    Instruction(r'\I16X8.\Q15MULRSAT\K{\_s}', r'\hex{FD}~~\hex{82}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iq15mulrsat_s'),
-    Instruction(r'\I16X8.\ALLTRUE', r'\hex{FD}~~\hex{83}', r'[\V128] \to [\I32]', r'valid-vtestop', r'exec-vtestop'),
-    Instruction(r'\I16X8.\BITMASK', r'\hex{FD}~~\hex{84}', r'[\V128] \to [\I32]', r'valid-vec-bitmask', r'exec-vec-bitmask'),
-    Instruction(r'\I16X8.\NARROW\K{\_i32x4\_s}', r'\hex{FD}~~\hex{85}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vec-narrow'),
-    Instruction(r'\I16X8.\NARROW\K{\_i32x4\_u}', r'\hex{FD}~~\hex{86}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vec-narrow'),
-    Instruction(r'\I16X8.\VEXTEND\K{\_low\_i8x16\_s}', r'\hex{FD}~~\hex{87}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
-    Instruction(r'\I16X8.\VEXTEND\K{\_high\_i8x16\_s}', r'\hex{FD}~~\hex{88}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
-    Instruction(r'\I16X8.\VEXTEND\K{\_low\_i8x16\_u}', r'\hex{FD}~~\hex{89}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
-    Instruction(r'\I16X8.\VEXTEND\K{\_high\_i8x16\_u}', r'\hex{FD}~~\hex{8A}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
-    Instruction(r'\I16X8.\VSHL', r'\hex{FD}~~\hex{8B}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishl'),
-    Instruction(r'\I16X8.\VSHR\K{\_s}', r'\hex{FD}~~\hex{8C}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_s'),
-    Instruction(r'\I16X8.\VSHR\K{\_u}', r'\hex{FD}~~\hex{8D}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_u'),
-    Instruction(r'\I16X8.\VADD', r'\hex{FD}~~\hex{8E}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd'),
-    Instruction(r'\I16X8.\VADD\K{\_sat\_s}', r'\hex{FD}~~\hex{8F}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd_sat_s'),
-    Instruction(r'\I16X8.\VADD\K{\_sat\_u}', r'\hex{FD}~~\hex{90}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd_sat_u'),
-    Instruction(r'\I16X8.\VSUB', r'\hex{FD}~~\hex{91}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub'),
-    Instruction(r'\I16X8.\VSUB\K{\_sat\_s}', r'\hex{FD}~~\hex{92}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub_sat_s'),
-    Instruction(r'\I16X8.\VSUB\K{\_sat\_u}', r'\hex{FD}~~\hex{93}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub_sat_u'),
-    Instruction(r'\F64X2.\VNEAREST', r'\hex{FD}~~\hex{94}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fnearest'),
-    Instruction(r'\I16X8.\VMUL', r'\hex{FD}~~\hex{95}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imul'),
-    Instruction(r'\I16X8.\VMIN\K{\_s}', r'\hex{FD}~~\hex{96}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imin_s'),
-    Instruction(r'\I16X8.\VMIN\K{\_u}', r'\hex{FD}~~\hex{97}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imin_u'),
-    Instruction(r'\I16X8.\VMAX\K{\_s}', r'\hex{FD}~~\hex{98}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imax_s'),
-    Instruction(r'\I16X8.\VMAX\K{\_u}', r'\hex{FD}~~\hex{99}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imax_u'),
-    Instruction(r'\I16X8.\AVGR\K{\_u}', r'\hex{FD}~~\hex{9B}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iavgr_u'),
-    Instruction(r'\I16X8.\EXTMUL\K{\_low\_i8x16\_s}', r'\hex{FD}~~\hex{9C}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
-    Instruction(r'\I16X8.\EXTMUL\K{\_high\_i8x16\_s}', r'\hex{FD}~~\hex{9D}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
-    Instruction(r'\I16X8.\EXTMUL\K{\_low\_i8x16\_u}', r'\hex{FD}~~\hex{9E}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
-    Instruction(r'\I16X8.\EXTMUL\K{\_high\_i8x16\_u}', r'\hex{FD}~~\hex{9F}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
-    Instruction(r'\I32X4.\VABS', r'\hex{FD}~~\hex{A0}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-iabs'),
-    Instruction(r'\I32X4.\VNEG', r'\hex{FD}~~\hex{A1}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ineg'),
-    Instruction(r'\I32X4.\ALLTRUE', r'\hex{FD}~~\hex{A3}', r'[\V128] \to [\I32]', r'valid-vtestop', r'exec-vtestop'),
-    Instruction(r'\I32X4.\BITMASK', r'\hex{FD}~~\hex{A4}', r'[\V128] \to [\I32]', r'valid-vec-bitmask', r'exec-vec-bitmask'),
-    Instruction(r'\I32X4.\VEXTEND\K{\_low\_i16x8\_s}', r'\hex{FD}~~\hex{A7}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
-    Instruction(r'\I32X4.\VEXTEND\K{\_high\_i16x8\_s}', r'\hex{FD}~~\hex{A8}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
-    Instruction(r'\I32X4.\VEXTEND\K{\_low\_i16x8\_u}', r'\hex{FD}~~\hex{A9}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
-    Instruction(r'\I32X4.\VEXTEND\K{\_high\_i16x8\_u}', r'\hex{FD}~~\hex{AA}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
-    Instruction(r'\I32X4.\VSHL', r'\hex{FD}~~\hex{AB}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishl'),
-    Instruction(r'\I32X4.\VSHR\K{\_s}', r'\hex{FD}~~\hex{AC}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_s'),
-    Instruction(r'\I32X4.\VSHR\K{\_u}', r'\hex{FD}~~\hex{AD}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_u'),
-    Instruction(r'\I32X4.\VADD', r'\hex{FD}~~\hex{AE}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd'),
-    Instruction(r'\I32X4.\VSUB', r'\hex{FD}~~\hex{B1}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub'),
-    Instruction(r'\I32X4.\VMUL', r'\hex{FD}~~\hex{B5}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imul'),
-    Instruction(r'\I32X4.\VMIN\K{\_s}', r'\hex{FD}~~\hex{B6}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imin_s'),
-    Instruction(r'\I32X4.\VMIN\K{\_u}', r'\hex{FD}~~\hex{B7}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imin_u'),
-    Instruction(r'\I32X4.\VMAX\K{\_s}', r'\hex{FD}~~\hex{B8}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imax_s'),
-    Instruction(r'\I32X4.\VMAX\K{\_u}', r'\hex{FD}~~\hex{B9}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imax_u'),
-    Instruction(r'\I32X4.\DOT\K{\_i16x8\_s}', r'\hex{FD}~~\hex{BA}', r'[\V128~\V128] \to [\V128]', r'valid-vec-dot', r'exec-vec-dot'),
-    Instruction(r'\I32X4.\EXTMUL\K{\_low\_i16x8\_s}', r'\hex{FD}~~\hex{BC}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
-    Instruction(r'\I32X4.\EXTMUL\K{\_high\_i16x8\_s}', r'\hex{FD}~~\hex{BD}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
-    Instruction(r'\I32X4.\EXTMUL\K{\_low\_i16x8\_u}', r'\hex{FD}~~\hex{BE}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
-    Instruction(r'\I32X4.\EXTMUL\K{\_high\_i16x8\_u}', r'\hex{FD}~~\hex{BF}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
-    Instruction(r'\I64X2.\VABS', r'\hex{FD}~~\hex{C0}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-iabs'),
-    Instruction(r'\I64X2.\VNEG', r'\hex{FD}~~\hex{C1}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ineg'),
-    Instruction(r'\I64X2.\ALLTRUE', r'\hex{FD}~~\hex{C3}', r'[\V128] \to [\I32]', r'valid-vtestop', r'exec-vtestop'),
-    Instruction(r'\I64X2.\BITMASK', r'\hex{FD}~~\hex{C4}', r'[\V128] \to [\I32]', r'valid-vec-bitmask', r'exec-vec-bitmask'),
-    Instruction(r'\I64X2.\VEXTEND\K{\_low\_i32x4\_s}', r'\hex{FD}~~\hex{C7}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
-    Instruction(r'\I64X2.\VEXTEND\K{\_high\_i32x4\_s}', r'\hex{FD}~~\hex{C8}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
-    Instruction(r'\I64X2.\VEXTEND\K{\_low\_i32x4\_u}', r'\hex{FD}~~\hex{C9}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
-    Instruction(r'\I64X2.\VEXTEND\K{\_high\_i32x4\_u}', r'\hex{FD}~~\hex{CA}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
-    Instruction(r'\I64X2.\VSHL', r'\hex{FD}~~\hex{CB}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishl'),
-    Instruction(r'\I64X2.\VSHR\K{\_s}', r'\hex{FD}~~\hex{CC}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_s'),
-    Instruction(r'\I64X2.\VSHR\K{\_u}', r'\hex{FD}~~\hex{CD}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_u'),
-    Instruction(r'\I64X2.\VADD', r'\hex{FD}~~\hex{CE}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd'),
-    Instruction(r'\I64X2.\VSUB', r'\hex{FD}~~\hex{D1}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub'),
-    Instruction(r'\I64X2.\VMUL', r'\hex{FD}~~\hex{D5}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imul'),
-    Instruction(r'\I64X2.\VEQ', r'\hex{FD}~~\hex{D6}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ieq'),
-    Instruction(r'\I64X2.\VNE', r'\hex{FD}~~\hex{D7}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ine'),
-    Instruction(r'\I64X2.\VLT\K{\_s}', r'\hex{FD}~~\hex{D8}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ilt_s'),
-    Instruction(r'\I64X2.\VGT\K{\_s}', r'\hex{FD}~~\hex{D9}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-igt_s'),
-    Instruction(r'\I64X2.\VLE\K{\_s}', r'\hex{FD}~~\hex{DA}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ile_s'),
-    Instruction(r'\I64X2.\VGE\K{\_s}', r'\hex{FD}~~\hex{DB}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ige_s'),
-    Instruction(r'\I64X2.\EXTMUL\K{\_low\_i32x4\_s}', r'\hex{FD}~~\hex{DC}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
-    Instruction(r'\I64X2.\EXTMUL\K{\_high\_i32x4\_s}', r'\hex{FD}~~\hex{DD}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
-    Instruction(r'\I64X2.\EXTMUL\K{\_low\_i32x4\_u}', r'\hex{FD}~~\hex{DE}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
-    Instruction(r'\I64X2.\EXTMUL\K{\_high\_i32x4\_u}', r'\hex{FD}~~\hex{DF}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
-    Instruction(r'\F32X4.\VABS', r'\hex{FD}~~\hex{E0}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fabs'),
-    Instruction(r'\F32X4.\VNEG', r'\hex{FD}~~\hex{E1}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fneg'),
-    Instruction(r'\F32X4.\VSQRT', r'\hex{FD}~~\hex{E3}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fsqrt'),
-    Instruction(r'\F32X4.\VADD', r'\hex{FD}~~\hex{E4}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fadd'),
-    Instruction(r'\F32X4.\VSUB', r'\hex{FD}~~\hex{E5}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fsub'),
-    Instruction(r'\F32X4.\VMUL', r'\hex{FD}~~\hex{E6}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmul'),
-    Instruction(r'\F32X4.\VDIV', r'\hex{FD}~~\hex{E7}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fdiv'),
-    Instruction(r'\F32X4.\VMIN', r'\hex{FD}~~\hex{E8}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmin'),
-    Instruction(r'\F32X4.\VMAX', r'\hex{FD}~~\hex{E9}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmax'),
-    Instruction(r'\F32X4.\VPMIN', r'\hex{FD}~~\hex{EA}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fpmin'),
-    Instruction(r'\F32X4.\VPMAX', r'\hex{FD}~~\hex{EB}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fpmax'),
-    Instruction(r'\F64X2.\VABS', r'\hex{FD}~~\hex{EC}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fabs'),
-    Instruction(r'\F64X2.\VNEG', r'\hex{FD}~~\hex{ED}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fneg'),
-    Instruction(r'\F64X2.\VSQRT', r'\hex{FD}~~\hex{EF}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fsqrt'),
-    Instruction(r'\F64X2.\VADD', r'\hex{FD}~~\hex{F0}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fadd'),
-    Instruction(r'\F64X2.\VSUB', r'\hex{FD}~~\hex{F1}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fsub'),
-    Instruction(r'\F64X2.\VMUL', r'\hex{FD}~~\hex{F2}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmul'),
-    Instruction(r'\F64X2.\VDIV', r'\hex{FD}~~\hex{F3}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fdiv'),
-    Instruction(r'\F64X2.\VMIN', r'\hex{FD}~~\hex{F4}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmin'),
-    Instruction(r'\F64X2.\VMAX', r'\hex{FD}~~\hex{F5}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmax'),
-    Instruction(r'\F64X2.\VPMIN', r'\hex{FD}~~\hex{F6}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fpmin'),
-    Instruction(r'\F64X2.\VPMAX', r'\hex{FD}~~\hex{F7}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fpmax'),
-    Instruction(r'\I32X4.\TRUNC\K{\_sat\_f32x4\_s}', r'\hex{FD}~~\hex{F8}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-trunc_sat_s'),
-    Instruction(r'\I32X4.\TRUNC\K{\_sat\_f32x4\_u}', r'\hex{FD}~~\hex{F9}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-trunc_sat_u'),
-    Instruction(r'\F32X4.\VCONVERT\K{\_i32x4\_s}', r'\hex{FD}~~\hex{FA}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-convert_s'),
-    Instruction(r'\F32X4.\VCONVERT\K{\_i32x4\_u}', r'\hex{FD}~~\hex{FB}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-convert_u'),
-    Instruction(r'\I32X4.\VTRUNC\K{\_sat\_f64x2\_s\_zero}', r'\hex{FD}~~\hex{FC}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-trunc_sat_s'),
-    Instruction(r'\I32X4.\VTRUNC\K{\_sat\_f64x2\_u\_zero}', r'\hex{FD}~~\hex{FD}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-trunc_sat_u'),
-    Instruction(r'\F64X2.\VCONVERT\K{\_low\_i32x4\_s}', r'\hex{FD}~~\hex{FE}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-convert_s'),
-    Instruction(r'\F64X2.\VCONVERT\K{\_low\_i32x4\_u}', r'\hex{FD}~~\hex{FF}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-convert_u'),
+    Instruction(r'\I16X8.\VABS', r'\hex{FD}~~\hex{80}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-iabs'),
+    Instruction(r'\I16X8.\VNEG', r'\hex{FD}~~\hex{81}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ineg'),
+    Instruction(r'\I16X8.\Q15MULRSAT\K{\_s}', r'\hex{FD}~~\hex{82}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iq15mulrsat_s'),
+    Instruction(r'\I16X8.\ALLTRUE', r'\hex{FD}~~\hex{83}~~\hex{01}', r'[\V128] \to [\I32]', r'valid-vtestop', r'exec-vtestop'),
+    Instruction(r'\I16X8.\BITMASK', r'\hex{FD}~~\hex{84}~~\hex{01}', r'[\V128] \to [\I32]', r'valid-vec-bitmask', r'exec-vec-bitmask'),
+    Instruction(r'\I16X8.\NARROW\K{\_i32x4\_s}', r'\hex{FD}~~\hex{85}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vec-narrow'),
+    Instruction(r'\I16X8.\NARROW\K{\_i32x4\_u}', r'\hex{FD}~~\hex{86}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vec-narrow'),
+    Instruction(r'\I16X8.\VEXTEND\K{\_low\_i8x16\_s}', r'\hex{FD}~~\hex{87}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I16X8.\VEXTEND\K{\_high\_i8x16\_s}', r'\hex{FD}~~\hex{88}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I16X8.\VEXTEND\K{\_low\_i8x16\_u}', r'\hex{FD}~~\hex{89}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I16X8.\VEXTEND\K{\_high\_i8x16\_u}', r'\hex{FD}~~\hex{8A}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I16X8.\VSHL', r'\hex{FD}~~\hex{8B}~~\hex{01}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishl'),
+    Instruction(r'\I16X8.\VSHR\K{\_s}', r'\hex{FD}~~\hex{8C}~~\hex{01}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_s'),
+    Instruction(r'\I16X8.\VSHR\K{\_u}', r'\hex{FD}~~\hex{8D}~~\hex{01}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_u'),
+    Instruction(r'\I16X8.\VADD', r'\hex{FD}~~\hex{8E}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd'),
+    Instruction(r'\I16X8.\VADD\K{\_sat\_s}', r'\hex{FD}~~\hex{8F}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd_sat_s'),
+    Instruction(r'\I16X8.\VADD\K{\_sat\_u}', r'\hex{FD}~~\hex{90}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd_sat_u'),
+    Instruction(r'\I16X8.\VSUB', r'\hex{FD}~~\hex{91}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub'),
+    Instruction(r'\I16X8.\VSUB\K{\_sat\_s}', r'\hex{FD}~~\hex{92}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub_sat_s'),
+    Instruction(r'\I16X8.\VSUB\K{\_sat\_u}', r'\hex{FD}~~\hex{93}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub_sat_u'),
+    Instruction(r'\F64X2.\VNEAREST', r'\hex{FD}~~\hex{94}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fnearest'),
+    Instruction(r'\I16X8.\VMUL', r'\hex{FD}~~\hex{95}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imul'),
+    Instruction(r'\I16X8.\VMIN\K{\_s}', r'\hex{FD}~~\hex{96}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imin_s'),
+    Instruction(r'\I16X8.\VMIN\K{\_u}', r'\hex{FD}~~\hex{97}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imin_u'),
+    Instruction(r'\I16X8.\VMAX\K{\_s}', r'\hex{FD}~~\hex{98}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imax_s'),
+    Instruction(r'\I16X8.\VMAX\K{\_u}', r'\hex{FD}~~\hex{99}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imax_u'),
+    Instruction(r'\I16X8.\AVGR\K{\_u}', r'\hex{FD}~~\hex{9B}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iavgr_u'),
+    Instruction(r'\I16X8.\EXTMUL\K{\_low\_i8x16\_s}', r'\hex{FD}~~\hex{9C}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I16X8.\EXTMUL\K{\_high\_i8x16\_s}', r'\hex{FD}~~\hex{9D}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I16X8.\EXTMUL\K{\_low\_i8x16\_u}', r'\hex{FD}~~\hex{9E}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I16X8.\EXTMUL\K{\_high\_i8x16\_u}', r'\hex{FD}~~\hex{9F}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I32X4.\VABS', r'\hex{FD}~~\hex{A0}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-iabs'),
+    Instruction(r'\I32X4.\VNEG', r'\hex{FD}~~\hex{A1}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ineg'),
+    Instruction(r'\I32X4.\ALLTRUE', r'\hex{FD}~~\hex{A3}~~\hex{01}', r'[\V128] \to [\I32]', r'valid-vtestop', r'exec-vtestop'),
+    Instruction(r'\I32X4.\BITMASK', r'\hex{FD}~~\hex{A4}~~\hex{01}', r'[\V128] \to [\I32]', r'valid-vec-bitmask', r'exec-vec-bitmask'),
+    Instruction(r'\I32X4.\VEXTEND\K{\_low\_i16x8\_s}', r'\hex{FD}~~\hex{A7}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I32X4.\VEXTEND\K{\_high\_i16x8\_s}', r'\hex{FD}~~\hex{A8}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I32X4.\VEXTEND\K{\_low\_i16x8\_u}', r'\hex{FD}~~\hex{A9}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I32X4.\VEXTEND\K{\_high\_i16x8\_u}', r'\hex{FD}~~\hex{AA}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I32X4.\VSHL', r'\hex{FD}~~\hex{AB}~~\hex{01}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishl'),
+    Instruction(r'\I32X4.\VSHR\K{\_s}', r'\hex{FD}~~\hex{AC}~~\hex{01}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_s'),
+    Instruction(r'\I32X4.\VSHR\K{\_u}', r'\hex{FD}~~\hex{AD}~~\hex{01}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_u'),
+    Instruction(r'\I32X4.\VADD', r'\hex{FD}~~\hex{AE}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd'),
+    Instruction(r'\I32X4.\VSUB', r'\hex{FD}~~\hex{B1}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub'),
+    Instruction(r'\I32X4.\VMUL', r'\hex{FD}~~\hex{B5}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imul'),
+    Instruction(r'\I32X4.\VMIN\K{\_s}', r'\hex{FD}~~\hex{B6}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imin_s'),
+    Instruction(r'\I32X4.\VMIN\K{\_u}', r'\hex{FD}~~\hex{B7}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imin_u'),
+    Instruction(r'\I32X4.\VMAX\K{\_s}', r'\hex{FD}~~\hex{B8}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imax_s'),
+    Instruction(r'\I32X4.\VMAX\K{\_u}', r'\hex{FD}~~\hex{B9}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imax_u'),
+    Instruction(r'\I32X4.\DOT\K{\_i16x8\_s}', r'\hex{FD}~~\hex{BA}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vec-dot', r'exec-vec-dot'),
+    Instruction(r'\I32X4.\EXTMUL\K{\_low\_i16x8\_s}', r'\hex{FD}~~\hex{BC}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I32X4.\EXTMUL\K{\_high\_i16x8\_s}', r'\hex{FD}~~\hex{BD}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I32X4.\EXTMUL\K{\_low\_i16x8\_u}', r'\hex{FD}~~\hex{BE}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I32X4.\EXTMUL\K{\_high\_i16x8\_u}', r'\hex{FD}~~\hex{BF}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I64X2.\VABS', r'\hex{FD}~~\hex{C0}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-iabs'),
+    Instruction(r'\I64X2.\VNEG', r'\hex{FD}~~\hex{C1}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-ineg'),
+    Instruction(r'\I64X2.\ALLTRUE', r'\hex{FD}~~\hex{C3}~~\hex{01}', r'[\V128] \to [\I32]', r'valid-vtestop', r'exec-vtestop'),
+    Instruction(r'\I64X2.\BITMASK', r'\hex{FD}~~\hex{C4}~~\hex{01}', r'[\V128] \to [\I32]', r'valid-vec-bitmask', r'exec-vec-bitmask'),
+    Instruction(r'\I64X2.\VEXTEND\K{\_low\_i32x4\_s}', r'\hex{FD}~~\hex{C7}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I64X2.\VEXTEND\K{\_high\_i32x4\_s}', r'\hex{FD}~~\hex{C8}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I64X2.\VEXTEND\K{\_low\_i32x4\_u}', r'\hex{FD}~~\hex{C9}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I64X2.\VEXTEND\K{\_high\_i32x4\_u}', r'\hex{FD}~~\hex{CA}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vcvtop'),
+    Instruction(r'\I64X2.\VSHL', r'\hex{FD}~~\hex{CB}~~\hex{01}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishl'),
+    Instruction(r'\I64X2.\VSHR\K{\_s}', r'\hex{FD}~~\hex{CC}~~\hex{01}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_s'),
+    Instruction(r'\I64X2.\VSHR\K{\_u}', r'\hex{FD}~~\hex{CD}~~\hex{01}', r'[\V128~\I32] \to [\V128]', r'valid-vishiftop', r'exec-vishiftop', r'op-ishr_u'),
+    Instruction(r'\I64X2.\VADD', r'\hex{FD}~~\hex{CE}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-iadd'),
+    Instruction(r'\I64X2.\VSUB', r'\hex{FD}~~\hex{D1}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-isub'),
+    Instruction(r'\I64X2.\VMUL', r'\hex{FD}~~\hex{D5}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-imul'),
+    Instruction(r'\I64X2.\VEQ', r'\hex{FD}~~\hex{D6}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ieq'),
+    Instruction(r'\I64X2.\VNE', r'\hex{FD}~~\hex{D7}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ine'),
+    Instruction(r'\I64X2.\VLT\K{\_s}', r'\hex{FD}~~\hex{D8}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ilt_s'),
+    Instruction(r'\I64X2.\VGT\K{\_s}', r'\hex{FD}~~\hex{D9}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-igt_s'),
+    Instruction(r'\I64X2.\VLE\K{\_s}', r'\hex{FD}~~\hex{DA}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ile_s'),
+    Instruction(r'\I64X2.\VGE\K{\_s}', r'\hex{FD}~~\hex{DB}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-ige_s'),
+    Instruction(r'\I64X2.\EXTMUL\K{\_low\_i32x4\_s}', r'\hex{FD}~~\hex{DC}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I64X2.\EXTMUL\K{\_high\_i32x4\_s}', r'\hex{FD}~~\hex{DD}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I64X2.\EXTMUL\K{\_low\_i32x4\_u}', r'\hex{FD}~~\hex{DE}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\I64X2.\EXTMUL\K{\_high\_i32x4\_u}', r'\hex{FD}~~\hex{DF}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vec-extmul', r'exec-vec-extmul'),
+    Instruction(r'\F32X4.\VABS', r'\hex{FD}~~\hex{E0}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fabs'),
+    Instruction(r'\F32X4.\VNEG', r'\hex{FD}~~\hex{E1}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fneg'),
+    Instruction(r'\F32X4.\VSQRT', r'\hex{FD}~~\hex{E3}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fsqrt'),
+    Instruction(r'\F32X4.\VADD', r'\hex{FD}~~\hex{E4}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fadd'),
+    Instruction(r'\F32X4.\VSUB', r'\hex{FD}~~\hex{E5}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fsub'),
+    Instruction(r'\F32X4.\VMUL', r'\hex{FD}~~\hex{E6}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmul'),
+    Instruction(r'\F32X4.\VDIV', r'\hex{FD}~~\hex{E7}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fdiv'),
+    Instruction(r'\F32X4.\VMIN', r'\hex{FD}~~\hex{E8}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmin'),
+    Instruction(r'\F32X4.\VMAX', r'\hex{FD}~~\hex{E9}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmax'),
+    Instruction(r'\F32X4.\VPMIN', r'\hex{FD}~~\hex{EA}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fpmin'),
+    Instruction(r'\F32X4.\VPMAX', r'\hex{FD}~~\hex{EB}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fpmax'),
+    Instruction(r'\F64X2.\VABS', r'\hex{FD}~~\hex{EC}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fabs'),
+    Instruction(r'\F64X2.\VNEG', r'\hex{FD}~~\hex{ED}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fneg'),
+    Instruction(r'\F64X2.\VSQRT', r'\hex{FD}~~\hex{EF}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vunop', r'exec-vunop', r'op-fsqrt'),
+    Instruction(r'\F64X2.\VADD', r'\hex{FD}~~\hex{F0}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fadd'),
+    Instruction(r'\F64X2.\VSUB', r'\hex{FD}~~\hex{F1}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fsub'),
+    Instruction(r'\F64X2.\VMUL', r'\hex{FD}~~\hex{F2}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmul'),
+    Instruction(r'\F64X2.\VDIV', r'\hex{FD}~~\hex{F3}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fdiv'),
+    Instruction(r'\F64X2.\VMIN', r'\hex{FD}~~\hex{F4}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmin'),
+    Instruction(r'\F64X2.\VMAX', r'\hex{FD}~~\hex{F5}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fmax'),
+    Instruction(r'\F64X2.\VPMIN', r'\hex{FD}~~\hex{F6}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fpmin'),
+    Instruction(r'\F64X2.\VPMAX', r'\hex{FD}~~\hex{F7}~~\hex{01}', r'[\V128~\V128] \to [\V128]', r'valid-vbinop', r'exec-vbinop', r'op-fpmax'),
+    Instruction(r'\I32X4.\TRUNC\K{\_sat\_f32x4\_s}', r'\hex{FD}~~\hex{F8}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-trunc_sat_s'),
+    Instruction(r'\I32X4.\TRUNC\K{\_sat\_f32x4\_u}', r'\hex{FD}~~\hex{F9}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-trunc_sat_u'),
+    Instruction(r'\F32X4.\VCONVERT\K{\_i32x4\_s}', r'\hex{FD}~~\hex{FA}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-convert_s'),
+    Instruction(r'\F32X4.\VCONVERT\K{\_i32x4\_u}', r'\hex{FD}~~\hex{FB}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-convert_u'),
+    Instruction(r'\I32X4.\VTRUNC\K{\_sat\_f64x2\_s\_zero}', r'\hex{FD}~~\hex{FC}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-trunc_sat_s'),
+    Instruction(r'\I32X4.\VTRUNC\K{\_sat\_f64x2\_u\_zero}', r'\hex{FD}~~\hex{FD}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-trunc_sat_u'),
+    Instruction(r'\F64X2.\VCONVERT\K{\_low\_i32x4\_s}', r'\hex{FD}~~\hex{FE}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-convert_s'),
+    Instruction(r'\F64X2.\VCONVERT\K{\_low\_i32x4\_u}', r'\hex{FD}~~\hex{FF}~~\hex{01}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-convert_u'),
 ]
 
 
diff --git a/document/core/appendix/index-instructions.rst b/document/core/appendix/index-instructions.rst
index 2a6e6f397..a82fa9a62 100644
--- a/document/core/appendix/index-instructions.rst
+++ b/document/core/appendix/index-instructions.rst
@@ -6,513 +6,513 @@
 Index of Instructions
 ---------------------
 
-=================================================  ==========================  =============================================  =============================================  ==================================================================
-Instruction                                        Binary Opcode               Type                                           Validation                                     Execution                                                         
-=================================================  ==========================  =============================================  =============================================  ==================================================================
-:math:`\UNREACHABLE`                               :math:`\hex{00}`            :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-unreachable>`          :ref:`execution <exec-unreachable>`                               
-:math:`\NOP`                                       :math:`\hex{01}`            :math:`[] \to []`                              :ref:`validation <valid-nop>`                  :ref:`execution <exec-nop>`                                       
-:math:`\BLOCK~\X{bt}`                              :math:`\hex{02}`            :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-block>`                :ref:`execution <exec-block>`                                     
-:math:`\LOOP~\X{bt}`                               :math:`\hex{03}`            :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-loop>`                 :ref:`execution <exec-loop>`                                      
-:math:`\IF~\X{bt}`                                 :math:`\hex{04}`            :math:`[t_1^\ast~\I32] \to [t_2^\ast]`         :ref:`validation <valid-if>`                   :ref:`execution <exec-if>`                                        
-:math:`\ELSE`                                      :math:`\hex{05}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{06}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{07}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{08}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{09}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{0A}`                                                                                                                                                                            
-:math:`\END`                                       :math:`\hex{0B}`                                                                                                                                                                            
-:math:`\BR~l`                                      :math:`\hex{0C}`            :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`       :ref:`validation <valid-br>`                   :ref:`execution <exec-br>`                                        
-:math:`\BRIF~l`                                    :math:`\hex{0D}`            :math:`[t^\ast~\I32] \to [t^\ast]`             :ref:`validation <valid-br_if>`                :ref:`execution <exec-br_if>`                                     
-:math:`\BRTABLE~l^\ast~l`                          :math:`\hex{0E}`            :math:`[t_1^\ast~t^\ast~\I32] \to [t_2^\ast]`  :ref:`validation <valid-br_table>`             :ref:`execution <exec-br_table>`                                  
-:math:`\RETURN`                                    :math:`\hex{0F}`            :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`       :ref:`validation <valid-return>`               :ref:`execution <exec-return>`                                    
-:math:`\CALL~x`                                    :math:`\hex{10}`            :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-call>`                 :ref:`execution <exec-call>`                                      
-:math:`\CALLINDIRECT~x~y`                          :math:`\hex{11}`            :math:`[t_1^\ast~\I32] \to [t_2^\ast]`         :ref:`validation <valid-call_indirect>`        :ref:`execution <exec-call_indirect>`                             
-(reserved)                                         :math:`\hex{12}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{13}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{14}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{15}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{16}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{17}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{18}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{19}`                                                                                                                                                                            
-:math:`\DROP`                                      :math:`\hex{1A}`            :math:`[t] \to []`                             :ref:`validation <valid-drop>`                 :ref:`execution <exec-drop>`                                      
-:math:`\SELECT`                                    :math:`\hex{1B}`            :math:`[t~t~\I32] \to [t]`                     :ref:`validation <valid-select>`               :ref:`execution <exec-select>`                                    
-:math:`\SELECT~t`                                  :math:`\hex{1C}`            :math:`[t~t~\I32] \to [t]`                     :ref:`validation <valid-select>`               :ref:`execution <exec-select>`                                    
-(reserved)                                         :math:`\hex{1D}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{1E}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{1F}`                                                                                                                                                                            
-:math:`\LOCALGET~x`                                :math:`\hex{20}`            :math:`[] \to [t]`                             :ref:`validation <valid-local.get>`            :ref:`execution <exec-local.get>`                                 
-:math:`\LOCALSET~x`                                :math:`\hex{21}`            :math:`[t] \to []`                             :ref:`validation <valid-local.set>`            :ref:`execution <exec-local.set>`                                 
-:math:`\LOCALTEE~x`                                :math:`\hex{22}`            :math:`[t] \to [t]`                            :ref:`validation <valid-local.tee>`            :ref:`execution <exec-local.tee>`                                 
-:math:`\GLOBALGET~x`                               :math:`\hex{23}`            :math:`[] \to [t]`                             :ref:`validation <valid-global.get>`           :ref:`execution <exec-global.get>`                                
-:math:`\GLOBALSET~x`                               :math:`\hex{24}`            :math:`[t] \to []`                             :ref:`validation <valid-global.set>`           :ref:`execution <exec-global.set>`                                
-:math:`\TABLEGET~x`                                :math:`\hex{25}`            :math:`[\I32] \to [t]`                         :ref:`validation <valid-table.get>`            :ref:`execution <exec-table.get>`                                 
-:math:`\TABLESET~x`                                :math:`\hex{26}`            :math:`[\I32~t] \to []`                        :ref:`validation <valid-table.set>`            :ref:`execution <exec-table.set>`                                 
-(reserved)                                         :math:`\hex{27}`                                                                                                                                                                            
-:math:`\I32.\LOAD~\memarg`                         :math:`\hex{28}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
-:math:`\I64.\LOAD~\memarg`                         :math:`\hex{29}`            :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
-:math:`\F32.\LOAD~\memarg`                         :math:`\hex{2A}`            :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
-:math:`\F64.\LOAD~\memarg`                         :math:`\hex{2B}`            :math:`[\I32] \to [\F64]`                      :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
-:math:`\I32.\LOAD\K{8\_s}~\memarg`                 :math:`\hex{2C}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
-:math:`\I32.\LOAD\K{8\_u}~\memarg`                 :math:`\hex{2D}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
-:math:`\I32.\LOAD\K{16\_s}~\memarg`                :math:`\hex{2E}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
-:math:`\I32.\LOAD\K{16\_u}~\memarg`                :math:`\hex{2F}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
-:math:`\I64.\LOAD\K{8\_s}~\memarg`                 :math:`\hex{30}`            :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
-:math:`\I64.\LOAD\K{8\_u}~\memarg`                 :math:`\hex{31}`            :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
-:math:`\I64.\LOAD\K{16\_s}~\memarg`                :math:`\hex{32}`            :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
-:math:`\I64.\LOAD\K{16\_u}~\memarg`                :math:`\hex{33}`            :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
-:math:`\I64.\LOAD\K{32\_s}~\memarg`                :math:`\hex{34}`            :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
-:math:`\I64.\LOAD\K{32\_u}~\memarg`                :math:`\hex{35}`            :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
-:math:`\I32.\STORE~\memarg`                        :math:`\hex{36}`            :math:`[\I32~\I32] \to []`                     :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
-:math:`\I64.\STORE~\memarg`                        :math:`\hex{37}`            :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
-:math:`\F32.\STORE~\memarg`                        :math:`\hex{38}`            :math:`[\I32~\F32] \to []`                     :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
-:math:`\F64.\STORE~\memarg`                        :math:`\hex{39}`            :math:`[\I32~\F64] \to []`                     :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
-:math:`\I32.\STORE\K{8}~\memarg`                   :math:`\hex{3A}`            :math:`[\I32~\I32] \to []`                     :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
-:math:`\I32.\STORE\K{16}~\memarg`                  :math:`\hex{3B}`            :math:`[\I32~\I32] \to []`                     :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
-:math:`\I64.\STORE\K{8}~\memarg`                   :math:`\hex{3C}`            :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
-:math:`\I64.\STORE\K{16}~\memarg`                  :math:`\hex{3D}`            :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
-:math:`\I64.\STORE\K{32}~\memarg`                  :math:`\hex{3E}`            :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
-:math:`\MEMORYSIZE`                                :math:`\hex{3F}`            :math:`[] \to [\I32]`                          :ref:`validation <valid-memory.size>`          :ref:`execution <exec-memory.size>`                               
-:math:`\MEMORYGROW`                                :math:`\hex{40}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-memory.grow>`          :ref:`execution <exec-memory.grow>`                               
-:math:`\I32.\CONST~\i32`                           :math:`\hex{41}`            :math:`[] \to [\I32]`                          :ref:`validation <valid-const>`                :ref:`execution <exec-const>`                                     
-:math:`\I64.\CONST~\i64`                           :math:`\hex{42}`            :math:`[] \to [\I64]`                          :ref:`validation <valid-const>`                :ref:`execution <exec-const>`                                     
-:math:`\F32.\CONST~\f32`                           :math:`\hex{43}`            :math:`[] \to [\F32]`                          :ref:`validation <valid-const>`                :ref:`execution <exec-const>`                                     
-:math:`\F64.\CONST~\f64`                           :math:`\hex{44}`            :math:`[] \to [\F64]`                          :ref:`validation <valid-const>`                :ref:`execution <exec-const>`                                     
-:math:`\I32.\EQZ`                                  :math:`\hex{45}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-testop>`               :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`         
-:math:`\I32.\EQ`                                   :math:`\hex{46}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`           
-:math:`\I32.\NE`                                   :math:`\hex{47}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`           
-:math:`\I32.\LT\K{\_s}`                            :math:`\hex{48}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`         
-:math:`\I32.\LT\K{\_u}`                            :math:`\hex{49}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`         
-:math:`\I32.\GT\K{\_s}`                            :math:`\hex{4A}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`         
-:math:`\I32.\GT\K{\_u}`                            :math:`\hex{4B}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`         
-:math:`\I32.\LE\K{\_s}`                            :math:`\hex{4C}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`         
-:math:`\I32.\LE\K{\_u}`                            :math:`\hex{4D}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`         
-:math:`\I32.\GE\K{\_s}`                            :math:`\hex{4E}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`         
-:math:`\I32.\GE\K{\_u}`                            :math:`\hex{4F}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`         
-:math:`\I64.\EQZ`                                  :math:`\hex{50}`            :math:`[\I64] \to [\I32]`                      :ref:`validation <valid-testop>`               :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`         
-:math:`\I64.\EQ`                                   :math:`\hex{51}`            :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`           
-:math:`\I64.\NE`                                   :math:`\hex{52}`            :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`           
-:math:`\I64.\LT\K{\_s}`                            :math:`\hex{53}`            :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`         
-:math:`\I64.\LT\K{\_u}`                            :math:`\hex{54}`            :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`         
-:math:`\I64.\GT\K{\_s}`                            :math:`\hex{55}`            :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`         
-:math:`\I64.\GT\K{\_u}`                            :math:`\hex{56}`            :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`         
-:math:`\I64.\LE\K{\_s}`                            :math:`\hex{57}`            :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`         
-:math:`\I64.\LE\K{\_u}`                            :math:`\hex{58}`            :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`         
-:math:`\I64.\GE\K{\_s}`                            :math:`\hex{59}`            :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`         
-:math:`\I64.\GE\K{\_u}`                            :math:`\hex{5A}`            :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`         
-:math:`\F32.\EQ`                                   :math:`\hex{5B}`            :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`           
-:math:`\F32.\NE`                                   :math:`\hex{5C}`            :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`           
-:math:`\F32.\LT`                                   :math:`\hex{5D}`            :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`           
-:math:`\F32.\GT`                                   :math:`\hex{5E}`            :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`           
-:math:`\F32.\LE`                                   :math:`\hex{5F}`            :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`           
-:math:`\F32.\GE`                                   :math:`\hex{60}`            :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`           
-:math:`\F64.\EQ`                                   :math:`\hex{61}`            :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`           
-:math:`\F64.\NE`                                   :math:`\hex{62}`            :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`           
-:math:`\F64.\LT`                                   :math:`\hex{63}`            :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`           
-:math:`\F64.\GT`                                   :math:`\hex{64}`            :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`           
-:math:`\F64.\LE`                                   :math:`\hex{65}`            :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`           
-:math:`\F64.\GE`                                   :math:`\hex{66}`            :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`           
-:math:`\I32.\CLZ`                                  :math:`\hex{67}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`           
-:math:`\I32.\CTZ`                                  :math:`\hex{68}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`           
-:math:`\I32.\POPCNT`                               :math:`\hex{69}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`        
-:math:`\I32.\ADD`                                  :math:`\hex{6A}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`          
-:math:`\I32.\SUB`                                  :math:`\hex{6B}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`          
-:math:`\I32.\MUL`                                  :math:`\hex{6C}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`          
-:math:`\I32.\DIV\K{\_s}`                           :math:`\hex{6D}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`        
-:math:`\I32.\DIV\K{\_u}`                           :math:`\hex{6E}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`        
-:math:`\I32.\REM\K{\_s}`                           :math:`\hex{6F}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`        
-:math:`\I32.\REM\K{\_u}`                           :math:`\hex{70}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`        
-:math:`\I32.\AND`                                  :math:`\hex{71}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`          
-:math:`\I32.\OR`                                   :math:`\hex{72}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`           
-:math:`\I32.\XOR`                                  :math:`\hex{73}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`          
-:math:`\I32.\SHL`                                  :math:`\hex{74}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`          
-:math:`\I32.\SHR\K{\_s}`                           :math:`\hex{75}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`        
-:math:`\I32.\SHR\K{\_u}`                           :math:`\hex{76}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`        
-:math:`\I32.\ROTL`                                 :math:`\hex{77}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`         
-:math:`\I32.\ROTR`                                 :math:`\hex{78}`            :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`         
-:math:`\I64.\CLZ`                                  :math:`\hex{79}`            :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`           
-:math:`\I64.\CTZ`                                  :math:`\hex{7A}`            :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`           
-:math:`\I64.\POPCNT`                               :math:`\hex{7B}`            :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`        
-:math:`\I64.\ADD`                                  :math:`\hex{7C}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`          
-:math:`\I64.\SUB`                                  :math:`\hex{7D}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`          
-:math:`\I64.\MUL`                                  :math:`\hex{7E}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`          
-:math:`\I64.\DIV\K{\_s}`                           :math:`\hex{7F}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`        
-:math:`\I64.\DIV\K{\_u}`                           :math:`\hex{80}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`        
-:math:`\I64.\REM\K{\_s}`                           :math:`\hex{81}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`        
-:math:`\I64.\REM\K{\_u}`                           :math:`\hex{82}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`        
-:math:`\I64.\AND`                                  :math:`\hex{83}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`          
-:math:`\I64.\OR`                                   :math:`\hex{84}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`           
-:math:`\I64.\XOR`                                  :math:`\hex{85}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`          
-:math:`\I64.\SHL`                                  :math:`\hex{86}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`          
-:math:`\I64.\SHR\K{\_s}`                           :math:`\hex{87}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`        
-:math:`\I64.\SHR\K{\_u}`                           :math:`\hex{88}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`        
-:math:`\I64.\ROTL`                                 :math:`\hex{89}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`         
-:math:`\I64.\ROTR`                                 :math:`\hex{8A}`            :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`         
-:math:`\F32.\ABS`                                  :math:`\hex{8B}`            :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`           
-:math:`\F32.\NEG`                                  :math:`\hex{8C}`            :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`           
-:math:`\F32.\CEIL`                                 :math:`\hex{8D}`            :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`          
-:math:`\F32.\FLOOR`                                :math:`\hex{8E}`            :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`         
-:math:`\F32.\TRUNC`                                :math:`\hex{8F}`            :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`         
-:math:`\F32.\NEAREST`                              :math:`\hex{90}`            :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`       
-:math:`\F32.\SQRT`                                 :math:`\hex{91}`            :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`          
-:math:`\F32.\ADD`                                  :math:`\hex{92}`            :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`          
-:math:`\F32.\SUB`                                  :math:`\hex{93}`            :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`          
-:math:`\F32.\MUL`                                  :math:`\hex{94}`            :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`          
-:math:`\F32.\DIV`                                  :math:`\hex{95}`            :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`          
-:math:`\F32.\FMIN`                                 :math:`\hex{96}`            :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`          
-:math:`\F32.\FMAX`                                 :math:`\hex{97}`            :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`          
-:math:`\F32.\COPYSIGN`                             :math:`\hex{98}`            :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`     
-:math:`\F64.\ABS`                                  :math:`\hex{99}`            :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`           
-:math:`\F64.\NEG`                                  :math:`\hex{9A}`            :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`           
-:math:`\F64.\CEIL`                                 :math:`\hex{9B}`            :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`          
-:math:`\F64.\FLOOR`                                :math:`\hex{9C}`            :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`         
-:math:`\F64.\TRUNC`                                :math:`\hex{9D}`            :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`         
-:math:`\F64.\NEAREST`                              :math:`\hex{9E}`            :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`       
-:math:`\F64.\SQRT`                                 :math:`\hex{9F}`            :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`          
-:math:`\F64.\ADD`                                  :math:`\hex{A0}`            :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`          
-:math:`\F64.\SUB`                                  :math:`\hex{A1}`            :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`          
-:math:`\F64.\MUL`                                  :math:`\hex{A2}`            :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`          
-:math:`\F64.\DIV`                                  :math:`\hex{A3}`            :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`          
-:math:`\F64.\FMIN`                                 :math:`\hex{A4}`            :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`          
-:math:`\F64.\FMAX`                                 :math:`\hex{A5}`            :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`          
-:math:`\F64.\COPYSIGN`                             :math:`\hex{A6}`            :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`     
-:math:`\I32.\WRAP\K{\_}\I64`                       :math:`\hex{A7}`            :math:`[\I64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-wrap>`          
-:math:`\I32.\TRUNC\K{\_}\F32\K{\_s}`               :math:`\hex{A8}`            :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`       
-:math:`\I32.\TRUNC\K{\_}\F32\K{\_u}`               :math:`\hex{A9}`            :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`       
-:math:`\I32.\TRUNC\K{\_}\F64\K{\_s}`               :math:`\hex{AA}`            :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`       
-:math:`\I32.\TRUNC\K{\_}\F64\K{\_u}`               :math:`\hex{AB}`            :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`       
-:math:`\I64.\EXTEND\K{\_}\I32\K{\_s}`              :math:`\hex{AC}`            :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_s>`      
-:math:`\I64.\EXTEND\K{\_}\I32\K{\_u}`              :math:`\hex{AD}`            :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_u>`      
-:math:`\I64.\TRUNC\K{\_}\F32\K{\_s}`               :math:`\hex{AE}`            :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`       
-:math:`\I64.\TRUNC\K{\_}\F32\K{\_u}`               :math:`\hex{AF}`            :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`       
-:math:`\I64.\TRUNC\K{\_}\F64\K{\_s}`               :math:`\hex{B0}`            :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`       
-:math:`\I64.\TRUNC\K{\_}\F64\K{\_u}`               :math:`\hex{B1}`            :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`       
-:math:`\F32.\CONVERT\K{\_}\I32\K{\_s}`             :math:`\hex{B2}`            :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`     
-:math:`\F32.\CONVERT\K{\_}\I32\K{\_u}`             :math:`\hex{B3}`            :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`     
-:math:`\F32.\CONVERT\K{\_}\I64\K{\_s}`             :math:`\hex{B4}`            :math:`[\I64] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`     
-:math:`\F32.\CONVERT\K{\_}\I64\K{\_u}`             :math:`\hex{B5}`            :math:`[\I64] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`     
-:math:`\F32.\DEMOTE\K{\_}\F64`                     :math:`\hex{B6}`            :math:`[\F64] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-demote>`        
-:math:`\F64.\CONVERT\K{\_}\I32\K{\_s}`             :math:`\hex{B7}`            :math:`[\I32] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`     
-:math:`\F64.\CONVERT\K{\_}\I32\K{\_u}`             :math:`\hex{B8}`            :math:`[\I32] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`     
-:math:`\F64.\CONVERT\K{\_}\I64\K{\_s}`             :math:`\hex{B9}`            :math:`[\I64] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`     
-:math:`\F64.\CONVERT\K{\_}\I64\K{\_u}`             :math:`\hex{BA}`            :math:`[\I64] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`     
-:math:`\F64.\PROMOTE\K{\_}\F32`                    :math:`\hex{BB}`            :math:`[\F32] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-promote>`       
-:math:`\I32.\REINTERPRET\K{\_}\F32`                :math:`\hex{BC}`            :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`   
-:math:`\I64.\REINTERPRET\K{\_}\F64`                :math:`\hex{BD}`            :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`   
-:math:`\F32.\REINTERPRET\K{\_}\I32`                :math:`\hex{BE}`            :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`   
-:math:`\F64.\REINTERPRET\K{\_}\I64`                :math:`\hex{BF}`            :math:`[\I64] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`   
-:math:`\I32.\EXTEND\K{8\_s}`                       :math:`\hex{C0}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
-:math:`\I32.\EXTEND\K{16\_s}`                      :math:`\hex{C1}`            :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
-:math:`\I64.\EXTEND\K{8\_s}`                       :math:`\hex{C2}`            :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
-:math:`\I64.\EXTEND\K{16\_s}`                      :math:`\hex{C3}`            :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
-:math:`\I64.\EXTEND\K{32\_s}`                      :math:`\hex{C4}`            :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
-(reserved)                                         :math:`\hex{C5}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{C6}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{C7}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{C8}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{C9}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{CA}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{CB}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{CC}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{CD}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{CE}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{CF}`                                                                                                                                                                            
-:math:`\REFNULL~t`                                 :math:`\hex{D0}`            :math:`[] \to [t]`                             :ref:`validation <valid-ref.null>`             :ref:`execution <exec-ref.null>`                                  
-:math:`\REFISNULL`                                 :math:`\hex{D1}`            :math:`[t] \to [\I32]`                         :ref:`validation <valid-ref.is_null>`          :ref:`execution <exec-ref.is_null>`                               
-:math:`\REFFUNC~x`                                 :math:`\hex{D2}`            :math:`[] \to [\FUNCREF]`                      :ref:`validation <valid-ref.func>`             :ref:`execution <exec-ref.func>`                                  
-(reserved)                                         :math:`\hex{D3}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{D4}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{D5}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{D6}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{D7}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{D8}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{D9}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{DA}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{DB}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{DC}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{DD}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{DE}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{DF}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{E0}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{E1}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{E2}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{E3}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{E4}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{E5}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{E6}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{E7}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{E8}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{E9}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{EA}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{EB}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{EC}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{ED}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{EE}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{EF}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{F0}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{F1}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{F2}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{F3}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{F4}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{F5}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{F6}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{F7}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{F8}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{F9}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{FA}`                                                                                                                                                                            
-(reserved)                                         :math:`\hex{FB}`                                                                                                                                                                            
-:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_s}`          :math:`\hex{FC}~\hex{00}`   :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
-:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_u}`          :math:`\hex{FC}~\hex{01}`   :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
-:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_s}`          :math:`\hex{FC}~\hex{02}`   :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
-:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_u}`          :math:`\hex{FC}~\hex{03}`   :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
-:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_s}`          :math:`\hex{FC}~\hex{04}`   :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
-:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_u}`          :math:`\hex{FC}~\hex{05}`   :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
-:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_s}`          :math:`\hex{FC}~\hex{06}`   :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
-:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_u}`          :math:`\hex{FC}~\hex{07}`   :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
-:math:`\MEMORYINIT~x`                              :math:`\hex{FC}~\hex{08}`   :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-memory.init>`          :ref:`execution <exec-memory.init>`                               
-:math:`\DATADROP~x`                                :math:`\hex{FC}~\hex{09}`   :math:`[] \to []`                              :ref:`validation <valid-data.drop>`            :ref:`execution <exec-data.drop>`                                 
-:math:`\MEMORYCOPY`                                :math:`\hex{FC}~\hex{0A}`   :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-memory.copy>`          :ref:`execution <exec-memory.copy>`                               
-:math:`\MEMORYFILL`                                :math:`\hex{FC}~\hex{0B}`   :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-memory.fill>`          :ref:`execution <exec-memory.fill>`                               
-:math:`\TABLEINIT~x~y`                             :math:`\hex{FC}~\hex{0C}`   :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-table.init>`           :ref:`execution <exec-table.init>`                                
-:math:`\ELEMDROP~x`                                :math:`\hex{FC}~\hex{0D}`   :math:`[] \to []`                              :ref:`validation <valid-elem.drop>`            :ref:`execution <exec-elem.drop>`                                 
-:math:`\TABLECOPY~x~y`                             :math:`\hex{FC}~\hex{0E}`   :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-table.copy>`           :ref:`execution <exec-table.copy>`                                
-:math:`\TABLEGROW~x`                               :math:`\hex{FC}~\hex{0F}`   :math:`[t~\I32] \to [\I32]`                    :ref:`validation <valid-table.grow>`           :ref:`execution <exec-table.grow>`                                
-:math:`\TABLESIZE~x`                               :math:`\hex{FC}~\hex{10}`   :math:`[] \to [\I32]`                          :ref:`validation <valid-table.size>`           :ref:`execution <exec-table.size>`                                
-:math:`\TABLEFILL~x`                               :math:`\hex{FC}~\hex{11}`   :math:`[\I32~t~\I32] \to []`                   :ref:`validation <valid-table.fill>`           :ref:`execution <exec-table.fill>`                                
-:math:`\V128.\LOAD~\memarg`                        :math:`\hex{FD}~~\hex{00}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
-:math:`\V128.\LOAD\K{8x8\_s}~\memarg`              :math:`\hex{FD}~~\hex{01}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
-:math:`\V128.\LOAD\K{8x8\_u}~\memarg`              :math:`\hex{FD}~~\hex{02}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
-:math:`\V128.\LOAD\K{16x4\_s}~\memarg`             :math:`\hex{FD}~~\hex{03}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
-:math:`\V128.\LOAD\K{16x4\_u}~\memarg`             :math:`\hex{FD}~~\hex{04}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
-:math:`\V128.\LOAD\K{32x2\_s}~\memarg`             :math:`\hex{FD}~~\hex{05}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
-:math:`\V128.\LOAD\K{32x2\_u}~\memarg`             :math:`\hex{FD}~~\hex{06}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
-:math:`\V128.\LOAD\K{\_splat}~\memarg`             :math:`\hex{FD}~~\hex{07}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
-:math:`\V128.\LOAD\K{\_splat}~\memarg`             :math:`\hex{FD}~~\hex{08}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
-:math:`\V128.\LOAD\K{\_splat}~\memarg`             :math:`\hex{FD}~~\hex{09}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
-:math:`\V128.\LOAD\K{\_splat}~\memarg`             :math:`\hex{FD}~~\hex{0A}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
-:math:`\V128.\STORE~\memarg`                       :math:`\hex{FD}~~\hex{0B}`  :math:`[\I32~\V128] \to []`                    :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
-:math:`\V128.\VCONST~\i128`                        :math:`\hex{FD}~~\hex{0C}`  :math:`[] \to [\V128]`                         :ref:`validation <valid-vconst>`               :ref:`execution <exec-vconst>`                                    
-:math:`\I8X16.\SHUFFLE~\laneidx^{16}`              :math:`\hex{FD}~~\hex{0D}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-shuffle>`          :ref:`execution <exec-vec-shuffle>`                               
-:math:`\I8X16.\SWIZZLE`                            :math:`\hex{FD}~~\hex{0E}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-swizzle>`                               
-:math:`\I8X16.\SPLAT`                              :math:`\hex{FD}~~\hex{0F}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
-:math:`\I16X8.\SPLAT`                              :math:`\hex{FD}~~\hex{10}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
-:math:`\I32X4.\SPLAT`                              :math:`\hex{FD}~~\hex{11}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
-:math:`\I64X2.\SPLAT`                              :math:`\hex{FD}~~\hex{12}`  :math:`[\I64] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
-:math:`\F32X4.\SPLAT`                              :math:`\hex{FD}~~\hex{13}`  :math:`[\F32] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
-:math:`\F64X2.\SPLAT`                              :math:`\hex{FD}~~\hex{14}`  :math:`[\F64] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
-:math:`\I8X16.\EXTRACTLANE\K{\_s}~\laneidx`        :math:`\hex{FD}~~\hex{15}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
-:math:`\I8X16.\EXTRACTLANE\K{\_u}~\laneidx`        :math:`\hex{FD}~~\hex{16}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
-:math:`\I8X16.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{17}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
-:math:`\I16X8.\EXTRACTLANE\K{\_s}~\laneidx`        :math:`\hex{FD}~~\hex{18}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
-:math:`\I16X8.\EXTRACTLANE\K{\_u}~\laneidx`        :math:`\hex{FD}~~\hex{19}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
-:math:`\I16X8.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{1A}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
-:math:`\I32X4.\EXTRACTLANE~\laneidx`               :math:`\hex{FD}~~\hex{1B}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
-:math:`\I32X4.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{1C}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
-:math:`\I64X2.\EXTRACTLANE~\laneidx`               :math:`\hex{FD}~~\hex{1D}`  :math:`[\V128] \to [\I64]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
-:math:`\I64X2.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{1E}`  :math:`[\V128~\I64] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
-:math:`\F32X4.\EXTRACTLANE~\laneidx`               :math:`\hex{FD}~~\hex{1F}`  :math:`[\V128] \to [\F32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
-:math:`\F32X4.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{20}`  :math:`[\V128~\F32] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
-:math:`\F64X2.\EXTRACTLANE~\laneidx`               :math:`\hex{FD}~~\hex{21}`  :math:`[\V128] \to [\F64]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
-:math:`\F64X2.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{22}`  :math:`[\V128~\F64] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
-:math:`\I8X16.\VEQ`                                :math:`\hex{FD}~~\hex{23}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ieq>`          
-:math:`\I8X16.\VNE`                                :math:`\hex{FD}~~\hex{24}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ine>`          
-:math:`\I8X16.\VLT\K{\_s}`                         :math:`\hex{FD}~~\hex{25}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_s>`        
-:math:`\I8X16.\VLT\K{\_u}`                         :math:`\hex{FD}~~\hex{26}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_u>`        
-:math:`\I8X16.\VGT\K{\_s}`                         :math:`\hex{FD}~~\hex{27}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_s>`        
-:math:`\I8X16.\VGT\K{\_u}`                         :math:`\hex{FD}~~\hex{28}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_u>`        
-:math:`\I8X16.\VLE\K{\_s}`                         :math:`\hex{FD}~~\hex{29}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_s>`        
-:math:`\I8X16.\VLE\K{\_u}`                         :math:`\hex{FD}~~\hex{2A}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_u>`        
-:math:`\I8X16.\VGE\K{\_s}`                         :math:`\hex{FD}~~\hex{2B}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_s>`        
-:math:`\I8X16.\VGE\K{\_u}`                         :math:`\hex{FD}~~\hex{2C}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_u>`        
-:math:`\I16X8.\VEQ`                                :math:`\hex{FD}~~\hex{2D}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ieq>`          
-:math:`\I16X8.\VNE`                                :math:`\hex{FD}~~\hex{2E}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ine>`          
-:math:`\I16X8.\VLT\K{\_s}`                         :math:`\hex{FD}~~\hex{2F}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_s>`        
-:math:`\I16X8.\VLT\K{\_u}`                         :math:`\hex{FD}~~\hex{30}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_u>`        
-:math:`\I16X8.\VGT\K{\_s}`                         :math:`\hex{FD}~~\hex{31}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_s>`        
-:math:`\I16X8.\VGT\K{\_u}`                         :math:`\hex{FD}~~\hex{32}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_u>`        
-:math:`\I16X8.\VLE\K{\_s}`                         :math:`\hex{FD}~~\hex{33}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_s>`        
-:math:`\I16X8.\VLE\K{\_u}`                         :math:`\hex{FD}~~\hex{34}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_u>`        
-:math:`\I16X8.\VGE\K{\_s}`                         :math:`\hex{FD}~~\hex{35}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_s>`        
-:math:`\I16X8.\VGE\K{\_u}`                         :math:`\hex{FD}~~\hex{36}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_u>`        
-:math:`\I32X4.\VEQ`                                :math:`\hex{FD}~~\hex{37}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ieq>`          
-:math:`\I32X4.\VNE`                                :math:`\hex{FD}~~\hex{38}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ine>`          
-:math:`\I32X4.\VLT\K{\_s}`                         :math:`\hex{FD}~~\hex{39}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_s>`        
-:math:`\I32X4.\VLT\K{\_u}`                         :math:`\hex{FD}~~\hex{3A}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_u>`        
-:math:`\I32X4.\VGT\K{\_s}`                         :math:`\hex{FD}~~\hex{3B}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_s>`        
-:math:`\I32X4.\VGT\K{\_u}`                         :math:`\hex{FD}~~\hex{3C}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_u>`        
-:math:`\I32X4.\VLE\K{\_s}`                         :math:`\hex{FD}~~\hex{3D}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_s>`        
-:math:`\I32X4.\VLE\K{\_u}`                         :math:`\hex{FD}~~\hex{3E}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_u>`        
-:math:`\I32X4.\VGE\K{\_s}`                         :math:`\hex{FD}~~\hex{3F}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_s>`        
-:math:`\I32X4.\VGE\K{\_u}`                         :math:`\hex{FD}~~\hex{40}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_u>`        
-:math:`\F32X4.\VEQ`                                :math:`\hex{FD}~~\hex{41}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-feq>`          
-:math:`\F32X4.\VNE`                                :math:`\hex{FD}~~\hex{42}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fne>`          
-:math:`\F32X4.\VLT`                                :math:`\hex{FD}~~\hex{43}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-flt>`          
-:math:`\F32X4.\VGT`                                :math:`\hex{FD}~~\hex{44}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fgt>`          
-:math:`\F32X4.\VLE`                                :math:`\hex{FD}~~\hex{45}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fle>`          
-:math:`\F32X4.\VGE`                                :math:`\hex{FD}~~\hex{46}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fge>`          
-:math:`\F64X2.\VEQ`                                :math:`\hex{FD}~~\hex{47}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-feq>`          
-:math:`\F64X2.\VNE`                                :math:`\hex{FD}~~\hex{48}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fne>`          
-:math:`\F64X2.\VLT`                                :math:`\hex{FD}~~\hex{49}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-flt>`          
-:math:`\F64X2.\VGT`                                :math:`\hex{FD}~~\hex{4A}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fgt>`          
-:math:`\F64X2.\VLE`                                :math:`\hex{FD}~~\hex{4B}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fle>`          
-:math:`\F64X2.\VGE`                                :math:`\hex{FD}~~\hex{4C}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fge>`          
-:math:`\V128.\VNOT`                                :math:`\hex{FD}~~\hex{4D}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vvunop>`               :ref:`execution <exec-vvunop>`, :ref:`operator <op-inot>`         
-:math:`\V128.\VAND`                                :math:`\hex{FD}~~\hex{4E}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vvbinop>`              :ref:`execution <exec-vvbinop>`, :ref:`operator <op-iand>`        
-:math:`\V128.\VANDNOT`                             :math:`\hex{FD}~~\hex{4F}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vvbinop>`              :ref:`execution <exec-vvbinop>`, :ref:`operator <op-iandnot>`     
-:math:`\V128.\VOR`                                 :math:`\hex{FD}~~\hex{50}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vvbinop>`              :ref:`execution <exec-vvbinop>`, :ref:`operator <op-ior>`         
-:math:`\V128.\VXOR`                                :math:`\hex{FD}~~\hex{51}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vvbinop>`              :ref:`execution <exec-vvbinop>`, :ref:`operator <op-ixor>`        
-:math:`\V128.\BITSELECT`                           :math:`\hex{FD}~~\hex{52}`  :math:`[\V128~\V128~\V128] \to [\V128]`        :ref:`validation <valid-vvternop>`             :ref:`execution <exec-vvternop>`, :ref:`operator <op-ibitselect>` 
-:math:`\V128.\ANYTRUE`                             :math:`\hex{FD}~~\hex{53}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vvtestop>`             :ref:`execution <exec-vvtestop>`                                  
-:math:`\V128.\LOAD\K{8\_lane}~\memarg~\laneidx`    :math:`\hex{FD}~~\hex{54}`  :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
-:math:`\V128.\LOAD\K{16\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{55}`  :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
-:math:`\V128.\LOAD\K{32\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{56}`  :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
-:math:`\V128.\LOAD\K{64\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{57}`  :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
-:math:`\V128.\STORE\K{8\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{58}`  :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
-:math:`\V128.\STORE\K{16\_lane}~\memarg~\laneidx`  :math:`\hex{FD}~~\hex{59}`  :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
-:math:`\V128.\STORE\K{32\_lane}~\memarg~\laneidx`  :math:`\hex{FD}~~\hex{5A}`  :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
-:math:`\V128.\STORE\K{64\_lane}~\memarg~\laneidx`  :math:`\hex{FD}~~\hex{5B}`  :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
-:math:`\V128.\LOAD\K{32\_zero}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{5C}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-zero>`            :ref:`execution <exec-load-zero>`                                 
-:math:`\V128.\LOAD\K{64\_zero}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{5D}`  :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-zero>`            :ref:`execution <exec-load-zero>`                                 
-:math:`\F32X4.\VDEMOTE\K{\_f64x2\_zero}`           :math:`\hex{FD}~~\hex{5E}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-demote>`       
-:math:`\F64X2.\VPROMOTE\K{\_low\_f32x4}`           :math:`\hex{FD}~~\hex{5F}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-promote>`      
-:math:`\I8X16.\VABS`                               :math:`\hex{FD}~~\hex{60}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-iabs>`          
-:math:`\I8X16.\VNEG`                               :math:`\hex{FD}~~\hex{61}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ineg>`          
-:math:`\I8X16.\VPOPCNT`                            :math:`\hex{FD}~~\hex{62}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ipopcnt>`       
-:math:`\I8X16.\ALLTRUE`                            :math:`\hex{FD}~~\hex{63}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vtestop>`              :ref:`execution <exec-vtestop>`                                   
-:math:`\I8X16.\BITMASK`                            :math:`\hex{FD}~~\hex{64}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-bitmask>`          :ref:`execution <exec-vec-bitmask>`                               
-:math:`\I8X16.\NARROW\K{\_i16x8\_s}`               :math:`\hex{FD}~~\hex{65}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-narrow>`                                
-:math:`\I8X16.\NARROW\K{\_i16x8\_u}`               :math:`\hex{FD}~~\hex{66}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-narrow>`                                
-:math:`\F32X4.\VCEIL`                              :math:`\hex{FD}~~\hex{67}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fceil>`         
-:math:`\F32X4.\VFLOOR`                             :math:`\hex{FD}~~\hex{68}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ffloor>`        
-:math:`\F32X4.\VTRUNC`                             :math:`\hex{FD}~~\hex{69}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ftrunc>`        
-:math:`\F32X4.\VNEAREST`                           :math:`\hex{FD}~~\hex{6A}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fnearest>`      
-:math:`\I8X16.\VSHL`                               :math:`\hex{FD}~~\hex{6B}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishl>`      
-:math:`\I8X16.\VSHR\K{\_s}`                        :math:`\hex{FD}~~\hex{6C}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_s>`    
-:math:`\I8X16.\VSHR\K{\_u}`                        :math:`\hex{FD}~~\hex{6D}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_u>`    
-:math:`\I8X16.\VADD`                               :math:`\hex{FD}~~\hex{6E}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd>`         
-:math:`\I8X16.\VADD\K{\_sat\_s}`                   :math:`\hex{FD}~~\hex{6F}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd_sat_s>`   
-:math:`\I8X16.\VADD\K{\_sat\_u}`                   :math:`\hex{FD}~~\hex{70}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd_sat_u>`   
-:math:`\I8X16.\VSUB`                               :math:`\hex{FD}~~\hex{71}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub>`         
-:math:`\I8X16.\VSUB\K{\_sat\_s}`                   :math:`\hex{FD}~~\hex{72}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub_sat_s>`   
-:math:`\I8X16.\VSUB\K{\_sat\_u}`                   :math:`\hex{FD}~~\hex{73}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub_sat_u>`   
-:math:`\F64X2.\VCEIL`                              :math:`\hex{FD}~~\hex{74}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fceil>`         
-:math:`\F64X2.\VFLOOR`                             :math:`\hex{FD}~~\hex{75}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ffloor>`        
-:math:`\I8X16.\VMIN\K{\_s}`                        :math:`\hex{FD}~~\hex{76}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_s>`       
-:math:`\I8X16.\VMIN\K{\_u}`                        :math:`\hex{FD}~~\hex{77}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_u>`       
-:math:`\I8X16.\VMAX\K{\_s}`                        :math:`\hex{FD}~~\hex{78}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_s>`       
-:math:`\I8X16.\VMAX\K{\_u}`                        :math:`\hex{FD}~~\hex{79}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_u>`       
-:math:`\F64X2.\VTRUNC`                             :math:`\hex{FD}~~\hex{7A}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ftrunc>`        
-:math:`\I8X16.\AVGR\K{\_u}`                        :math:`\hex{FD}~~\hex{7B}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iavgr_u>`      
-:math:`\I16X8.\EXTADDPAIRWISE\K{\_i8x16\_s}`       :math:`\hex{FD}~~\hex{7C}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vec-extadd_pairwise>`  :ref:`execution <exec-vec-extadd_pairwise>`                       
-:math:`\I16X8.\EXTADDPAIRWISE\K{\_i8x16\_u}`       :math:`\hex{FD}~~\hex{7D}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vec-extadd_pairwise>`  :ref:`execution <exec-vec-extadd_pairwise>`                       
-:math:`\I32X4.\EXTADDPAIRWISE\K{\_i16x8\_s}`       :math:`\hex{FD}~~\hex{7E}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vec-extadd_pairwise>`  :ref:`execution <exec-vec-extadd_pairwise>`                       
-:math:`\I32X4.\EXTADDPAIRWISE\K{\_i16x8\_u}`       :math:`\hex{FD}~~\hex{7F}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vec-extadd_pairwise>`  :ref:`execution <exec-vec-extadd_pairwise>`                       
-:math:`\I16X8.\VABS`                               :math:`\hex{FD}~~\hex{80}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-iabs>`          
-:math:`\I16X8.\VNEG`                               :math:`\hex{FD}~~\hex{81}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ineg>`          
-:math:`\I16X8.\Q15MULRSAT\K{\_s}`                  :math:`\hex{FD}~~\hex{82}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iq15mulrsat_s>`
-:math:`\I16X8.\ALLTRUE`                            :math:`\hex{FD}~~\hex{83}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vtestop>`              :ref:`execution <exec-vtestop>`                                   
-:math:`\I16X8.\BITMASK`                            :math:`\hex{FD}~~\hex{84}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-bitmask>`          :ref:`execution <exec-vec-bitmask>`                               
-:math:`\I16X8.\NARROW\K{\_i32x4\_s}`               :math:`\hex{FD}~~\hex{85}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-narrow>`                                
-:math:`\I16X8.\NARROW\K{\_i32x4\_u}`               :math:`\hex{FD}~~\hex{86}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-narrow>`                                
-:math:`\I16X8.\VEXTEND\K{\_low\_i8x16\_s}`         :math:`\hex{FD}~~\hex{87}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I16X8.\VEXTEND\K{\_high\_i8x16\_s}`        :math:`\hex{FD}~~\hex{88}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I16X8.\VEXTEND\K{\_low\_i8x16\_u}`         :math:`\hex{FD}~~\hex{89}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I16X8.\VEXTEND\K{\_high\_i8x16\_u}`        :math:`\hex{FD}~~\hex{8A}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I16X8.\VSHL`                               :math:`\hex{FD}~~\hex{8B}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishl>`      
-:math:`\I16X8.\VSHR\K{\_s}`                        :math:`\hex{FD}~~\hex{8C}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_s>`    
-:math:`\I16X8.\VSHR\K{\_u}`                        :math:`\hex{FD}~~\hex{8D}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_u>`    
-:math:`\I16X8.\VADD`                               :math:`\hex{FD}~~\hex{8E}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd>`         
-:math:`\I16X8.\VADD\K{\_sat\_s}`                   :math:`\hex{FD}~~\hex{8F}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd_sat_s>`   
-:math:`\I16X8.\VADD\K{\_sat\_u}`                   :math:`\hex{FD}~~\hex{90}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd_sat_u>`   
-:math:`\I16X8.\VSUB`                               :math:`\hex{FD}~~\hex{91}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub>`         
-:math:`\I16X8.\VSUB\K{\_sat\_s}`                   :math:`\hex{FD}~~\hex{92}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub_sat_s>`   
-:math:`\I16X8.\VSUB\K{\_sat\_u}`                   :math:`\hex{FD}~~\hex{93}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub_sat_u>`   
-:math:`\F64X2.\VNEAREST`                           :math:`\hex{FD}~~\hex{94}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fnearest>`      
-:math:`\I16X8.\VMUL`                               :math:`\hex{FD}~~\hex{95}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imul>`         
-:math:`\I16X8.\VMIN\K{\_s}`                        :math:`\hex{FD}~~\hex{96}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_s>`       
-:math:`\I16X8.\VMIN\K{\_u}`                        :math:`\hex{FD}~~\hex{97}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_u>`       
-:math:`\I16X8.\VMAX\K{\_s}`                        :math:`\hex{FD}~~\hex{98}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_s>`       
-:math:`\I16X8.\VMAX\K{\_u}`                        :math:`\hex{FD}~~\hex{99}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_u>`       
-:math:`\I16X8.\AVGR\K{\_u}`                        :math:`\hex{FD}~~\hex{9B}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iavgr_u>`      
-:math:`\I16X8.\EXTMUL\K{\_low\_i8x16\_s}`          :math:`\hex{FD}~~\hex{9C}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I16X8.\EXTMUL\K{\_high\_i8x16\_s}`         :math:`\hex{FD}~~\hex{9D}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I16X8.\EXTMUL\K{\_low\_i8x16\_u}`          :math:`\hex{FD}~~\hex{9E}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I16X8.\EXTMUL\K{\_high\_i8x16\_u}`         :math:`\hex{FD}~~\hex{9F}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I32X4.\VABS`                               :math:`\hex{FD}~~\hex{A0}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-iabs>`          
-:math:`\I32X4.\VNEG`                               :math:`\hex{FD}~~\hex{A1}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ineg>`          
-:math:`\I32X4.\ALLTRUE`                            :math:`\hex{FD}~~\hex{A3}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vtestop>`              :ref:`execution <exec-vtestop>`                                   
-:math:`\I32X4.\BITMASK`                            :math:`\hex{FD}~~\hex{A4}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-bitmask>`          :ref:`execution <exec-vec-bitmask>`                               
-:math:`\I32X4.\VEXTEND\K{\_low\_i16x8\_s}`         :math:`\hex{FD}~~\hex{A7}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I32X4.\VEXTEND\K{\_high\_i16x8\_s}`        :math:`\hex{FD}~~\hex{A8}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I32X4.\VEXTEND\K{\_low\_i16x8\_u}`         :math:`\hex{FD}~~\hex{A9}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I32X4.\VEXTEND\K{\_high\_i16x8\_u}`        :math:`\hex{FD}~~\hex{AA}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I32X4.\VSHL`                               :math:`\hex{FD}~~\hex{AB}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishl>`      
-:math:`\I32X4.\VSHR\K{\_s}`                        :math:`\hex{FD}~~\hex{AC}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_s>`    
-:math:`\I32X4.\VSHR\K{\_u}`                        :math:`\hex{FD}~~\hex{AD}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_u>`    
-:math:`\I32X4.\VADD`                               :math:`\hex{FD}~~\hex{AE}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd>`         
-:math:`\I32X4.\VSUB`                               :math:`\hex{FD}~~\hex{B1}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub>`         
-:math:`\I32X4.\VMUL`                               :math:`\hex{FD}~~\hex{B5}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imul>`         
-:math:`\I32X4.\VMIN\K{\_s}`                        :math:`\hex{FD}~~\hex{B6}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_s>`       
-:math:`\I32X4.\VMIN\K{\_u}`                        :math:`\hex{FD}~~\hex{B7}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_u>`       
-:math:`\I32X4.\VMAX\K{\_s}`                        :math:`\hex{FD}~~\hex{B8}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_s>`       
-:math:`\I32X4.\VMAX\K{\_u}`                        :math:`\hex{FD}~~\hex{B9}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_u>`       
-:math:`\I32X4.\DOT\K{\_i16x8\_s}`                  :math:`\hex{FD}~~\hex{BA}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-dot>`              :ref:`execution <exec-vec-dot>`                                   
-:math:`\I32X4.\EXTMUL\K{\_low\_i16x8\_s}`          :math:`\hex{FD}~~\hex{BC}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I32X4.\EXTMUL\K{\_high\_i16x8\_s}`         :math:`\hex{FD}~~\hex{BD}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I32X4.\EXTMUL\K{\_low\_i16x8\_u}`          :math:`\hex{FD}~~\hex{BE}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I32X4.\EXTMUL\K{\_high\_i16x8\_u}`         :math:`\hex{FD}~~\hex{BF}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I64X2.\VABS`                               :math:`\hex{FD}~~\hex{C0}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-iabs>`          
-:math:`\I64X2.\VNEG`                               :math:`\hex{FD}~~\hex{C1}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ineg>`          
-:math:`\I64X2.\ALLTRUE`                            :math:`\hex{FD}~~\hex{C3}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vtestop>`              :ref:`execution <exec-vtestop>`                                   
-:math:`\I64X2.\BITMASK`                            :math:`\hex{FD}~~\hex{C4}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-bitmask>`          :ref:`execution <exec-vec-bitmask>`                               
-:math:`\I64X2.\VEXTEND\K{\_low\_i32x4\_s}`         :math:`\hex{FD}~~\hex{C7}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I64X2.\VEXTEND\K{\_high\_i32x4\_s}`        :math:`\hex{FD}~~\hex{C8}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I64X2.\VEXTEND\K{\_low\_i32x4\_u}`         :math:`\hex{FD}~~\hex{C9}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I64X2.\VEXTEND\K{\_high\_i32x4\_u}`        :math:`\hex{FD}~~\hex{CA}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I64X2.\VSHL`                               :math:`\hex{FD}~~\hex{CB}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishl>`      
-:math:`\I64X2.\VSHR\K{\_s}`                        :math:`\hex{FD}~~\hex{CC}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_s>`    
-:math:`\I64X2.\VSHR\K{\_u}`                        :math:`\hex{FD}~~\hex{CD}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_u>`    
-:math:`\I64X2.\VADD`                               :math:`\hex{FD}~~\hex{CE}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd>`         
-:math:`\I64X2.\VSUB`                               :math:`\hex{FD}~~\hex{D1}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub>`         
-:math:`\I64X2.\VMUL`                               :math:`\hex{FD}~~\hex{D5}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imul>`         
-:math:`\I64X2.\VEQ`                                :math:`\hex{FD}~~\hex{D6}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ieq>`          
-:math:`\I64X2.\VNE`                                :math:`\hex{FD}~~\hex{D7}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ine>`          
-:math:`\I64X2.\VLT\K{\_s}`                         :math:`\hex{FD}~~\hex{D8}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_s>`        
-:math:`\I64X2.\VGT\K{\_s}`                         :math:`\hex{FD}~~\hex{D9}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_s>`        
-:math:`\I64X2.\VLE\K{\_s}`                         :math:`\hex{FD}~~\hex{DA}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_s>`        
-:math:`\I64X2.\VGE\K{\_s}`                         :math:`\hex{FD}~~\hex{DB}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_s>`        
-:math:`\I64X2.\EXTMUL\K{\_low\_i32x4\_s}`          :math:`\hex{FD}~~\hex{DC}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I64X2.\EXTMUL\K{\_high\_i32x4\_s}`         :math:`\hex{FD}~~\hex{DD}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I64X2.\EXTMUL\K{\_low\_i32x4\_u}`          :math:`\hex{FD}~~\hex{DE}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I64X2.\EXTMUL\K{\_high\_i32x4\_u}`         :math:`\hex{FD}~~\hex{DF}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\F32X4.\VABS`                               :math:`\hex{FD}~~\hex{E0}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fabs>`          
-:math:`\F32X4.\VNEG`                               :math:`\hex{FD}~~\hex{E1}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fneg>`          
-:math:`\F32X4.\VSQRT`                              :math:`\hex{FD}~~\hex{E3}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fsqrt>`         
-:math:`\F32X4.\VADD`                               :math:`\hex{FD}~~\hex{E4}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fadd>`         
-:math:`\F32X4.\VSUB`                               :math:`\hex{FD}~~\hex{E5}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fsub>`         
-:math:`\F32X4.\VMUL`                               :math:`\hex{FD}~~\hex{E6}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmul>`         
-:math:`\F32X4.\VDIV`                               :math:`\hex{FD}~~\hex{E7}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fdiv>`         
-:math:`\F32X4.\VMIN`                               :math:`\hex{FD}~~\hex{E8}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmin>`         
-:math:`\F32X4.\VMAX`                               :math:`\hex{FD}~~\hex{E9}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmax>`         
-:math:`\F32X4.\VPMIN`                              :math:`\hex{FD}~~\hex{EA}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fpmin>`        
-:math:`\F32X4.\VPMAX`                              :math:`\hex{FD}~~\hex{EB}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fpmax>`        
-:math:`\F64X2.\VABS`                               :math:`\hex{FD}~~\hex{EC}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fabs>`          
-:math:`\F64X2.\VNEG`                               :math:`\hex{FD}~~\hex{ED}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fneg>`          
-:math:`\F64X2.\VSQRT`                              :math:`\hex{FD}~~\hex{EF}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fsqrt>`         
-:math:`\F64X2.\VADD`                               :math:`\hex{FD}~~\hex{F0}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fadd>`         
-:math:`\F64X2.\VSUB`                               :math:`\hex{FD}~~\hex{F1}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fsub>`         
-:math:`\F64X2.\VMUL`                               :math:`\hex{FD}~~\hex{F2}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmul>`         
-:math:`\F64X2.\VDIV`                               :math:`\hex{FD}~~\hex{F3}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fdiv>`         
-:math:`\F64X2.\VMIN`                               :math:`\hex{FD}~~\hex{F4}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmin>`         
-:math:`\F64X2.\VMAX`                               :math:`\hex{FD}~~\hex{F5}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmax>`         
-:math:`\F64X2.\VPMIN`                              :math:`\hex{FD}~~\hex{F6}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fpmin>`        
-:math:`\F64X2.\VPMAX`                              :math:`\hex{FD}~~\hex{F7}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fpmax>`        
-:math:`\I32X4.\TRUNC\K{\_sat\_f32x4\_s}`           :math:`\hex{FD}~~\hex{F8}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-trunc_sat_s>`  
-:math:`\I32X4.\TRUNC\K{\_sat\_f32x4\_u}`           :math:`\hex{FD}~~\hex{F9}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-trunc_sat_u>`  
-:math:`\F32X4.\VCONVERT\K{\_i32x4\_s}`             :math:`\hex{FD}~~\hex{FA}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_s>`    
-:math:`\F32X4.\VCONVERT\K{\_i32x4\_u}`             :math:`\hex{FD}~~\hex{FB}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_u>`    
-:math:`\I32X4.\VTRUNC\K{\_sat\_f64x2\_s\_zero}`    :math:`\hex{FD}~~\hex{FC}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-trunc_sat_s>`  
-:math:`\I32X4.\VTRUNC\K{\_sat\_f64x2\_u\_zero}`    :math:`\hex{FD}~~\hex{FD}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-trunc_sat_u>`  
-:math:`\F64X2.\VCONVERT\K{\_low\_i32x4\_s}`        :math:`\hex{FD}~~\hex{FE}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_s>`    
-:math:`\F64X2.\VCONVERT\K{\_low\_i32x4\_u}`        :math:`\hex{FD}~~\hex{FF}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_u>`    
-=================================================  ==========================  =============================================  =============================================  ==================================================================
+=================================================  ====================================  =============================================  =============================================  ==================================================================
+Instruction                                        Binary Opcode                         Type                                           Validation                                     Execution                                                         
+=================================================  ====================================  =============================================  =============================================  ==================================================================
+:math:`\UNREACHABLE`                               :math:`\hex{00}`                      :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-unreachable>`          :ref:`execution <exec-unreachable>`                               
+:math:`\NOP`                                       :math:`\hex{01}`                      :math:`[] \to []`                              :ref:`validation <valid-nop>`                  :ref:`execution <exec-nop>`                                       
+:math:`\BLOCK~\X{bt}`                              :math:`\hex{02}`                      :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-block>`                :ref:`execution <exec-block>`                                     
+:math:`\LOOP~\X{bt}`                               :math:`\hex{03}`                      :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-loop>`                 :ref:`execution <exec-loop>`                                      
+:math:`\IF~\X{bt}`                                 :math:`\hex{04}`                      :math:`[t_1^\ast~\I32] \to [t_2^\ast]`         :ref:`validation <valid-if>`                   :ref:`execution <exec-if>`                                        
+:math:`\ELSE`                                      :math:`\hex{05}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{06}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{07}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{08}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{09}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{0A}`                                                                                                                                                                                      
+:math:`\END`                                       :math:`\hex{0B}`                                                                                                                                                                                      
+:math:`\BR~l`                                      :math:`\hex{0C}`                      :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`       :ref:`validation <valid-br>`                   :ref:`execution <exec-br>`                                        
+:math:`\BRIF~l`                                    :math:`\hex{0D}`                      :math:`[t^\ast~\I32] \to [t^\ast]`             :ref:`validation <valid-br_if>`                :ref:`execution <exec-br_if>`                                     
+:math:`\BRTABLE~l^\ast~l`                          :math:`\hex{0E}`                      :math:`[t_1^\ast~t^\ast~\I32] \to [t_2^\ast]`  :ref:`validation <valid-br_table>`             :ref:`execution <exec-br_table>`                                  
+:math:`\RETURN`                                    :math:`\hex{0F}`                      :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`       :ref:`validation <valid-return>`               :ref:`execution <exec-return>`                                    
+:math:`\CALL~x`                                    :math:`\hex{10}`                      :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-call>`                 :ref:`execution <exec-call>`                                      
+:math:`\CALLINDIRECT~x~y`                          :math:`\hex{11}`                      :math:`[t_1^\ast~\I32] \to [t_2^\ast]`         :ref:`validation <valid-call_indirect>`        :ref:`execution <exec-call_indirect>`                             
+(reserved)                                         :math:`\hex{12}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{13}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{14}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{15}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{16}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{17}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{18}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{19}`                                                                                                                                                                                      
+:math:`\DROP`                                      :math:`\hex{1A}`                      :math:`[t] \to []`                             :ref:`validation <valid-drop>`                 :ref:`execution <exec-drop>`                                      
+:math:`\SELECT`                                    :math:`\hex{1B}`                      :math:`[t~t~\I32] \to [t]`                     :ref:`validation <valid-select>`               :ref:`execution <exec-select>`                                    
+:math:`\SELECT~t`                                  :math:`\hex{1C}`                      :math:`[t~t~\I32] \to [t]`                     :ref:`validation <valid-select>`               :ref:`execution <exec-select>`                                    
+(reserved)                                         :math:`\hex{1D}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{1E}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{1F}`                                                                                                                                                                                      
+:math:`\LOCALGET~x`                                :math:`\hex{20}`                      :math:`[] \to [t]`                             :ref:`validation <valid-local.get>`            :ref:`execution <exec-local.get>`                                 
+:math:`\LOCALSET~x`                                :math:`\hex{21}`                      :math:`[t] \to []`                             :ref:`validation <valid-local.set>`            :ref:`execution <exec-local.set>`                                 
+:math:`\LOCALTEE~x`                                :math:`\hex{22}`                      :math:`[t] \to [t]`                            :ref:`validation <valid-local.tee>`            :ref:`execution <exec-local.tee>`                                 
+:math:`\GLOBALGET~x`                               :math:`\hex{23}`                      :math:`[] \to [t]`                             :ref:`validation <valid-global.get>`           :ref:`execution <exec-global.get>`                                
+:math:`\GLOBALSET~x`                               :math:`\hex{24}`                      :math:`[t] \to []`                             :ref:`validation <valid-global.set>`           :ref:`execution <exec-global.set>`                                
+:math:`\TABLEGET~x`                                :math:`\hex{25}`                      :math:`[\I32] \to [t]`                         :ref:`validation <valid-table.get>`            :ref:`execution <exec-table.get>`                                 
+:math:`\TABLESET~x`                                :math:`\hex{26}`                      :math:`[\I32~t] \to []`                        :ref:`validation <valid-table.set>`            :ref:`execution <exec-table.set>`                                 
+(reserved)                                         :math:`\hex{27}`                                                                                                                                                                                      
+:math:`\I32.\LOAD~\memarg`                         :math:`\hex{28}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
+:math:`\I64.\LOAD~\memarg`                         :math:`\hex{29}`                      :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
+:math:`\F32.\LOAD~\memarg`                         :math:`\hex{2A}`                      :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
+:math:`\F64.\LOAD~\memarg`                         :math:`\hex{2B}`                      :math:`[\I32] \to [\F64]`                      :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
+:math:`\I32.\LOAD\K{8\_s}~\memarg`                 :math:`\hex{2C}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I32.\LOAD\K{8\_u}~\memarg`                 :math:`\hex{2D}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I32.\LOAD\K{16\_s}~\memarg`                :math:`\hex{2E}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I32.\LOAD\K{16\_u}~\memarg`                :math:`\hex{2F}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I64.\LOAD\K{8\_s}~\memarg`                 :math:`\hex{30}`                      :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I64.\LOAD\K{8\_u}~\memarg`                 :math:`\hex{31}`                      :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I64.\LOAD\K{16\_s}~\memarg`                :math:`\hex{32}`                      :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I64.\LOAD\K{16\_u}~\memarg`                :math:`\hex{33}`                      :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I64.\LOAD\K{32\_s}~\memarg`                :math:`\hex{34}`                      :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I64.\LOAD\K{32\_u}~\memarg`                :math:`\hex{35}`                      :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
+:math:`\I32.\STORE~\memarg`                        :math:`\hex{36}`                      :math:`[\I32~\I32] \to []`                     :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
+:math:`\I64.\STORE~\memarg`                        :math:`\hex{37}`                      :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
+:math:`\F32.\STORE~\memarg`                        :math:`\hex{38}`                      :math:`[\I32~\F32] \to []`                     :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
+:math:`\F64.\STORE~\memarg`                        :math:`\hex{39}`                      :math:`[\I32~\F64] \to []`                     :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
+:math:`\I32.\STORE\K{8}~\memarg`                   :math:`\hex{3A}`                      :math:`[\I32~\I32] \to []`                     :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
+:math:`\I32.\STORE\K{16}~\memarg`                  :math:`\hex{3B}`                      :math:`[\I32~\I32] \to []`                     :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
+:math:`\I64.\STORE\K{8}~\memarg`                   :math:`\hex{3C}`                      :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
+:math:`\I64.\STORE\K{16}~\memarg`                  :math:`\hex{3D}`                      :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
+:math:`\I64.\STORE\K{32}~\memarg`                  :math:`\hex{3E}`                      :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
+:math:`\MEMORYSIZE`                                :math:`\hex{3F}`                      :math:`[] \to [\I32]`                          :ref:`validation <valid-memory.size>`          :ref:`execution <exec-memory.size>`                               
+:math:`\MEMORYGROW`                                :math:`\hex{40}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-memory.grow>`          :ref:`execution <exec-memory.grow>`                               
+:math:`\I32.\CONST~\i32`                           :math:`\hex{41}`                      :math:`[] \to [\I32]`                          :ref:`validation <valid-const>`                :ref:`execution <exec-const>`                                     
+:math:`\I64.\CONST~\i64`                           :math:`\hex{42}`                      :math:`[] \to [\I64]`                          :ref:`validation <valid-const>`                :ref:`execution <exec-const>`                                     
+:math:`\F32.\CONST~\f32`                           :math:`\hex{43}`                      :math:`[] \to [\F32]`                          :ref:`validation <valid-const>`                :ref:`execution <exec-const>`                                     
+:math:`\F64.\CONST~\f64`                           :math:`\hex{44}`                      :math:`[] \to [\F64]`                          :ref:`validation <valid-const>`                :ref:`execution <exec-const>`                                     
+:math:`\I32.\EQZ`                                  :math:`\hex{45}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-testop>`               :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`         
+:math:`\I32.\EQ`                                   :math:`\hex{46}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`           
+:math:`\I32.\NE`                                   :math:`\hex{47}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`           
+:math:`\I32.\LT\K{\_s}`                            :math:`\hex{48}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`         
+:math:`\I32.\LT\K{\_u}`                            :math:`\hex{49}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`         
+:math:`\I32.\GT\K{\_s}`                            :math:`\hex{4A}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`         
+:math:`\I32.\GT\K{\_u}`                            :math:`\hex{4B}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`         
+:math:`\I32.\LE\K{\_s}`                            :math:`\hex{4C}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`         
+:math:`\I32.\LE\K{\_u}`                            :math:`\hex{4D}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`         
+:math:`\I32.\GE\K{\_s}`                            :math:`\hex{4E}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`         
+:math:`\I32.\GE\K{\_u}`                            :math:`\hex{4F}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`         
+:math:`\I64.\EQZ`                                  :math:`\hex{50}`                      :math:`[\I64] \to [\I32]`                      :ref:`validation <valid-testop>`               :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`         
+:math:`\I64.\EQ`                                   :math:`\hex{51}`                      :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`           
+:math:`\I64.\NE`                                   :math:`\hex{52}`                      :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`           
+:math:`\I64.\LT\K{\_s}`                            :math:`\hex{53}`                      :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`         
+:math:`\I64.\LT\K{\_u}`                            :math:`\hex{54}`                      :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`         
+:math:`\I64.\GT\K{\_s}`                            :math:`\hex{55}`                      :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`         
+:math:`\I64.\GT\K{\_u}`                            :math:`\hex{56}`                      :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`         
+:math:`\I64.\LE\K{\_s}`                            :math:`\hex{57}`                      :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`         
+:math:`\I64.\LE\K{\_u}`                            :math:`\hex{58}`                      :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`         
+:math:`\I64.\GE\K{\_s}`                            :math:`\hex{59}`                      :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`         
+:math:`\I64.\GE\K{\_u}`                            :math:`\hex{5A}`                      :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`         
+:math:`\F32.\EQ`                                   :math:`\hex{5B}`                      :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`           
+:math:`\F32.\NE`                                   :math:`\hex{5C}`                      :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`           
+:math:`\F32.\LT`                                   :math:`\hex{5D}`                      :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`           
+:math:`\F32.\GT`                                   :math:`\hex{5E}`                      :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`           
+:math:`\F32.\LE`                                   :math:`\hex{5F}`                      :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`           
+:math:`\F32.\GE`                                   :math:`\hex{60}`                      :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`           
+:math:`\F64.\EQ`                                   :math:`\hex{61}`                      :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`           
+:math:`\F64.\NE`                                   :math:`\hex{62}`                      :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`           
+:math:`\F64.\LT`                                   :math:`\hex{63}`                      :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`           
+:math:`\F64.\GT`                                   :math:`\hex{64}`                      :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`           
+:math:`\F64.\LE`                                   :math:`\hex{65}`                      :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`           
+:math:`\F64.\GE`                                   :math:`\hex{66}`                      :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`           
+:math:`\I32.\CLZ`                                  :math:`\hex{67}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`           
+:math:`\I32.\CTZ`                                  :math:`\hex{68}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`           
+:math:`\I32.\POPCNT`                               :math:`\hex{69}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`        
+:math:`\I32.\ADD`                                  :math:`\hex{6A}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`          
+:math:`\I32.\SUB`                                  :math:`\hex{6B}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`          
+:math:`\I32.\MUL`                                  :math:`\hex{6C}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`          
+:math:`\I32.\DIV\K{\_s}`                           :math:`\hex{6D}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`        
+:math:`\I32.\DIV\K{\_u}`                           :math:`\hex{6E}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`        
+:math:`\I32.\REM\K{\_s}`                           :math:`\hex{6F}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`        
+:math:`\I32.\REM\K{\_u}`                           :math:`\hex{70}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`        
+:math:`\I32.\AND`                                  :math:`\hex{71}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`          
+:math:`\I32.\OR`                                   :math:`\hex{72}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`           
+:math:`\I32.\XOR`                                  :math:`\hex{73}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`          
+:math:`\I32.\SHL`                                  :math:`\hex{74}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`          
+:math:`\I32.\SHR\K{\_s}`                           :math:`\hex{75}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`        
+:math:`\I32.\SHR\K{\_u}`                           :math:`\hex{76}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`        
+:math:`\I32.\ROTL`                                 :math:`\hex{77}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`         
+:math:`\I32.\ROTR`                                 :math:`\hex{78}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`         
+:math:`\I64.\CLZ`                                  :math:`\hex{79}`                      :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`           
+:math:`\I64.\CTZ`                                  :math:`\hex{7A}`                      :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`           
+:math:`\I64.\POPCNT`                               :math:`\hex{7B}`                      :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`        
+:math:`\I64.\ADD`                                  :math:`\hex{7C}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`          
+:math:`\I64.\SUB`                                  :math:`\hex{7D}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`          
+:math:`\I64.\MUL`                                  :math:`\hex{7E}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`          
+:math:`\I64.\DIV\K{\_s}`                           :math:`\hex{7F}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`        
+:math:`\I64.\DIV\K{\_u}`                           :math:`\hex{80}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`        
+:math:`\I64.\REM\K{\_s}`                           :math:`\hex{81}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`        
+:math:`\I64.\REM\K{\_u}`                           :math:`\hex{82}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`        
+:math:`\I64.\AND`                                  :math:`\hex{83}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`          
+:math:`\I64.\OR`                                   :math:`\hex{84}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`           
+:math:`\I64.\XOR`                                  :math:`\hex{85}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`          
+:math:`\I64.\SHL`                                  :math:`\hex{86}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`          
+:math:`\I64.\SHR\K{\_s}`                           :math:`\hex{87}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`        
+:math:`\I64.\SHR\K{\_u}`                           :math:`\hex{88}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`        
+:math:`\I64.\ROTL`                                 :math:`\hex{89}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`         
+:math:`\I64.\ROTR`                                 :math:`\hex{8A}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`         
+:math:`\F32.\ABS`                                  :math:`\hex{8B}`                      :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`           
+:math:`\F32.\NEG`                                  :math:`\hex{8C}`                      :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`           
+:math:`\F32.\CEIL`                                 :math:`\hex{8D}`                      :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`          
+:math:`\F32.\FLOOR`                                :math:`\hex{8E}`                      :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`         
+:math:`\F32.\TRUNC`                                :math:`\hex{8F}`                      :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`         
+:math:`\F32.\NEAREST`                              :math:`\hex{90}`                      :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`       
+:math:`\F32.\SQRT`                                 :math:`\hex{91}`                      :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`          
+:math:`\F32.\ADD`                                  :math:`\hex{92}`                      :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`          
+:math:`\F32.\SUB`                                  :math:`\hex{93}`                      :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`          
+:math:`\F32.\MUL`                                  :math:`\hex{94}`                      :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`          
+:math:`\F32.\DIV`                                  :math:`\hex{95}`                      :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`          
+:math:`\F32.\FMIN`                                 :math:`\hex{96}`                      :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`          
+:math:`\F32.\FMAX`                                 :math:`\hex{97}`                      :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`          
+:math:`\F32.\COPYSIGN`                             :math:`\hex{98}`                      :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`     
+:math:`\F64.\ABS`                                  :math:`\hex{99}`                      :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`           
+:math:`\F64.\NEG`                                  :math:`\hex{9A}`                      :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`           
+:math:`\F64.\CEIL`                                 :math:`\hex{9B}`                      :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`          
+:math:`\F64.\FLOOR`                                :math:`\hex{9C}`                      :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`         
+:math:`\F64.\TRUNC`                                :math:`\hex{9D}`                      :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`         
+:math:`\F64.\NEAREST`                              :math:`\hex{9E}`                      :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`       
+:math:`\F64.\SQRT`                                 :math:`\hex{9F}`                      :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`          
+:math:`\F64.\ADD`                                  :math:`\hex{A0}`                      :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`          
+:math:`\F64.\SUB`                                  :math:`\hex{A1}`                      :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`          
+:math:`\F64.\MUL`                                  :math:`\hex{A2}`                      :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`          
+:math:`\F64.\DIV`                                  :math:`\hex{A3}`                      :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`          
+:math:`\F64.\FMIN`                                 :math:`\hex{A4}`                      :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`          
+:math:`\F64.\FMAX`                                 :math:`\hex{A5}`                      :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`          
+:math:`\F64.\COPYSIGN`                             :math:`\hex{A6}`                      :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`     
+:math:`\I32.\WRAP\K{\_}\I64`                       :math:`\hex{A7}`                      :math:`[\I64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-wrap>`          
+:math:`\I32.\TRUNC\K{\_}\F32\K{\_s}`               :math:`\hex{A8}`                      :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`       
+:math:`\I32.\TRUNC\K{\_}\F32\K{\_u}`               :math:`\hex{A9}`                      :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`       
+:math:`\I32.\TRUNC\K{\_}\F64\K{\_s}`               :math:`\hex{AA}`                      :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`       
+:math:`\I32.\TRUNC\K{\_}\F64\K{\_u}`               :math:`\hex{AB}`                      :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`       
+:math:`\I64.\EXTEND\K{\_}\I32\K{\_s}`              :math:`\hex{AC}`                      :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_s>`      
+:math:`\I64.\EXTEND\K{\_}\I32\K{\_u}`              :math:`\hex{AD}`                      :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_u>`      
+:math:`\I64.\TRUNC\K{\_}\F32\K{\_s}`               :math:`\hex{AE}`                      :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`       
+:math:`\I64.\TRUNC\K{\_}\F32\K{\_u}`               :math:`\hex{AF}`                      :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`       
+:math:`\I64.\TRUNC\K{\_}\F64\K{\_s}`               :math:`\hex{B0}`                      :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`       
+:math:`\I64.\TRUNC\K{\_}\F64\K{\_u}`               :math:`\hex{B1}`                      :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`       
+:math:`\F32.\CONVERT\K{\_}\I32\K{\_s}`             :math:`\hex{B2}`                      :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`     
+:math:`\F32.\CONVERT\K{\_}\I32\K{\_u}`             :math:`\hex{B3}`                      :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`     
+:math:`\F32.\CONVERT\K{\_}\I64\K{\_s}`             :math:`\hex{B4}`                      :math:`[\I64] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`     
+:math:`\F32.\CONVERT\K{\_}\I64\K{\_u}`             :math:`\hex{B5}`                      :math:`[\I64] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`     
+:math:`\F32.\DEMOTE\K{\_}\F64`                     :math:`\hex{B6}`                      :math:`[\F64] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-demote>`        
+:math:`\F64.\CONVERT\K{\_}\I32\K{\_s}`             :math:`\hex{B7}`                      :math:`[\I32] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`     
+:math:`\F64.\CONVERT\K{\_}\I32\K{\_u}`             :math:`\hex{B8}`                      :math:`[\I32] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`     
+:math:`\F64.\CONVERT\K{\_}\I64\K{\_s}`             :math:`\hex{B9}`                      :math:`[\I64] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`     
+:math:`\F64.\CONVERT\K{\_}\I64\K{\_u}`             :math:`\hex{BA}`                      :math:`[\I64] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`     
+:math:`\F64.\PROMOTE\K{\_}\F32`                    :math:`\hex{BB}`                      :math:`[\F32] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-promote>`       
+:math:`\I32.\REINTERPRET\K{\_}\F32`                :math:`\hex{BC}`                      :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`   
+:math:`\I64.\REINTERPRET\K{\_}\F64`                :math:`\hex{BD}`                      :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`   
+:math:`\F32.\REINTERPRET\K{\_}\I32`                :math:`\hex{BE}`                      :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`   
+:math:`\F64.\REINTERPRET\K{\_}\I64`                :math:`\hex{BF}`                      :math:`[\I64] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`   
+:math:`\I32.\EXTEND\K{8\_s}`                       :math:`\hex{C0}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
+:math:`\I32.\EXTEND\K{16\_s}`                      :math:`\hex{C1}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
+:math:`\I64.\EXTEND\K{8\_s}`                       :math:`\hex{C2}`                      :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
+:math:`\I64.\EXTEND\K{16\_s}`                      :math:`\hex{C3}`                      :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
+:math:`\I64.\EXTEND\K{32\_s}`                      :math:`\hex{C4}`                      :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
+(reserved)                                         :math:`\hex{C5}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{C6}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{C7}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{C8}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{C9}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{CA}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{CB}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{CC}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{CD}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{CE}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{CF}`                                                                                                                                                                                      
+:math:`\REFNULL~t`                                 :math:`\hex{D0}`                      :math:`[] \to [t]`                             :ref:`validation <valid-ref.null>`             :ref:`execution <exec-ref.null>`                                  
+:math:`\REFISNULL`                                 :math:`\hex{D1}`                      :math:`[t] \to [\I32]`                         :ref:`validation <valid-ref.is_null>`          :ref:`execution <exec-ref.is_null>`                               
+:math:`\REFFUNC~x`                                 :math:`\hex{D2}`                      :math:`[] \to [\FUNCREF]`                      :ref:`validation <valid-ref.func>`             :ref:`execution <exec-ref.func>`                                  
+(reserved)                                         :math:`\hex{D3}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{D4}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{D5}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{D6}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{D7}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{D8}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{D9}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{DA}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{DB}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{DC}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{DD}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{DE}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{DF}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{E0}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{E1}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{E2}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{E3}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{E4}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{E5}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{E6}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{E7}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{E8}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{E9}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{EA}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{EB}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{EC}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{ED}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{EE}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{EF}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{F0}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{F1}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{F2}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{F3}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{F4}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{F5}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{F6}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{F7}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{F8}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{F9}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{FA}`                                                                                                                                                                                      
+(reserved)                                         :math:`\hex{FB}`                                                                                                                                                                                      
+:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_s}`          :math:`\hex{FC}~\hex{00}`             :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
+:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_u}`          :math:`\hex{FC}~\hex{01}`             :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
+:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_s}`          :math:`\hex{FC}~\hex{02}`             :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
+:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_u}`          :math:`\hex{FC}~\hex{03}`             :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
+:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_s}`          :math:`\hex{FC}~\hex{04}`             :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
+:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_u}`          :math:`\hex{FC}~\hex{05}`             :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
+:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_s}`          :math:`\hex{FC}~\hex{06}`             :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
+:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_u}`          :math:`\hex{FC}~\hex{07}`             :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
+:math:`\MEMORYINIT~x`                              :math:`\hex{FC}~\hex{08}`             :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-memory.init>`          :ref:`execution <exec-memory.init>`                               
+:math:`\DATADROP~x`                                :math:`\hex{FC}~\hex{09}`             :math:`[] \to []`                              :ref:`validation <valid-data.drop>`            :ref:`execution <exec-data.drop>`                                 
+:math:`\MEMORYCOPY`                                :math:`\hex{FC}~\hex{0A}`             :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-memory.copy>`          :ref:`execution <exec-memory.copy>`                               
+:math:`\MEMORYFILL`                                :math:`\hex{FC}~\hex{0B}`             :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-memory.fill>`          :ref:`execution <exec-memory.fill>`                               
+:math:`\TABLEINIT~x~y`                             :math:`\hex{FC}~\hex{0C}`             :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-table.init>`           :ref:`execution <exec-table.init>`                                
+:math:`\ELEMDROP~x`                                :math:`\hex{FC}~\hex{0D}`             :math:`[] \to []`                              :ref:`validation <valid-elem.drop>`            :ref:`execution <exec-elem.drop>`                                 
+:math:`\TABLECOPY~x~y`                             :math:`\hex{FC}~\hex{0E}`             :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-table.copy>`           :ref:`execution <exec-table.copy>`                                
+:math:`\TABLEGROW~x`                               :math:`\hex{FC}~\hex{0F}`             :math:`[t~\I32] \to [\I32]`                    :ref:`validation <valid-table.grow>`           :ref:`execution <exec-table.grow>`                                
+:math:`\TABLESIZE~x`                               :math:`\hex{FC}~\hex{10}`             :math:`[] \to [\I32]`                          :ref:`validation <valid-table.size>`           :ref:`execution <exec-table.size>`                                
+:math:`\TABLEFILL~x`                               :math:`\hex{FC}~\hex{11}`             :math:`[\I32~t~\I32] \to []`                   :ref:`validation <valid-table.fill>`           :ref:`execution <exec-table.fill>`                                
+:math:`\V128.\LOAD~\memarg`                        :math:`\hex{FD}~~\hex{00}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
+:math:`\V128.\LOAD\K{8x8\_s}~\memarg`              :math:`\hex{FD}~~\hex{01}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\V128.\LOAD\K{8x8\_u}~\memarg`              :math:`\hex{FD}~~\hex{02}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\V128.\LOAD\K{16x4\_s}~\memarg`             :math:`\hex{FD}~~\hex{03}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\V128.\LOAD\K{16x4\_u}~\memarg`             :math:`\hex{FD}~~\hex{04}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\V128.\LOAD\K{32x2\_s}~\memarg`             :math:`\hex{FD}~~\hex{05}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\V128.\LOAD\K{32x2\_u}~\memarg`             :math:`\hex{FD}~~\hex{06}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
+:math:`\V128.\LOAD\K{\_splat}~\memarg`             :math:`\hex{FD}~~\hex{07}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
+:math:`\V128.\LOAD\K{\_splat}~\memarg`             :math:`\hex{FD}~~\hex{08}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
+:math:`\V128.\LOAD\K{\_splat}~\memarg`             :math:`\hex{FD}~~\hex{09}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
+:math:`\V128.\LOAD\K{\_splat}~\memarg`             :math:`\hex{FD}~~\hex{0A}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
+:math:`\V128.\STORE~\memarg`                       :math:`\hex{FD}~~\hex{0B}`            :math:`[\I32~\V128] \to []`                    :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
+:math:`\V128.\VCONST~\i128`                        :math:`\hex{FD}~~\hex{0C}`            :math:`[] \to [\V128]`                         :ref:`validation <valid-vconst>`               :ref:`execution <exec-vconst>`                                    
+:math:`\I8X16.\SHUFFLE~\laneidx^{16}`              :math:`\hex{FD}~~\hex{0D}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-shuffle>`          :ref:`execution <exec-vec-shuffle>`                               
+:math:`\I8X16.\SWIZZLE`                            :math:`\hex{FD}~~\hex{0E}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-swizzle>`                               
+:math:`\I8X16.\SPLAT`                              :math:`\hex{FD}~~\hex{0F}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
+:math:`\I16X8.\SPLAT`                              :math:`\hex{FD}~~\hex{10}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
+:math:`\I32X4.\SPLAT`                              :math:`\hex{FD}~~\hex{11}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
+:math:`\I64X2.\SPLAT`                              :math:`\hex{FD}~~\hex{12}`            :math:`[\I64] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
+:math:`\F32X4.\SPLAT`                              :math:`\hex{FD}~~\hex{13}`            :math:`[\F32] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
+:math:`\F64X2.\SPLAT`                              :math:`\hex{FD}~~\hex{14}`            :math:`[\F64] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
+:math:`\I8X16.\EXTRACTLANE\K{\_s}~\laneidx`        :math:`\hex{FD}~~\hex{15}`            :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\I8X16.\EXTRACTLANE\K{\_u}~\laneidx`        :math:`\hex{FD}~~\hex{16}`            :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\I8X16.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{17}`            :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
+:math:`\I16X8.\EXTRACTLANE\K{\_s}~\laneidx`        :math:`\hex{FD}~~\hex{18}`            :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\I16X8.\EXTRACTLANE\K{\_u}~\laneidx`        :math:`\hex{FD}~~\hex{19}`            :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\I16X8.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{1A}`            :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
+:math:`\I32X4.\EXTRACTLANE~\laneidx`               :math:`\hex{FD}~~\hex{1B}`            :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\I32X4.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{1C}`            :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
+:math:`\I64X2.\EXTRACTLANE~\laneidx`               :math:`\hex{FD}~~\hex{1D}`            :math:`[\V128] \to [\I64]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\I64X2.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{1E}`            :math:`[\V128~\I64] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
+:math:`\F32X4.\EXTRACTLANE~\laneidx`               :math:`\hex{FD}~~\hex{1F}`            :math:`[\V128] \to [\F32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\F32X4.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{20}`            :math:`[\V128~\F32] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
+:math:`\F64X2.\EXTRACTLANE~\laneidx`               :math:`\hex{FD}~~\hex{21}`            :math:`[\V128] \to [\F64]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
+:math:`\F64X2.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{22}`            :math:`[\V128~\F64] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
+:math:`\I8X16.\VEQ`                                :math:`\hex{FD}~~\hex{23}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ieq>`          
+:math:`\I8X16.\VNE`                                :math:`\hex{FD}~~\hex{24}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ine>`          
+:math:`\I8X16.\VLT\K{\_s}`                         :math:`\hex{FD}~~\hex{25}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_s>`        
+:math:`\I8X16.\VLT\K{\_u}`                         :math:`\hex{FD}~~\hex{26}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_u>`        
+:math:`\I8X16.\VGT\K{\_s}`                         :math:`\hex{FD}~~\hex{27}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_s>`        
+:math:`\I8X16.\VGT\K{\_u}`                         :math:`\hex{FD}~~\hex{28}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_u>`        
+:math:`\I8X16.\VLE\K{\_s}`                         :math:`\hex{FD}~~\hex{29}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_s>`        
+:math:`\I8X16.\VLE\K{\_u}`                         :math:`\hex{FD}~~\hex{2A}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_u>`        
+:math:`\I8X16.\VGE\K{\_s}`                         :math:`\hex{FD}~~\hex{2B}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_s>`        
+:math:`\I8X16.\VGE\K{\_u}`                         :math:`\hex{FD}~~\hex{2C}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_u>`        
+:math:`\I16X8.\VEQ`                                :math:`\hex{FD}~~\hex{2D}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ieq>`          
+:math:`\I16X8.\VNE`                                :math:`\hex{FD}~~\hex{2E}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ine>`          
+:math:`\I16X8.\VLT\K{\_s}`                         :math:`\hex{FD}~~\hex{2F}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_s>`        
+:math:`\I16X8.\VLT\K{\_u}`                         :math:`\hex{FD}~~\hex{30}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_u>`        
+:math:`\I16X8.\VGT\K{\_s}`                         :math:`\hex{FD}~~\hex{31}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_s>`        
+:math:`\I16X8.\VGT\K{\_u}`                         :math:`\hex{FD}~~\hex{32}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_u>`        
+:math:`\I16X8.\VLE\K{\_s}`                         :math:`\hex{FD}~~\hex{33}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_s>`        
+:math:`\I16X8.\VLE\K{\_u}`                         :math:`\hex{FD}~~\hex{34}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_u>`        
+:math:`\I16X8.\VGE\K{\_s}`                         :math:`\hex{FD}~~\hex{35}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_s>`        
+:math:`\I16X8.\VGE\K{\_u}`                         :math:`\hex{FD}~~\hex{36}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_u>`        
+:math:`\I32X4.\VEQ`                                :math:`\hex{FD}~~\hex{37}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ieq>`          
+:math:`\I32X4.\VNE`                                :math:`\hex{FD}~~\hex{38}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ine>`          
+:math:`\I32X4.\VLT\K{\_s}`                         :math:`\hex{FD}~~\hex{39}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_s>`        
+:math:`\I32X4.\VLT\K{\_u}`                         :math:`\hex{FD}~~\hex{3A}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_u>`        
+:math:`\I32X4.\VGT\K{\_s}`                         :math:`\hex{FD}~~\hex{3B}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_s>`        
+:math:`\I32X4.\VGT\K{\_u}`                         :math:`\hex{FD}~~\hex{3C}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_u>`        
+:math:`\I32X4.\VLE\K{\_s}`                         :math:`\hex{FD}~~\hex{3D}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_s>`        
+:math:`\I32X4.\VLE\K{\_u}`                         :math:`\hex{FD}~~\hex{3E}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_u>`        
+:math:`\I32X4.\VGE\K{\_s}`                         :math:`\hex{FD}~~\hex{3F}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_s>`        
+:math:`\I32X4.\VGE\K{\_u}`                         :math:`\hex{FD}~~\hex{40}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_u>`        
+:math:`\F32X4.\VEQ`                                :math:`\hex{FD}~~\hex{41}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-feq>`          
+:math:`\F32X4.\VNE`                                :math:`\hex{FD}~~\hex{42}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fne>`          
+:math:`\F32X4.\VLT`                                :math:`\hex{FD}~~\hex{43}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-flt>`          
+:math:`\F32X4.\VGT`                                :math:`\hex{FD}~~\hex{44}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fgt>`          
+:math:`\F32X4.\VLE`                                :math:`\hex{FD}~~\hex{45}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fle>`          
+:math:`\F32X4.\VGE`                                :math:`\hex{FD}~~\hex{46}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fge>`          
+:math:`\F64X2.\VEQ`                                :math:`\hex{FD}~~\hex{47}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-feq>`          
+:math:`\F64X2.\VNE`                                :math:`\hex{FD}~~\hex{48}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fne>`          
+:math:`\F64X2.\VLT`                                :math:`\hex{FD}~~\hex{49}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-flt>`          
+:math:`\F64X2.\VGT`                                :math:`\hex{FD}~~\hex{4A}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fgt>`          
+:math:`\F64X2.\VLE`                                :math:`\hex{FD}~~\hex{4B}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fle>`          
+:math:`\F64X2.\VGE`                                :math:`\hex{FD}~~\hex{4C}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fge>`          
+:math:`\V128.\VNOT`                                :math:`\hex{FD}~~\hex{4D}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vvunop>`               :ref:`execution <exec-vvunop>`, :ref:`operator <op-inot>`         
+:math:`\V128.\VAND`                                :math:`\hex{FD}~~\hex{4E}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vvbinop>`              :ref:`execution <exec-vvbinop>`, :ref:`operator <op-iand>`        
+:math:`\V128.\VANDNOT`                             :math:`\hex{FD}~~\hex{4F}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vvbinop>`              :ref:`execution <exec-vvbinop>`, :ref:`operator <op-iandnot>`     
+:math:`\V128.\VOR`                                 :math:`\hex{FD}~~\hex{50}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vvbinop>`              :ref:`execution <exec-vvbinop>`, :ref:`operator <op-ior>`         
+:math:`\V128.\VXOR`                                :math:`\hex{FD}~~\hex{51}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vvbinop>`              :ref:`execution <exec-vvbinop>`, :ref:`operator <op-ixor>`        
+:math:`\V128.\BITSELECT`                           :math:`\hex{FD}~~\hex{52}`            :math:`[\V128~\V128~\V128] \to [\V128]`        :ref:`validation <valid-vvternop>`             :ref:`execution <exec-vvternop>`, :ref:`operator <op-ibitselect>` 
+:math:`\V128.\ANYTRUE`                             :math:`\hex{FD}~~\hex{53}`            :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vvtestop>`             :ref:`execution <exec-vvtestop>`                                  
+:math:`\V128.\LOAD\K{8\_lane}~\memarg~\laneidx`    :math:`\hex{FD}~~\hex{54}`            :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
+:math:`\V128.\LOAD\K{16\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{55}`            :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
+:math:`\V128.\LOAD\K{32\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{56}`            :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
+:math:`\V128.\LOAD\K{64\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{57}`            :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
+:math:`\V128.\STORE\K{8\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{58}`            :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
+:math:`\V128.\STORE\K{16\_lane}~\memarg~\laneidx`  :math:`\hex{FD}~~\hex{59}`            :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
+:math:`\V128.\STORE\K{32\_lane}~\memarg~\laneidx`  :math:`\hex{FD}~~\hex{5A}`            :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
+:math:`\V128.\STORE\K{64\_lane}~\memarg~\laneidx`  :math:`\hex{FD}~~\hex{5B}`            :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
+:math:`\V128.\LOAD\K{32\_zero}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{5C}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-zero>`            :ref:`execution <exec-load-zero>`                                 
+:math:`\V128.\LOAD\K{64\_zero}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{5D}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-zero>`            :ref:`execution <exec-load-zero>`                                 
+:math:`\F32X4.\VDEMOTE\K{\_f64x2\_zero}`           :math:`\hex{FD}~~\hex{5E}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-demote>`       
+:math:`\F64X2.\VPROMOTE\K{\_low\_f32x4}`           :math:`\hex{FD}~~\hex{5F}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-promote>`      
+:math:`\I8X16.\VABS`                               :math:`\hex{FD}~~\hex{60}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-iabs>`          
+:math:`\I8X16.\VNEG`                               :math:`\hex{FD}~~\hex{61}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ineg>`          
+:math:`\I8X16.\VPOPCNT`                            :math:`\hex{FD}~~\hex{62}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ipopcnt>`       
+:math:`\I8X16.\ALLTRUE`                            :math:`\hex{FD}~~\hex{63}`            :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vtestop>`              :ref:`execution <exec-vtestop>`                                   
+:math:`\I8X16.\BITMASK`                            :math:`\hex{FD}~~\hex{64}`            :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-bitmask>`          :ref:`execution <exec-vec-bitmask>`                               
+:math:`\I8X16.\NARROW\K{\_i16x8\_s}`               :math:`\hex{FD}~~\hex{65}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-narrow>`                                
+:math:`\I8X16.\NARROW\K{\_i16x8\_u}`               :math:`\hex{FD}~~\hex{66}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-narrow>`                                
+:math:`\F32X4.\VCEIL`                              :math:`\hex{FD}~~\hex{67}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fceil>`         
+:math:`\F32X4.\VFLOOR`                             :math:`\hex{FD}~~\hex{68}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ffloor>`        
+:math:`\F32X4.\VTRUNC`                             :math:`\hex{FD}~~\hex{69}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ftrunc>`        
+:math:`\F32X4.\VNEAREST`                           :math:`\hex{FD}~~\hex{6A}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fnearest>`      
+:math:`\I8X16.\VSHL`                               :math:`\hex{FD}~~\hex{6B}`            :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishl>`      
+:math:`\I8X16.\VSHR\K{\_s}`                        :math:`\hex{FD}~~\hex{6C}`            :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_s>`    
+:math:`\I8X16.\VSHR\K{\_u}`                        :math:`\hex{FD}~~\hex{6D}`            :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_u>`    
+:math:`\I8X16.\VADD`                               :math:`\hex{FD}~~\hex{6E}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd>`         
+:math:`\I8X16.\VADD\K{\_sat\_s}`                   :math:`\hex{FD}~~\hex{6F}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd_sat_s>`   
+:math:`\I8X16.\VADD\K{\_sat\_u}`                   :math:`\hex{FD}~~\hex{70}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd_sat_u>`   
+:math:`\I8X16.\VSUB`                               :math:`\hex{FD}~~\hex{71}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub>`         
+:math:`\I8X16.\VSUB\K{\_sat\_s}`                   :math:`\hex{FD}~~\hex{72}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub_sat_s>`   
+:math:`\I8X16.\VSUB\K{\_sat\_u}`                   :math:`\hex{FD}~~\hex{73}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub_sat_u>`   
+:math:`\F64X2.\VCEIL`                              :math:`\hex{FD}~~\hex{74}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fceil>`         
+:math:`\F64X2.\VFLOOR`                             :math:`\hex{FD}~~\hex{75}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ffloor>`        
+:math:`\I8X16.\VMIN\K{\_s}`                        :math:`\hex{FD}~~\hex{76}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_s>`       
+:math:`\I8X16.\VMIN\K{\_u}`                        :math:`\hex{FD}~~\hex{77}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_u>`       
+:math:`\I8X16.\VMAX\K{\_s}`                        :math:`\hex{FD}~~\hex{78}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_s>`       
+:math:`\I8X16.\VMAX\K{\_u}`                        :math:`\hex{FD}~~\hex{79}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_u>`       
+:math:`\F64X2.\VTRUNC`                             :math:`\hex{FD}~~\hex{7A}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ftrunc>`        
+:math:`\I8X16.\AVGR\K{\_u}`                        :math:`\hex{FD}~~\hex{7B}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iavgr_u>`      
+:math:`\I16X8.\EXTADDPAIRWISE\K{\_i8x16\_s}`       :math:`\hex{FD}~~\hex{7C}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vec-extadd_pairwise>`  :ref:`execution <exec-vec-extadd_pairwise>`                       
+:math:`\I16X8.\EXTADDPAIRWISE\K{\_i8x16\_u}`       :math:`\hex{FD}~~\hex{7D}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vec-extadd_pairwise>`  :ref:`execution <exec-vec-extadd_pairwise>`                       
+:math:`\I32X4.\EXTADDPAIRWISE\K{\_i16x8\_s}`       :math:`\hex{FD}~~\hex{7E}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vec-extadd_pairwise>`  :ref:`execution <exec-vec-extadd_pairwise>`                       
+:math:`\I32X4.\EXTADDPAIRWISE\K{\_i16x8\_u}`       :math:`\hex{FD}~~\hex{7F}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vec-extadd_pairwise>`  :ref:`execution <exec-vec-extadd_pairwise>`                       
+:math:`\I16X8.\VABS`                               :math:`\hex{FD}~~\hex{80}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-iabs>`          
+:math:`\I16X8.\VNEG`                               :math:`\hex{FD}~~\hex{81}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ineg>`          
+:math:`\I16X8.\Q15MULRSAT\K{\_s}`                  :math:`\hex{FD}~~\hex{82}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iq15mulrsat_s>`
+:math:`\I16X8.\ALLTRUE`                            :math:`\hex{FD}~~\hex{83}~~\hex{01}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vtestop>`              :ref:`execution <exec-vtestop>`                                   
+:math:`\I16X8.\BITMASK`                            :math:`\hex{FD}~~\hex{84}~~\hex{01}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-bitmask>`          :ref:`execution <exec-vec-bitmask>`                               
+:math:`\I16X8.\NARROW\K{\_i32x4\_s}`               :math:`\hex{FD}~~\hex{85}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-narrow>`                                
+:math:`\I16X8.\NARROW\K{\_i32x4\_u}`               :math:`\hex{FD}~~\hex{86}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-narrow>`                                
+:math:`\I16X8.\VEXTEND\K{\_low\_i8x16\_s}`         :math:`\hex{FD}~~\hex{87}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I16X8.\VEXTEND\K{\_high\_i8x16\_s}`        :math:`\hex{FD}~~\hex{88}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I16X8.\VEXTEND\K{\_low\_i8x16\_u}`         :math:`\hex{FD}~~\hex{89}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I16X8.\VEXTEND\K{\_high\_i8x16\_u}`        :math:`\hex{FD}~~\hex{8A}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I16X8.\VSHL`                               :math:`\hex{FD}~~\hex{8B}~~\hex{01}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishl>`      
+:math:`\I16X8.\VSHR\K{\_s}`                        :math:`\hex{FD}~~\hex{8C}~~\hex{01}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_s>`    
+:math:`\I16X8.\VSHR\K{\_u}`                        :math:`\hex{FD}~~\hex{8D}~~\hex{01}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_u>`    
+:math:`\I16X8.\VADD`                               :math:`\hex{FD}~~\hex{8E}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd>`         
+:math:`\I16X8.\VADD\K{\_sat\_s}`                   :math:`\hex{FD}~~\hex{8F}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd_sat_s>`   
+:math:`\I16X8.\VADD\K{\_sat\_u}`                   :math:`\hex{FD}~~\hex{90}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd_sat_u>`   
+:math:`\I16X8.\VSUB`                               :math:`\hex{FD}~~\hex{91}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub>`         
+:math:`\I16X8.\VSUB\K{\_sat\_s}`                   :math:`\hex{FD}~~\hex{92}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub_sat_s>`   
+:math:`\I16X8.\VSUB\K{\_sat\_u}`                   :math:`\hex{FD}~~\hex{93}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub_sat_u>`   
+:math:`\F64X2.\VNEAREST`                           :math:`\hex{FD}~~\hex{94}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fnearest>`      
+:math:`\I16X8.\VMUL`                               :math:`\hex{FD}~~\hex{95}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imul>`         
+:math:`\I16X8.\VMIN\K{\_s}`                        :math:`\hex{FD}~~\hex{96}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_s>`       
+:math:`\I16X8.\VMIN\K{\_u}`                        :math:`\hex{FD}~~\hex{97}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_u>`       
+:math:`\I16X8.\VMAX\K{\_s}`                        :math:`\hex{FD}~~\hex{98}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_s>`       
+:math:`\I16X8.\VMAX\K{\_u}`                        :math:`\hex{FD}~~\hex{99}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_u>`       
+:math:`\I16X8.\AVGR\K{\_u}`                        :math:`\hex{FD}~~\hex{9B}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iavgr_u>`      
+:math:`\I16X8.\EXTMUL\K{\_low\_i8x16\_s}`          :math:`\hex{FD}~~\hex{9C}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I16X8.\EXTMUL\K{\_high\_i8x16\_s}`         :math:`\hex{FD}~~\hex{9D}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I16X8.\EXTMUL\K{\_low\_i8x16\_u}`          :math:`\hex{FD}~~\hex{9E}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I16X8.\EXTMUL\K{\_high\_i8x16\_u}`         :math:`\hex{FD}~~\hex{9F}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I32X4.\VABS`                               :math:`\hex{FD}~~\hex{A0}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-iabs>`          
+:math:`\I32X4.\VNEG`                               :math:`\hex{FD}~~\hex{A1}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ineg>`          
+:math:`\I32X4.\ALLTRUE`                            :math:`\hex{FD}~~\hex{A3}~~\hex{01}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vtestop>`              :ref:`execution <exec-vtestop>`                                   
+:math:`\I32X4.\BITMASK`                            :math:`\hex{FD}~~\hex{A4}~~\hex{01}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-bitmask>`          :ref:`execution <exec-vec-bitmask>`                               
+:math:`\I32X4.\VEXTEND\K{\_low\_i16x8\_s}`         :math:`\hex{FD}~~\hex{A7}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I32X4.\VEXTEND\K{\_high\_i16x8\_s}`        :math:`\hex{FD}~~\hex{A8}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I32X4.\VEXTEND\K{\_low\_i16x8\_u}`         :math:`\hex{FD}~~\hex{A9}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I32X4.\VEXTEND\K{\_high\_i16x8\_u}`        :math:`\hex{FD}~~\hex{AA}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I32X4.\VSHL`                               :math:`\hex{FD}~~\hex{AB}~~\hex{01}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishl>`      
+:math:`\I32X4.\VSHR\K{\_s}`                        :math:`\hex{FD}~~\hex{AC}~~\hex{01}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_s>`    
+:math:`\I32X4.\VSHR\K{\_u}`                        :math:`\hex{FD}~~\hex{AD}~~\hex{01}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_u>`    
+:math:`\I32X4.\VADD`                               :math:`\hex{FD}~~\hex{AE}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd>`         
+:math:`\I32X4.\VSUB`                               :math:`\hex{FD}~~\hex{B1}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub>`         
+:math:`\I32X4.\VMUL`                               :math:`\hex{FD}~~\hex{B5}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imul>`         
+:math:`\I32X4.\VMIN\K{\_s}`                        :math:`\hex{FD}~~\hex{B6}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_s>`       
+:math:`\I32X4.\VMIN\K{\_u}`                        :math:`\hex{FD}~~\hex{B7}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_u>`       
+:math:`\I32X4.\VMAX\K{\_s}`                        :math:`\hex{FD}~~\hex{B8}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_s>`       
+:math:`\I32X4.\VMAX\K{\_u}`                        :math:`\hex{FD}~~\hex{B9}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_u>`       
+:math:`\I32X4.\DOT\K{\_i16x8\_s}`                  :math:`\hex{FD}~~\hex{BA}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-dot>`              :ref:`execution <exec-vec-dot>`                                   
+:math:`\I32X4.\EXTMUL\K{\_low\_i16x8\_s}`          :math:`\hex{FD}~~\hex{BC}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I32X4.\EXTMUL\K{\_high\_i16x8\_s}`         :math:`\hex{FD}~~\hex{BD}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I32X4.\EXTMUL\K{\_low\_i16x8\_u}`          :math:`\hex{FD}~~\hex{BE}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I32X4.\EXTMUL\K{\_high\_i16x8\_u}`         :math:`\hex{FD}~~\hex{BF}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I64X2.\VABS`                               :math:`\hex{FD}~~\hex{C0}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-iabs>`          
+:math:`\I64X2.\VNEG`                               :math:`\hex{FD}~~\hex{C1}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ineg>`          
+:math:`\I64X2.\ALLTRUE`                            :math:`\hex{FD}~~\hex{C3}~~\hex{01}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vtestop>`              :ref:`execution <exec-vtestop>`                                   
+:math:`\I64X2.\BITMASK`                            :math:`\hex{FD}~~\hex{C4}~~\hex{01}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-bitmask>`          :ref:`execution <exec-vec-bitmask>`                               
+:math:`\I64X2.\VEXTEND\K{\_low\_i32x4\_s}`         :math:`\hex{FD}~~\hex{C7}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I64X2.\VEXTEND\K{\_high\_i32x4\_s}`        :math:`\hex{FD}~~\hex{C8}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I64X2.\VEXTEND\K{\_low\_i32x4\_u}`         :math:`\hex{FD}~~\hex{C9}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I64X2.\VEXTEND\K{\_high\_i32x4\_u}`        :math:`\hex{FD}~~\hex{CA}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
+:math:`\I64X2.\VSHL`                               :math:`\hex{FD}~~\hex{CB}~~\hex{01}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishl>`      
+:math:`\I64X2.\VSHR\K{\_s}`                        :math:`\hex{FD}~~\hex{CC}~~\hex{01}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_s>`    
+:math:`\I64X2.\VSHR\K{\_u}`                        :math:`\hex{FD}~~\hex{CD}~~\hex{01}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_u>`    
+:math:`\I64X2.\VADD`                               :math:`\hex{FD}~~\hex{CE}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd>`         
+:math:`\I64X2.\VSUB`                               :math:`\hex{FD}~~\hex{D1}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub>`         
+:math:`\I64X2.\VMUL`                               :math:`\hex{FD}~~\hex{D5}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imul>`         
+:math:`\I64X2.\VEQ`                                :math:`\hex{FD}~~\hex{D6}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ieq>`          
+:math:`\I64X2.\VNE`                                :math:`\hex{FD}~~\hex{D7}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ine>`          
+:math:`\I64X2.\VLT\K{\_s}`                         :math:`\hex{FD}~~\hex{D8}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_s>`        
+:math:`\I64X2.\VGT\K{\_s}`                         :math:`\hex{FD}~~\hex{D9}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_s>`        
+:math:`\I64X2.\VLE\K{\_s}`                         :math:`\hex{FD}~~\hex{DA}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_s>`        
+:math:`\I64X2.\VGE\K{\_s}`                         :math:`\hex{FD}~~\hex{DB}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_s>`        
+:math:`\I64X2.\EXTMUL\K{\_low\_i32x4\_s}`          :math:`\hex{FD}~~\hex{DC}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I64X2.\EXTMUL\K{\_high\_i32x4\_s}`         :math:`\hex{FD}~~\hex{DD}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I64X2.\EXTMUL\K{\_low\_i32x4\_u}`          :math:`\hex{FD}~~\hex{DE}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\I64X2.\EXTMUL\K{\_high\_i32x4\_u}`         :math:`\hex{FD}~~\hex{DF}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
+:math:`\F32X4.\VABS`                               :math:`\hex{FD}~~\hex{E0}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fabs>`          
+:math:`\F32X4.\VNEG`                               :math:`\hex{FD}~~\hex{E1}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fneg>`          
+:math:`\F32X4.\VSQRT`                              :math:`\hex{FD}~~\hex{E3}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fsqrt>`         
+:math:`\F32X4.\VADD`                               :math:`\hex{FD}~~\hex{E4}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fadd>`         
+:math:`\F32X4.\VSUB`                               :math:`\hex{FD}~~\hex{E5}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fsub>`         
+:math:`\F32X4.\VMUL`                               :math:`\hex{FD}~~\hex{E6}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmul>`         
+:math:`\F32X4.\VDIV`                               :math:`\hex{FD}~~\hex{E7}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fdiv>`         
+:math:`\F32X4.\VMIN`                               :math:`\hex{FD}~~\hex{E8}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmin>`         
+:math:`\F32X4.\VMAX`                               :math:`\hex{FD}~~\hex{E9}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmax>`         
+:math:`\F32X4.\VPMIN`                              :math:`\hex{FD}~~\hex{EA}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fpmin>`        
+:math:`\F32X4.\VPMAX`                              :math:`\hex{FD}~~\hex{EB}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fpmax>`        
+:math:`\F64X2.\VABS`                               :math:`\hex{FD}~~\hex{EC}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fabs>`          
+:math:`\F64X2.\VNEG`                               :math:`\hex{FD}~~\hex{ED}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fneg>`          
+:math:`\F64X2.\VSQRT`                              :math:`\hex{FD}~~\hex{EF}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fsqrt>`         
+:math:`\F64X2.\VADD`                               :math:`\hex{FD}~~\hex{F0}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fadd>`         
+:math:`\F64X2.\VSUB`                               :math:`\hex{FD}~~\hex{F1}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fsub>`         
+:math:`\F64X2.\VMUL`                               :math:`\hex{FD}~~\hex{F2}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmul>`         
+:math:`\F64X2.\VDIV`                               :math:`\hex{FD}~~\hex{F3}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fdiv>`         
+:math:`\F64X2.\VMIN`                               :math:`\hex{FD}~~\hex{F4}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmin>`         
+:math:`\F64X2.\VMAX`                               :math:`\hex{FD}~~\hex{F5}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmax>`         
+:math:`\F64X2.\VPMIN`                              :math:`\hex{FD}~~\hex{F6}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fpmin>`        
+:math:`\F64X2.\VPMAX`                              :math:`\hex{FD}~~\hex{F7}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fpmax>`        
+:math:`\I32X4.\TRUNC\K{\_sat\_f32x4\_s}`           :math:`\hex{FD}~~\hex{F8}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-trunc_sat_s>`  
+:math:`\I32X4.\TRUNC\K{\_sat\_f32x4\_u}`           :math:`\hex{FD}~~\hex{F9}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-trunc_sat_u>`  
+:math:`\F32X4.\VCONVERT\K{\_i32x4\_s}`             :math:`\hex{FD}~~\hex{FA}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_s>`    
+:math:`\F32X4.\VCONVERT\K{\_i32x4\_u}`             :math:`\hex{FD}~~\hex{FB}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_u>`    
+:math:`\I32X4.\VTRUNC\K{\_sat\_f64x2\_s\_zero}`    :math:`\hex{FD}~~\hex{FC}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-trunc_sat_s>`  
+:math:`\I32X4.\VTRUNC\K{\_sat\_f64x2\_u\_zero}`    :math:`\hex{FD}~~\hex{FD}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-trunc_sat_u>`  
+:math:`\F64X2.\VCONVERT\K{\_low\_i32x4\_s}`        :math:`\hex{FD}~~\hex{FE}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_s>`    
+:math:`\F64X2.\VCONVERT\K{\_low\_i32x4\_u}`        :math:`\hex{FD}~~\hex{FF}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_u>`    
+=================================================  ====================================  =============================================  =============================================  ==================================================================

From 656e20a6108e39f1ac00a8b116ac0fd52d812a0c Mon Sep 17 00:00:00 2001
From: Ethan Jones <ictrobot@outlook.com>
Date: Tue, 17 May 2022 08:24:00 +0100
Subject: [PATCH 123/285] [spec] Fix v128.loadX_splat in instruction index
 (#1477)

---
 document/core/appendix/gen-index-instructions.py | 8 ++++----
 document/core/appendix/index-instructions.rst    | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/document/core/appendix/gen-index-instructions.py b/document/core/appendix/gen-index-instructions.py
index 4e04cfff6..2b61b5508 100755
--- a/document/core/appendix/gen-index-instructions.py
+++ b/document/core/appendix/gen-index-instructions.py
@@ -338,10 +338,10 @@ def Instruction(name, opcode, type=None, validation=None, execution=None, operat
     Instruction(r'\V128.\LOAD\K{16x4\_u}~\memarg', r'\hex{FD}~~\hex{04}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
     Instruction(r'\V128.\LOAD\K{32x2\_s}~\memarg', r'\hex{FD}~~\hex{05}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
     Instruction(r'\V128.\LOAD\K{32x2\_u}~\memarg', r'\hex{FD}~~\hex{06}', r'[\I32] \to [\V128]', r'valid-load-extend', r'exec-load-extend'),
-    Instruction(r'\V128.\LOAD\K{\_splat}~\memarg', r'\hex{FD}~~\hex{07}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
-    Instruction(r'\V128.\LOAD\K{\_splat}~\memarg', r'\hex{FD}~~\hex{08}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
-    Instruction(r'\V128.\LOAD\K{\_splat}~\memarg', r'\hex{FD}~~\hex{09}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
-    Instruction(r'\V128.\LOAD\K{\_splat}~\memarg', r'\hex{FD}~~\hex{0A}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
+    Instruction(r'\V128.\LOAD\K{8\_splat}~\memarg', r'\hex{FD}~~\hex{07}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
+    Instruction(r'\V128.\LOAD\K{16\_splat}~\memarg', r'\hex{FD}~~\hex{08}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
+    Instruction(r'\V128.\LOAD\K{32\_splat}~\memarg', r'\hex{FD}~~\hex{09}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
+    Instruction(r'\V128.\LOAD\K{64\_splat}~\memarg', r'\hex{FD}~~\hex{0A}', r'[\I32] \to [\V128]', r'valid-load-splat', r'exec-load-splat'),
     Instruction(r'\V128.\STORE~\memarg', r'\hex{FD}~~\hex{0B}', r'[\I32~\V128] \to []', r'valid-store', r'exec-store'),
     Instruction(r'\V128.\VCONST~\i128', r'\hex{FD}~~\hex{0C}', r'[] \to [\V128]', r'valid-vconst', r'exec-vconst'),
     Instruction(r'\I8X16.\SHUFFLE~\laneidx^{16}', r'\hex{FD}~~\hex{0D}', r'[\V128~\V128] \to [\V128]', r'valid-vec-shuffle', r'exec-vec-shuffle'),
diff --git a/document/core/appendix/index-instructions.rst b/document/core/appendix/index-instructions.rst
index a82fa9a62..0636a4266 100644
--- a/document/core/appendix/index-instructions.rst
+++ b/document/core/appendix/index-instructions.rst
@@ -286,10 +286,10 @@ Instruction                                        Binary Opcode
 :math:`\V128.\LOAD\K{16x4\_u}~\memarg`             :math:`\hex{FD}~~\hex{04}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
 :math:`\V128.\LOAD\K{32x2\_s}~\memarg`             :math:`\hex{FD}~~\hex{05}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
 :math:`\V128.\LOAD\K{32x2\_u}~\memarg`             :math:`\hex{FD}~~\hex{06}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
-:math:`\V128.\LOAD\K{\_splat}~\memarg`             :math:`\hex{FD}~~\hex{07}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
-:math:`\V128.\LOAD\K{\_splat}~\memarg`             :math:`\hex{FD}~~\hex{08}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
-:math:`\V128.\LOAD\K{\_splat}~\memarg`             :math:`\hex{FD}~~\hex{09}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
-:math:`\V128.\LOAD\K{\_splat}~\memarg`             :math:`\hex{FD}~~\hex{0A}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
+:math:`\V128.\LOAD\K{8\_splat}~\memarg`            :math:`\hex{FD}~~\hex{07}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
+:math:`\V128.\LOAD\K{16\_splat}~\memarg`           :math:`\hex{FD}~~\hex{08}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
+:math:`\V128.\LOAD\K{32\_splat}~\memarg`           :math:`\hex{FD}~~\hex{09}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
+:math:`\V128.\LOAD\K{64\_splat}~\memarg`           :math:`\hex{FD}~~\hex{0A}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
 :math:`\V128.\STORE~\memarg`                       :math:`\hex{FD}~~\hex{0B}`            :math:`[\I32~\V128] \to []`                    :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
 :math:`\V128.\VCONST~\i128`                        :math:`\hex{FD}~~\hex{0C}`            :math:`[] \to [\V128]`                         :ref:`validation <valid-vconst>`               :ref:`execution <exec-vconst>`                                    
 :math:`\I8X16.\SHUFFLE~\laneidx^{16}`              :math:`\hex{FD}~~\hex{0D}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-shuffle>`          :ref:`execution <exec-vec-shuffle>`                               

From 1b849c713eff03474e78352042fb51a79043b110 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ole=20Kr=C3=BCger?= <ole.kruger@trili.tech>
Date: Tue, 17 May 2022 15:58:39 +0100
Subject: [PATCH 124/285] [interpreter] Dune test suite (#1478)

---
 interpreter/dune-project => dune-project |  0
 interpreter/Makefile                     |  9 ++++++--
 interpreter/dune                         | 27 ++++++++++++++++++++----
 3 files changed, 30 insertions(+), 6 deletions(-)
 rename interpreter/dune-project => dune-project (100%)

diff --git a/interpreter/dune-project b/dune-project
similarity index 100%
rename from interpreter/dune-project
rename to dune-project
diff --git a/interpreter/Makefile b/interpreter/Makefile
index 4ff333d17..78fce53d8 100644
--- a/interpreter/Makefile
+++ b/interpreter/Makefile
@@ -27,7 +27,7 @@ JS =		# set to JS shell command to run JS tests
 
 # Main targets
 
-.PHONY:		default opt unopt libopt libunopt jslib all land zip smallint
+.PHONY:		default opt unopt libopt libunopt jslib all land zip smallint dunebuild
 
 default:	opt
 debug:		unopt
@@ -41,6 +41,8 @@ land:		$(WINMAKE) all
 zip: 		$(ZIP)
 smallint:	smallint.native
 
+dunebuild:
+	dune build
 
 # Building executable
 
@@ -136,7 +138,7 @@ TESTDIR =	../test/core
 TESTFILES =	$(shell cd $(TESTDIR); ls *.wast; ls [a-z]*/*.wast)
 TESTS =		$(TESTFILES:%.wast=%)
 
-.PHONY:		test debugtest partest
+.PHONY:		test debugtest partest dune-test
 
 test:		$(OPT) smallint
 		$(TESTDIR)/run.py --wasm `pwd`/$(OPT) $(if $(JS),--js '$(JS)',)
@@ -168,6 +170,9 @@ quiettest/%:	$(OPT)
 smallinttest:	smallint
 		@./smallint.native
 
+dunetest:
+	dune test
+
 # Miscellaneous targets
 
 .PHONY:		clean
diff --git a/interpreter/dune b/interpreter/dune
index 2b5cd3572..6f6dfff3e 100644
--- a/interpreter/dune
+++ b/interpreter/dune
@@ -3,10 +3,11 @@
 (library
  (name wasm)
  ; The 'main' module shall not be part of the library, as it would start the
- ; WASM REPL every time in all the dependencies.
+ ; Wasm REPL every time in all the dependencies.
  ; We also need to exclude the 'wasm' module as it overlaps with the library
  ; name.
- (modules :standard \ main wasm))
+ ; 'smallint' is a separate test module.
+ (modules :standard \ main wasm smallint))
 
 (executable
  (name main)
@@ -15,6 +16,13 @@
  (flags
   (-open Wasm)))
 
+(executable
+ (name smallint)
+ (modules smallint)
+ (libraries wasm)
+ (flags
+  (-open Wasm)))
+
 (subdir
  text
  (rule
@@ -28,6 +36,17 @@
   (modules parser)))
 
 (env
- (dev
+ (_
   (flags
-   (-w +a-4-27-42-44-45 -warn-error +a-3))))
+   (-w +a-4-27-42-44-45-70 -warn-error +a-3))))
+
+(rule
+ (alias runtest)
+ (deps
+  ./main.exe
+  ./smallint.exe
+  (source_tree ../test))
+ (action
+  (progn
+   (run ../test/core/run.py --wasm ./main.exe)
+   (run ./smallint.exe))))

From a2758426b38cba0e4bc57e0cc1ad99b143597212 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Tue, 31 May 2022 18:10:01 +0200
Subject: [PATCH 125/285] [interpreter] Fix warning flags for OCaml 4.13
 (#1481)

---
 interpreter/Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interpreter/Makefile b/interpreter/Makefile
index 78fce53d8..1783a9c4d 100644
--- a/interpreter/Makefile
+++ b/interpreter/Makefile
@@ -19,7 +19,7 @@ WINMAKE =	winmake.bat
 
 DIRS =		util syntax binary text valid runtime exec script host main tests
 LIBS =		bigarray
-FLAGS = 	-lexflags -ml -cflags '-w +a-4-27-42-44-45 -warn-error +a-3'
+FLAGS = 	-lexflags -ml -cflags '-w +a-4-27-42-44-45-70 -warn-error +a-3'
 OCBA =		ocamlbuild $(FLAGS) $(DIRS:%=-I %)
 OCB =		$(OCBA) $(LIBS:%=-libs %)
 JS =		# set to JS shell command to run JS tests

From f1229e10c774359355963d93694b48f225a008e1 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Wed, 1 Jun 2022 09:39:42 +0200
Subject: [PATCH 126/285] [interpreter] Simplify lexer and avoid table overflow
 on some architectures (#1482)

---
 interpreter/text/lexer.mll | 1119 ++++++++++++++++++------------------
 1 file changed, 570 insertions(+), 549 deletions(-)

diff --git a/interpreter/text/lexer.mll b/interpreter/text/lexer.mll
index c5d759fb8..161520e0a 100644
--- a/interpreter/text/lexer.mll
+++ b/interpreter/text/lexer.mll
@@ -1,17 +1,18 @@
 {
 open Parser
 open Operators
+open Source
 
 let convert_pos pos =
-  { Source.file = pos.Lexing.pos_fname;
-    Source.line = pos.Lexing.pos_lnum;
-    Source.column = pos.Lexing.pos_cnum - pos.Lexing.pos_bol
+  { file = pos.Lexing.pos_fname;
+    line = pos.Lexing.pos_lnum;
+    column = pos.Lexing.pos_cnum - pos.Lexing.pos_bol
   }
 
 let region lexbuf =
   let left = convert_pos (Lexing.lexeme_start_p lexbuf) in
   let right = convert_pos (Lexing.lexeme_end_p lexbuf) in
-  {Source.left = left; Source.right = right}
+  {left = left; right = right}
 
 let error lexbuf msg = raise (Script.Syntax (region lexbuf, msg))
 let error_nest start lexbuf msg =
@@ -47,92 +48,7 @@ let string s =
   done;
   Buffer.contents b
 
-let num_type = function
-  | "i32" -> Types.I32Type
-  | "i64" -> Types.I64Type
-  | "f32" -> Types.F32Type
-  | "f64" -> Types.F64Type
-  | _ -> assert false
-
-let vec_type = function
-  | "v128" -> Types.V128Type
-  | _ -> assert false
-
-let intop t i32 i64 =
-  match t with
-  | "i32" -> i32
-  | "i64" -> i64
-  | _ -> assert false
-
-let floatop t f32 f64 =
-  match t with
-  | "f32" -> f32
-  | "f64" -> f64
-  | _ -> assert false
-
-let numop t i32 i64 f32 f64 =
-  match t with
-  | "i32" -> i32
-  | "i64" -> i64
-  | "f32" -> f32
-  | "f64" -> f64
-  | _ -> assert false
-
-let v128op s i8x16 i16x8 i32x4 i64x2 f32x4 f64x2 =
-  match s with
-  | "i8x16" -> i8x16
-  | "i16x8" -> i16x8
-  | "i32x4" -> i32x4
-  | "i64x2" -> i64x2
-  | "f32x4" -> f32x4
-  | "f64x2" -> f64x2
-  | _ -> assert false
-
-let v128intop s i8x16 i16x8 i32x4 i64x2 =
-  match s with
-  | "i8x16" -> i8x16
-  | "i16x8" -> i16x8
-  | "i32x4" -> i32x4
-  | "i64x2" -> i64x2
-  | _ -> assert false
-
-let v128floatop s f32x4 f64x2 =
-  match s with
-  | "f32x4" -> f32x4
-  | "f64x2" -> f64x2
-  | _ -> assert false
-
-let memsz sz m8 m16 m32 =
-  match sz with
-  | "8" -> m8
-  | "16" -> m16
-  | "32" -> m32
-  | _ -> assert false
-
-let ext e s u =
-  match e with
-  | 's' -> s
-  | 'u' -> u
-  | _ -> assert false
-
 let opt = Lib.Option.get
-
-let v128_shape = function
-  | "i8x16" -> V128.I8x16 ()
-  | "i16x8" -> V128.I16x8 ()
-  | "i32x4" -> V128.I32x4 ()
-  | "i64x2" -> V128.I64x2 ()
-  | "f32x4" -> V128.F32x4 ()
-  | "f64x2" -> V128.F64x2 ()
-  | _ -> assert false
-
-let only shapes s lexbuf =
-  if not (List.mem s shapes) then
-    unknown lexbuf
-
-let except shapes s lexbuf =
-  if (List.mem s shapes) then
-    unknown lexbuf
 }
 
 let sign = '+' | '-'
@@ -181,8 +97,13 @@ let float =
   | sign? "nan"
   | sign? "nan:" "0x" hexnum
 let string = '"' character* '"'
-let reserved = (letter | digit | '_' | symbol)+
-let name = '$' reserved
+
+let idchar = letter | digit | '_' | symbol
+let name = idchar+
+let id = '$' name
+
+let keyword = ['a'-'z'] (letter | digit | '_' | '.' | ':')+
+let reserved = name | ',' | ';' | '[' | ']' | '{' | '}'
 
 let ixx = "i" ("32" | "64")
 let fxx = "f" ("32" | "64")
@@ -211,469 +132,569 @@ rule token = parse
   | '"'character*'\\'_
     { error_nest (Lexing.lexeme_end_p lexbuf) lexbuf "illegal escape" }
 
-  | "extern" { EXTERN }
-  | "externref" { EXTERNREF }
-  | "funcref" { FUNCREF }
-  | nxx as t { NUM_TYPE (num_type t) }
-  | vxxx as t { VEC_TYPE (vec_type t) }
-  | "mut" { MUT }
-
-  | v128_shape as s { VEC_SHAPE (v128_shape s) }
-
-  | (nxx as t)".const"
-    { let open Source in
-      CONST (numop t
-        (fun s -> let n = I32.of_string s.it in
-          i32_const (n @@ s.at), Values.I32 n)
-        (fun s -> let n = I64.of_string s.it in
-          i64_const (n @@ s.at), Values.I64 n)
-        (fun s -> let n = F32.of_string s.it in
-          f32_const (n @@ s.at), Values.F32 n)
-        (fun s -> let n = F64.of_string s.it in
-          f64_const (n @@ s.at), Values.F64 n))
-    }
-  | vxxx".const"
-    { let open Source in
-      VEC_CONST
-        (fun shape ss at ->
-          let v = V128.of_strings shape (List.map (fun s -> s.it) ss) in
-          (v128_const (v @@ at), Values.V128 v))
+  | keyword as s
+    { match s with
+      | "i32" -> NUM_TYPE Types.I32Type
+      | "i64" -> NUM_TYPE Types.I64Type
+      | "f32" -> NUM_TYPE Types.F32Type
+      | "f64" -> NUM_TYPE Types.F64Type
+      | "v128" -> VEC_TYPE Types.V128Type
+      | "i8x16" -> VEC_SHAPE (V128.I8x16 ())
+      | "i16x8" -> VEC_SHAPE (V128.I16x8 ())
+      | "i32x4" -> VEC_SHAPE (V128.I32x4 ())
+      | "i64x2" -> VEC_SHAPE (V128.I64x2 ())
+      | "f32x4" -> VEC_SHAPE (V128.F32x4 ())
+      | "f64x2" -> VEC_SHAPE (V128.F64x2 ())
+
+      | "extern" -> EXTERN
+      | "externref" -> EXTERNREF
+      | "funcref" -> FUNCREF
+      | "mut" -> MUT
+
+      | "nop" -> NOP
+      | "unreachable" -> UNREACHABLE
+      | "drop" -> DROP
+      | "block" -> BLOCK
+      | "loop" -> LOOP
+      | "end" -> END
+      | "br" -> BR
+      | "br_if" -> BR_IF
+      | "br_table" -> BR_TABLE
+      | "return" -> RETURN
+      | "if" -> IF
+      | "then" -> THEN
+      | "else" -> ELSE
+      | "select" -> SELECT
+      | "call" -> CALL
+      | "call_indirect" -> CALL_INDIRECT
+
+      | "local.get" -> LOCAL_GET
+      | "local.set" -> LOCAL_SET
+      | "local.tee" -> LOCAL_TEE
+      | "global.get" -> GLOBAL_GET
+      | "global.set" -> GLOBAL_SET
+
+      | "table.get" -> TABLE_GET
+      | "table.set" -> TABLE_SET
+      | "table.size" -> TABLE_SIZE
+      | "table.grow" -> TABLE_GROW
+      | "table.fill" -> TABLE_FILL
+      | "table.copy" -> TABLE_COPY
+      | "table.init" -> TABLE_INIT
+      | "elem.drop" -> ELEM_DROP
+
+      | "memory.size" -> MEMORY_SIZE
+      | "memory.grow" -> MEMORY_GROW
+      | "memory.fill" -> MEMORY_FILL
+      | "memory.copy" -> MEMORY_COPY
+      | "memory.init" -> MEMORY_INIT
+      | "data.drop" -> DATA_DROP
+
+      | "i32.load" -> LOAD (fun a o -> i32_load (opt a 2) o)
+      | "i64.load" -> LOAD (fun a o -> i64_load (opt a 3) o)
+      | "f32.load" -> LOAD (fun a o -> f32_load (opt a 2) o)
+      | "f64.load" -> LOAD (fun a o -> f64_load (opt a 3) o)
+      | "i32.store" -> STORE (fun a o -> i32_store (opt a 2) o)
+      | "i64.store" -> STORE (fun a o -> i64_store (opt a 3) o)
+      | "f32.store" -> STORE (fun a o -> f32_store (opt a 2) o)
+      | "f64.store" -> STORE (fun a o -> f64_store (opt a 3) o)
+
+      | "i32.load8_u" -> LOAD (fun a o -> i32_load8_u (opt a 0) o)
+      | "i32.load8_s" -> LOAD (fun a o -> i32_load8_s (opt a 0) o)
+      | "i32.load16_u" -> LOAD (fun a o -> i32_load16_u (opt a 1) o)
+      | "i32.load16_s" -> LOAD (fun a o -> i32_load16_s (opt a 1) o)
+      | "i64.load8_u" -> LOAD (fun a o -> i64_load8_u (opt a 0) o)
+      | "i64.load8_s" -> LOAD (fun a o -> i64_load8_s (opt a 0) o)
+      | "i64.load16_u" -> LOAD (fun a o -> i64_load16_u (opt a 1) o)
+      | "i64.load16_s" -> LOAD (fun a o -> i64_load16_s (opt a 1) o)
+      | "i64.load32_u" -> LOAD (fun a o -> i64_load32_u (opt a 2) o)
+      | "i64.load32_s" -> LOAD (fun a o -> i64_load32_s (opt a 2) o)
+
+      | "i32.store8" -> LOAD (fun a o -> i32_store8 (opt a 0) o)
+      | "i32.store16" -> LOAD (fun a o -> i32_store16 (opt a 1) o)
+      | "i64.store8" -> LOAD (fun a o -> i64_store8 (opt a 0) o)
+      | "i64.store16" -> LOAD (fun a o -> i64_store16 (opt a 1) o)
+      | "i64.store32" -> LOAD (fun a o -> i64_store32 (opt a 2) o)
+
+      | "v128.load" -> VEC_LOAD (fun a o -> v128_load (opt a 4) o)
+      | "v128.store" -> VEC_STORE (fun a o -> v128_store (opt a 4) o)
+      | "v128.load8x8_u" -> VEC_LOAD (fun a o -> v128_load8x8_u (opt a 3) o)
+      | "v128.load8x8_s" -> VEC_LOAD (fun a o -> v128_load8x8_s (opt a 3) o)
+      | "v128.load16x4_u" -> VEC_LOAD (fun a o -> v128_load16x4_u (opt a 3) o)
+      | "v128.load16x4_s" -> VEC_LOAD (fun a o -> v128_load16x4_s (opt a 3) o)
+      | "v128.load32x2_u" -> VEC_LOAD (fun a o -> v128_load32x2_u (opt a 3) o)
+      | "v128.load32x2_s" -> VEC_LOAD (fun a o -> v128_load32x2_s (opt a 3) o)
+      | "v128.load8_splat" ->
+        VEC_LOAD (fun a o -> v128_load8_splat (opt a 0) o)
+      | "v128.load16_splat" ->
+        VEC_LOAD (fun a o -> v128_load16_splat (opt a 1) o)
+      | "v128.load32_splat" ->
+        VEC_LOAD (fun a o -> v128_load32_splat (opt a 2) o)
+      | "v128.load64_splat" ->
+        VEC_LOAD (fun a o -> v128_load64_splat (opt a 3) o)
+      | "v128.load32_zero" ->
+        VEC_LOAD (fun a o -> v128_load32_zero (opt a 2) o)
+      | "v128.load64_zero" ->
+        VEC_LOAD (fun a o -> v128_load64_zero (opt a 3) o)
+      | "v128.load8_lane" ->
+        VEC_LOAD_LANE (fun a o i -> v128_load8_lane (opt a 0) o i)
+      | "v128.load16_lane" ->
+        VEC_LOAD_LANE (fun a o i -> v128_load16_lane (opt a 1) o i)
+      | "v128.load32_lane" ->
+        VEC_LOAD_LANE (fun a o i -> v128_load32_lane (opt a 2) o i)
+      | "v128.load64_lane" ->
+        VEC_LOAD_LANE (fun a o i -> v128_load64_lane (opt a 3) o i)
+      | "v128.store8_lane" ->
+        VEC_STORE_LANE (fun a o i -> v128_store8_lane (opt a 0) o i)
+      | "v128.store16_lane" ->
+        VEC_STORE_LANE (fun a o i -> v128_store16_lane (opt a 1) o i)
+      | "v128.store32_lane" ->
+        VEC_STORE_LANE (fun a o i -> v128_store32_lane (opt a 2) o i)
+      | "v128.store64_lane" ->
+        VEC_STORE_LANE (fun a o i -> v128_store64_lane (opt a 3) o i)
+
+      | "i32.const" ->
+        CONST (fun s ->
+          let n = I32.of_string s.it in i32_const (n @@ s.at), Values.I32 n)
+      | "i64.const" ->
+        CONST (fun s ->
+          let n = I64.of_string s.it in i64_const (n @@ s.at), Values.I64 n)
+      | "f32.const" ->
+        CONST (fun s ->
+          let n = F32.of_string s.it in f32_const (n @@ s.at), Values.F32 n)
+      | "f64.const" ->
+        CONST (fun s ->
+          let n = F64.of_string s.it in f64_const (n @@ s.at), Values.F64 n)
+      | "v128.const" ->
+        VEC_CONST
+          (fun shape ss at ->
+            let v = V128.of_strings shape (List.map (fun s -> s.it) ss) in
+            (v128_const (v @@ at), Values.V128 v))
+
+      | "ref.null" -> REF_NULL
+      | "ref.func" -> REF_FUNC
+      | "ref.extern" -> REF_EXTERN
+      | "ref.is_null" -> REF_IS_NULL
+
+      | "i32.clz" -> UNARY i32_clz
+      | "i32.ctz" -> UNARY i32_ctz
+      | "i32.popcnt" -> UNARY i32_popcnt
+      | "i32.extend8_s" -> UNARY i32_extend8_s
+      | "i32.extend16_s" -> UNARY i32_extend16_s
+      | "i64.clz" -> UNARY i64_clz
+      | "i64.ctz" -> UNARY i64_ctz
+      | "i64.popcnt" -> UNARY i64_popcnt
+      | "i64.extend8_s" -> UNARY i64_extend8_s
+      | "i64.extend16_s" -> UNARY i64_extend16_s
+      | "i64.extend32_s" -> UNARY i64_extend32_s
+
+      | "f32.neg" -> UNARY f32_neg
+      | "f32.abs" -> UNARY f32_abs
+      | "f32.sqrt" -> UNARY f32_sqrt
+      | "f32.ceil" -> UNARY f32_ceil
+      | "f32.floor" -> UNARY f32_floor
+      | "f32.trunc" -> UNARY f32_trunc
+      | "f32.nearest" -> UNARY f32_nearest
+      | "f64.neg" -> UNARY f64_neg
+      | "f64.abs" -> UNARY f64_abs
+      | "f64.sqrt" -> UNARY f64_sqrt
+      | "f64.ceil" -> UNARY f64_ceil
+      | "f64.floor" -> UNARY f64_floor
+      | "f64.trunc" -> UNARY f64_trunc
+      | "f64.nearest" -> UNARY f64_nearest
+
+      | "i32.add" -> BINARY i32_add
+      | "i32.sub" -> BINARY i32_sub
+      | "i32.mul" -> BINARY i32_mul
+      | "i32.div_u" -> BINARY i32_div_u
+      | "i32.div_s" -> BINARY i32_div_s
+      | "i32.rem_u" -> BINARY i32_rem_u
+      | "i32.rem_s" -> BINARY i32_rem_s
+      | "i32.and" -> BINARY i32_and
+      | "i32.or" -> BINARY i32_or
+      | "i32.xor" -> BINARY i32_xor
+      | "i32.shl" -> BINARY i32_shl
+      | "i32.shr_u" -> BINARY i32_shr_u
+      | "i32.shr_s" -> BINARY i32_shr_s
+      | "i32.rotl" -> BINARY i32_rotl
+      | "i32.rotr" -> BINARY i32_rotr
+      | "i64.add" -> BINARY i64_add
+      | "i64.sub" -> BINARY i64_sub
+      | "i64.mul" -> BINARY i64_mul
+      | "i64.div_u" -> BINARY i64_div_u
+      | "i64.div_s" -> BINARY i64_div_s
+      | "i64.rem_u" -> BINARY i64_rem_u
+      | "i64.rem_s" -> BINARY i64_rem_s
+      | "i64.and" -> BINARY i64_and
+      | "i64.or" -> BINARY i64_or
+      | "i64.xor" -> BINARY i64_xor
+      | "i64.shl" -> BINARY i64_shl
+      | "i64.shr_u" -> BINARY i64_shr_u
+      | "i64.shr_s" -> BINARY i64_shr_s
+      | "i64.rotl" -> BINARY i64_rotl
+      | "i64.rotr" -> BINARY i64_rotr
+
+      | "f32.add" -> BINARY f32_add
+      | "f32.sub" -> BINARY f32_sub
+      | "f32.mul" -> BINARY f32_mul
+      | "f32.div" -> BINARY f32_div
+      | "f32.min" -> BINARY f32_min
+      | "f32.max" -> BINARY f32_max
+      | "f32.copysign" -> BINARY f32_copysign
+      | "f64.add" -> BINARY f64_add
+      | "f64.sub" -> BINARY f64_sub
+      | "f64.mul" -> BINARY f64_mul
+      | "f64.div" -> BINARY f64_div
+      | "f64.min" -> BINARY f64_min
+      | "f64.max" -> BINARY f64_max
+      | "f64.copysign" -> BINARY f64_copysign
+
+      | "i32.eqz" -> TEST i32_eqz
+      | "i64.eqz" -> TEST i64_eqz
+
+      | "i32.eq" -> COMPARE i32_eq
+      | "i32.ne" -> COMPARE i32_ne
+      | "i32.lt_u" -> COMPARE i32_lt_u
+      | "i32.lt_s" -> COMPARE i32_lt_s
+      | "i32.le_u" -> COMPARE i32_le_u
+      | "i32.le_s" -> COMPARE i32_le_s
+      | "i32.gt_u" -> COMPARE i32_gt_u
+      | "i32.gt_s" -> COMPARE i32_gt_s
+      | "i32.ge_u" -> COMPARE i32_ge_u
+      | "i32.ge_s" -> COMPARE i32_ge_s
+      | "i64.eq" -> COMPARE i64_eq
+      | "i64.ne" -> COMPARE i64_ne
+      | "i64.lt_u" -> COMPARE i64_lt_u
+      | "i64.lt_s" -> COMPARE i64_lt_s
+      | "i64.le_u" -> COMPARE i64_le_u
+      | "i64.le_s" -> COMPARE i64_le_s
+      | "i64.gt_u" -> COMPARE i64_gt_u
+      | "i64.gt_s" -> COMPARE i64_gt_s
+      | "i64.ge_u" -> COMPARE i64_ge_u
+      | "i64.ge_s" -> COMPARE i64_ge_s
+
+      | "f32.eq" -> COMPARE f32_eq
+      | "f32.ne" -> COMPARE f32_ne
+      | "f32.lt" -> COMPARE f32_lt
+      | "f32.le" -> COMPARE f32_le
+      | "f32.gt" -> COMPARE f32_gt
+      | "f32.ge" -> COMPARE f32_ge
+      | "f64.eq" -> COMPARE f64_eq
+      | "f64.ne" -> COMPARE f64_ne
+      | "f64.lt" -> COMPARE f64_lt
+      | "f64.le" -> COMPARE f64_le
+      | "f64.gt" -> COMPARE f64_gt
+      | "f64.ge" -> COMPARE f64_ge
+
+      | "i32.wrap_i64" -> CONVERT i32_wrap_i64
+      | "i64.extend_i32_s" -> CONVERT i64_extend_i32_s
+      | "i64.extend_i32_u" -> CONVERT i64_extend_i32_u
+      | "f32.demote_f64" -> CONVERT f32_demote_f64
+      | "f64.promote_f32" -> CONVERT f64_promote_f32
+      | "i32.trunc_f32_u" -> CONVERT i32_trunc_f32_u
+      | "i32.trunc_f32_s" -> CONVERT i32_trunc_f32_s
+      | "i64.trunc_f32_u" -> CONVERT i64_trunc_f32_u
+      | "i64.trunc_f32_s" -> CONVERT i64_trunc_f32_s
+      | "i32.trunc_f64_u" -> CONVERT i32_trunc_f64_u
+      | "i32.trunc_f64_s" -> CONVERT i32_trunc_f64_s
+      | "i64.trunc_f64_u" -> CONVERT i64_trunc_f64_u
+      | "i64.trunc_f64_s" -> CONVERT i64_trunc_f64_s
+      | "i32.trunc_sat_f32_u" -> CONVERT i32_trunc_sat_f32_u
+      | "i32.trunc_sat_f32_s" -> CONVERT i32_trunc_sat_f32_s
+      | "i64.trunc_sat_f32_u" -> CONVERT i64_trunc_sat_f32_u
+      | "i64.trunc_sat_f32_s" -> CONVERT i64_trunc_sat_f32_s
+      | "i32.trunc_sat_f64_u" -> CONVERT i32_trunc_sat_f64_u
+      | "i32.trunc_sat_f64_s" -> CONVERT i32_trunc_sat_f64_s
+      | "i64.trunc_sat_f64_u" -> CONVERT i64_trunc_sat_f64_u
+      | "i64.trunc_sat_f64_s" -> CONVERT i64_trunc_sat_f64_s
+      | "f32.convert_i32_u" -> CONVERT f32_convert_i32_u
+      | "f32.convert_i32_s" -> CONVERT f32_convert_i32_s
+      | "f64.convert_i32_u" -> CONVERT f64_convert_i32_u
+      | "f64.convert_i32_s" -> CONVERT f64_convert_i32_s
+      | "f32.convert_i64_u" -> CONVERT f32_convert_i64_u
+      | "f32.convert_i64_s" -> CONVERT f32_convert_i64_s
+      | "f64.convert_i64_u" -> CONVERT f64_convert_i64_u
+      | "f64.convert_i64_s" -> CONVERT f64_convert_i64_s
+      | "f32.reinterpret_i32" -> CONVERT f32_reinterpret_i32
+      | "f64.reinterpret_i64" -> CONVERT f64_reinterpret_i64
+      | "i32.reinterpret_f32" -> CONVERT i32_reinterpret_f32
+      | "i64.reinterpret_f64" -> CONVERT i64_reinterpret_f64
+
+      | "v128.not" -> VEC_UNARY v128_not
+      | "v128.and" -> VEC_UNARY v128_and
+      | "v128.andnot" -> VEC_UNARY v128_andnot
+      | "v128.or" -> VEC_UNARY v128_or
+      | "v128.xor" -> VEC_UNARY v128_xor
+      | "v128.bitselect" -> VEC_TERNARY v128_bitselect
+      | "v128.any_true" -> VEC_TEST v128_any_true
+
+      | "i8x16.neg" -> VEC_UNARY i8x16_neg
+      | "i16x8.neg" -> VEC_UNARY i16x8_neg
+      | "i32x4.neg" -> VEC_UNARY i32x4_neg
+      | "i64x2.neg" -> VEC_UNARY i64x2_neg
+      | "i8x16.abs" -> VEC_UNARY i8x16_abs
+      | "i16x8.abs" -> VEC_UNARY i16x8_abs
+      | "i32x4.abs" -> VEC_UNARY i32x4_abs
+      | "i64x2.abs" -> VEC_UNARY i64x2_abs
+      | "i8x16.popcnt" -> VEC_UNARY i8x16_popcnt
+      | "i8x16.avgr_u" -> VEC_UNARY i8x16_avgr_u
+      | "i16x8.avgr_u" -> VEC_UNARY i16x8_avgr_u
+
+      | "f32x4.neg" -> VEC_UNARY f32x4_neg
+      | "f64x2.neg" -> VEC_UNARY f64x2_neg
+      | "f32x4.abs" -> VEC_UNARY f32x4_abs
+      | "f64x2.abs" -> VEC_UNARY f64x2_abs
+      | "f32x4.sqrt" -> VEC_UNARY f32x4_sqrt
+      | "f64x2.sqrt" -> VEC_UNARY f64x2_sqrt
+      | "f32x4.ceil" -> VEC_UNARY f32x4_ceil
+      | "f64x2.ceil" -> VEC_UNARY f64x2_ceil
+      | "f32x4.floor" -> VEC_UNARY f32x4_floor
+      | "f64x2.floor" -> VEC_UNARY f64x2_floor
+      | "f32x4.trunc" -> VEC_UNARY f32x4_trunc
+      | "f64x2.trunc" -> VEC_UNARY f64x2_trunc
+      | "f32x4.nearest" -> VEC_UNARY f32x4_nearest
+      | "f64x2.nearest" -> VEC_UNARY f64x2_nearest
+
+      | "i32x4.trunc_sat_f32x4_u" -> VEC_UNARY i32x4_trunc_sat_f32x4_u
+      | "i32x4.trunc_sat_f32x4_s" -> VEC_UNARY i32x4_trunc_sat_f32x4_s
+      | "i32x4.trunc_sat_f64x2_u_zero" ->
+        VEC_UNARY i32x4_trunc_sat_f64x2_u_zero
+      | "i32x4.trunc_sat_f64x2_s_zero" ->
+        VEC_UNARY i32x4_trunc_sat_f64x2_s_zero
+      | "f64x2.promote_low_f32x4" -> VEC_UNARY f64x2_promote_low_f32x4
+      | "f32x4.demote_f64x2_zero" -> VEC_UNARY f32x4_demote_f64x2_zero
+      | "f32x4.convert_i32x4_u" -> VEC_UNARY f32x4_convert_i32x4_u
+      | "f32x4.convert_i32x4_s" -> VEC_UNARY f32x4_convert_i32x4_s
+      | "f64x2.convert_low_i32x4_u" -> VEC_UNARY f64x2_convert_low_i32x4_u
+      | "f64x2.convert_low_i32x4_s" -> VEC_UNARY f64x2_convert_low_i32x4_s
+      | "i16x8.extadd_pairwise_i8x16_u" ->
+        VEC_UNARY i16x8_extadd_pairwise_i8x16_u
+      | "i16x8.extadd_pairwise_i8x16_s" ->
+        VEC_UNARY i16x8_extadd_pairwise_i8x16_s
+      | "i32x4.extadd_pairwise_i16x8_u" ->
+        VEC_UNARY i32x4_extadd_pairwise_i16x8_u
+      | "i32x4.extadd_pairwise_i16x8_s" ->
+        VEC_UNARY i32x4_extadd_pairwise_i16x8_s
+
+      | "i8x16.eq" -> VEC_BINARY i8x16_eq
+      | "i16x8.eq" -> VEC_BINARY i16x8_eq
+      | "i32x4.eq" -> VEC_BINARY i32x4_eq
+      | "i64x2.eq" -> VEC_BINARY i64x2_eq
+      | "i8x16.ne" -> VEC_BINARY i8x16_ne
+      | "i16x8.ne" -> VEC_BINARY i16x8_ne
+      | "i32x4.ne" -> VEC_BINARY i32x4_ne
+      | "i64x2.ne" -> VEC_BINARY i64x2_ne
+      | "i8x16.lt_u" -> VEC_BINARY i8x16_lt_u
+      | "i8x16.lt_s" -> VEC_BINARY i8x16_lt_s
+      | "i16x8.lt_u" -> VEC_BINARY i16x8_lt_u
+      | "i16x8.lt_s" -> VEC_BINARY i16x8_lt_s
+      | "i32x4.lt_u" -> VEC_BINARY i32x4_lt_u
+      | "i32x4.lt_s" -> VEC_BINARY i32x4_lt_s
+      | "i64x2.lt_s" -> VEC_BINARY i64x2_lt_s
+      | "i8x16.le_u" -> VEC_BINARY i8x16_le_u
+      | "i8x16.le_s" -> VEC_BINARY i8x16_le_s
+      | "i16x8.le_u" -> VEC_BINARY i16x8_le_u
+      | "i16x8.le_s" -> VEC_BINARY i16x8_le_s
+      | "i32x4.le_u" -> VEC_BINARY i32x4_le_u
+      | "i32x4.le_s" -> VEC_BINARY i32x4_le_s
+      | "i64x2.le_s" -> VEC_BINARY i64x2_le_s
+      | "i8x16.gt_u" -> VEC_BINARY i8x16_gt_u
+      | "i8x16.gt_s" -> VEC_BINARY i8x16_gt_s
+      | "i16x8.gt_u" -> VEC_BINARY i16x8_gt_u
+      | "i16x8.gt_s" -> VEC_BINARY i16x8_gt_s
+      | "i32x4.gt_u" -> VEC_BINARY i32x4_gt_u
+      | "i32x4.gt_s" -> VEC_BINARY i32x4_gt_s
+      | "i64x2.gt_s" -> VEC_BINARY i64x2_gt_s
+      | "i8x16.ge_u" -> VEC_BINARY i8x16_ge_u
+      | "i8x16.ge_s" -> VEC_BINARY i8x16_ge_s
+      | "i16x8.ge_u" -> VEC_BINARY i16x8_ge_u
+      | "i16x8.ge_s" -> VEC_BINARY i16x8_ge_s
+      | "i32x4.ge_u" -> VEC_BINARY i32x4_ge_u
+      | "i32x4.ge_s" -> VEC_BINARY i32x4_ge_s
+      | "i64x2.ge_s" -> VEC_BINARY i64x2_ge_s
+
+      | "f32x4.eq" -> VEC_BINARY f32x4_eq
+      | "f64x2.eq" -> VEC_BINARY f64x2_eq
+      | "f32x4.ne" -> VEC_BINARY f32x4_ne
+      | "f64x2.ne" -> VEC_BINARY f64x2_ne
+      | "f32x4.lt" -> VEC_BINARY f32x4_lt
+      | "f64x2.lt" -> VEC_BINARY f64x2_lt
+      | "f32x4.le" -> VEC_BINARY f32x4_le
+      | "f64x2.le" -> VEC_BINARY f64x2_le
+      | "f32x4.gt" -> VEC_BINARY f32x4_gt
+      | "f64x2.gt" -> VEC_BINARY f64x2_gt
+      | "f32x4.ge" -> VEC_BINARY f32x4_ge
+      | "f64x2.ge" -> VEC_BINARY f64x2_ge
+      | "i8x16.swizzle" -> VEC_BINARY i8x16_swizzle
+
+      | "i8x16.add" -> VEC_BINARY i8x16_add
+      | "i16x8.add" -> VEC_BINARY i16x8_add
+      | "i32x4.add" -> VEC_BINARY i32x4_add
+      | "i64x2.add" -> VEC_BINARY i64x2_add
+      | "i8x16.sub" -> VEC_BINARY i8x16_sub
+      | "i16x8.sub" -> VEC_BINARY i16x8_sub
+      | "i32x4.sub" -> VEC_BINARY i32x4_sub
+      | "i64x2.sub" -> VEC_BINARY i64x2_sub
+      | "i16x8.mul" -> VEC_BINARY i16x8_mul
+      | "i32x4.mul" -> VEC_BINARY i32x4_mul
+      | "i64x2.mul" -> VEC_BINARY i64x2_mul
+      | "i8x16.add_sat_u" -> VEC_BINARY i8x16_add_sat_u
+      | "i8x16.add_sat_s" -> VEC_BINARY i8x16_add_sat_s
+      | "i16x8.add_sat_u" -> VEC_BINARY i16x8_add_sat_u
+      | "i16x8.add_sat_s" -> VEC_BINARY i16x8_add_sat_s
+      | "i8x16.sub_sat_u" -> VEC_BINARY i8x16_sub_sat_u
+      | "i8x16.sub_sat_s" -> VEC_BINARY i8x16_sub_sat_s
+      | "i16x8.sub_sat_u" -> VEC_BINARY i16x8_sub_sat_u
+      | "i16x8.sub_sat_s" -> VEC_BINARY i16x8_sub_sat_s
+      | "i32x4.dot_i16x8_s" -> VEC_BINARY i32x4_dot_i16x8_s
+
+      | "i8x16.min_u" -> VEC_BINARY i8x16_min_u
+      | "i16x8.min_u" -> VEC_BINARY i16x8_min_u
+      | "i32x4.min_u" -> VEC_BINARY i32x4_min_u
+      | "i8x16.min_s" -> VEC_BINARY i8x16_min_s
+      | "i16x8.min_s" -> VEC_BINARY i16x8_min_s
+      | "i32x4.min_s" -> VEC_BINARY i32x4_min_s
+      | "i8x16.max_u" -> VEC_BINARY i8x16_max_u
+      | "i16x8.max_u" -> VEC_BINARY i16x8_max_u
+      | "i32x4.max_u" -> VEC_BINARY i32x4_max_u
+      | "i8x16.max_s" -> VEC_BINARY i8x16_max_s
+      | "i16x8.max_s" -> VEC_BINARY i16x8_max_s
+      | "i32x4.max_s" -> VEC_BINARY i32x4_max_s
+
+      | "f32x4.add" -> VEC_BINARY f32x4_add
+      | "f64x2.add" -> VEC_BINARY f64x2_add
+      | "f32x4.sub" -> VEC_BINARY f32x4_sub
+      | "f64x2.sub" -> VEC_BINARY f64x2_sub
+      | "f32x4.mul" -> VEC_BINARY f32x4_mul
+      | "f64x2.mul" -> VEC_BINARY f64x2_mul
+      | "f32x4.div" -> VEC_BINARY f32x4_div
+      | "f64x2.div" -> VEC_BINARY f64x2_div
+
+      | "f32x4.min" -> VEC_BINARY f32x4_min
+      | "f64x2.min" -> VEC_BINARY f64x2_min
+      | "f32x4.max" -> VEC_BINARY f32x4_max
+      | "f64x2.max" -> VEC_BINARY f64x2_max
+      | "f32x4.pmin" -> VEC_BINARY f32x4_pmin
+      | "f64x2.pmin" -> VEC_BINARY f64x2_pmin
+      | "f32x4.pmax" -> VEC_BINARY f32x4_pmax
+      | "f64x2.pmax" -> VEC_BINARY f64x2_pmax
+
+      | "i16x8.q15mulr_sat_s" -> VEC_BINARY i16x8_q15mulr_sat_s
+      | "i8x16.narrow_i16x8_u" -> VEC_BINARY i8x16_narrow_i16x8_u
+      | "i8x16.narrow_i16x8_s" -> VEC_BINARY i8x16_narrow_i16x8_s
+      | "i16x8.narrow_i32x4_u" -> VEC_BINARY i16x8_narrow_i32x4_u
+      | "i16x8.narrow_i32x4_s" -> VEC_BINARY i16x8_narrow_i32x4_s
+      | "i16x8.extend_low_i8x16_u" -> VEC_UNARY i16x8_extend_low_i8x16_u
+      | "i16x8.extend_low_i8x16_s" -> VEC_UNARY i16x8_extend_low_i8x16_s
+      | "i16x8.extend_high_i8x16_u" -> VEC_UNARY i16x8_extend_high_i8x16_u
+      | "i16x8.extend_high_i8x16_s" -> VEC_UNARY i16x8_extend_high_i8x16_s
+      | "i32x4.extend_low_i16x8_u" -> VEC_UNARY i32x4_extend_low_i16x8_u
+      | "i32x4.extend_low_i16x8_s" -> VEC_UNARY i32x4_extend_low_i16x8_s
+      | "i32x4.extend_high_i16x8_u" -> VEC_UNARY i32x4_extend_high_i16x8_u
+      | "i32x4.extend_high_i16x8_s" -> VEC_UNARY i32x4_extend_high_i16x8_s
+      | "i64x2.extend_low_i32x4_u" -> VEC_UNARY i64x2_extend_low_i32x4_u
+      | "i64x2.extend_low_i32x4_s" -> VEC_UNARY i64x2_extend_low_i32x4_s
+      | "i64x2.extend_high_i32x4_u" -> VEC_UNARY i64x2_extend_high_i32x4_u
+      | "i64x2.extend_high_i32x4_s" -> VEC_UNARY i64x2_extend_high_i32x4_s
+      | "i16x8.extmul_low_i8x16_u" -> VEC_UNARY i16x8_extmul_low_i8x16_u
+      | "i16x8.extmul_low_i8x16_s" -> VEC_UNARY i16x8_extmul_low_i8x16_s
+      | "i16x8.extmul_high_i8x16_u" -> VEC_UNARY i16x8_extmul_high_i8x16_u
+      | "i16x8.extmul_high_i8x16_s" -> VEC_UNARY i16x8_extmul_high_i8x16_s
+      | "i32x4.extmul_low_i16x8_u" -> VEC_UNARY i32x4_extmul_low_i16x8_u
+      | "i32x4.extmul_low_i16x8_s" -> VEC_UNARY i32x4_extmul_low_i16x8_s
+      | "i32x4.extmul_high_i16x8_u" -> VEC_UNARY i32x4_extmul_high_i16x8_u
+      | "i32x4.extmul_high_i16x8_s" -> VEC_UNARY i32x4_extmul_high_i16x8_s
+      | "i64x2.extmul_low_i32x4_u" -> VEC_UNARY i64x2_extmul_low_i32x4_u
+      | "i64x2.extmul_low_i32x4_s" -> VEC_UNARY i64x2_extmul_low_i32x4_s
+      | "i64x2.extmul_high_i32x4_u" -> VEC_UNARY i64x2_extmul_high_i32x4_u
+      | "i64x2.extmul_high_i32x4_s" -> VEC_UNARY i64x2_extmul_high_i32x4_s
+
+      | "i8x16.all_true" -> VEC_TEST i8x16_all_true
+      | "i16x8.all_true" -> VEC_TEST i16x8_all_true
+      | "i32x4.all_true" -> VEC_TEST i32x4_all_true
+      | "i64x2.all_true" -> VEC_TEST i64x2_all_true
+      | "i8x16.bitmask" -> VEC_BITMASK i8x16_bitmask
+      | "i16x8.bitmask" -> VEC_BITMASK i16x8_bitmask
+      | "i32x4.bitmask" -> VEC_BITMASK i32x4_bitmask
+      | "i64x2.bitmask" -> VEC_BITMASK i64x2_bitmask
+      | "i8x16.shl" -> VEC_SHIFT i8x16_shl
+      | "i16x8.shl" -> VEC_SHIFT i16x8_shl
+      | "i32x4.shl" -> VEC_SHIFT i32x4_shl
+      | "i64x2.shl" -> VEC_SHIFT i64x2_shl
+      | "i8x16.shr_u" -> VEC_SHIFT i8x16_shr_u
+      | "i8x16.shr_s" -> VEC_SHIFT i8x16_shr_s
+      | "i16x8.shr_u" -> VEC_SHIFT i16x8_shr_u
+      | "i16x8.shr_s" -> VEC_SHIFT i16x8_shr_s
+      | "i32x4.shr_u" -> VEC_SHIFT i32x4_shr_u
+      | "i32x4.shr_s" -> VEC_SHIFT i32x4_shr_s
+      | "i64x2.shr_u" -> VEC_SHIFT i64x2_shr_u
+      | "i64x2.shr_s" -> VEC_SHIFT i64x2_shr_s
+      | "i8x16.shuffle" -> VEC_SHUFFLE
+
+      | "i8x16.splat" -> VEC_SPLAT i8x16_splat
+      | "i16x8.splat" -> VEC_SPLAT i16x8_splat
+      | "i32x4.splat" -> VEC_SPLAT i32x4_splat
+      | "i64x2.splat" -> VEC_SPLAT i64x2_splat
+      | "f32x4.splat" -> VEC_SPLAT f32x4_splat
+      | "f64x2.splat" -> VEC_SPLAT f64x2_splat
+      | "i8x16.extract_lane_u" -> VEC_EXTRACT i8x16_extract_lane_u
+      | "i8x16.extract_lane_s" -> VEC_EXTRACT i8x16_extract_lane_s
+      | "i16x8.extract_lane_u" -> VEC_EXTRACT i16x8_extract_lane_u
+      | "i16x8.extract_lane_s" -> VEC_EXTRACT i16x8_extract_lane_s
+      | "i32x4.extract_lane" -> VEC_EXTRACT i32x4_extract_lane
+      | "i64x2.extract_lane" -> VEC_EXTRACT i64x2_extract_lane
+      | "f32x4.extract_lane" -> VEC_EXTRACT f32x4_extract_lane
+      | "f64x2.extract_lane" -> VEC_EXTRACT f64x2_extract_lane
+      | "i8x16.replace_lane" -> VEC_REPLACE i8x16_replace_lane
+      | "i16x8.replace_lane" -> VEC_REPLACE i16x8_replace_lane
+      | "i32x4.replace_lane" -> VEC_REPLACE i32x4_replace_lane
+      | "i64x2.replace_lane" -> VEC_REPLACE i64x2_replace_lane
+      | "f32x4.replace_lane" -> VEC_REPLACE f32x4_replace_lane
+      | "f64x2.replace_lane" -> VEC_REPLACE f64x2_replace_lane
+
+      | "type" -> TYPE
+      | "func" -> FUNC
+      | "param" -> PARAM
+      | "result" -> RESULT
+      | "start" -> START
+      | "local" -> LOCAL
+      | "global" -> GLOBAL
+      | "table" -> TABLE
+      | "memory" -> MEMORY
+      | "elem" -> ELEM
+      | "data" -> DATA
+      | "declare" -> DECLARE
+      | "offset" -> OFFSET
+      | "item" -> ITEM
+      | "import" -> IMPORT
+      | "export" -> EXPORT
+
+      | "module" -> MODULE
+      | "binary" -> BIN
+      | "quote" -> QUOTE
+
+      | "script" -> SCRIPT
+      | "register" -> REGISTER
+      | "invoke" -> INVOKE
+      | "get" -> GET
+      | "assert_malformed" -> ASSERT_MALFORMED
+      | "assert_invalid" -> ASSERT_INVALID
+      | "assert_unlinkable" -> ASSERT_UNLINKABLE
+      | "assert_return" -> ASSERT_RETURN
+      | "assert_trap" -> ASSERT_TRAP
+      | "assert_exhaustion" -> ASSERT_EXHAUSTION
+      | "nan:canonical" -> NAN Script.CanonicalNan
+      | "nan:arithmetic" -> NAN Script.ArithmeticNan
+      | "input" -> INPUT
+      | "output" -> OUTPUT
+
+      | _ -> unknown lexbuf
     }
-  | "ref.null" { REF_NULL }
-  | "ref.func" { REF_FUNC }
-  | "ref.extern" { REF_EXTERN }
-  | "ref.is_null" { REF_IS_NULL }
-
-  | "nop" { NOP }
-  | "unreachable" { UNREACHABLE }
-  | "drop" { DROP }
-  | "block" { BLOCK }
-  | "loop" { LOOP }
-  | "end" { END }
-  | "br" { BR }
-  | "br_if" { BR_IF }
-  | "br_table" { BR_TABLE }
-  | "return" { RETURN }
-  | "if" { IF }
-  | "then" { THEN }
-  | "else" { ELSE }
-  | "select" { SELECT }
-  | "call" { CALL }
-  | "call_indirect" { CALL_INDIRECT }
-
-  | "local.get" { LOCAL_GET }
-  | "local.set" { LOCAL_SET }
-  | "local.tee" { LOCAL_TEE }
-  | "global.get" { GLOBAL_GET }
-  | "global.set" { GLOBAL_SET }
-
-  | "table.get" { TABLE_GET }
-  | "table.set" { TABLE_SET }
-  | "table.size" { TABLE_SIZE }
-  | "table.grow" { TABLE_GROW }
-  | "table.fill" { TABLE_FILL }
-  | "table.copy" { TABLE_COPY }
-  | "table.init" { TABLE_INIT }
-  | "elem.drop" { ELEM_DROP }
-
-  | "memory.size" { MEMORY_SIZE }
-  | "memory.grow" { MEMORY_GROW }
-  | "memory.fill" { MEMORY_FILL }
-  | "memory.copy" { MEMORY_COPY }
-  | "memory.init" { MEMORY_INIT }
-  | "data.drop" { DATA_DROP }
-
-  | (nxx as t)".load"
-    { LOAD (fun a o ->
-        numop t (i32_load (opt a 2)) (i64_load (opt a 3))
-                (f32_load (opt a 2)) (f64_load (opt a 3)) o) }
-  | (nxx as t)".store"
-    { STORE (fun a o ->
-        numop t (i32_store (opt a 2)) (i64_store (opt a 3))
-                (f32_store (opt a 2)) (f64_store (opt a 3)) o) }
-  | (ixx as t)".load"(mem_size as sz)"_"(sign as s)
-    { if t = "i32" && sz = "32" then unknown lexbuf;
-      LOAD (fun a o ->
-        intop t
-          (memsz sz
-            (ext s i32_load8_s i32_load8_u (opt a 0))
-            (ext s i32_load16_s i32_load16_u (opt a 1))
-            (fun _ -> unreachable) o)
-          (memsz sz
-            (ext s i64_load8_s i64_load8_u (opt a 0))
-            (ext s i64_load16_s i64_load16_u (opt a 1))
-            (ext s i64_load32_s i64_load32_u (opt a 2)) o)) }
-  | (ixx as t)".store"(mem_size as sz)
-    { if t = "i32" && sz = "32" then unknown lexbuf;
-      STORE (fun a o ->
-        intop t
-          (memsz sz
-            (i32_store8 (opt a 0))
-            (i32_store16 (opt a 1))
-            (fun _ -> unreachable) o)
-          (memsz sz
-            (i64_store8 (opt a 0))
-            (i64_store16 (opt a 1))
-            (i64_store32 (opt a 2)) o)) }
-  | "v128.load"
-    { VEC_LOAD (fun a o -> (v128_load (opt a 4)) o) }
-  | "v128.store"
-    { VEC_STORE (fun a o -> (v128_store (opt a 4)) o) }
-  | "v128.load8x8_"(sign as s)
-    { VEC_LOAD (fun a o -> (ext s v128_load8x8_s v128_load8x8_u (opt a 3)) o) }
-  | "v128.load16x4_"(sign as s)
-    { VEC_LOAD (fun a o -> (ext s v128_load16x4_s v128_load16x4_u (opt a 3)) o) }
-  | "v128.load32x2_"(sign as s)
-    { VEC_LOAD (fun a o -> (ext s v128_load32x2_s v128_load32x2_u (opt a 3)) o) }
-  | "v128.load8_splat"
-    { VEC_LOAD (fun a o -> (v128_load8_splat (opt a 0)) o) }
-  | "v128.load16_splat"
-    { VEC_LOAD (fun a o -> (v128_load16_splat (opt a 1)) o) }
-  | "v128.load32_splat"
-    { VEC_LOAD (fun a o -> (v128_load32_splat (opt a 2)) o) }
-  | "v128.load64_splat"
-    { VEC_LOAD (fun a o -> (v128_load64_splat (opt a 3)) o) }
-  | "v128.load32_zero"
-    { VEC_LOAD (fun a o -> (v128_load32_zero (opt a 2)) o) }
-  | "v128.load64_zero"
-    { VEC_LOAD (fun a o -> (v128_load64_zero (opt a 3)) o) }
-  | "v128.load8_lane"
-    { VEC_LOAD_LANE (fun a o i -> (v128_load8_lane (opt a 0)) o i) }
-  | "v128.load16_lane"
-    { VEC_LOAD_LANE (fun a o i -> (v128_load16_lane (opt a 1)) o i) }
-  | "v128.load32_lane"
-    { VEC_LOAD_LANE (fun a o i -> (v128_load32_lane (opt a 2)) o i) }
-  | "v128.load64_lane"
-    { VEC_LOAD_LANE (fun a o i -> (v128_load64_lane (opt a 3)) o i) }
-  | "v128.store8_lane"
-    { VEC_STORE_LANE (fun a o i -> (v128_store8_lane (opt a 0)) o i) }
-  | "v128.store16_lane"
-    { VEC_STORE_LANE (fun a o i -> (v128_store16_lane (opt a 1)) o i) }
-  | "v128.store32_lane"
-    { VEC_STORE_LANE (fun a o i -> (v128_store32_lane (opt a 2)) o i) }
-  | "v128.store64_lane"
-    { VEC_STORE_LANE (fun a o i -> (v128_store64_lane (opt a 3)) o i) }
 
   | "offset="(nat as s) { OFFSET_EQ_NAT s }
   | "align="(nat as s) { ALIGN_EQ_NAT s }
 
-  | (ixx as t)".clz" { UNARY (intop t i32_clz i64_clz) }
-  | (ixx as t)".ctz" { UNARY (intop t i32_ctz i64_ctz) }
-  | (ixx as t)".popcnt" { UNARY (intop t i32_popcnt i64_popcnt) }
-  | (ixx as t)".extend8_s" { UNARY (intop t i32_extend8_s i64_extend8_s) }
-  | (ixx as t)".extend16_s" { UNARY (intop t i32_extend16_s i64_extend16_s) }
-  | "i64.extend32_s" { UNARY i64_extend32_s }
-  | (fxx as t)".neg" { UNARY (floatop t f32_neg f64_neg) }
-  | (fxx as t)".abs" { UNARY (floatop t f32_abs f64_abs) }
-  | (fxx as t)".sqrt" { UNARY (floatop t f32_sqrt f64_sqrt) }
-  | (fxx as t)".ceil" { UNARY (floatop t f32_ceil f64_ceil) }
-  | (fxx as t)".floor" { UNARY (floatop t f32_floor f64_floor) }
-  | (fxx as t)".trunc" { UNARY (floatop t f32_trunc f64_trunc) }
-  | (fxx as t)".nearest" { UNARY (floatop t f32_nearest f64_nearest) }
-
-  | (ixx as t)".add" { BINARY (intop t i32_add i64_add) }
-  | (ixx as t)".sub" { BINARY (intop t i32_sub i64_sub) }
-  | (ixx as t)".mul" { BINARY (intop t i32_mul i64_mul) }
-  | (ixx as t)".div_s" { BINARY (intop t i32_div_s i64_div_s) }
-  | (ixx as t)".div_u" { BINARY (intop t i32_div_u i64_div_u) }
-  | (ixx as t)".rem_s" { BINARY (intop t i32_rem_s i64_rem_s) }
-  | (ixx as t)".rem_u" { BINARY (intop t i32_rem_u i64_rem_u) }
-  | (ixx as t)".and" { BINARY (intop t i32_and i64_and) }
-  | (ixx as t)".or" { BINARY (intop t i32_or i64_or) }
-  | (ixx as t)".xor" { BINARY (intop t i32_xor i64_xor) }
-  | (ixx as t)".shl" { BINARY (intop t i32_shl i64_shl) }
-  | (ixx as t)".shr_s" { BINARY (intop t i32_shr_s i64_shr_s) }
-  | (ixx as t)".shr_u" { BINARY (intop t i32_shr_u i64_shr_u) }
-  | (ixx as t)".rotl" { BINARY (intop t i32_rotl i64_rotl) }
-  | (ixx as t)".rotr" { BINARY (intop t i32_rotr i64_rotr) }
-  | (fxx as t)".add" { BINARY (floatop t f32_add f64_add) }
-  | (fxx as t)".sub" { BINARY (floatop t f32_sub f64_sub) }
-  | (fxx as t)".mul" { BINARY (floatop t f32_mul f64_mul) }
-  | (fxx as t)".div" { BINARY (floatop t f32_div f64_div) }
-  | (fxx as t)".min" { BINARY (floatop t f32_min f64_min) }
-  | (fxx as t)".max" { BINARY (floatop t f32_max f64_max) }
-  | (fxx as t)".copysign" { BINARY (floatop t f32_copysign f64_copysign) }
-
-  | (ixx as t)".eqz" { TEST (intop t i32_eqz i64_eqz) }
-
-  | (ixx as t)".eq" { COMPARE (intop t i32_eq i64_eq) }
-  | (ixx as t)".ne" { COMPARE (intop t i32_ne i64_ne) }
-  | (ixx as t)".lt_s" { COMPARE (intop t i32_lt_s i64_lt_s) }
-  | (ixx as t)".lt_u" { COMPARE (intop t i32_lt_u i64_lt_u) }
-  | (ixx as t)".le_s" { COMPARE (intop t i32_le_s i64_le_s) }
-  | (ixx as t)".le_u" { COMPARE (intop t i32_le_u i64_le_u) }
-  | (ixx as t)".gt_s" { COMPARE (intop t i32_gt_s i64_gt_s) }
-  | (ixx as t)".gt_u" { COMPARE (intop t i32_gt_u i64_gt_u) }
-  | (ixx as t)".ge_s" { COMPARE (intop t i32_ge_s i64_ge_s) }
-  | (ixx as t)".ge_u" { COMPARE (intop t i32_ge_u i64_ge_u) }
-  | (fxx as t)".eq" { COMPARE (floatop t f32_eq f64_eq) }
-  | (fxx as t)".ne" { COMPARE (floatop t f32_ne f64_ne) }
-  | (fxx as t)".lt" { COMPARE (floatop t f32_lt f64_lt) }
-  | (fxx as t)".le" { COMPARE (floatop t f32_le f64_le) }
-  | (fxx as t)".gt" { COMPARE (floatop t f32_gt f64_gt) }
-  | (fxx as t)".ge" { COMPARE (floatop t f32_ge f64_ge) }
-
-  | "i32.wrap_i64" { CONVERT i32_wrap_i64 }
-  | "i64.extend_i32_s" { CONVERT i64_extend_i32_s }
-  | "i64.extend_i32_u" { CONVERT i64_extend_i32_u }
-  | "f32.demote_f64" { CONVERT f32_demote_f64 }
-  | "f64.promote_f32" { CONVERT f64_promote_f32 }
-  | (ixx as t)".trunc_f32_s"
-    { CONVERT (intop t i32_trunc_f32_s i64_trunc_f32_s) }
-  | (ixx as t)".trunc_f32_u"
-    { CONVERT (intop t i32_trunc_f32_u i64_trunc_f32_u) }
-  | (ixx as t)".trunc_f64_s"
-    { CONVERT (intop t i32_trunc_f64_s i64_trunc_f64_s) }
-  | (ixx as t)".trunc_f64_u"
-    { CONVERT (intop t i32_trunc_f64_u i64_trunc_f64_u) }
-  | (ixx as t)".trunc_sat_f32_s"
-    { CONVERT (intop t i32_trunc_sat_f32_s i64_trunc_sat_f32_s) }
-  | (ixx as t)".trunc_sat_f32_u"
-    { CONVERT (intop t i32_trunc_sat_f32_u i64_trunc_sat_f32_u) }
-  | (ixx as t)".trunc_sat_f64_s"
-    { CONVERT (intop t i32_trunc_sat_f64_s i64_trunc_sat_f64_s) }
-  | (ixx as t)".trunc_sat_f64_u"
-    { CONVERT (intop t i32_trunc_sat_f64_u i64_trunc_sat_f64_u) }
-  | (fxx as t)".convert_i32_s"
-    { CONVERT (floatop t f32_convert_i32_s f64_convert_i32_s) }
-  | (fxx as t)".convert_i32_u"
-    { CONVERT (floatop t f32_convert_i32_u f64_convert_i32_u) }
-  | (fxx as t)".convert_i64_s"
-    { CONVERT (floatop t f32_convert_i64_s f64_convert_i64_s) }
-  | (fxx as t)".convert_i64_u"
-    { CONVERT (floatop t f32_convert_i64_u f64_convert_i64_u) }
-  | "f32.reinterpret_i32" { CONVERT f32_reinterpret_i32 }
-  | "f64.reinterpret_i64" { CONVERT f64_reinterpret_i64 }
-  | "i32.reinterpret_f32" { CONVERT i32_reinterpret_f32 }
-  | "i64.reinterpret_f64" { CONVERT i64_reinterpret_f64 }
-
-  | "type" { TYPE }
-  | "func" { FUNC }
-  | "start" { START }
-  | "param" { PARAM }
-  | "result" { RESULT }
-  | "local" { LOCAL }
-  | "global" { GLOBAL }
-  | "table" { TABLE }
-  | "memory" { MEMORY }
-  | "elem" { ELEM }
-  | "data" { DATA }
-  | "declare" { DECLARE }
-  | "offset" { OFFSET }
-  | "item" { ITEM }
-  | "import" { IMPORT }
-  | "export" { EXPORT }
-
-  | "module" { MODULE }
-  | "binary" { BIN }
-  | "quote" { QUOTE }
-
-  | "script" { SCRIPT }
-  | "register" { REGISTER }
-  | "invoke" { INVOKE }
-  | "get" { GET }
-  | "assert_malformed" { ASSERT_MALFORMED }
-  | "assert_invalid" { ASSERT_INVALID }
-  | "assert_unlinkable" { ASSERT_UNLINKABLE }
-  | "assert_return" { ASSERT_RETURN }
-  | "assert_trap" { ASSERT_TRAP }
-  | "assert_exhaustion" { ASSERT_EXHAUSTION }
-  | "nan:canonical" { NAN Script.CanonicalNan }
-  | "nan:arithmetic" { NAN Script.ArithmeticNan }
-  | "input" { INPUT }
-  | "output" { OUTPUT }
-
-  | vxxx".not" { VEC_UNARY v128_not }
-  | vxxx".and" { VEC_UNARY v128_and }
-  | vxxx".andnot" { VEC_UNARY v128_andnot }
-  | vxxx".or" { VEC_UNARY v128_or }
-  | vxxx".xor" { VEC_UNARY v128_xor }
-  | vxxx".bitselect" { VEC_TERNARY v128_bitselect }
-  | vxxx".any_true" { VEC_TEST (v128_any_true) }
-
-  | (v128_shape as s)".neg"
-    { VEC_UNARY
-        (v128op s i8x16_neg i16x8_neg i32x4_neg i64x2_neg f32x4_neg f64x2_neg) }
-  | (v128_float_shape as s)".sqrt"
-    { VEC_UNARY (v128floatop s f32x4_sqrt f64x2_sqrt) }
-  | (v128_float_shape as s)".ceil"
-    { VEC_UNARY (v128floatop s f32x4_ceil f64x2_ceil) }
-  | (v128_float_shape as s)".floor"
-    { VEC_UNARY (v128floatop s f32x4_floor f64x2_floor) }
-  | (v128_float_shape as s)".trunc"
-    { VEC_UNARY (v128floatop s f32x4_trunc f64x2_trunc) }
-  | (v128_float_shape as s)".nearest"
-    { VEC_UNARY (v128floatop s f32x4_nearest f64x2_nearest) }
-  | (v128_shape as s)".abs"
-    { VEC_UNARY
-        (v128op s i8x16_abs i16x8_abs i32x4_abs i64x2_abs f32x4_abs f64x2_abs) }
-  | "i8x16.popcnt" { VEC_UNARY i8x16_popcnt }
-  | (v128_int_shape as s)".avgr_u"
-    { only ["i8x16"; "i16x8"] s lexbuf;
-      VEC_UNARY (v128intop s i8x16_avgr_u i16x8_avgr_u unreachable unreachable) }
-  | "i32x4.trunc_sat_f32x4_"(sign as s)
-    { VEC_UNARY (ext s i32x4_trunc_sat_f32x4_s i32x4_trunc_sat_f32x4_u) }
-  | "i32x4.trunc_sat_f64x2_"(sign as s)"_zero"
-    { VEC_UNARY (ext s i32x4_trunc_sat_f64x2_s_zero i32x4_trunc_sat_f64x2_u_zero) }
-  | "f64x2.promote_low_f32x4"
-    { VEC_UNARY f64x2_promote_low_f32x4 }
-  | "f32x4.demote_f64x2_zero"
-    { VEC_UNARY f32x4_demote_f64x2_zero }
-  | "f32x4.convert_i32x4_"(sign as s)
-    { VEC_UNARY (ext s f32x4_convert_i32x4_s f32x4_convert_i32x4_u) }
-  | "f64x2.convert_low_i32x4_"(sign as s)
-    { VEC_UNARY (ext s f64x2_convert_low_i32x4_s f64x2_convert_low_i32x4_u) }
-  | "i16x8.extadd_pairwise_i8x16_"(sign as s)
-    { VEC_UNARY (ext s i16x8_extadd_pairwise_i8x16_s i16x8_extadd_pairwise_i8x16_u) }
-  | "i32x4.extadd_pairwise_i16x8_"(sign as s)
-    { VEC_UNARY (ext s i32x4_extadd_pairwise_i16x8_s i32x4_extadd_pairwise_i16x8_u) }
-
-  | (v128_shape as s)".eq"
-    { VEC_BINARY (v128op s i8x16_eq i16x8_eq i32x4_eq i64x2_eq f32x4_eq f64x2_eq) }
-  | (v128_shape as s)".ne"
-    { VEC_BINARY (v128op s i8x16_ne i16x8_ne i32x4_ne i64x2_ne f32x4_ne f64x2_ne) }
-  | (v128_int_shape as s)".lt_s"
-    { VEC_BINARY (v128intop s i8x16_lt_s i16x8_lt_s i32x4_lt_s i64x2_lt_s) }
-  | (v128_int_shape as s)".lt_u"
-    { except ["i64x2"] s lexbuf;
-      VEC_BINARY (v128intop s i8x16_lt_u i16x8_lt_u i32x4_lt_u unreachable) }
-  | (v128_int_shape as s)".le_s"
-    { VEC_BINARY (v128intop s i8x16_le_s i16x8_le_s i32x4_le_s i64x2_le_s) }
-  | (v128_int_shape as s)".le_u"
-    { except ["i64x2"] s lexbuf;
-      VEC_BINARY (v128intop s i8x16_le_u i16x8_le_u i32x4_le_u unreachable) }
-  | (v128_int_shape as s)".gt_s"
-    { VEC_BINARY (v128intop s i8x16_gt_s i16x8_gt_s i32x4_gt_s i64x2_gt_s) }
-  | (v128_int_shape as s)".gt_u"
-    { except ["i64x2"] s lexbuf;
-      VEC_BINARY (v128intop s i8x16_gt_u i16x8_gt_u i32x4_gt_u unreachable) }
-  | (v128_int_shape as s)".ge_s"
-    { VEC_BINARY (v128intop s i8x16_ge_s i16x8_ge_s i32x4_ge_s i64x2_ge_s) }
-  | (v128_int_shape as s)".ge_u"
-    { except ["i64x2"] s lexbuf;
-      VEC_BINARY (v128intop s i8x16_ge_u i16x8_ge_u i32x4_ge_u unreachable) }
-  | (v128_float_shape as s)".lt" { VEC_BINARY (v128floatop s f32x4_lt f64x2_lt) }
-  | (v128_float_shape as s)".le" { VEC_BINARY (v128floatop s f32x4_le f64x2_le) }
-  | (v128_float_shape as s)".gt" { VEC_BINARY (v128floatop s f32x4_gt f64x2_gt) }
-  | (v128_float_shape as s)".ge" { VEC_BINARY (v128floatop s f32x4_ge f64x2_ge) }
-  | "i8x16.swizzle" { VEC_BINARY i8x16_swizzle }
-
-  | (v128_shape as s)".add"
-    { VEC_BINARY
-        (v128op s i8x16_add i16x8_add i32x4_add i64x2_add f32x4_add f64x2_add) }
-  | (v128_shape as s)".sub"
-    { VEC_BINARY
-        (v128op s i8x16_sub i16x8_sub i32x4_sub i64x2_sub f32x4_sub f64x2_sub) }
-  | (v128_shape as s)".min_s"
-    { only ["i8x16"; "i16x8"; "i32x4"] s lexbuf;
-      VEC_BINARY
-        (v128op s i8x16_min_s i16x8_min_s i32x4_min_s unreachable
-                  unreachable unreachable) }
-  | (v128_shape as s)".min_u"
-    { only ["i8x16"; "i16x8"; "i32x4"] s lexbuf;
-      VEC_BINARY
-        (v128op s i8x16_min_u i16x8_min_u i32x4_min_u unreachable
-                  unreachable unreachable) }
-  | (v128_shape as s)".max_s"
-    { only ["i8x16"; "i16x8"; "i32x4"] s lexbuf;
-      VEC_BINARY
-        (v128op s i8x16_max_s i16x8_max_s i32x4_max_s unreachable
-                  unreachable unreachable) }
-  | (v128_shape as s)".max_u"
-    { only ["i8x16"; "i16x8"; "i32x4"] s lexbuf;
-      VEC_BINARY
-        (v128op s i8x16_max_u i16x8_max_u i32x4_max_u unreachable
-                  unreachable unreachable) }
-  | (v128_shape as s)".mul"
-    { only ["i16x8"; "i32x4"; "i64x2"; "f32x4"; "f64x2"] s lexbuf;
-      VEC_BINARY
-        (v128op s unreachable i16x8_mul i32x4_mul i64x2_mul f32x4_mul f64x2_mul) }
-  | (v128_float_shape as s)".div"
-    { VEC_BINARY (v128floatop s f32x4_div f64x2_div) }
-  | (v128_float_shape as s)".min"
-    { VEC_BINARY (v128floatop s f32x4_min f64x2_min) }
-  | (v128_float_shape as s)".max"
-    { VEC_BINARY (v128floatop s f32x4_max f64x2_max) }
-  | (v128_float_shape as s)".pmin"
-    { VEC_BINARY (v128floatop s f32x4_pmin f64x2_pmin) }
-  | (v128_float_shape as s)".pmax"
-    { VEC_BINARY (v128floatop s f32x4_pmax f64x2_pmax) }
-  | "i8x16.add_sat_"(sign as s)
-    { VEC_BINARY (ext s i8x16_add_sat_s i8x16_add_sat_u) }
-  | "i8x16.sub_sat_"(sign as s)
-    { VEC_BINARY (ext s i8x16_sub_sat_s i8x16_sub_sat_u) }
-  | "i16x8.add_sat_"(sign as s)
-    { VEC_BINARY (ext s i16x8_add_sat_s i16x8_add_sat_u) }
-  | "i16x8.sub_sat_"(sign as s)
-    { VEC_BINARY (ext s i16x8_sub_sat_s i16x8_sub_sat_u) }
-  | "i32x4.dot_i16x8_s"
-    { VEC_BINARY i32x4_dot_i16x8_s }
-  | "i8x16.narrow_i16x8_"(sign as s)
-    { VEC_BINARY (ext s i8x16_narrow_i16x8_s i8x16_narrow_i16x8_u) }
-  | "i16x8.narrow_i32x4_"(sign as s)
-    { VEC_BINARY (ext s i16x8_narrow_i32x4_s i16x8_narrow_i32x4_u) }
-  | "i16x8.extend_low_i8x16_"(sign as s)
-    { VEC_UNARY (ext s i16x8_extend_low_i8x16_s i16x8_extend_low_i8x16_u) }
-  | "i16x8.extend_high_i8x16_"(sign as s)
-    { VEC_UNARY (ext s i16x8_extend_high_i8x16_s i16x8_extend_high_i8x16_u) }
-  | "i32x4.extend_low_i16x8_"(sign as s)
-    { VEC_UNARY (ext s i32x4_extend_low_i16x8_s i32x4_extend_low_i16x8_u) }
-  | "i32x4.extend_high_i16x8_"(sign as s)
-    { VEC_UNARY (ext s i32x4_extend_high_i16x8_s i32x4_extend_high_i16x8_u) }
-  | "i64x2.extend_low_i32x4_"(sign as s)
-    { VEC_UNARY (ext s i64x2_extend_low_i32x4_s i64x2_extend_low_i32x4_u) }
-  | "i64x2.extend_high_i32x4_"(sign as s)
-    { VEC_UNARY (ext s i64x2_extend_high_i32x4_s i64x2_extend_high_i32x4_u) }
-  | "i16x8.extmul_low_i8x16_"(sign as s)
-    { VEC_BINARY (ext s i16x8_extmul_low_i8x16_s i16x8_extmul_low_i8x16_u) }
-  | "i16x8.extmul_high_i8x16_"(sign as s)
-    { VEC_BINARY (ext s i16x8_extmul_high_i8x16_s i16x8_extmul_high_i8x16_u) }
-  | "i32x4.extmul_low_i16x8_"(sign as s)
-    { VEC_BINARY (ext s i32x4_extmul_low_i16x8_s i32x4_extmul_low_i16x8_u) }
-  | "i32x4.extmul_high_i16x8_"(sign as s)
-    { VEC_BINARY (ext s i32x4_extmul_high_i16x8_s i32x4_extmul_high_i16x8_u) }
-  | "i64x2.extmul_low_i32x4_"(sign as s)
-    { VEC_BINARY (ext s i64x2_extmul_low_i32x4_s i64x2_extmul_low_i32x4_u) }
-  | "i64x2.extmul_high_i32x4_"(sign as s)
-    { VEC_BINARY (ext s i64x2_extmul_high_i32x4_s i64x2_extmul_high_i32x4_u) }
-  | "i16x8.q15mulr_sat_s"
-    { VEC_BINARY i16x8_q15mulr_sat_s }
-
-  | (v128_int_shape as s)".all_true"
-    { VEC_TEST
-        (v128intop s i8x16_all_true i16x8_all_true i32x4_all_true i64x2_all_true) }
-  | (v128_int_shape as s)".bitmask"
-    { VEC_BITMASK
-        (v128intop s i8x16_bitmask i16x8_bitmask i32x4_bitmask i64x2_bitmask) }
-  | (v128_int_shape as s)".shl"
-    { VEC_SHIFT (v128intop s i8x16_shl i16x8_shl i32x4_shl i64x2_shl) }
-  | (v128_int_shape as s)".shr_s"
-    { VEC_SHIFT (v128intop s i8x16_shr_s i16x8_shr_s i32x4_shr_s i64x2_shr_s) }
-  | (v128_int_shape as s)".shr_u"
-    { VEC_SHIFT (v128intop s i8x16_shr_u i16x8_shr_u i32x4_shr_u i64x2_shr_u) }
-  | "i8x16.shuffle" { VEC_SHUFFLE }
-
-  | (v128_shape as s)".splat"
-    { VEC_SPLAT (v128op s i8x16_splat i16x8_splat i32x4_splat
-                           i64x2_splat f32x4_splat f64x2_splat) }
-  | (v128_shape as s)".extract_lane"
-    { except ["i8x16"; "i16x8"] s lexbuf;
-      VEC_EXTRACT (fun i ->
-        v128op s
-          (fun _ -> unreachable) (fun _ -> unreachable)
-          i32x4_extract_lane i64x2_extract_lane
-          f32x4_extract_lane f64x2_extract_lane i) }
-  | (("i8x16"|"i16x8") as t)".extract_lane_"(sign as s)
-    { VEC_EXTRACT (fun i ->
-        if t = "i8x16"
-        then ext s i8x16_extract_lane_s i8x16_extract_lane_u i
-        else ext s i16x8_extract_lane_s i16x8_extract_lane_u i )}
-  | (v128_shape as s)".replace_lane"
-    { VEC_REPLACE
-        (v128op s i8x16_replace_lane i16x8_replace_lane i32x4_replace_lane
-                  i64x2_replace_lane f32x4_replace_lane f64x2_replace_lane) }
-
-  | name as s { VAR s }
+  | id as s { VAR s }
 
   | ";;"utf8_no_nl*eof { EOF }
   | ";;"utf8_no_nl*'\n' { Lexing.new_line lexbuf; token lexbuf }

From 5ef67fb3f4906eb31be7fbd872dbc4625c5923b7 Mon Sep 17 00:00:00 2001
From: aathan <aathan_github@memeplex.com>
Date: Wed, 1 Jun 2022 10:48:13 -0700
Subject: [PATCH 127/285] [spec] Editorial nit (#1484)

---
 document/core/syntax/values.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/syntax/values.rst b/document/core/syntax/values.rst
index c4e7f89c3..564ddc2d6 100644
--- a/document/core/syntax/values.rst
+++ b/document/core/syntax/values.rst
@@ -61,7 +61,7 @@ Different classes of *integers* with different value ranges are distinguished by
      \uN \\
    \end{array}
 
-The latter class defines *uninterpreted* integers, whose signedness interpretation can vary depending on context.
+The class |iN| defines *uninterpreted* integers, whose signedness interpretation can vary depending on context.
 In the abstract syntax, they are represented as unsigned values.
 However, some operations :ref:`convert <aux-signed>` them to signed based on a two's complement interpretation.
 

From 0fd268849b6bcdd11247d4d79bd1625832f83534 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Tue, 7 Jun 2022 19:18:46 +0200
Subject: [PATCH 128/285] [interpreter] Produce error messages in encoder
 (#1488)

---
 interpreter/binary/decode.ml | 224 ++++++++++++----------
 interpreter/binary/encode.ml | 362 ++++++++++++++++++++---------------
 2 files changed, 329 insertions(+), 257 deletions(-)

diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 392f61b21..fa3a0ef9e 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -14,6 +14,7 @@ let stream name bs = {name; bytes = bs; pos = ref 0}
 let len s = String.length s.bytes
 let pos s = !(s.pos)
 let eos s = (pos s = len s)
+let reset s pos = s.pos := pos
 
 let check n s = if pos s + n > len s then raise EOS
 let skip n s = if n < 0 then raise EOS else check n s; s.pos := !(s.pos) + n
@@ -26,15 +27,16 @@ let get_string n s = let i = pos s in skip n s; String.sub s.bytes i n
 
 (* Errors *)
 
+open Source
+
 module Code = Error.Make ()
 exception Code = Code.Error
 
 let string_of_byte b = Printf.sprintf "%02x" b
 let string_of_multi n = Printf.sprintf "%02lx" n
 
-let position s pos = Source.({file = s.name; line = -1; column = pos})
-let region s left right =
-  Source.({left = position s left; right = position s right})
+let position s pos = {file = s.name; line = -1; column = pos}
+let region s left right = {left = position s left; right = position s right}
 
 let error s pos msg = raise (Code (region s pos pos, msg))
 let require b s pos msg = if not b then error s pos msg
@@ -55,70 +57,76 @@ let at f s =
   let left = pos s in
   let x = f s in
   let right = pos s in
-  Source.(x @@ region s left right)
-
+  x @@ region s left right
 
 
 (* Generic values *)
 
-let u8 s =
+let byte s =
   get s
 
-let u16 s =
-  let lo = u8 s in
-  let hi = u8 s in
+let word16 s =
+  let lo = byte s in
+  let hi = byte s in
   hi lsl 8 + lo
 
-let u32 s =
-  let lo = Int32.of_int (u16 s) in
-  let hi = Int32.of_int (u16 s) in
+let word32 s =
+  let lo = Int32.of_int (word16 s) in
+  let hi = Int32.of_int (word16 s) in
   Int32.(add lo (shift_left hi 16))
 
-let u64 s =
-  let lo = I64_convert.extend_i32_u (u32 s) in
-  let hi = I64_convert.extend_i32_u (u32 s) in
+let word64 s =
+  let lo = I64_convert.extend_i32_u (word32 s) in
+  let hi = I64_convert.extend_i32_u (word32 s) in
   Int64.(add lo (shift_left hi 32))
 
-let rec vuN n s =
+let rec uN n s =
   require (n > 0) s (pos s) "integer representation too long";
-  let b = u8 s in
+  let b = byte s in
   require (n >= 7 || b land 0x7f < 1 lsl n) s (pos s - 1) "integer too large";
   let x = Int64.of_int (b land 0x7f) in
-  if b land 0x80 = 0 then x else Int64.(logor x (shift_left (vuN (n - 7) s) 7))
+  if b land 0x80 = 0 then x else Int64.(logor x (shift_left (uN (n - 7) s) 7))
 
-let rec vsN n s =
+let rec sN n s =
   require (n > 0) s (pos s) "integer representation too long";
-  let b = u8 s in
+  let b = byte s in
   let mask = (-1 lsl (n - 1)) land 0x7f in
   require (n >= 7 || b land mask = 0 || b land mask = mask) s (pos s - 1)
     "integer too large";
   let x = Int64.of_int (b land 0x7f) in
   if b land 0x80 = 0
   then (if b land 0x40 = 0 then x else Int64.(logor x (logxor (-1L) 0x7fL)))
-  else Int64.(logor x (shift_left (vsN (n - 7) s) 7))
-
-let vu1 s = Int64.to_int (vuN 1 s)
-let vu32 s = Int64.to_int32 (vuN 32 s)
-let vs7 s = Int64.to_int (vsN 7 s)
-let vs32 s = Int64.to_int32 (vsN 32 s)
-let vs33 s = I32_convert.wrap_i64 (vsN 33 s)
-let vs64 s = vsN 64 s
-let f32 s = F32.of_bits (u32 s)
-let f64 s = F64.of_bits (u64 s)
+  else Int64.(logor x (shift_left (sN (n - 7) s) 7))
+
+let u1 s = Int64.to_int (uN 1 s)
+let u32 s = Int64.to_int32 (uN 32 s)
+let s7 s = Int64.to_int (sN 7 s)
+let s32 s = Int64.to_int32 (sN 32 s)
+let s33 s = I32_convert.wrap_i64 (sN 33 s)
+let s64 s = sN 64 s
+let f32 s = F32.of_bits (word32 s)
+let f64 s = F64.of_bits (word64 s)
 let v128 s = V128.of_bits (get_string (Types.vec_size Types.V128Type) s)
 
 let len32 s =
   let pos = pos s in
-  let n = vu32 s in
+  let n = u32 s in
   if I32.le_u n (Int32.of_int (len s - pos)) then Int32.to_int n else
     error s pos "length out of bounds"
 
-let bool s = (vu1 s = 1)
+let bool s = (u1 s = 1)
 let string s = let n = len32 s in get_string n s
 let rec list f n s = if n = 0 then [] else let x = f s in x :: list f (n - 1) s
 let opt f b s = if b then Some (f s) else None
 let vec f s = let n = len32 s in list f n s
 
+let rec either fs s =
+  match fs with
+  | [] -> assert false
+  | [f] -> f s
+  | f::fs' ->
+    let pos = pos s in try f s with Code _ -> reset s pos; either fs' s
+
 let name s =
   let pos = pos s in
   try Utf8.decode (string s) with Utf8.Utf8 ->
@@ -137,7 +145,7 @@ let sized f s =
 open Types
 
 let num_type s =
-  match vs7 s with
+  match s7 s with
   | -0x01 -> I32Type
   | -0x02 -> I64Type
   | -0x03 -> F32Type
@@ -145,48 +153,50 @@ let num_type s =
   | _ -> error s (pos s - 1) "malformed number type"
 
 let vec_type s =
-  match vs7 s with
+  match s7 s with
   | -0x05 -> V128Type
   | _ -> error s (pos s - 1) "malformed vector type"
 
 let ref_type s =
-  match vs7 s with
+  match s7 s with
   | -0x10 -> FuncRefType
   | -0x11 -> ExternRefType
   | _ -> error s (pos s - 1) "malformed reference type"
 
 let value_type s =
-  match peek s with
-  | Some n when n >= ((-0x04) land 0x7f) -> NumType (num_type s)
-  | Some n when n >= ((-0x0f) land 0x7f) -> VecType (vec_type s)
-  | _ -> RefType (ref_type s)
+  either [
+    (fun s -> NumType (num_type s));
+    (fun s -> VecType (vec_type s));
+    (fun s -> RefType (ref_type s));
+  ] s
 
 let result_type s = vec value_type s
+
 let func_type s =
-  match vs7 s with
+  match s7 s with
   | -0x20 ->
-    let ins = result_type s in
-    let out = result_type s in
-    FuncType (ins, out)
+    let ts1 = result_type s in
+    let ts2 = result_type s in
+    FuncType (ts1, ts2)
   | _ -> error s (pos s - 1) "malformed function type"
 
-let limits vu s =
+let limits uN s =
   let has_max = bool s in
-  let min = vu s in
-  let max = opt vu has_max s in
+  let min = uN s in
+  let max = opt uN has_max s in
   {min; max}
 
 let table_type s =
   let t = ref_type s in
-  let lim = limits vu32 s in
+  let lim = limits u32 s in
   TableType (lim, t)
 
 let memory_type s =
-  let lim = limits vu32 s in
+  let lim = limits u32 s in
   MemoryType lim
 
 let mutability s =
-  match u8 s with
+  match byte s with
   | 0 -> Immutable
   | 1 -> Mutable
   | _ -> error s (pos s - 1) "malformed mutability"
@@ -197,28 +207,30 @@ let global_type s =
   GlobalType (t, mut)
 
 
-(* Decode instructions *)
+(* Instructions *)
 
 open Ast
 open Operators
 
-let var s = vu32 s
+let var s = u32 s
 
-let op s = u8 s
+let op s = byte s
 let end_ s = expect 0x0b s "END opcode expected"
 let zero s = expect 0x00 s "zero byte expected"
 
 let memop s =
-  let align = vu32 s in
+  let align = u32 s in
   require (I32.le_u align 32l) s (pos s - 1) "malformed memop flags";
-  let offset = vu32 s in
+  let offset = u32 s in
   Int32.to_int align, offset
 
 let block_type s =
-  match peek s with
-  | Some 0x40 -> skip 1 s; ValBlockType None
-  | Some b when b land 0xc0 = 0x40 -> ValBlockType (Some (value_type s))
-  | _ -> VarBlockType (at vs33 s)
+  let p = pos s in
+  either [
+    (fun s -> let x = at s33 s in require (x.it >= 0l) s p ""; VarBlockType x);
+    (fun s -> expect 0x40 s ""; ValBlockType None);
+    (fun s -> ValBlockType (Some (value_type s)));
+  ] s
 
 let rec instr s =
   let pos = pos s in
@@ -313,8 +325,8 @@ let rec instr s =
   | 0x3f -> zero s; memory_size
   | 0x40 -> zero s; memory_grow
 
-  | 0x41 -> i32_const (at vs32 s)
-  | 0x42 -> i64_const (at vs64 s)
+  | 0x41 -> i32_const (at s32 s)
+  | 0x42 -> i64_const (at s64 s)
   | 0x43 -> f32_const (at f32 s)
   | 0x44 -> f64_const (at f64 s)
 
@@ -465,7 +477,7 @@ let rec instr s =
   | 0xd2 -> ref_func (at var s)
 
   | 0xfc as b ->
-    (match vu32 s with
+    (match u32 s with
     | 0x00l -> i32_trunc_sat_f32_s
     | 0x01l -> i32_trunc_sat_f32_u
     | 0x02l -> i32_trunc_sat_f64_s
@@ -499,7 +511,7 @@ let rec instr s =
     )
 
   | 0xfd ->
-    (match vu32 s with
+    (match u32 s with
     | 0x00l -> let a, o = memop s in v128_load a o
     | 0x01l -> let a, o = memop s in v128_load8x8_s a o
     | 0x02l -> let a, o = memop s in v128_load8x8_u a o
@@ -513,7 +525,7 @@ let rec instr s =
     | 0x0al -> let a, o = memop s in v128_load64_splat a o
     | 0x0bl -> let a, o = memop s in v128_store a o
     | 0x0cl -> v128_const (at v128 s)
-    | 0x0dl -> i8x16_shuffle (List.init 16 (fun x -> u8 s))
+    | 0x0dl -> i8x16_shuffle (List.init 16 (fun _ -> byte s))
     | 0x0el -> i8x16_swizzle
     | 0x0fl -> i8x16_splat
     | 0x10l -> i16x8_splat
@@ -521,20 +533,20 @@ let rec instr s =
     | 0x12l -> i64x2_splat
     | 0x13l -> f32x4_splat
     | 0x14l -> f64x2_splat
-    | 0x15l -> let i = u8 s in i8x16_extract_lane_s i
-    | 0x16l -> let i = u8 s in i8x16_extract_lane_u i
-    | 0x17l -> let i = u8 s in i8x16_replace_lane i
-    | 0x18l -> let i = u8 s in i16x8_extract_lane_s i
-    | 0x19l -> let i = u8 s in i16x8_extract_lane_u i
-    | 0x1al -> let i = u8 s in i16x8_replace_lane i
-    | 0x1bl -> let i = u8 s in i32x4_extract_lane i
-    | 0x1cl -> let i = u8 s in i32x4_replace_lane i
-    | 0x1dl -> let i = u8 s in i64x2_extract_lane i
-    | 0x1el -> let i = u8 s in i64x2_replace_lane i
-    | 0x1fl -> let i = u8 s in f32x4_extract_lane i
-    | 0x20l -> let i = u8 s in f32x4_replace_lane i
-    | 0x21l -> let i = u8 s in f64x2_extract_lane i
-    | 0x22l -> let i = u8 s in f64x2_replace_lane i
+    | 0x15l -> let i = byte s in i8x16_extract_lane_s i
+    | 0x16l -> let i = byte s in i8x16_extract_lane_u i
+    | 0x17l -> let i = byte s in i8x16_replace_lane i
+    | 0x18l -> let i = byte s in i16x8_extract_lane_s i
+    | 0x19l -> let i = byte s in i16x8_extract_lane_u i
+    | 0x1al -> let i = byte s in i16x8_replace_lane i
+    | 0x1bl -> let i = byte s in i32x4_extract_lane i
+    | 0x1cl -> let i = byte s in i32x4_replace_lane i
+    | 0x1dl -> let i = byte s in i64x2_extract_lane i
+    | 0x1el -> let i = byte s in i64x2_replace_lane i
+    | 0x1fl -> let i = byte s in f32x4_extract_lane i
+    | 0x20l -> let i = byte s in f32x4_replace_lane i
+    | 0x21l -> let i = byte s in f64x2_extract_lane i
+    | 0x22l -> let i = byte s in f64x2_replace_lane i
     | 0x23l -> i8x16_eq
     | 0x24l -> i8x16_ne
     | 0x25l -> i8x16_lt_s
@@ -586,35 +598,35 @@ let rec instr s =
     | 0x53l -> v128_any_true
     | 0x54l ->
       let a, o = memop s in
-      let lane = u8 s in
+      let lane = byte s in
       v128_load8_lane a o lane
     | 0x55l ->
       let a, o = memop s in
-      let lane = u8 s in
+      let lane = byte s in
       v128_load16_lane a o lane
     | 0x56l ->
       let a, o = memop s in
-      let lane = u8 s in
+      let lane = byte s in
       v128_load32_lane a o lane
     | 0x57l ->
       let a, o = memop s in
-      let lane = u8 s in
+      let lane = byte s in
       v128_load64_lane a o lane
     | 0x58l ->
       let a, o = memop s in
-      let lane = u8 s in
+      let lane = byte s in
       v128_store8_lane a o lane
     | 0x59l ->
       let a, o = memop s in
-      let lane = u8 s in
+      let lane = byte s in
       v128_store16_lane a o lane
     | 0x5al ->
       let a, o = memop s in
-      let lane = u8 s in
+      let lane = byte s in
       v128_store32_lane a o lane
     | 0x5bl ->
       let a, o = memop s in
-      let lane = u8 s in
+      let lane = byte s in
       v128_store64_lane a o lane
     | 0x5cl -> let a, o = memop s in v128_load32_zero a o
     | 0x5dl -> let a, o = memop s in v128_load64_zero a o
@@ -772,7 +784,7 @@ and instr_block' s es =
   | _ ->
     let pos = pos s in
     let e' = instr s in
-    instr_block' s (Source.(e' @@ region s pos pos) :: es)
+    instr_block' s ((e' @@ region s pos pos) :: es)
 
 let const s =
   let c = at instr_block s in
@@ -804,7 +816,7 @@ let id s =
 
 let section_with_size tag f default s =
   match id s with
-  | Some tag' when tag' = tag -> ignore (u8 s); sized f s
+  | Some tag' when tag' = tag -> skip 1 s; sized f s
   | _ -> default
 
 let section tag f default s =
@@ -822,7 +834,7 @@ let type_section s =
 (* Import section *)
 
 let import_desc s =
-  match u8 s with
+  match byte s with
   | 0x00 -> FuncImport (at var s)
   | 0x01 -> TableImport (table_type s)
   | 0x02 -> MemoryImport (memory_type s)
@@ -879,7 +891,7 @@ let global_section s =
 (* Export section *)
 
 let export_desc s =
-  match u8 s with
+  match byte s with
   | 0x00 -> FuncExport (at var s)
   | 0x01 -> TableExport (at var s)
   | 0x02 -> MemoryExport (at var s)
@@ -908,20 +920,23 @@ let start_section s =
 (* Code section *)
 
 let local s =
-  let n = vu32 s in
+  let n = u32 s in
   let t = value_type s in
   n, t
 
-let code _ s =
+let locals s =
   let pos = pos s in
   let nts = vec local s in
   let ns = List.map (fun (n, _) -> I64_convert.extend_i32_u n) nts in
   require (I64.lt_u (List.fold_left I64.add 0L ns) 0x1_0000_0000L)
     s pos "too many locals";
-  let locals = List.flatten (List.map (Lib.Fun.uncurry Lib.List32.make) nts) in
+  List.flatten (List.map (Lib.Fun.uncurry Lib.List32.make) nts)
+
+let code _ s =
+  let locals = locals s in
   let body = instr_block s in
   end_ s;
-  {locals; body; ftype = Source.((-1l) @@ Source.no_region)}
+  {locals; body; ftype = -1l @@ no_region}
 
 let code_section s =
   section `CodeSection (vec (at (sized code))) [] s
@@ -938,7 +953,7 @@ let active s =
   Active {index; offset}
 
 let active_zero s =
-  let index = Source.(0l @@ Source.no_region) in
+  let index = 0l @@ no_region in
   let offset = const s in
   Active {index; offset}
 
@@ -947,15 +962,15 @@ let declarative s =
 
 let elem_index s =
   let x = at var s in
-  [Source.(ref_func x @@ x.at)]
+  [ref_func x @@ x.at]
 
 let elem_kind s =
-  match u8 s with
+  match byte s with
   | 0x00 -> FuncRefType
   | _ -> error s (pos s - 1) "malformed element kind"
 
 let elem s =
-  match vu32 s with
+  match u32 s with
   | 0x00l ->
     let emode = at active_zero s in
     let einit = vec (at elem_index) s in
@@ -1003,7 +1018,7 @@ let elem_section s =
 (* Data section *)
 
 let data s =
-  match vu32 s with
+  match u32 s with
   | 0x00l ->
     let dmode = at active_zero s in
     let dinit = string s in
@@ -1025,7 +1040,7 @@ let data_section s =
 (* DataCount section *)
 
 let data_count s =
-  Some (vu32 s)
+  Some (u32 s)
 
 let data_count_section s =
   section `DataCountSection data_count None s
@@ -1055,9 +1070,9 @@ let rec iterate f s = if f s <> None then iterate f s
 let magic = 0x6d736100l
 
 let module_ s =
-  let header = u32 s in
+  let header = word32 s in
   require (header = magic) s 0 "magic header not detected";
-  let version = u32 s in
+  let version = word32 s in
   require (version = Encode.version) s 4 "unknown binary version";
   iterate custom_section s;
   let types = type_section s in
@@ -1093,17 +1108,16 @@ let module_ s =
     List.for_all Free.(fun f -> (func f).datas = Set.empty) func_bodies)
     s (len s) "data count section required";
   let funcs =
-    List.map2 Source.(fun t f -> {f.it with ftype = t} @@ f.at)
-      func_types func_bodies
+    List.map2 (fun t f -> {f.it with ftype = t} @@ f.at) func_types func_bodies
   in {types; tables; memories; globals; funcs; imports; exports; elems; datas; start}
 
 
 let decode name bs = at module_ (stream name bs)
 
 let all_custom tag s =
-  let header = u32 s in
+  let header = word32 s in
   require (header = magic) s 0 "magic header not detected";
-  let version = u32 s in
+  let version = word32 s in
   require (version = Encode.version) s 4 "unknown binary version";
   let rec collect () =
     iterate non_custom_section s;
diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index aafc3d986..f5665bb1c 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -1,4 +1,4 @@
-(* Version *)
+(* Binary format version *)
 
 let version = 1l
 
@@ -8,6 +8,8 @@ let version = 1l
 module Code = Error.Make ()
 exception Code = Code.Error
 
+let error = Code.error
+
 
 (* Encoding stream *)
 
@@ -35,50 +37,50 @@ module E (S : sig val stream : stream end) =
 struct
   let s = S.stream
 
+
   (* Generic values *)
 
-  let u8 i = put s (Char.chr (i land 0xff))
-  let u16 i = u8 (i land 0xff); u8 (i lsr 8)
-  let u32 i =
-    Int32.(u16 (to_int (logand i 0xffffl));
-           u16 (to_int (shift_right i 16)))
-  let u64 i =
-    Int64.(u32 (to_int32 (logand i 0xffffffffL));
-           u32 (to_int32 (shift_right i 32)))
+  let byte i = put s (Char.chr (i land 0xff))
+  let word16 i = byte (i land 0xff); byte (i lsr 8)
+  let word32 i =
+    Int32.(word16 (to_int (logand i 0xffffl));
+           word16 (to_int (shift_right i 16)))
+  let word64 i =
+    Int64.(word32 (to_int32 (logand i 0xffffffffL));
+           word32 (to_int32 (shift_right i 32)))
 
-  let rec vu64 i =
+  let rec u64 i =
     let b = Int64.(to_int (logand i 0x7fL)) in
-    if 0L <= i && i < 128L then u8 b
-    else (u8 (b lor 0x80); vu64 (Int64.shift_right_logical i 7))
+    if 0L <= i && i < 128L then byte b
+    else (byte (b lor 0x80); u64 (Int64.shift_right_logical i 7))
 
-  let rec vs64 i =
+  let rec s64 i =
     let b = Int64.(to_int (logand i 0x7fL)) in
-    if -64L <= i && i < 64L then u8 b
-    else (u8 (b lor 0x80); vs64 (Int64.shift_right i 7))
-
-  let vu1 i = vu64 Int64.(logand (of_int i) 1L)
-  let vu32 i = vu64 Int64.(logand (of_int32 i) 0xffffffffL)
-  let vs7 i = vs64 (Int64.of_int i)
-  let vs32 i = vs64 (Int64.of_int32 i)
-  let vs33 i = vs64 (I64_convert.extend_i32_s i)
-  let f32 x = u32 (F32.to_bits x)
-  let f64 x = u64 (F64.to_bits x)
+    if -64L <= i && i < 64L then byte b
+    else (byte (b lor 0x80); s64 (Int64.shift_right i 7))
+
+  let u1 i = u64 Int64.(logand (of_int i) 1L)
+  let u32 i = u64 Int64.(logand (of_int32 i) 0xffffffffL)
+  let s7 i = s64 (Int64.of_int i)
+  let s32 i = s64 (Int64.of_int32 i)
+  let s33 i = s64 (I64_convert.extend_i32_s i)
+  let f32 x = word32 (F32.to_bits x)
+  let f64 x = word64 (F64.to_bits x)
   let v128 v = String.iter (put s) (V128.to_bits v)
 
   let len i =
     if Int32.to_int (Int32.of_int i) <> i then
-      Code.error Source.no_region
-        "cannot encode length with more than 32 bit";
-    vu32 (Int32.of_int i)
+      Code.error Source.no_region "length out of bounds";
+    u32 (Int32.of_int i)
 
-  let bool b = vu1 (if b then 1 else 0)
+  let bool b = u1 (if b then 1 else 0)
   let string bs = len (String.length bs); put_string s bs
   let name n = string (Utf8.encode n)
   let list f xs = List.iter f xs
   let opt f xo = Lib.Option.app f xo
   let vec f xs = len (List.length xs); list f xs
 
-  let gap32 () = let p = pos s in u32 0l; u8 0; p
+  let gap32 () = let p = pos s in word32 0l; byte 0; p
   let patch_gap32 p n =
     assert (n <= 0x0fff_ffff); (* Strings cannot excess 2G anyway *)
     let lsb i = Char.chr (i land 0xff) in
@@ -88,22 +90,23 @@ struct
     patch s (p + 3) (lsb ((n lsr 21) lor 0x80));
     patch s (p + 4) (lsb (n lsr 28))
 
+
   (* Types *)
 
   open Types
 
   let num_type = function
-    | I32Type -> vs7 (-0x01)
-    | I64Type -> vs7 (-0x02)
-    | F32Type -> vs7 (-0x03)
-    | F64Type -> vs7 (-0x04)
+    | I32Type -> s7 (-0x01)
+    | I64Type -> s7 (-0x02)
+    | F32Type -> s7 (-0x03)
+    | F64Type -> s7 (-0x04)
 
   let vec_type = function
-    | V128Type -> vs7 (-0x05)
+    | V128Type -> s7 (-0x05)
 
   let ref_type = function
-    | FuncRefType -> vs7 (-0x10)
-    | ExternRefType -> vs7 (-0x11)
+    | FuncRefType -> s7 (-0x10)
+    | ExternRefType -> s7 (-0x11)
 
   let value_type = function
     | NumType t -> num_type t
@@ -112,43 +115,45 @@ struct
 
   let func_type = function
     | FuncType (ts1, ts2) ->
-      vs7 (-0x20); vec value_type ts1; vec value_type ts2
+      s7 (-0x20); vec value_type ts1; vec value_type ts2
+
 
   let limits vu {min; max} =
     bool (max <> None); vu min; opt vu max
 
   let table_type = function
-    | TableType (lim, t) -> ref_type t; limits vu32 lim
+    | TableType (lim, t) -> ref_type t; limits u32 lim
 
   let memory_type = function
-    | MemoryType lim -> limits vu32 lim
+    | MemoryType lim -> limits u32 lim
 
   let mutability = function
-    | Immutable -> u8 0
-    | Mutable -> u8 1
+    | Immutable -> byte 0
+    | Mutable -> byte 1
 
   let global_type = function
     | GlobalType (t, mut) -> value_type t; mutability mut
 
-  (* Expressions *)
+
+  (* Instructions *)
 
   open Source
   open Ast
   open Values
   open V128
 
-  let op n = u8 n
-  let vecop n = op 0xfd; vu32 n
+  let op n = byte n
+  let vecop n = op 0xfd; u32 n
   let end_ () = op 0x0b
 
-  let memop {align; offset; _} = vu32 (Int32.of_int align); vu32 offset
+  let memop {align; offset; _} = u32 (Int32.of_int align); u32 offset
 
-  let var x = vu32 x.it
+  let var x = u32 x.it
 
   let block_type = function
-    | VarBlockType x -> vs33 x.it
-    | ValBlockType None -> vs7 (-0x40)
+    | ValBlockType None -> s33 (-0x40l)
     | ValBlockType (Some t) -> value_type t
+    | VarBlockType x -> s33 x.it
 
   let rec instr e =
     match e.it with
@@ -181,12 +186,12 @@ struct
 
     | TableGet x -> op 0x25; var x
     | TableSet x -> op 0x26; var x
-    | TableSize x -> op 0xfc; vu32 0x10l; var x
-    | TableGrow x -> op 0xfc; vu32 0x0fl; var x
-    | TableFill x -> op 0xfc; vu32 0x11l; var x
-    | TableCopy (x, y) -> op 0xfc; vu32 0x0el; var x; var y
-    | TableInit (x, y) -> op 0xfc; vu32 0x0cl; var y; var x
-    | ElemDrop x -> op 0xfc; vu32 0x0dl; var x
+    | TableSize x -> op 0xfc; u32 0x10l; var x
+    | TableGrow x -> op 0xfc; u32 0x0fl; var x
+    | TableFill x -> op 0xfc; u32 0x11l; var x
+    | TableCopy (x, y) -> op 0xfc; u32 0x0el; var x; var y
+    | TableInit (x, y) -> op 0xfc; u32 0x0cl; var y; var x
+    | ElemDrop x -> op 0xfc; u32 0x0dl; var x
 
     | Load ({ty = I32Type; pack = None; _} as mo) -> op 0x28; memop mo
     | Load ({ty = I64Type; pack = None; _} as mo) -> op 0x29; memop mo
@@ -201,7 +206,7 @@ struct
     | Load ({ty = I32Type; pack = Some (Pack16, ZX); _} as mo) ->
       op 0x2f; memop mo
     | Load {ty = I32Type; pack = Some (Pack32, _); _} ->
-      assert false
+      error e.at "illegal instruction i32.load32"
     | Load ({ty = I64Type; pack = Some (Pack8, SX); _} as mo) ->
       op 0x30; memop mo
     | Load ({ty = I64Type; pack = Some (Pack8, ZX); _} as mo) ->
@@ -215,9 +220,9 @@ struct
     | Load ({ty = I64Type; pack = Some (Pack32, ZX); _} as mo) ->
       op 0x35; memop mo
     | Load {ty = F32Type | F64Type; pack = Some _; _} ->
-      assert false
+      error e.at "illegal instruction fxx.loadN"
     | Load {ty = I32Type | I64Type; pack = Some (Pack64, _); _} ->
-      assert false
+      error e.at "illegal instruction ixx.load64"
 
     | Store ({ty = I32Type; pack = None; _} as mo) -> op 0x36; memop mo
     | Store ({ty = I64Type; pack = None; _} as mo) -> op 0x37; memop mo
@@ -225,12 +230,15 @@ struct
     | Store ({ty = F64Type; pack = None; _} as mo) -> op 0x39; memop mo
     | Store ({ty = I32Type; pack = Some Pack8; _} as mo) -> op 0x3a; memop mo
     | Store ({ty = I32Type; pack = Some Pack16; _} as mo) -> op 0x3b; memop mo
-    | Store {ty = I32Type; pack = Some Pack32; _} -> assert false
+    | Store {ty = I32Type; pack = Some Pack32; _} ->
+      error e.at "illegal instruction i32.store32"
     | Store ({ty = I64Type; pack = Some Pack8; _} as mo) -> op 0x3c; memop mo
     | Store ({ty = I64Type; pack = Some Pack16; _} as mo) -> op 0x3d; memop mo
     | Store ({ty = I64Type; pack = Some Pack32; _} as mo) -> op 0x3e; memop mo
-    | Store {ty = F32Type | F64Type; pack = Some _; _} -> assert false
-    | Store {ty = (I32Type | I64Type); pack = Some Pack64; _} -> assert false
+    | Store {ty = F32Type | F64Type; pack = Some _; _} ->
+      error e.at "illegal instruction fxx.storeN"
+    | Store {ty = (I32Type | I64Type); pack = Some Pack64; _} ->
+      error e.at "illegal instruction ixx.store64"
 
     | VecLoad ({ty = V128Type; pack = None; _} as mo) ->
       vecop 0x00l; memop mo
@@ -258,41 +266,42 @@ struct
       vecop 0x5cl; memop mo
     | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtZero); _} as mo) ->
       vecop 0x5dl; memop mo
-    | VecLoad _ -> assert false
+    | VecLoad _ ->
+      error e.at "illegal instruction v128.loadNxM_<ext>"
 
     | VecLoadLane ({ty = V128Type; pack = Pack8; _} as mo, i) ->
-      vecop 0x54l; memop mo; u8 i;
+      vecop 0x54l; memop mo; byte i;
     | VecLoadLane ({ty = V128Type; pack = Pack16; _} as mo, i) ->
-      vecop 0x55l; memop mo; u8 i;
+      vecop 0x55l; memop mo; byte i;
     | VecLoadLane ({ty = V128Type; pack = Pack32; _} as mo, i) ->
-      vecop 0x56l; memop mo; u8 i;
+      vecop 0x56l; memop mo; byte i;
     | VecLoadLane ({ty = V128Type; pack = Pack64; _} as mo, i) ->
-      vecop 0x57l; memop mo; u8 i;
+      vecop 0x57l; memop mo; byte i;
 
     | VecStore ({ty = V128Type; _} as mo) -> vecop 0x0bl; memop mo
 
     | VecStoreLane ({ty = V128Type; pack = Pack8; _} as mo, i) ->
-      vecop 0x58l; memop mo; u8 i;
+      vecop 0x58l; memop mo; byte i;
     | VecStoreLane ({ty = V128Type; pack = Pack16; _} as mo, i) ->
-      vecop 0x59l; memop mo; u8 i;
+      vecop 0x59l; memop mo; byte i;
     | VecStoreLane ({ty = V128Type; pack = Pack32; _} as mo, i) ->
-      vecop 0x5al; memop mo; u8 i;
+      vecop 0x5al; memop mo; byte i;
     | VecStoreLane ({ty = V128Type; pack = Pack64; _} as mo, i) ->
-      vecop 0x5bl; memop mo; u8 i;
+      vecop 0x5bl; memop mo; byte i;
 
-    | MemorySize -> op 0x3f; u8 0x00
-    | MemoryGrow -> op 0x40; u8 0x00
-    | MemoryFill -> op 0xfc; vu32 0x0bl; u8 0x00
-    | MemoryCopy -> op 0xfc; vu32 0x0al; u8 0x00; u8 0x00
-    | MemoryInit x -> op 0xfc; vu32 0x08l; var x; u8 0x00
-    | DataDrop x -> op 0xfc; vu32 0x09l; var x
+    | MemorySize -> op 0x3f; byte 0x00
+    | MemoryGrow -> op 0x40; byte 0x00
+    | MemoryFill -> op 0xfc; u32 0x0bl; byte 0x00
+    | MemoryCopy -> op 0xfc; u32 0x0al; byte 0x00; byte 0x00
+    | MemoryInit x -> op 0xfc; u32 0x08l; var x; byte 0x00
+    | DataDrop x -> op 0xfc; u32 0x09l; var x
 
     | RefNull t -> op 0xd0; ref_type t
     | RefIsNull -> op 0xd1
     | RefFunc x -> op 0xd2; var x
 
-    | Const {it = I32 c; _} -> op 0x41; vs32 c
-    | Const {it = I64 c; _} -> op 0x42; vs64 c
+    | Const {it = I32 c; _} -> op 0x41; s32 c
+    | Const {it = I64 c; _} -> op 0x42; s64 c
     | Const {it = F32 c; _} -> op 0x43; f32 c
     | Const {it = F64 c; _} -> op 0x44; f64 c
 
@@ -341,7 +350,8 @@ struct
     | Unary (I32 I32Op.Popcnt) -> op 0x69
     | Unary (I32 (I32Op.ExtendS Pack8)) -> op 0xc0
     | Unary (I32 (I32Op.ExtendS Pack16)) -> op 0xc1
-    | Unary (I32 (I32Op.ExtendS (Pack32 | Pack64))) -> assert false
+    | Unary (I32 (I32Op.ExtendS (Pack32 | Pack64))) ->
+      error e.at "illegal instruction i32.extendN_s"
 
     | Unary (I64 I64Op.Clz) -> op 0x79
     | Unary (I64 I64Op.Ctz) -> op 0x7a
@@ -349,7 +359,8 @@ struct
     | Unary (I64 (I64Op.ExtendS Pack8)) -> op 0xc2
     | Unary (I64 (I64Op.ExtendS Pack16)) -> op 0xc3
     | Unary (I64 (I64Op.ExtendS Pack32)) -> op 0xc4
-    | Unary (I64 (I64Op.ExtendS Pack64)) -> assert false
+    | Unary (I64 (I64Op.ExtendS Pack64)) ->
+      error e.at "illegal instruction i64.extend64_s"
 
     | Unary (F32 F32Op.Abs) -> op 0x8b
     | Unary (F32 F32Op.Neg) -> op 0x8c
@@ -415,37 +426,41 @@ struct
     | Binary (F64 F64Op.Max) -> op 0xa5
     | Binary (F64 F64Op.CopySign) -> op 0xa6
 
-    | Convert (I32 I32Op.ExtendSI32) -> assert false
-    | Convert (I32 I32Op.ExtendUI32) -> assert false
+    | Convert (I32 I32Op.ExtendSI32) ->
+      error e.at "illegal instruction i32.extend_i32_s"
+    | Convert (I32 I32Op.ExtendUI32) ->
+      error e.at "illegal instruction i32.extend_i32_u"
     | Convert (I32 I32Op.WrapI64) -> op 0xa7
     | Convert (I32 I32Op.TruncSF32) -> op 0xa8
     | Convert (I32 I32Op.TruncUF32) -> op 0xa9
     | Convert (I32 I32Op.TruncSF64) -> op 0xaa
     | Convert (I32 I32Op.TruncUF64) -> op 0xab
-    | Convert (I32 I32Op.TruncSatSF32) -> op 0xfc; vu32 0x00l
-    | Convert (I32 I32Op.TruncSatUF32) -> op 0xfc; vu32 0x01l
-    | Convert (I32 I32Op.TruncSatSF64) -> op 0xfc; vu32 0x02l
-    | Convert (I32 I32Op.TruncSatUF64) -> op 0xfc; vu32 0x03l
+    | Convert (I32 I32Op.TruncSatSF32) -> op 0xfc; u32 0x00l
+    | Convert (I32 I32Op.TruncSatUF32) -> op 0xfc; u32 0x01l
+    | Convert (I32 I32Op.TruncSatSF64) -> op 0xfc; u32 0x02l
+    | Convert (I32 I32Op.TruncSatUF64) -> op 0xfc; u32 0x03l
     | Convert (I32 I32Op.ReinterpretFloat) -> op 0xbc
 
     | Convert (I64 I64Op.ExtendSI32) -> op 0xac
     | Convert (I64 I64Op.ExtendUI32) -> op 0xad
-    | Convert (I64 I64Op.WrapI64) -> assert false
+    | Convert (I64 I64Op.WrapI64) ->
+      error e.at "illegal instruction i64.wrap_i64"
     | Convert (I64 I64Op.TruncSF32) -> op 0xae
     | Convert (I64 I64Op.TruncUF32) -> op 0xaf
     | Convert (I64 I64Op.TruncSF64) -> op 0xb0
     | Convert (I64 I64Op.TruncUF64) -> op 0xb1
-    | Convert (I64 I64Op.TruncSatSF32) -> op 0xfc; vu32 0x04l
-    | Convert (I64 I64Op.TruncSatUF32) -> op 0xfc; vu32 0x05l
-    | Convert (I64 I64Op.TruncSatSF64) -> op 0xfc; vu32 0x06l
-    | Convert (I64 I64Op.TruncSatUF64) -> op 0xfc; vu32 0x07l
+    | Convert (I64 I64Op.TruncSatSF32) -> op 0xfc; u32 0x04l
+    | Convert (I64 I64Op.TruncSatUF32) -> op 0xfc; u32 0x05l
+    | Convert (I64 I64Op.TruncSatSF64) -> op 0xfc; u32 0x06l
+    | Convert (I64 I64Op.TruncSatUF64) -> op 0xfc; u32 0x07l
     | Convert (I64 I64Op.ReinterpretFloat) -> op 0xbd
 
     | Convert (F32 F32Op.ConvertSI32) -> op 0xb2
     | Convert (F32 F32Op.ConvertUI32) -> op 0xb3
     | Convert (F32 F32Op.ConvertSI64) -> op 0xb4
     | Convert (F32 F32Op.ConvertUI64) -> op 0xb5
-    | Convert (F32 F32Op.PromoteF32) -> assert false
+    | Convert (F32 F32Op.PromoteF32) ->
+      error e.at "illegal instruction f32.promote_f32"
     | Convert (F32 F32Op.DemoteF64) -> op 0xb6
     | Convert (F32 F32Op.ReinterpretInt) -> op 0xbe
 
@@ -454,7 +469,8 @@ struct
     | Convert (F64 F64Op.ConvertSI64) -> op 0xb9
     | Convert (F64 F64Op.ConvertUI64) -> op 0xba
     | Convert (F64 F64Op.PromoteF32) -> op 0xbb
-    | Convert (F64 F64Op.DemoteF64) -> assert false
+    | Convert (F64 F64Op.DemoteF64) ->
+      error e.at "illegal instruction f64.demote_f64"
     | Convert (F64 F64Op.ReinterpretInt) -> op 0xbf
 
     | VecConst {it = V128 c; _} -> vecop 0x0cl; v128 c
@@ -470,13 +486,16 @@ struct
     | VecUnary (V128 (I8x16 V128Op.Popcnt)) -> vecop 0x62l
     | VecUnary (V128 (I16x8 V128Op.Abs)) -> vecop 0x80l
     | VecUnary (V128 (I16x8 V128Op.Neg)) -> vecop 0x81l
-    | VecUnary (V128 (I16x8 V128Op.Popcnt)) -> assert false
+    | VecUnary (V128 (I16x8 V128Op.Popcnt)) ->
+      error e.at "illegal instruction i16x8.popcnt"
     | VecUnary (V128 (I32x4 V128Op.Abs)) -> vecop 0xa0l
     | VecUnary (V128 (I32x4 V128Op.Neg)) -> vecop 0xa1l
-    | VecUnary (V128 (I32x4 V128Op.Popcnt)) -> assert false
+    | VecUnary (V128 (I32x4 V128Op.Popcnt)) ->
+      error e.at "illegal instruction i32x4.popcnt"
     | VecUnary (V128 (I64x2 V128Op.Abs)) -> vecop 0xc0l
     | VecUnary (V128 (I64x2 V128Op.Neg)) -> vecop 0xc1l
-    | VecUnary (V128 (I64x2 V128Op.Popcnt)) -> assert false
+    | VecUnary (V128 (I64x2 V128Op.Popcnt)) ->
+      error e.at "illegal instruction i64x2.popcnt"
     | VecUnary (V128 (F32x4 V128Op.Ceil)) -> vecop 0x67l
     | VecUnary (V128 (F32x4 V128Op.Floor)) -> vecop 0x68l
     | VecUnary (V128 (F32x4 V128Op.Trunc)) -> vecop 0x69l
@@ -525,13 +544,17 @@ struct
     | VecCompare (V128 (I64x2 V128Op.Eq)) -> vecop 0xd6l
     | VecCompare (V128 (I64x2 V128Op.Ne)) -> vecop 0xd7l
     | VecCompare (V128 (I64x2 V128Op.LtS)) -> vecop 0xd8l
-    | VecCompare (V128 (I64x2 V128Op.LtU)) -> assert false
+    | VecCompare (V128 (I64x2 V128Op.LtU)) ->
+      error e.at "illegal instruction i64x2.lt_u"
     | VecCompare (V128 (I64x2 V128Op.GtS)) -> vecop 0xd9l
-    | VecCompare (V128 (I64x2 V128Op.GtU)) -> assert false
+    | VecCompare (V128 (I64x2 V128Op.GtU)) ->
+      error e.at "illegal instruction i64x2.gt_u"
     | VecCompare (V128 (I64x2 V128Op.LeS)) -> vecop 0xdal
-    | VecCompare (V128 (I64x2 V128Op.LeU)) -> assert false
+    | VecCompare (V128 (I64x2 V128Op.LeU)) ->
+      error e.at "illegal instruction i64x2.le_u"
     | VecCompare (V128 (I64x2 V128Op.GeS)) -> vecop 0xdbl
-    | VecCompare (V128 (I64x2 V128Op.GeU)) -> assert false
+    | VecCompare (V128 (I64x2 V128Op.GeU)) ->
+      error e.at "illegal instruction i64x2.ge_u"
     | VecCompare (V128 (F32x4 V128Op.Eq)) -> vecop 0x41l
     | VecCompare (V128 (F32x4 V128Op.Ne)) -> vecop 0x42l
     | VecCompare (V128 (F32x4 V128Op.Lt)) -> vecop 0x43l
@@ -545,7 +568,7 @@ struct
     | VecCompare (V128 (F64x2 V128Op.Le)) -> vecop 0x4bl
     | VecCompare (V128 (F64x2 V128Op.Ge)) -> vecop 0x4cl
 
-    | VecBinary (V128 (I8x16 (V128Op.Shuffle is))) -> vecop 0x0dl; List.iter u8 is
+    | VecBinary (V128 (I8x16 (V128Op.Shuffle is))) -> vecop 0x0dl; List.iter byte is
     | VecBinary (V128 (I8x16 V128Op.Swizzle)) -> vecop 0x0el
     | VecBinary (V128 (I8x16 V128Op.NarrowS)) -> vecop 0x65l
     | VecBinary (V128 (I8x16 V128Op.NarrowU)) -> vecop 0x66l
@@ -614,16 +637,19 @@ struct
     | VecBinary (V128 (F64x2 V128Op.Max)) -> vecop 0xf5l
     | VecBinary (V128 (F64x2 V128Op.Pmin)) -> vecop 0xf6l
     | VecBinary (V128 (F64x2 V128Op.Pmax)) -> vecop 0xf7l
-    | VecBinary (V128 _) -> assert false
+    | VecBinary (V128 _) ->
+      error e.at "illegal binary vector instruction"
 
-    | VecConvert (V128 (I8x16 _)) -> assert false
+    | VecConvert (V128 (I8x16 _)) ->
+      error e.at "illegal i8x16 conversion instruction"
     | VecConvert (V128 (I16x8 V128Op.ExtendLowS)) -> vecop 0x87l
     | VecConvert (V128 (I16x8 V128Op.ExtendHighS)) -> vecop 0x88l
     | VecConvert (V128 (I16x8 V128Op.ExtendLowU)) -> vecop 0x89l
     | VecConvert (V128 (I16x8 V128Op.ExtendHighU)) -> vecop 0x8al
     | VecConvert (V128 (I16x8 V128Op.ExtAddPairwiseS)) -> vecop 0x7cl
     | VecConvert (V128 (I16x8 V128Op.ExtAddPairwiseU)) -> vecop 0x7dl
-    | VecConvert (V128 (I16x8 _)) -> assert false
+    | VecConvert (V128 (I16x8 _)) ->
+      error e.at "illegal i16x8 conversion instruction"
     | VecConvert (V128 (I32x4 V128Op.ExtendLowS)) -> vecop 0xa7l
     | VecConvert (V128 (I32x4 V128Op.ExtendHighS)) -> vecop 0xa8l
     | VecConvert (V128 (I32x4 V128Op.ExtendLowU)) -> vecop 0xa9l
@@ -638,12 +664,15 @@ struct
     | VecConvert (V128 (I64x2 V128Op.ExtendHighS)) -> vecop 0xc8l
     | VecConvert (V128 (I64x2 V128Op.ExtendLowU)) -> vecop 0xc9l
     | VecConvert (V128 (I64x2 V128Op.ExtendHighU)) -> vecop 0xcal
-    | VecConvert (V128 (I64x2 _)) -> assert false
+    | VecConvert (V128 (I64x2 _)) ->
+      error e.at "illegal i64x2 conversion instruction"
     | VecConvert (V128 (F32x4 V128Op.DemoteZeroF64x2)) -> vecop 0x5el
-    | VecConvert (V128 (F32x4 V128Op.PromoteLowF32x4)) -> assert false
+    | VecConvert (V128 (F32x4 V128Op.PromoteLowF32x4)) ->
+      error e.at "illegal instruction f32x4.promote_low_f32x4"
     | VecConvert (V128 (F32x4 V128Op.ConvertSI32x4)) -> vecop 0xfal
     | VecConvert (V128 (F32x4 V128Op.ConvertUI32x4)) -> vecop 0xfbl
-    | VecConvert (V128 (F64x2 V128Op.DemoteZeroF64x2)) -> assert false
+    | VecConvert (V128 (F64x2 V128Op.DemoteZeroF64x2)) ->
+      error e.at "illegal instruction f64x2.demote_zero_f64x2"
     | VecConvert (V128 (F64x2 V128Op.PromoteLowF32x4)) -> vecop 0x5fl
     | VecConvert (V128 (F64x2 V128Op.ConvertSI32x4)) -> vecop 0xfel
     | VecConvert (V128 (F64x2 V128Op.ConvertUI32x4)) -> vecop 0xffl
@@ -683,49 +712,54 @@ struct
     | VecSplat (V128 ((F32x4 V128Op.Splat))) -> vecop 0x13l
     | VecSplat (V128 ((F64x2 V128Op.Splat))) -> vecop 0x14l
 
-    | VecExtract (V128 (I8x16 (V128Op.Extract (i, SX)))) -> vecop 0x15l; u8 i
-    | VecExtract (V128 (I8x16 (V128Op.Extract (i, ZX)))) -> vecop 0x16l; u8 i
-    | VecExtract (V128 (I16x8 (V128Op.Extract (i, SX)))) -> vecop 0x18l; u8 i
-    | VecExtract (V128 (I16x8 (V128Op.Extract (i, ZX)))) -> vecop 0x19l; u8 i
-    | VecExtract (V128 (I32x4 (V128Op.Extract (i, ())))) -> vecop 0x1bl; u8 i
-    | VecExtract (V128 (I64x2 (V128Op.Extract (i, ())))) -> vecop 0x1dl; u8 i
-    | VecExtract (V128 (F32x4 (V128Op.Extract (i, ())))) -> vecop 0x1fl; u8 i
-    | VecExtract (V128 (F64x2 (V128Op.Extract (i, ())))) -> vecop 0x21l; u8 i
-
-    | VecReplace (V128 (I8x16 (V128Op.Replace i))) -> vecop 0x17l; u8 i
-    | VecReplace (V128 (I16x8 (V128Op.Replace i))) -> vecop 0x1al; u8 i
-    | VecReplace (V128 (I32x4 (V128Op.Replace i))) -> vecop 0x1cl; u8 i
-    | VecReplace (V128 (I64x2 (V128Op.Replace i))) -> vecop 0x1el; u8 i
-    | VecReplace (V128 (F32x4 (V128Op.Replace i))) -> vecop 0x20l; u8 i
-    | VecReplace (V128 (F64x2 (V128Op.Replace i))) -> vecop 0x22l; u8 i
+    | VecExtract (V128 (I8x16 (V128Op.Extract (i, SX)))) -> vecop 0x15l; byte i
+    | VecExtract (V128 (I8x16 (V128Op.Extract (i, ZX)))) -> vecop 0x16l; byte i
+    | VecExtract (V128 (I16x8 (V128Op.Extract (i, SX)))) -> vecop 0x18l; byte i
+    | VecExtract (V128 (I16x8 (V128Op.Extract (i, ZX)))) -> vecop 0x19l; byte i
+    | VecExtract (V128 (I32x4 (V128Op.Extract (i, ())))) -> vecop 0x1bl; byte i
+    | VecExtract (V128 (I64x2 (V128Op.Extract (i, ())))) -> vecop 0x1dl; byte i
+    | VecExtract (V128 (F32x4 (V128Op.Extract (i, ())))) -> vecop 0x1fl; byte i
+    | VecExtract (V128 (F64x2 (V128Op.Extract (i, ())))) -> vecop 0x21l; byte i
+
+    | VecReplace (V128 (I8x16 (V128Op.Replace i))) -> vecop 0x17l; byte i
+    | VecReplace (V128 (I16x8 (V128Op.Replace i))) -> vecop 0x1al; byte i
+    | VecReplace (V128 (I32x4 (V128Op.Replace i))) -> vecop 0x1cl; byte i
+    | VecReplace (V128 (I64x2 (V128Op.Replace i))) -> vecop 0x1el; byte i
+    | VecReplace (V128 (F32x4 (V128Op.Replace i))) -> vecop 0x20l; byte i
+    | VecReplace (V128 (F64x2 (V128Op.Replace i))) -> vecop 0x22l; byte i
 
   let const c =
     list instr c.it; end_ ()
 
+
   (* Sections *)
 
   let section id f x needed =
     if needed then begin
-      u8 id;
+      byte id;
       let g = gap32 () in
       let p = pos s in
       f x;
       patch_gap32 g (pos s - p)
     end
 
+
   (* Type section *)
+
   let type_ t = func_type t.it
 
   let type_section ts =
     section 1 (vec type_) ts (ts <> [])
 
+
   (* Import section *)
+
   let import_desc d =
     match d.it with
-    | FuncImport x -> u8 0x00; var x
-    | TableImport t -> u8 0x01; table_type t
-    | MemoryImport t -> u8 0x02; memory_type t
-    | GlobalImport t -> u8 0x03; global_type t
+    | FuncImport x -> byte 0x00; var x
+    | TableImport t -> byte 0x01; table_type t
+    | MemoryImport t -> byte 0x02; memory_type t
+    | GlobalImport t -> byte 0x03; global_type t
 
   let import im =
     let {module_name; item_name; idesc} = im.it in
@@ -734,13 +768,17 @@ struct
   let import_section ims =
     section 2 (vec import) ims (ims <> [])
 
+
   (* Function section *)
+
   let func f = var f.it.ftype
 
   let func_section fs =
     section 3 (vec func) fs (fs <> [])
 
+
   (* Table section *)
+
   let table tab =
     let {ttype} = tab.it in
     table_type ttype
@@ -748,7 +786,9 @@ struct
   let table_section tabs =
     section 4 (vec table) tabs (tabs <> [])
 
+
   (* Memory section *)
+
   let memory mem =
     let {mtype} = mem.it in
     memory_type mtype
@@ -756,7 +796,9 @@ struct
   let memory_section mems =
     section 5 (vec memory) mems (mems <> [])
 
+
   (* Global section *)
+
   let global g =
     let {gtype; ginit} = g.it in
     global_type gtype; const ginit
@@ -764,13 +806,15 @@ struct
   let global_section gs =
     section 6 (vec global) gs (gs <> [])
 
+
   (* Export section *)
+
   let export_desc d =
     match d.it with
-    | FuncExport x -> u8 0; var x
-    | TableExport x -> u8 1; var x
-    | MemoryExport x -> u8 2; var x
-    | GlobalExport x -> u8 3; var x
+    | FuncExport x -> byte 0; var x
+    | TableExport x -> byte 1; var x
+    | MemoryExport x -> byte 2; var x
+    | GlobalExport x -> byte 3; var x
 
   let export ex =
     let {name = n; edesc} = ex.it in
@@ -779,7 +823,9 @@ struct
   let export_section exs =
     section 7 (vec export) exs (exs <> [])
 
+
   (* Start section *)
+
   let start st =
     let {sfunc} = st.it in
     var sfunc
@@ -787,20 +833,22 @@ struct
   let start_section xo =
     section 8 (opt start) xo (xo <> None)
 
+
   (* Code section *)
-  let compress ts =
+
+  let local (t, n) = len n; value_type t
+
+  let locals locs =
     let combine t = function
       | (t', n) :: ts when t = t' -> (t, n + 1) :: ts
       | ts -> (t, 1) :: ts
-    in List.fold_right combine ts []
-
-  let local (t, n) = len n; value_type t
+    in vec local (List.fold_right combine locs [])
 
   let code f =
-    let {locals; body; _} = f.it in
+    let {locals = locs; body; _} = f.it in
     let g = gap32 () in
     let p = pos s in
-    vec local (compress locals);
+    locals locs;
     list instr body;
     end_ ();
     patch_gap32 g (pos s - p)
@@ -808,13 +856,15 @@ struct
   let code_section fs =
     section 10 (vec code) fs (fs <> [])
 
+
   (* Element section *)
+
   let is_elem_kind = function
     | FuncRefType -> true
     | _ -> false
 
   let elem_kind = function
-    | FuncRefType -> u8 0x00
+    | FuncRefType -> byte 0x00
     | _ -> assert false
 
   let is_elem_index e =
@@ -832,49 +882,55 @@ struct
     if is_elem_kind etype && List.for_all is_elem_index einit then
       match emode.it with
       | Passive ->
-        vu32 0x01l; elem_kind etype; vec elem_index einit
-      | Active {index; offset} when index.it = 0l && etype = FuncRefType ->
-        vu32 0x00l; const offset; vec elem_index einit
+        u32 0x01l; elem_kind etype; vec elem_index einit
+      | Active {index; offset} when index.it = 0l && is_elem_kind etype ->
+        u32 0x00l; const offset; vec elem_index einit
       | Active {index; offset} ->
-        vu32 0x02l;
+        u32 0x02l;
         var index; const offset; elem_kind etype; vec elem_index einit
       | Declarative ->
-        vu32 0x03l; elem_kind etype; vec elem_index einit
+        u32 0x03l; elem_kind etype; vec elem_index einit
     else
       match emode.it with
       | Passive ->
-        vu32 0x05l; ref_type etype; vec const einit
-      | Active {index; offset} when index.it = 0l && etype = FuncRefType ->
-        vu32 0x04l; const offset; vec const einit
+        u32 0x05l; ref_type etype; vec const einit
+      | Active {index; offset} when index.it = 0l && is_elem_kind etype ->
+        u32 0x04l; const offset; vec const einit
       | Active {index; offset} ->
-        vu32 0x06l; var index; const offset; ref_type etype; vec const einit
+        u32 0x06l; var index; const offset; ref_type etype; vec const einit
       | Declarative ->
-        vu32 0x07l; ref_type etype; vec const einit
+        u32 0x07l; ref_type etype; vec const einit
 
   let elem_section elems =
     section 9 (vec elem) elems (elems <> [])
 
+
   (* Data section *)
+
   let data seg =
     let {dinit; dmode} = seg.it in
     match dmode.it with
     | Passive ->
-      vu32 0x01l; string dinit
+      u32 0x01l; string dinit
     | Active {index; offset} when index.it = 0l ->
-      vu32 0x00l; const offset; string dinit
+      u32 0x00l; const offset; string dinit
     | Active {index; offset} ->
-      vu32 0x02l; var index; const offset; string dinit
+      u32 0x02l; var index; const offset; string dinit
     | Declarative ->
-      assert false
+      error dmode.at "illegal declarative data segment"
 
   let data_section datas =
     section 11 (vec data) datas (datas <> [])
 
+
   (* Data count section *)
+
   let data_count_section datas m =
     section 12 len (List.length datas) Free.((module_ m).datas <> Set.empty)
 
+
   (* Custom section *)
+
   let custom (n, bs) =
     name n;
     put_string s bs
@@ -882,10 +938,12 @@ struct
   let custom_section n bs =
     section 0 custom (n, bs) true
 
+
   (* Module *)
+
   let module_ m =
-    u32 0x6d736100l;
-    u32 version;
+    word32 0x6d736100l;
+    word32 version;
     type_section m.it.types;
     import_section m.it.imports;
     func_section m.it.funcs;

From 7991db35a46b56145893e63605c3eda3b39e8af6 Mon Sep 17 00:00:00 2001
From: Thomas Lively <7121787+tlively@users.noreply.github.com>
Date: Tue, 7 Jun 2022 14:21:14 -0700
Subject: [PATCH 129/285] [spec] Add missing close paren on table abbreviation
 (#1486)

Also remove an unnecessary space in the previous table abbreviation.
---
 document/core/text/modules.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/text/modules.rst b/document/core/text/modules.rst
index 0964dfdaa..fde59878a 100644
--- a/document/core/text/modules.rst
+++ b/document/core/text/modules.rst
@@ -290,7 +290,7 @@ An :ref:`element segment <text-elem>` can be given inline with a table definitio
 .. math::
    \begin{array}{llclll}
    \production{module field} &
-     \text{(}~\text{table}~~\Tid^?~~\Treftype~~\text{(}~\text{elem}~~\expr^n{:}\Tvec(\Telemexpr)~\text{)}~~\text{)} \quad\equiv \\ & \qquad
+     \text{(}~\text{table}~~\Tid^?~~\Treftype~~\text{(}~\text{elem}~~\expr^n{:}\Tvec(\Telemexpr)~\text{)}~\text{)} \quad\equiv \\ & \qquad
        \text{(}~\text{table}~~\Tid'~~n~~n~~\Treftype~\text{)} \\ & \qquad
        \text{(}~\text{elem}~~\text{(}~\text{table}~~\Tid'~\text{)}~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Tvec(\Telemexpr)~\text{)}
        \\ & \qquad\qquad
@@ -300,7 +300,7 @@ An :ref:`element segment <text-elem>` can be given inline with a table definitio
 .. math::
    \begin{array}{llclll}
    \production{module field} &
-     \text{(}~\text{table}~~\Tid^?~~\Treftype~~\text{(}~\text{elem}~~x^n{:}\Tvec(\Tfuncidx)~\text{)} \quad\equiv \\ & \qquad
+     \text{(}~\text{table}~~\Tid^?~~\Treftype~~\text{(}~\text{elem}~~x^n{:}\Tvec(\Tfuncidx)~\text{)}~\text{)} \quad\equiv \\ & \qquad
        \text{(}~\text{table}~~\Tid'~~n~~n~~\Treftype~\text{)} \\ & \qquad
        \text{(}~\text{elem}~~\text{(}~\text{table}~~\Tid'~\text{)}~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Tvec(\Tfuncidx)~\text{)}
        \\ & \qquad\qquad

From f8c221c313e718d7c0ebfa21111a713cf6d1e58c Mon Sep 17 00:00:00 2001
From: Alberto Fiori <9143617+fifofefe@users.noreply.github.com>
Date: Wed, 8 Jun 2022 15:40:16 +0200
Subject: [PATCH 130/285] [spec] Remove outdated note (#1491)

---
 document/core/exec/runtime.rst | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index e5c97ed78..149a53a8b 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -84,10 +84,6 @@ It is either a sequence of :ref:`values <syntax-val>` or a :ref:`trap <syntax-tr
      \TRAP
    \end{array}
 
-.. note::
-   In the current version of WebAssembly, a result can consist of at most one value.
-
-
 .. index:: ! store, function instance, table instance, memory instance, global instance, module, allocation
    pair: abstract syntax; store
 .. _syntax-store:

From efb7f3de98af32678e741221671a219450f1ffc6 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 8 Jun 2022 15:45:10 +0200
Subject: [PATCH 131/285] Eps

---
 interpreter/binary/decode.ml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 4f17d3d0d..2e66bfc8e 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -160,13 +160,13 @@ let vec_type s =
 let var_type s =
   let pos = pos s in
   match s33 s with
-  | i when i >= 0l -> i
+  | i when i >= 0l -> SynVar i
   | _ -> error s pos "malformed type index"
 
 let heap_type s =
   let pos = pos s in
   either [
-    (fun s -> let x = var_type s in DefHeapType (SynVar x));
+    (fun s -> DefHeapType (var_type s));
     (fun s ->
       match s7 s with
       | -0x10 -> FuncHeapType
@@ -250,7 +250,7 @@ let memop s =
 
 let block_type s =
   either [
-    (fun s -> let x = var_type s in VarBlockType (SynVar x));
+    (fun s -> VarBlockType (var_type s));
     (fun s -> expect 0x40 s ""; ValBlockType None);
     (fun s -> ValBlockType (Some (value_type s)));
   ] s

From 2cdd5acb214dff87a857374945487290e2cf422b Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Thu, 9 Jun 2022 12:25:43 +0200
Subject: [PATCH 132/285] [interpreter] Factor data and element segments into
 abstract types (#1492)

---
 interpreter/exec/eval.ml        | 23 ++++++++++++-----------
 interpreter/exec/ixx.ml         |  4 ++--
 interpreter/runtime/data.ml     |  7 +++++++
 interpreter/runtime/data.mli    |  7 +++++++
 interpreter/runtime/elem.ml     |  7 +++++++
 interpreter/runtime/elem.mli    |  9 +++++++++
 interpreter/runtime/instance.ml |  8 ++++----
 7 files changed, 48 insertions(+), 17 deletions(-)
 create mode 100644 interpreter/runtime/data.ml
 create mode 100644 interpreter/runtime/data.mli
 create mode 100644 interpreter/runtime/elem.ml
 create mode 100644 interpreter/runtime/elem.mli

diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index 74e7f1a72..3a112ce49 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -134,7 +134,7 @@ let mem_oob frame x i n =
 
 let data_oob frame x i n =
   I64.gt_u (I64.add (I64_convert.extend_i32_u i) (I64_convert.extend_i32_u n))
-    (I64.of_int_u (String.length !(data frame.inst x)))
+    (Data.size (data frame.inst x))
 
 let table_oob frame x i n =
   I64.gt_u (I64.add (I64_convert.extend_i32_u i) (I64_convert.extend_i32_u n))
@@ -142,7 +142,7 @@ let table_oob frame x i n =
 
 let elem_oob frame x i n =
   I64.gt_u (I64.add (I64_convert.extend_i32_u i) (I64_convert.extend_i32_u n))
-    (I64.of_int_u (List.length !(elem frame.inst x)))
+    (I64_convert.extend_i32_u (Elem.size (elem frame.inst x)))
 
 let rec step (c : config) : config =
   let {frame; code = vs, es; _} = c in
@@ -302,10 +302,10 @@ let rec step (c : config) : config =
         else if n = 0l then
           vs', []
         else
-          let seg = !(elem frame.inst y) in
+          let seg = elem frame.inst y in
           vs', List.map (at e.at) [
             Plain (Const (I32 d @@ e.at));
-            Refer (List.nth seg (Int32.to_int s));
+            Refer (Elem.load seg s);
             Plain (TableSet x);
             Plain (Const (I32 (I32.add d 1l) @@ e.at));
             Plain (Const (I32 (I32.add s 1l) @@ e.at));
@@ -315,7 +315,7 @@ let rec step (c : config) : config =
 
       | ElemDrop x, vs ->
         let seg = elem frame.inst x in
-        seg := [];
+        Elem.drop seg;
         vs, []
 
       | Load {offset; ty; pack; _}, Num (I32 i) :: vs' ->
@@ -465,11 +465,12 @@ let rec step (c : config) : config =
         else if n = 0l then
           vs', []
         else
-          let seg = !(data frame.inst x) in
-          let b = Int32.of_int (Char.code seg.[Int32.to_int s]) in
+          let seg = data frame.inst x in
+          let a = I64_convert.extend_i32_u s in
+          let b = Data.load seg a in
           vs', List.map (at e.at) [
             Plain (Const (I32 d @@ e.at));
-            Plain (Const (I32 b @@ e.at));
+            Plain (Const (I32 (I32.of_int_u (Char.code b)) @@ e.at));
             Plain (Store
               {ty = I32Type; align = 0; offset = 0l; pack = Some Pack8});
             Plain (Const (I32 (I32.add d 1l) @@ e.at));
@@ -480,7 +481,7 @@ let rec step (c : config) : config =
 
       | DataDrop x, vs ->
         let seg = data frame.inst x in
-        seg := "";
+        Data.drop seg;
         vs, []
 
       | RefNull t, vs' ->
@@ -715,11 +716,11 @@ let create_export (inst : module_inst) (ex : export) : export_inst =
 
 let create_elem (inst : module_inst) (seg : elem_segment) : elem_inst =
   let {etype; einit; _} = seg.it in
-  ref (List.map (fun c -> as_ref (eval_const inst c)) einit)
+  Elem.alloc (List.map (fun c -> as_ref (eval_const inst c)) einit)
 
 let create_data (inst : module_inst) (seg : data_segment) : data_inst =
   let {dinit; _} = seg.it in
-  ref dinit
+  Data.alloc dinit
 
 
 let add_import (m : module_) (ext : extern) (im : import) (inst : module_inst)
diff --git a/interpreter/exec/ixx.ml b/interpreter/exec/ixx.ml
index 18f8b7d06..0a13d22b6 100644
--- a/interpreter/exec/ixx.ml
+++ b/interpreter/exec/ixx.ml
@@ -30,8 +30,8 @@ sig
 
   val of_int : int -> t
   val to_int : t -> int
-  val of_int64: int64 -> t
-  val to_int64: t -> int64
+  val of_int64 : int64 -> t
+  val to_int64 : t -> int64
   val to_string : t -> string
   val to_hex_string : t -> string
 
diff --git a/interpreter/runtime/data.ml b/interpreter/runtime/data.ml
new file mode 100644
index 000000000..e73cd2f31
--- /dev/null
+++ b/interpreter/runtime/data.ml
@@ -0,0 +1,7 @@
+type data = string ref
+type t = data
+
+let alloc bs = ref bs
+let size seg = I64.of_int_u (String.length !seg)
+let load seg i = (!seg).[Int64.to_int i]
+let drop seg = seg := ""
diff --git a/interpreter/runtime/data.mli b/interpreter/runtime/data.mli
new file mode 100644
index 000000000..498c45149
--- /dev/null
+++ b/interpreter/runtime/data.mli
@@ -0,0 +1,7 @@
+type data
+type t = data
+
+val alloc : string -> data
+val size : data -> Memory.address
+val load : data -> Memory.address -> char
+val drop : data -> unit
diff --git a/interpreter/runtime/elem.ml b/interpreter/runtime/elem.ml
new file mode 100644
index 000000000..fe8997482
--- /dev/null
+++ b/interpreter/runtime/elem.ml
@@ -0,0 +1,7 @@
+type elem = Values.ref_ list ref
+type t = elem
+
+let alloc rs = ref rs
+let size seg = Lib.List32.length !seg
+let load seg i = Lib.List32.nth !seg i
+let drop seg = seg := []
diff --git a/interpreter/runtime/elem.mli b/interpreter/runtime/elem.mli
new file mode 100644
index 000000000..5eb0c0e56
--- /dev/null
+++ b/interpreter/runtime/elem.mli
@@ -0,0 +1,9 @@
+open Values
+
+type elem
+type t = elem
+
+val alloc : ref_ list -> elem
+val size : elem -> Table.size
+val load : elem -> Table.index -> ref_
+val drop : elem -> unit
diff --git a/interpreter/runtime/instance.ml b/interpreter/runtime/instance.ml
index 4d4fece07..0ae878c37 100644
--- a/interpreter/runtime/instance.ml
+++ b/interpreter/runtime/instance.ml
@@ -7,18 +7,18 @@ type module_inst =
   tables : table_inst list;
   memories : memory_inst list;
   globals : global_inst list;
-  exports : export_inst list;
   elems : elem_inst list;
   datas : data_inst list;
+  exports : export_inst list;
 }
 
 and func_inst = module_inst ref Func.t
 and table_inst = Table.t
 and memory_inst = Memory.t
 and global_inst = Global.t
+and elem_inst = Elem.t
+and data_inst = Data.t
 and export_inst = Ast.name * extern
-and elem_inst = Values.ref_ list ref
-and data_inst = string ref
 
 and extern =
   | ExternFunc of func_inst
@@ -55,7 +55,7 @@ let () =
 
 let empty_module_inst =
   { types = []; funcs = []; tables = []; memories = []; globals = [];
-    exports = []; elems = []; datas = [] }
+    elems = []; datas = []; exports = [] }
 
 let extern_type_of = function
   | ExternFunc func -> ExternFuncType (Func.type_of func)

From 044d0d2e77bdcbe891f7e0b9dd2ac01d56435f0b Mon Sep 17 00:00:00 2001
From: Keith Winstein <keithw@cs.stanford.edu>
Date: Mon, 13 Jun 2022 03:04:08 -0700
Subject: [PATCH 133/285] [spec] Update note on module initialization trapping
 (#1493)

---
 document/core/exec/modules.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index 0e8c9d50a..99eeb2756 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -596,7 +596,7 @@ Given a :ref:`store <syntax-store>` :math:`S`, a :ref:`module <syntax-module>` :
 
 Instantiation checks that the module is :ref:`valid <valid>` and the provided imports :ref:`match <match-externtype>` the declared types,
 and may *fail* with an error otherwise.
-Instantiation can also result in a :ref:`trap <trap>` from executing the start function.
+Instantiation can also result in a :ref:`trap <trap>` from initializing a table or memory from an active segment or from executing the start function.
 It is up to the :ref:`embedder <embedder>` to define how such conditions are reported.
 
 1. If :math:`\module` is not :ref:`valid <valid-module>`, then:

From d4e68e0c77acfbabc9bc05a3df40dac564a057b1 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 16 Jun 2022 11:47:42 +0200
Subject: [PATCH 134/285] Fix type equality

---
 interpreter/valid/match.ml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/interpreter/valid/match.ml b/interpreter/valid/match.ml
index cb07f7e85..3b1dac447 100644
--- a/interpreter/valid/match.ml
+++ b/interpreter/valid/match.ml
@@ -50,6 +50,7 @@ and eq_value_type c a t1 t2 =
   | NumType t1', NumType t2' -> eq_num_type c a t1' t2'
   | VecType t1', VecType t2' -> eq_vec_type c a t1' t2'
   | RefType t1', RefType t2' -> eq_ref_type c a t1' t2'
+  | BotType, BotType -> true
   | _, _ -> false
 
 and eq_result_type c a ts1 ts2 =

From 7258eb959f892b3cc7d21d6d4bb2f034fc8c245b Mon Sep 17 00:00:00 2001
From: mnordine <marknordine@gmail.com>
Date: Mon, 20 Jun 2022 08:23:33 -0300
Subject: [PATCH 135/285] Fix typo

---
 proposals/tail-call/Overview.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/proposals/tail-call/Overview.md b/proposals/tail-call/Overview.md
index ce08d1abc..b422654f0 100644
--- a/proposals/tail-call/Overview.md
+++ b/proposals/tail-call/Overview.md
@@ -102,7 +102,7 @@ Add two instructions:
 * `return_call <funcidx>`, the tail-call version of `call`
 * `return_call_indirect <tableidx> <typeidx>`, the tail-call version of `call_indirect`
 
-Other language extensions like [typed function refereces](https://github.com/WebAssembly/function-references/blob/master/proposals/function-references/Overview.md) that introduce new call instructions will also introduce tail versions of these new instructions.
+Other language extensions like [typed function references](https://github.com/WebAssembly/function-references/blob/master/proposals/function-references/Overview.md) that introduce new call instructions will also introduce tail versions of these new instructions.
 
 
 ### Validation

From 731ad9ff58b549b5dd1613375111acd44b8e8b76 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Mon, 27 Jun 2022 12:32:27 +0200
Subject: [PATCH 136/285] [spec] Add note about control stack invariant to
 algorithm (#1498)

---
 document/core/appendix/algorithm.rst | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/document/core/appendix/algorithm.rst b/document/core/appendix/algorithm.rst
index 72c83ea56..9b2c9a5b8 100644
--- a/document/core/appendix/algorithm.rst
+++ b/document/core/appendix/algorithm.rst
@@ -140,6 +140,8 @@ The type of the :ref:`label <syntax-label>` associated with a control frame is e
 
 Finally, the current frame can be marked as unreachable.
 In that case, all existing operand types are purged from the value stack, in order to allow for the :ref:`stack-polymorphism <polymorphism>` logic in :code:`pop_val` to take effect.
+Because every function has an implicit outermost label that corresponds to an implicit block frame,
+it is an invariant of the validation algorithm that there always is at least one frame on the control stack when validating an instruction, and hence, `ctrls[0]` is always defined.
 
 .. note::
    Even with the unreachable flag set, consecutive operands are still pushed to and popped from the operand stack.

From e0a6a312fa28c216d0b204e553e0c6d8c7cb440d Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Tue, 28 Jun 2022 22:50:26 +0200
Subject: [PATCH 137/285] [spec] Tweak tokenisation for text format (#1499)

---
 document/core/text/lexical.rst |   8 +-
 interpreter/text/lexer.mll     |  10 +-
 test/core/tokens.wast          | 274 +++++++++++++++++++++++++++++++++
 3 files changed, 284 insertions(+), 8 deletions(-)
 create mode 100644 test/core/tokens.wast

diff --git a/document/core/text/lexical.rst b/document/core/text/lexical.rst
index a3b4529d3..0c40a58d1 100644
--- a/document/core/text/lexical.rst
+++ b/document/core/text/lexical.rst
@@ -50,7 +50,7 @@ The character stream in the source text is divided, from left to right, into a s
      (\text{a} ~|~ \dots ~|~ \text{z})~\Tidchar^\ast
      \qquad (\mbox{if occurring as a literal terminal in the grammar}) \\
    \production{reserved} & \Treserved &::=&
-     \Tidchar^+ \\
+     (\Tidchar ~|~ \Tstring)^+ \\
    \end{array}
 
 Tokens are formed from the input character stream according to the *longest match* rule.
@@ -63,9 +63,9 @@ The set of *keyword* tokens is defined implicitly, by all occurrences of a :ref:
 Any token that does not fall into any of the other categories is considered *reserved*, and cannot occur in source text.
 
 .. note::
-   The effect of defining the set of reserved tokens is that all tokens must be separated by either parentheses or :ref:`white space <text-space>`.
-   For example, :math:`\text{0\$x}` is a single reserved token.
-   Consequently, it is not recognized as two separate tokens :math:`\text{0}` and :math:`\text{\$x}`, but instead disallowed.
+   The effect of defining the set of reserved tokens is that all tokens must be separated by either parentheses, :ref:`white space <text-space>`, or :ref:`comments <text-comment>`.
+   For example, :math:`\text{0\$x}` is a single reserved token, as is :math:`\text{"a""b"}`.
+   Consequently, they are not recognized as two separate tokens :math:`\text{0}` and :math:`\text{\$x}`, or :math:`"a"` and :math:`"b"`, respectively, but instead disallowed.
    This property of tokenization is not affected by the fact that the definition of reserved tokens overlaps with other token classes.
 
 
diff --git a/interpreter/text/lexer.mll b/interpreter/text/lexer.mll
index 161520e0a..d9a12b5d2 100644
--- a/interpreter/text/lexer.mll
+++ b/interpreter/text/lexer.mll
@@ -62,8 +62,9 @@ let symbol =
   ['+''-''*''/''\\''^''~''=''<''>''!''?''@''#''$''%''&''|'':''`''.''\'']
 
 let space = [' ''\t''\n''\r']
+let control = ['\x00'-'\x1f'] # space
 let ascii = ['\x00'-'\x7f']
-let ascii_no_nl = ['\x00'-'\x09''\x0b'-'\x7f']
+let ascii_no_nl = ascii # '\x0a'
 let utf8cont = ['\x80'-'\xbf']
 let utf8enc =
     ['\xc2'-'\xdf'] utf8cont
@@ -103,7 +104,7 @@ let name = idchar+
 let id = '$' name
 
 let keyword = ['a'-'z'] (letter | digit | '_' | '.' | ':')+
-let reserved = name | ',' | ';' | '[' | ']' | '{' | '}'
+let reserved = (idchar | string)+ | ',' | ';' | '[' | ']' | '{' | '}'
 
 let ixx = "i" ("32" | "64")
 let fxx = "f" ("32" | "64")
@@ -705,13 +706,14 @@ rule token = parse
   | eof { EOF }
 
   | reserved { unknown lexbuf }
-  | utf8 { error lexbuf "malformed operator" }
+  | control { error lexbuf "misplaced control character" }
+  | utf8enc { error lexbuf "misplaced unicode character" }
   | _ { error lexbuf "malformed UTF-8 encoding" }
 
 and comment start = parse
   | ";)" { () }
   | "(;" { comment (Lexing.lexeme_start_p lexbuf) lexbuf; comment start lexbuf }
   | '\n' { Lexing.new_line lexbuf; comment start lexbuf }
+  | utf8_no_nl { comment start lexbuf }
   | eof { error_nest start lexbuf "unclosed comment" }
-  | utf8 { comment start lexbuf }
   | _ { error lexbuf "malformed UTF-8 encoding" }
diff --git a/test/core/tokens.wast b/test/core/tokens.wast
new file mode 100644
index 000000000..4e785154e
--- /dev/null
+++ b/test/core/tokens.wast
@@ -0,0 +1,274 @@
+;; Tokens can be delimited by parentheses
+
+(module
+  (func(nop))
+)
+(module
+  (func (nop)nop)
+)
+(module
+  (func nop(nop))
+)
+(module
+  (func(nop)(nop))
+)
+(module
+  (func $f(nop))
+)
+(module
+  (func br 0(nop))
+)
+(module
+  (table 1 funcref)
+  (func)
+  (elem (i32.const 0)0)
+)
+(module
+  (table 1 funcref)
+  (func $f)
+  (elem (i32.const 0)$f)
+)
+(module
+  (memory 1)
+  (data (i32.const 0)"a")
+)
+(module
+  (import "spectest" "print"(func))
+)
+
+
+;; Tokens can be delimited by comments
+
+(module
+  (func;;bla
+  )
+)
+(module
+  (func (nop);;bla
+  )
+)
+(module
+  (func nop;;bla
+  )
+)
+(module
+  (func $f;;bla
+  )
+)
+(module
+  (func br 0;;bla
+  )
+)
+(module
+  (data "a";;bla
+  )
+)
+
+
+;; Space required between symbols and non-parenthesis tokens
+
+(module
+  (func (block $l (i32.const 0) (br_table 0 $l)))
+)
+(assert_malformed
+  (module quote
+    "(func (block $l (i32.const 0) (br_table 0$l)))"
+  )
+  "unknown operator"
+)
+
+(module
+  (func (block $l (i32.const 0) (br_table $l 0)))
+)
+(assert_malformed
+  (module quote
+    "(func (block $l (i32.const 0) (br_table $l0)))"
+  )
+  "unknown label"
+)
+
+(module
+  (func (block $l (i32.const 0) (br_table $l $l)))
+)
+(assert_malformed
+  (module quote
+    "(func (block $l (i32.const 0) (br_table $l$l)))"
+  )
+  "unknown label"
+)
+
+(module
+  (func (block $l0 (i32.const 0) (br_table $l0)))
+)
+(module
+  (func (block $l$l (i32.const 0) (br_table $l$l)))
+)
+
+
+;; Space required between strings and non-parenthesis tokens
+
+(module
+  (data "a")
+)
+(assert_malformed
+  (module quote
+    "(data\"a\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data $l "a")
+)
+(assert_malformed
+  (module quote
+    "(data $l\"a\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data $l " a")
+)
+(assert_malformed
+  (module quote
+    "(data $l\" a\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data $l "a ")
+)
+(assert_malformed
+  (module quote
+    "(data $l\"a \")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data $l "a " "b")
+)
+(assert_malformed
+  (module quote
+    "(data $l\"a \"\"b\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data $l "")
+)
+(assert_malformed
+  (module quote
+    "(data $l\"\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data $l " ")
+)
+(assert_malformed
+  (module quote
+    "(data $l\" \")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data $l " ")
+)
+(assert_malformed
+  (module quote
+    "(data $l\" \")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data "a" "b")
+)
+(assert_malformed
+  (module quote
+    "(data \"a\"\"b\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data "a" " b")
+)
+(assert_malformed
+  (module quote
+    "(data \"a\"\" b\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data "a " "b")
+)
+(assert_malformed
+  (module quote
+    "(data \"a \"\"b\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data "" "")
+)
+(assert_malformed
+  (module quote
+    "(data \"\"\"\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data "" " ")
+)
+(assert_malformed
+  (module quote
+    "(data \"\"\" \")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data " " "")
+)
+(assert_malformed
+  (module quote
+    "(data \" \"\"\")"
+  )
+  "unknown operator"
+)
+
+
+(assert_malformed
+  (module quote
+    "(func \"a\"x)"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(func \"a\"0)"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(func 0\"a\")"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(func \"a\"$x)"
+  )
+  "unknown operator"
+)

From d48af683f5e6d00c13f775ab07d29a15daf92203 Mon Sep 17 00:00:00 2001
From: cosine <CosineP@users.noreply.github.com>
Date: Mon, 11 Jul 2022 13:39:20 -0400
Subject: [PATCH 138/285] [test] Use still-illegal opcode (func-refs) (#1501)

---
 test/core/binary.wast | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/core/binary.wast b/test/core/binary.wast
index 891aad367..1b6b47129 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -1241,7 +1241,7 @@
   )                            ;; end
   "data count section required")
 
-;; passive element segment containing opcode other than ref.func or ref.null
+;; passive element segment containing illegal opcode
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
@@ -1258,7 +1258,7 @@
     "\09\07\01"                ;; Element section with one segment
     "\05\70"                   ;; Passive, funcref
     "\01"                      ;; 1 element
-    "\d3\00\0b"                ;; bad opcode, index 0, end
+    "\f3\00\0b"                ;; bad opcode, index 0, end
 
     "\0a\04\01"                ;; Code section
 

From 48bfb6d1076b92ec5c1bcc872bf6ac21f96e65ee Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Daniel=20Hillerstr=C3=B6m?= <daniel.hillerstrom@ed.ac.uk>
Date: Thu, 14 Jul 2022 19:11:02 +0100
Subject: [PATCH 139/285] Fix minor typos and consistency issues in the
 validation algorithm. (#61)

---
 document/core/appendix/algorithm.rst | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/document/core/appendix/algorithm.rst b/document/core/appendix/algorithm.rst
index fddc20e42..4ec2f99d6 100644
--- a/document/core/appendix/algorithm.rst
+++ b/document/core/appendix/algorithm.rst
@@ -34,11 +34,11 @@ Types are representable as a set of enumerations.
    func is_num(t : val_type) : bool =
      return t = I32 || t = I64 || t = F32 || t = F64 || t = Bot
 
-   func is_vec(t : val_type | Unknown) : bool =
-     return t = V128 || t = Unknown
+   func is_vec(t : val_type) : bool =
+     return t = V128 || t = Bot
 
-   func is_ref(t : val_type | Unknown) : bool =
-     return t = not (is_num t || is_vec t) || t = Bot
+   func is_ref(t : val_type) : bool =
+     return not (is_num t || is_vec t) || t = Bot
 
 Equivalence and subtyping checks can be defined on these types.
 
@@ -66,8 +66,8 @@ Equivalence and subtyping checks can be defined on these types.
 
    func matches(t1 : val_type, t2 : val_type) : bool =
      return
-       (is_num t1 && is_num t2 & t1 = t2) ||
-       (is_ref t1 && is_ref t2 & matches_ref(t1, t2)) ||
+       (is_num t1 && is_num t2 && t1 = t2) ||
+       (is_ref t1 && is_ref t2 && matches_ref(t1, t2)) ||
        t1 = Bot
 
 The algorithm uses two separate stacks: the *value stack* and the *control stack*.

From 7c9e3fb8c180579dc23baf54ce166ebad32cdaca Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 20 Jul 2022 09:59:09 +0200
Subject: [PATCH 140/285] Add definition of defaultable types (#62)

No rules for locals yet, since those are still being discussed.
---
 document/core/exec/runtime.rst  |  2 +-
 document/core/syntax/types.rst  |  1 +
 document/core/util/macros.def   |  4 +++
 document/core/valid/modules.rst |  4 ++-
 document/core/valid/types.rst   | 55 +++++++++++++++++++++++++++++++++
 5 files changed, 64 insertions(+), 2 deletions(-)

diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index 7e5c6fe93..50cb93e05 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -58,7 +58,7 @@ it is the respective value :math:`0` for :ref:`number types <syntax-numtype>`, :
    \begin{array}{lcl@{\qquad}l}
    \default_t &=& t{.}\CONST~0 & (\iff t = \numtype) \\
    \default_t &=& t{.}\CONST~0 & (\iff t = \vectype) \\
-   \default_t &=& \REFNULL~t & (\iff t = \reftype) \\
+   \default_t &=& \REFNULL~t & (\iff t = (\REF~\NULL~\heaptype)) \\
    \end{array}
 
 
diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index e675be3c7..bf264d39c 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -99,6 +99,7 @@ A *concrete* heap type consists of a :ref:`type index <syntax-typeidx>` and clas
    pair: abstract syntax; reference type
    pair: reference; type
 .. _syntax-reftype:
+.. _syntax-nullable:
 
 Reference Types
 ~~~~~~~~~~~~~~~
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index eb1e80936..3fb701f42 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -878,6 +878,7 @@
 .. Notation
 
 .. |ok| mathdef:: \mathrel{\mbox{ok}}
+.. |defaultable| mathdef:: \xref{valid/types}{valid-defaultable}{\mathrel{\mbox{defaultable}}}
 .. |const| mathdef:: \xref{valid/instructions}{valid-constant}{\mathrel{\mbox{const}}}
 
 .. |matchesnumtype| mathdef:: \xref{valid/matching}{match-numtype}{\leq}
@@ -924,6 +925,9 @@
 .. |vdashglobaltype| mathdef:: \xref{valid/types}{valid-globaltype}{\vdash}
 .. |vdashexterntype| mathdef:: \xref{valid/types}{valid-externtype}{\vdash}
 
+.. |vdashvaltypedefaultable| mathdef:: \xref{valid/types}{valid-defaultable}{\vdash}
+.. |vdashtabletypedefaultable| mathdef:: \xref{valid/types}{valid-defaultable}{\vdash}
+
 .. |vdashnumtypematch| mathdef:: \xref{valid/matching}{match-numtype}{\vdash}
 .. |vdashheaptypematch| mathdef:: \xref{valid/matching}{match-heaptype}{\vdash}
 .. |vdashreftypematch| mathdef:: \xref{valid/matching}{match-reftype}{\vdash}
diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index 51a71ef7f..efb9c4c1b 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -48,7 +48,7 @@ Functions :math:`\func` are classified by :ref:`function types <syntax-functype>
    }
 
 
-.. index:: table, table type
+.. index:: table, table type, defaultable
    pair: validation; table
    single: abstract syntax; table
 .. _valid-table:
@@ -68,6 +68,8 @@ Tables :math:`\table` are classified by :ref:`table types <syntax-tabletype>`.
 .. math::
    \frac{
      C \vdashtabletype \tabletype \ok
+     \qquad
+     C \vdashtabletypedefaultable \tabletype \defaultable
    }{
      C \vdashtable \{ \TTYPE~\tabletype \} : \tabletype
    }
diff --git a/document/core/valid/types.rst b/document/core/valid/types.rst
index 0b48eed46..562a60757 100644
--- a/document/core/valid/types.rst
+++ b/document/core/valid/types.rst
@@ -397,3 +397,58 @@ External Types
    }{
      C \vdashexterntype \ETGLOBAL~\globaltype \ok
    }
+
+
+.. index:: value type, ! defaultable, number type, vector type, reference type, table type
+.. _valid-defaultable:
+
+Defaultable Types
+~~~~~~~~~~~~~~~~~
+
+A type is *defaultable* if it has a :ref:`default value <default-val>` for initialization.
+
+Value Types
+...........
+
+* A defaultable :ref:`value type <syntax-valtype>` :math:`t` must be:
+
+  - either a :ref:`number type <syntax-numtype>`,
+
+  - or a :ref:`vector type <syntax-vectype>`,
+
+  - or a :ref:`nullable reference type <syntax-numtype>`.
+
+
+.. math::
+   \frac{
+   }{
+     C \vdashvaltypedefaultable \numtype \defaultable
+   }
+
+.. math::
+   \frac{
+   }{
+     C \vdashvaltypedefaultable \vectype \defaultable
+   }
+
+.. math::
+   \frac{
+   }{
+     C \vdashvaltypedefaultable (\REF~\NULL~\heaptype) \defaultable
+   }
+
+
+Table Types
+...........
+
+* A defaultable :ref:`table type <syntax-tabletype>` must be:
+
+  - of the form :math:`\limits~t`, where `t` is a :ref:`defaultable <valid-defaultable>` :ref:`reference type <syntax-numtype>`.
+
+
+.. math::
+   \frac{
+     C \vdashvaltypedefaultable \reftype \defaultable
+   }{
+     C \vdashtabletypedefaultable \limits~\reftype \defaultable
+   }

From b19633081e9030be288433a69002354b6d685648 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Fri, 22 Jul 2022 12:31:26 +0200
Subject: [PATCH 141/285] Remove func.bind (#64)

---
 interpreter/binary/decode.ml              |   3 +-
 interpreter/binary/encode.ml              |   1 -
 interpreter/exec/eval.ml                  |  19 +-
 interpreter/runtime/func.ml               |   3 -
 interpreter/runtime/func.mli              |   2 -
 interpreter/syntax/ast.ml                 |   1 -
 interpreter/syntax/free.ml                |   1 -
 interpreter/syntax/operators.ml           |   1 -
 interpreter/text/arrange.ml               |   1 -
 interpreter/text/lexer.mll                |   1 -
 interpreter/text/parser.mly               |   9 +-
 interpreter/valid/valid.ml                |  21 -
 proposals/function-references/Overview.md |  42 +-
 test/core/func_bind.wast                  | 552 ----------------------
 14 files changed, 5 insertions(+), 652 deletions(-)
 delete mode 100644 test/core/func_bind.wast

diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 2e66bfc8e..85ad9687d 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -320,7 +320,8 @@ let rec instr s =
 
   | 0x14 -> call_ref
   | 0x15 -> return_call_ref
-  | 0x16 -> func_bind (at var s)
+
+  | 0x16 as b -> illegal s pos b
 
   | 0x17 ->
     let bt = block_type s in
diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index 1553dc71c..4bfb59fb2 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -202,7 +202,6 @@ struct
     | CallRef -> op 0x14
     | CallIndirect (x, y) -> op 0x11; var y; var x
     | ReturnCallRef -> op 0x15
-    | FuncBind x -> op 0x16; var x
 
     | Drop -> op 0x1a
     | Select None -> op 0x1b
diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index 57a714d95..d92b25dd0 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -256,19 +256,6 @@ let rec step (c : config) : config =
         | _ -> assert false
         )
 
-      | FuncBind x, Ref (NullRef _) :: vs ->
-        vs, [Trapping "null function reference" @@ e.at]
-
-      | FuncBind x, Ref (FuncRef f) :: vs ->
-        let FuncType (ts, _) = Func.type_of f in
-        let FuncType (ts', _) = func_type c.frame.inst x in
-        let args, vs' =
-          try split (List.length ts - List.length ts') vs e.at
-          with Failure _ -> Crash.error e.at "type mismatch at function bind"
-        in
-        let f' = Func.alloc_closure (type_ c.frame.inst x) f args in
-        Ref (FuncRef f') :: vs', []
-
       | Drop, v :: vs' ->
         vs', []
 
@@ -738,9 +725,6 @@ let rec step (c : config) : config =
       | Func.HostFunc (_, f) ->
         (try List.rev (f (List.rev args)) @ vs', []
         with Crash (_, msg) -> Crash.error e.at msg)
-
-      | Func.ClosureFunc (_, f', args') ->
-        args @ args' @ vs', [Invoke f' @@ e.at]
       )
   in {c with code = vs', es' @ List.tl es}
 
@@ -759,10 +743,9 @@ let rec eval (c : config) : value stack =
 
 (* Functions & Constants *)
 
-let rec at_func = function
+let at_func = function
  | Func.AstFunc (_, _, f) -> f.at
  | Func.HostFunc _ -> no_region
- | Func.ClosureFunc (_, func, _) -> at_func func
 
 let invoke (func : func_inst) (vs : value list) : value list =
   let at = at_func func in
diff --git a/interpreter/runtime/func.ml b/interpreter/runtime/func.ml
index fbfadf8dd..929b0e5c0 100644
--- a/interpreter/runtime/func.ml
+++ b/interpreter/runtime/func.ml
@@ -5,15 +5,12 @@ type 'inst t = 'inst func
 and 'inst func =
   | AstFunc of sem_var * 'inst * Ast.func
   | HostFunc of sem_var * (value list -> value list)
-  | ClosureFunc of sem_var * 'inst func * value list
 
 let alloc x inst f = AstFunc (x, inst, f)
 let alloc_host x f = HostFunc (x, f)
-let alloc_closure x func vs = ClosureFunc (x, func, vs)
 
 let type_inst_of = function
   | AstFunc (x, _, _) -> x
   | HostFunc (x, _) -> x
-  | ClosureFunc (x, _, _) -> x
 
 let type_of f = as_func_def_type (def_of (type_inst_of f))
diff --git a/interpreter/runtime/func.mli b/interpreter/runtime/func.mli
index bb3b07018..982db2a0b 100644
--- a/interpreter/runtime/func.mli
+++ b/interpreter/runtime/func.mli
@@ -5,11 +5,9 @@ type 'inst t = 'inst func
 and 'inst func =
   | AstFunc of sem_var * 'inst * Ast.func
   | HostFunc of sem_var * (value list -> value list)
-  | ClosureFunc of sem_var * 'inst func * value list
 
 val alloc : sem_var -> 'inst -> Ast.func -> 'inst func
 val alloc_host : sem_var -> (value list -> value list) -> 'inst func
-val alloc_closure : sem_var -> 'inst func -> value list -> 'inst func
 
 val type_of : 'inst func -> func_type
 val type_inst_of : 'inst func -> sem_var
diff --git a/interpreter/syntax/ast.ml b/interpreter/syntax/ast.ml
index bba6d72c2..9552897d6 100644
--- a/interpreter/syntax/ast.ml
+++ b/interpreter/syntax/ast.ml
@@ -159,7 +159,6 @@ and instr' =
   | CallRef                           (* call function through reference *)
   | CallIndirect of idx * idx         (* call function through table *)
   | ReturnCallRef                     (* tail call through reference *)
-  | FuncBind of idx                   (* closure creation *)
   | LocalGet of idx                   (* read local idxiable *)
   | LocalSet of idx                   (* write local idxiable *)
   | LocalTee of idx                   (* write local idxiable and keep value *)
diff --git a/interpreter/syntax/free.ml b/interpreter/syntax/free.ml
index f597b28f2..cb8f2f654 100644
--- a/interpreter/syntax/free.ml
+++ b/interpreter/syntax/free.ml
@@ -116,7 +116,6 @@ let rec instr (e : instr) =
   | Return | CallRef | ReturnCallRef -> empty
   | Call x -> funcs (idx x)
   | CallIndirect (x, y) -> tables (idx x) ++ types (idx y)
-  | FuncBind x -> types (idx x)
   | LocalGet x | LocalSet x | LocalTee x -> locals (idx x)
   | GlobalGet x | GlobalSet x -> globals (idx x)
   | TableGet x | TableSet x | TableSize x | TableGrow x | TableFill x ->
diff --git a/interpreter/syntax/operators.ml b/interpreter/syntax/operators.ml
index bae67b076..de58f2eea 100644
--- a/interpreter/syntax/operators.ml
+++ b/interpreter/syntax/operators.ml
@@ -34,7 +34,6 @@ let call x = Call x
 let call_ref = CallRef
 let call_indirect x y = CallIndirect (x, y)
 let return_call_ref = ReturnCallRef
-let func_bind x = FuncBind x
 
 let local_get x = LocalGet x
 let local_set x = LocalSet x
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index 18a0a871b..2b02848e9 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -463,7 +463,6 @@ let rec instr e =
     | CallIndirect (x, y) ->
       "call_indirect " ^ var x, [Node ("type " ^ var y, [])]
     | ReturnCallRef -> "return_call_ref", []
-    | FuncBind x -> "func.bind", [Node ("type " ^ var x, [])]
     | LocalGet x -> "local.get " ^ var x, []
     | LocalSet x -> "local.set " ^ var x, []
     | LocalTee x -> "local.tee " ^ var x, []
diff --git a/interpreter/text/lexer.mll b/interpreter/text/lexer.mll
index 4678dd37a..ddf586f4d 100644
--- a/interpreter/text/lexer.mll
+++ b/interpreter/text/lexer.mll
@@ -173,7 +173,6 @@ rule token = parse
       | "call_ref" -> CALL_REF
       | "call_indirect" -> CALL_INDIRECT
       | "return_call_ref" -> RETURN_CALL_REF
-      | "func.bind" -> FUNC_BIND
 
       | "local.get" -> LOCAL_GET
       | "local.set" -> LOCAL_SET
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index c1feb01a0..a0ef1210c 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -243,7 +243,7 @@ let inline_func_type_explicit (c : context) x ft at =
 %token UNREACHABLE NOP DROP SELECT
 %token BLOCK END IF THEN ELSE LOOP LET
 %token BR BR_IF BR_TABLE BR_ON_NULL BR_ON_NON_NULL
-%token CALL CALL_REF CALL_INDIRECT RETURN RETURN_CALL_REF FUNC_BIND
+%token CALL CALL_REF CALL_INDIRECT RETURN RETURN_CALL_REF
 %token LOCAL_GET LOCAL_SET LOCAL_TEE GLOBAL_GET GLOBAL_SET
 %token TABLE_GET TABLE_SET
 %token TABLE_SIZE TABLE_GROW TABLE_FILL TABLE_COPY TABLE_INIT ELEM_DROP
@@ -550,8 +550,6 @@ call_instr :
     { let at = at () in fun c -> call_indirect ($2 c table) ($3 c) @@ at }
   | CALL_INDIRECT call_instr_type  /* Sugar */
     { let at = at () in fun c -> call_indirect (0l @@ at) ($2 c) @@ at }
-  | FUNC_BIND call_instr_type
-    { let at = at () in fun c -> func_bind ($2 c) @@ at }
 
 call_instr_type :
   | type_use call_instr_params
@@ -584,9 +582,6 @@ call_instr_instr :
   | CALL_INDIRECT call_instr_type_instr  /* Sugar */
     { let at1 = ati 1 in
       fun c -> let x, es = $2 c in call_indirect (0l @@ at1) x @@ at1, es }
-  | FUNC_BIND call_instr_type_instr
-    { let at1 = ati 1 in
-      fun c -> let x, es = $2 c in func_bind x @@ at1, es }
 
 call_instr_type_instr :
   | type_use call_instr_params_instr
@@ -724,8 +719,6 @@ expr1 :  /* Sugar */
   | CALL_INDIRECT call_expr_type  /* Sugar */
     { let at1 = ati 1 in
       fun c -> let x, es = $2 c in es, call_indirect (0l @@ at1) x }
-  | FUNC_BIND call_expr_type
-    { fun c -> let x, es = $2 c in es, func_bind x }
   | BLOCK labeling_opt block
     { fun c -> let c' = $2 c [] in let bt, es = $3 c' in [], block bt es }
   | LOOP labeling_opt block
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index 7bdad9c58..3f8fa53dd 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -143,7 +143,6 @@ type op_type = {ins : infer_result_type; outs : infer_result_type}
 
 let stack ts = (NoEllipses, ts)
 let (-->) ts1 ts2 = {ins = NoEllipses, ts1; outs = NoEllipses, ts2}
-let (-->..) ts1 ts2 = {ins = Ellipses, ts1; outs = NoEllipses, ts2}
 let (-->...) ts1 ts2 = {ins = Ellipses, ts1; outs = Ellipses, ts2}
 
 let check_stack (c : context) ts1 ts2 at =
@@ -431,26 +430,6 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : op_type
          " but stack has " ^ string_of_value_type (RefType rt))
     )
 
-  | FuncBind x ->
-    (match peek_ref 0 s e.at with
-    | (nul, DefHeapType (SynVar y)) ->
-      let FuncType (ts1, ts2) = func_type c (y @@ e.at) in
-      let FuncType (ts1', _) as ft' = func_type c x in
-      require (List.length ts1 >= List.length ts1') x.at
-        "type mismatch in function arguments";
-      let ts11, ts12 = Lib.List.split (List.length ts1 - List.length ts1') ts1 in
-      require (match_func_type c.types [] (FuncType (ts12, ts2)) ft') e.at
-        "type mismatch in function type";
-      (ts11 @ [RefType (nul, DefHeapType (SynVar y))]) -->
-        [RefType (NonNullable, DefHeapType (SynVar x.it))]
-    | (_, BotHeapType) as rt ->
-      [RefType rt] -->.. [RefType (NonNullable, DefHeapType (SynVar x.it))]
-    | rt ->
-      error e.at
-        ("type mismatch: instruction requires function reference type" ^
-         " but stack has " ^ string_of_value_type (RefType rt))
-    )
-
   | LocalGet x ->
     [] --> [local c x]
 
diff --git a/proposals/function-references/Overview.md b/proposals/function-references/Overview.md
index da019d1f4..5331d714c 100644
--- a/proposals/function-references/Overview.md
+++ b/proposals/function-references/Overview.md
@@ -10,10 +10,6 @@ The proposal has instructions for producing and consuming (calling) function ref
 
 Typed references have no canonical default value, because they cannot be null. To enable storing them in locals, which so far depend on default values for initialisation, the proposal also introduces a new instruction `let` for block-scoped locals whose initialisation values are taken from the operand stack.
 
-In addition to the above, we could also decide to include an instruction for forming a *closure* from a function reference, which takes a prefix of the function's arguments and returns a new function reference with those parameters bound. (Hence, conceptually, all function references would be closures of 0 or more parameters.)
-
-Note: In a Wasm engine, function references (whether first-class or as table entries) are already a form of closure since they must close over a specific module instance (its globals, tables, memory, etc) while their code is shared across multiple instances of the same module. It is hence expected that the ability to form language-level closures is not an observable extra cost.
-
 
 ### Motivation
 
@@ -23,8 +19,6 @@ Note: In a Wasm engine, function references (whether first-class or as table ent
 
 * Easier and more efficient exchange of function references between modules and with host environment
 
-* Optionally, support for safe closures
-
 * Separate independently useful features from [GC proposal](https://github.com/WebAssembly/gc/blob/master/proposals/gc/Overview.md)
 
 
@@ -42,8 +36,6 @@ Note: In a Wasm engine, function references (whether first-class or as table ent
 
 * Refine the instruction `ref.func $f` to return a typed function reference
 
-* Optionally add an instruction `func.bind` to create a closure
-
 * Add a block instruction `let (local t*) ... end` for introducing locals with block scope, in order to handle reference types without default initialisation values
 
 * Add an optional initialiser expression to table definitions, for element types that do not have an implicit default value.
@@ -68,36 +60,13 @@ The function `$hof` takes a function pointer as parameter, and is invoked by `$c
 )
 ```
 
-The function `$mk-adder` returns a closure of another function:
-```wasm
-(func $add (param i32 i32) (result i32) (i32.add (local.get 0) (local.get 1)))
-
-(func $mk-adder (param $i i32) (result (ref $i32-i32))
-  (func.bind $i32-i32 (local.get $i) (ref.func $add))
-)
-```
-
-The following function calls it and then applies the result twice:
-```wasm
-(func $main (result i32)
-  (call $mk-adder (i32.const 7))
-  (let (result i32) (local $f (ref $i32-i32))  ;; binds $f to top of stack
-    (i32.mul
-      (call_ref (i32.const 10) (local.get $f))
-      (call_ref (i32.const 12) (local.get $f))
-    )
-  )
-)
-```
-Note that we could not have used a function-level local for `$f` in this example, since the type `(ref $i32-i32)` is non-nullable and thus does not contain any default value to initialise the local with at the beginning of the function. By using `let` we can define a local that is initialised with values from the operand stack.
-
 It is also possible to create a typed function table:
 ```wasm
 (table 0 (ref $i32-i32))
 ```
 Such a table can neither contain `null` entries nor functions of another type. Any use of `call_indirect` on this table does hence avoid all runtime checks beyond the basic bounds check. By using multiple tables, each one can be given a homogeneous type. The table can be initialised by growing it (provding an explicit initialiser value. (Open Question: we could also extend table definitions to provide an explicit initialiser.)
 
-Typed references are a subtype of `funcref`, so they can also be used as untyped references. All previous uses of `ref.func` remain valid:
+Typed function references are a subtype of `funcref`, so they can also be used as untyped references. All previous uses of `ref.func` remain valid:
 ```wasm
 (func $f (param i32))
 (func $g)
@@ -219,14 +188,6 @@ The following rules, now defined in terms of heap types, replace and extend the
      - and `t2* <: C.result`
   - traps on `null`
 
-* Optional extension: `func.bind` creates or extends a closure by binding one or several parameters
-  - `func.bind $t' : [t0* (ref null $t)] -> [(ref $t')]`
-    - iff `$t = [t0* t1*] -> [t2*]`
-    - and `$t' = [t1'*] -> [t2'*]`
-    - and `t1'* <: t1*`
-    - and `t2* <: t2'*`
-  - traps on `null`
-
 
 #### Optional References
 
@@ -312,7 +273,6 @@ The opcode for heap types is encoded as an `s33`.
 | ------ | ------------------------ | ---------- |
 | 0x14   | `call_ref`               |            |
 | 0x15   | `return_call_ref`        |            |
-| 0x16   | `func.bind (type $t)`    | `$t : u32` |
 | 0x17   | `let <bt> <locals>`      | `bt : blocktype, locals : (as in functions)` |
 | 0xd3   | `ref.as_non_null`        |            |
 | 0xd4   | `br_on_null $l`          | `$l : u32` |
diff --git a/test/core/func_bind.wast b/test/core/func_bind.wast
deleted file mode 100644
index a0dd71419..000000000
--- a/test/core/func_bind.wast
+++ /dev/null
@@ -1,552 +0,0 @@
-(module
-  (type $unop (func (param i32) (result i32)))
-
-  (elem func $add)
-  (func $add (param i32 i32) (result i32) (i32.add (local.get 0) (local.get 1)))
-
-  (func $mk-adder (param $i i32) (result (ref $unop))
-    (func.bind (type $unop) (local.get $i) (ref.func $add))
-  )
-
-  (global $f (mut (ref null $unop)) (ref.null $unop))
-
-  (func (export "make") (param $i i32)
-    (global.set $f (call $mk-adder (local.get $i)))
-  )
-
-  (func (export "call") (param $j i32) (result i32)
-    (call_ref (local.get $j) (global.get $f))
-  )
-
-  (func (export "call2") (param $i i32) (param $j i32) (param $k i32) (result i32)
-    (local $f (ref null $unop))
-    (local.set $f (call $mk-adder (local.get $k)))
-
-    (i32.mul
-      (call_ref (local.get $i) (local.get $f))
-      (call_ref (local.get $j) (local.get $f))
-    )
-  )
-
-  (func (export "call3") (param $i i32) (param $j i32) (param $k i32) (result i32)
-
-    (i32.mul
-      (call_ref (local.get $i) (call $mk-adder (local.get $k)))
-      (call_ref (local.get $j) (call $mk-adder (local.get $k)))
-    )
-  )
-
-  (func (export "null") (result i32)
-    (func.bind (type $unop) (i32.const 1) (ref.null $unop))
-    (drop)
-  )
-)
-
-(assert_trap (invoke "call" (i32.const 0)) "null function")
-
-(assert_return (invoke "make" (i32.const 3)))
-(assert_return (invoke "call" (i32.const 2)) (i32.const 5))
-(assert_return (invoke "call" (i32.const 10)) (i32.const 13))
-
-(assert_return (invoke "make" (i32.const 0)))
-(assert_return (invoke "call" (i32.const 10)) (i32.const 10))
-
-(assert_return (invoke "make" (i32.const -3)))
-(assert_return (invoke "call" (i32.const 10)) (i32.const 7))
-
-(assert_return (invoke "call2" (i32.const 2) (i32.const 3) (i32.const 0)) (i32.const 6))
-(assert_return (invoke "call2" (i32.const 2) (i32.const 5) (i32.const 1)) (i32.const 18))
-(assert_return (invoke "call2" (i32.const 2) (i32.const 5) (i32.const 7)) (i32.const 108))
-
-(assert_return (invoke "call3" (i32.const 4) (i32.const 9) (i32.const 1)) (i32.const 50))
-(assert_return (invoke "call3" (i32.const 4) (i32.const 7) (i32.const 2)) (i32.const 54))
-(assert_return (invoke "call3" (i32.const 4) (i32.const 5) (i32.const 3)) (i32.const 56))
-
-(assert_trap (invoke "null") "null function")
-
-(module
-  (elem declare func $p $f)
-  (func $p (import "spectest" "print_f64_f64") (param f64 f64))
-  (func $f (param f64 f64 f64 f64) (result f64)
-    (f64.const 0)
-    (f64.add (f64.mul (local.get 0) (f64.const 1000)))
-    (f64.add (f64.mul (local.get 1) (f64.const 100)))
-    (f64.add (f64.mul (local.get 2) (f64.const 10)))
-    (f64.add (f64.mul (local.get 3) (f64.const 1)))
-  )
-
-  (type $p0 (func (param)))
-  (type $p1 (func (param f64)))
-  (type $p2 (func (param f64 f64)))
-  (type $f0 (func (param) (result f64)))
-  (type $f1 (func (param f64) (result f64)))
-  (type $f2 (func (param f64 f64) (result f64)))
-  (type $f3 (func (param f64 f64 f64) (result f64)))
-  (type $f4 (func (param f64 f64 f64 f64) (result f64)))
-
-  (table $tp 30 funcref)
-  (table $tf 50 funcref)
-
-  (func (export "call-p0") (param $i i32)
-    (call_indirect $tp (type $p0) (local.get $i))
-  )
-  (func (export "call-p1") (param $i i32) (param f64)
-    (call_indirect $tp (type $p1) (local.get 1) (local.get $i))
-  )
-  (func (export "call-p2") (param $i i32) (param f64 f64)
-    (call_indirect $tp (type $p2) (local.get 1) (local.get 2) (local.get $i))
-  )
-
-  (func (export "call-f0") (param $i i32) (result f64)
-    (call_indirect $tf (type $f0) (local.get $i))
-  )
-  (func (export "call-f1") (param $i i32) (param f64) (result f64)
-    (call_indirect $tf (type $f1) (local.get 1) (local.get $i))
-  )
-  (func (export "call-f2") (param $i i32) (param f64 f64) (result f64)
-    (call_indirect $tf (type $f2) (local.get 1) (local.get 2) (local.get $i))
-  )
-  (func (export "call-f3") (param $i i32) (param f64 f64 f64) (result f64)
-    (call_indirect $tf (type $f3) (local.get 1) (local.get 2) (local.get 3) (local.get $i))
-  )
-  (func (export "call-f4") (param $i i32) (param f64 f64 f64 f64) (result f64)
-    (call_indirect $tf (type $f4) (local.get 1) (local.get 2) (local.get 3) (local.get 4) (local.get $i))
-  )
-
-  (func (export "init")
-    ;; Host closures with arity 2
-    (table.set $tp (i32.const 20)
-      (ref.func $p)
-    )
-    (table.set $tp (i32.const 21)
-      (func.bind (type $p2)
-        (ref.func $p))
-    )
-
-    ;; Host closures with arity 1
-    (table.set $tp (i32.const 10)
-      (func.bind (type $p1) (f64.const 1)
-        (ref.func $p))
-    )
-    (table.set $tp (i32.const 11)
-      (func.bind (type $p1) (f64.const 1)
-        (func.bind (type $p2)
-          (ref.func $p)))
-    )
-    (table.set $tp (i32.const 12)
-      (func.bind (type $p1)
-        (func.bind (type $p1) (f64.const 1)
-          (func.bind (type $p2)
-            (ref.func $p))))
-    )
-
-    ;; Host closures with arity 0
-    (table.set $tp (i32.const 00)
-      (func.bind (type $p0) (f64.const 1) (f64.const 2)
-        (ref.func $p))
-    )
-    (table.set $tp (i32.const 01)
-      (func.bind (type $p0) (f64.const 2)
-       (func.bind (type $p1) (f64.const 1)
-         (ref.func $p)))
-    )
-    (table.set $tp (i32.const 02)
-      (func.bind (type $p0)
-        (func.bind (type $p0) (f64.const 2)
-          (func.bind (type $p1)
-            (func.bind (type $p1) (f64.const 1)
-              (func.bind (type $p2)
-                (func.bind (type $p2)
-                  (ref.func $p)))))))
-    )
-
-    ;; Wasm closures with arity 4
-    (table.set $tf (i32.const 40)
-      (ref.func $f)
-    )
-    (table.set $tf (i32.const 41)
-      (func.bind (type $f4)
-        (ref.func $f))
-    )
-
-    ;; Wasm closures with arity 3
-    (table.set $tf (i32.const 30)
-      (func.bind (type $f3) (f64.const 1)
-        (ref.func $f))
-    )
-    (table.set $tf (i32.const 31)
-      (func.bind (type $f3) (f64.const 1)
-        (func.bind (type $f4)
-          (ref.func $f)))
-    )
-    (table.set $tf (i32.const 32)
-      (func.bind (type $f3)
-        (func.bind (type $f3) (f64.const 1)
-          (func.bind (type $f4)
-            (ref.func $f))))
-    )
-
-    ;; Wasm closures with arity 2
-    (table.set $tf (i32.const 20)
-      (func.bind (type $f2) (f64.const 1) (f64.const 2)
-        (ref.func $f))
-    )
-    (table.set $tf (i32.const 21)
-      (func.bind (type $f2) (f64.const 2)
-        (func.bind (type $f3) (f64.const 1)
-          (ref.func $f)))
-    )
-    (table.set $tf (i32.const 22)
-      (func.bind (type $f2)
-        (func.bind (type $f2) (f64.const 2)
-          (func.bind (type $f3)
-            (func.bind (type $f3) (f64.const 1)
-              (func.bind (type $f4)
-                (func.bind (type $f4)
-                  (ref.func $f)))))))
-    )
-
-    ;; Wasm closures with arity 1
-    (table.set $tf (i32.const 10)
-      (func.bind (type $f1) (f64.const 1) (f64.const 2) (f64.const 3)
-        (ref.func $f))
-    )
-    (table.set $tf (i32.const 11)
-      (func.bind (type $f1) (f64.const 2) (f64.const 3)
-        (func.bind (type $f3) (f64.const 1)
-          (ref.func $f)))
-    )
-    (table.set $tf (i32.const 12)
-      (func.bind (type $f1) (f64.const 3)
-        (func.bind (type $f2) (f64.const 1) (f64.const 2)
-          (ref.func $f)))
-    )
-    (table.set $tf (i32.const 13)
-      (func.bind (type $f1) (f64.const 3)
-        (func.bind (type $f2) (f64.const 2)
-          (func.bind (type $f3) (f64.const 1)
-            (ref.func $f))))
-    )
-    (table.set $tf (i32.const 14)
-      (func.bind (type $f1)
-        (func.bind (type $f1)
-          (func.bind (type $f1) (f64.const 3)
-            (func.bind (type $f2)
-              (func.bind (type $f2)
-                (func.bind (type $f2) (f64.const 2)
-                  (func.bind (type $f3)
-                    (func.bind (type $f3)
-                      (func.bind (type $f3) (f64.const 1)
-                        (func.bind (type $f4)
-                          (func.bind (type $f4)
-                            (ref.func $f))))))))))))
-    )
-
-    ;; Wasm closures with arity 0
-    (table.set $tf (i32.const 00)
-      (func.bind (type $f0) (f64.const 1) (f64.const 2) (f64.const 3) (f64.const 4)
-        (ref.func $f))
-    )
-    (table.set $tf (i32.const 01)
-      (func.bind (type $f0) (f64.const 2) (f64.const 3) (f64.const 4)
-        (func.bind (type $f3) (f64.const 1)
-          (ref.func $f)))
-    )
-    (table.set $tf (i32.const 02)
-      (func.bind (type $f0) (f64.const 3) (f64.const 4)
-        (func.bind (type $f2) (f64.const 1) (f64.const 2)
-          (ref.func $f)))
-    )
-    (table.set $tf (i32.const 03)
-      (func.bind (type $f0) (f64.const 4)
-        (func.bind (type $f1) (f64.const 1) (f64.const 2) (f64.const 3)
-          (ref.func $f)))
-    )
-    (table.set $tf (i32.const 04)
-      (func.bind (type $f0) (f64.const 3) (f64.const 4)
-        (func.bind (type $f2) (f64.const 2)
-          (func.bind (type $f3) (f64.const 1)
-            (ref.func $f))))
-    )
-    (table.set $tf (i32.const 05)
-      (func.bind (type $f0) (f64.const 4)
-        (func.bind (type $f1) (f64.const 2) (f64.const 3)
-          (func.bind (type $f3) (f64.const 1)
-            (ref.func $f))))
-    )
-    (table.set $tf (i32.const 06)
-      (func.bind (type $f0) (f64.const 4)
-        (func.bind (type $f1) (f64.const 3)
-          (func.bind (type $f2) (f64.const 1) (f64.const 2)
-            (ref.func $f))))
-    )
-    (table.set $tf (i32.const 07)
-      (func.bind (type $f0) (f64.const 4)
-        (func.bind (type $f1) (f64.const 3)
-          (func.bind (type $f2) (f64.const 2)
-            (func.bind (type $f3) (f64.const 1)
-              (func.bind (type $f4)
-                (ref.func $f))))))
-    )
-    (table.set $tf (i32.const 08)
-      (func.bind (type $f0)
-        (func.bind (type $f0)
-          (func.bind (type $f0) (f64.const 4)
-            (func.bind (type $f1)
-              (func.bind (type $f1)
-                (func.bind (type $f1) (f64.const 2) (f64.const 3)
-                  (func.bind (type $f3)
-                    (func.bind (type $f3)
-                      (func.bind (type $f3) (f64.const 1)
-                        (func.bind (type $f4)
-                          (func.bind (type $f4)
-                            (ref.func $f))))))))))))
-    )
-  )
-)
-
-(invoke "init")
-
-(assert_return (invoke "call-p0" (i32.const 00)))
-(assert_return (invoke "call-p0" (i32.const 01)))
-(assert_return (invoke "call-p0" (i32.const 02)))
-(assert_return (invoke "call-p1" (i32.const 10) (f64.const 2)))
-(assert_return (invoke "call-p1" (i32.const 11) (f64.const 2)))
-(assert_return (invoke "call-p1" (i32.const 12) (f64.const 2)))
-(assert_return (invoke "call-p2" (i32.const 20) (f64.const 1) (f64.const 2)))
-(assert_return (invoke "call-p2" (i32.const 21) (f64.const 1) (f64.const 2)))
-
-(assert_return (invoke "call-f0" (i32.const 00)) (f64.const 1234))
-(assert_return (invoke "call-f0" (i32.const 01)) (f64.const 1234))
-(assert_return (invoke "call-f0" (i32.const 02)) (f64.const 1234))
-(assert_return (invoke "call-f0" (i32.const 03)) (f64.const 1234))
-(assert_return (invoke "call-f0" (i32.const 04)) (f64.const 1234))
-(assert_return (invoke "call-f0" (i32.const 05)) (f64.const 1234))
-(assert_return (invoke "call-f0" (i32.const 06)) (f64.const 1234))
-(assert_return (invoke "call-f0" (i32.const 07)) (f64.const 1234))
-(assert_return (invoke "call-f0" (i32.const 08)) (f64.const 1234))
-(assert_return (invoke "call-f1" (i32.const 10) (f64.const 4)) (f64.const 1234))
-(assert_return (invoke "call-f1" (i32.const 11) (f64.const 4)) (f64.const 1234))
-(assert_return (invoke "call-f1" (i32.const 12) (f64.const 4)) (f64.const 1234))
-(assert_return (invoke "call-f1" (i32.const 13) (f64.const 4)) (f64.const 1234))
-(assert_return (invoke "call-f1" (i32.const 14) (f64.const 4)) (f64.const 1234))
-(assert_return (invoke "call-f2" (i32.const 20) (f64.const 3) (f64.const 4)) (f64.const 1234))
-(assert_return (invoke "call-f2" (i32.const 21) (f64.const 3) (f64.const 4)) (f64.const 1234))
-(assert_return (invoke "call-f2" (i32.const 22) (f64.const 3) (f64.const 4)) (f64.const 1234))
-(assert_return (invoke "call-f3" (i32.const 30) (f64.const 2) (f64.const 3) (f64.const 4)) (f64.const 1234))
-(assert_return (invoke "call-f3" (i32.const 31) (f64.const 2) (f64.const 3) (f64.const 4)) (f64.const 1234))
-(assert_return (invoke "call-f3" (i32.const 32) (f64.const 2) (f64.const 3) (f64.const 4)) (f64.const 1234))
-(assert_return (invoke "call-f4" (i32.const 40) (f64.const 1) (f64.const 2) (f64.const 3) (f64.const 4)) (f64.const 1234))
-(assert_return (invoke "call-f4" (i32.const 41) (f64.const 1) (f64.const 2) (f64.const 3) (f64.const 4)) (f64.const 1234))
-
-
-(; Once we allow subtyping on function types:
-;; The runtime type of a closure is its internal one,
-;; not the static bind annotation.
-(module
-  (type $ii (func (param i32) (result i32)))
-  (type $fl (func (param i32 anyref) (result (ref null $ii))))
-  (type $fu (func (param i32 (ref $ii)) (result anyref)))
-  (type $fl' (func (param anyref) (result (ref null $ii))))
-  (type $fu' (func (param (ref $ii)) (result anyref)))
-
-  (elem declare func $sqr $f)
-  (func $sqr (param i32) (result i32) (i32.mul (local.get 0) (local.get 0)))
-  (func $f (type $fl) (ref.func $sqr))
-
-  (table $t 10 funcref)
-
-  (func (export "run") (result i32)
-    (table.set $t (i32.const 0) (func.bind (type $fu) (ref.func $f)))
-    (table.set $t (i32.const 1) (func.bind (type $fu') (i32.const 0) (ref.func $f)))
-
-    (i32.add
-      (call_ref (i32.const 2)
-        (call_indirect $t (type $fl) (i32.const 0) (ref.null $fl) (i32.const 0))
-      )
-      (call_ref (i32.const 3)
-        (call_indirect $t (type $fl') (ref.null $fl') (i32.const 1))
-      )
-    )
-  )
-)
-
-(assert_return (invoke "run") (i32.const 13))
-;)
-
-(; Instead, for now: ;)
-(assert_invalid
-  (module
-    (type $ii (func (param i32) (result i32)))
-    (type $fl (func (param i32 funcref) (result (ref null $ii))))
-    (type $fu (func (param i32 (ref $ii)) (result funcref)))
-
-    (elem declare func $sqr $f)
-    (func $sqr (param i32) (result i32) (i32.mul (local.get 0) (local.get 0)))
-    (func $f (type $fl) (ref.func $sqr))
-
-    (func (drop (func.bind (type $fu) (ref.func $f))))
-  )
-  "type mismatch"
-)
-
-(assert_invalid
-  (module
-    (type $ii (func (param i32) (result i32)))
-    (type $fl (func (param i32 funcref) (result (ref null $ii))))
-    (type $fu' (func (param (ref $ii)) (result funcref)))
-
-    (elem declare func $sqr $f)
-    (func $sqr (param i32) (result i32) (i32.mul (local.get 0) (local.get 0)))
-    (func $f (type $fl) (ref.func $sqr))
-
-    (func (drop (func.bind (type $fu') (i32.const 0) (ref.func $f))))
-  )
-  "type mismatch"
-)
-
-
-;; Null and unreachable typing.
-
-(module
-  (type $t (func))
-  (func (export "null") (result (ref $t))
-    (ref.null $t)
-    (func.bind)
-  )
-)
-(assert_trap (invoke "null") "null function")
-
-(module
-  (type $t (func (param f32)))
-  (func (export "null") (result (ref $t))
-    (ref.null $t)
-    (func.bind (type $t))
-  )
-)
-(assert_trap (invoke "null") "null function")
-
-(module
-  (type $t0 (func))
-  (type $t1 (func (param i64)))
-  (func (export "null") (result (ref $t0))
-    (i64.const 0)
-    (ref.null $t1)
-    (func.bind)
-  )
-)
-(assert_trap (invoke "null") "null function")
-
-(module
-  (type $t0 (func))
-  (type $t1 (func (param i64)))
-  (func (export "null") (result (ref $t0))
-    (i64.const 0)
-    (ref.null $t1)
-    (func.bind (type $t0))
-  )
-)
-(assert_trap (invoke "null") "null function")
-
-(assert_invalid
-  (module
-    (type $t (func (result f32)))
-    (func (export "null") (result i32)
-      (ref.null $t)
-      (func.bind)
-    )
-  )
-  "type mismatch"
-)
-
-
-(module
-  (type $t (func (param f32)))
-  (func (export "unreachable") (result (ref $t))
-    (unreachable)
-    (func.bind (type $t))
-  )
-)
-(assert_trap (invoke "unreachable") "unreachable")
-
-(module
-  (type $t (func (param f32) (result i32)))
-  (elem declare func $f)
-  (func $f (param i32 f32) (result i32) (local.get 0))
-
-  (func (export "unreachable") (result (ref $t))
-    (unreachable)
-    (ref.func $f)
-    (func.bind (type $t))
-  )
-)
-(assert_trap (invoke "unreachable") "unreachable")
-
-(assert_invalid
-  (module
-    (type $t (func (param f32)))
-    (elem declare func $f)
-    (func $f (param i32 f32) (result i32) (local.get 0))
-
-    (func (export "unreachable") (result (ref $t))
-      (unreachable)
-      (i64.const 0)
-      (ref.func $f)
-      (func.bind (type $t))
-    )
-  )
-  "type mismatch"
-)
-
-(assert_invalid
-  (module
-    (type $t (func))
-    (elem declare func $f)
-    (func $f (param i32) (result i32) (local.get 0))
-
-    (func (export "unreachable") (result (ref $t))
-      (unreachable)
-      (ref.func $f)
-      (func.bind (type $t))
-      (drop)
-      (i64.const 0)
-    )
-  )
-  "type mismatch"
-)
-
-(assert_invalid
-  (module
-    (func (export "null") (result i32)
-      (unreachable)
-      (func.bind)
-    )
-  )
-  "type mismatch"
-)
-
-(assert_invalid
-  (module
-    (type $t (func (param f32)))
-    (elem declare func $f)
-    (func $f (param i32 i32) (result i32) (local.get 0))
-
-    (func (export "unreachable") (result (ref $t))
-      (unreachable)
-      (ref.func $f)
-      (func.bind (type $t))
-    )
-  )
-  "type mismatch"
-)
-
-(assert_invalid
-  (module
-    (type $t (func))
-    (func $f (param $r externref)
-      (func.bind (type $t) (local.get $r))
-      (drop)
-    )
-  )
-  "type mismatch"
-)

From 1efa4d645f5a5be130050e4a093c6681fec7bb1f Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Sat, 23 Jul 2022 00:48:01 +0200
Subject: [PATCH 142/285] Implement 1a (#63)

---
 interpreter/binary/decode.ml              |   9 +-
 interpreter/binary/encode.ml              |   2 -
 interpreter/exec/eval.ml                  |  52 ++----
 interpreter/host/spectest.ml              |   4 +-
 interpreter/runtime/value.ml              |  20 +--
 interpreter/syntax/ast.ml                 |   1 -
 interpreter/syntax/free.ml                |   3 -
 interpreter/syntax/operators.ml           |   1 -
 interpreter/syntax/types.ml               |  13 +-
 interpreter/text/arrange.ml               |   3 -
 interpreter/text/parser.mly               |  83 +--------
 interpreter/util/lib.ml                   |   6 +
 interpreter/util/lib.mli                  |   1 +
 interpreter/valid/valid.ml                | 199 +++++++++++-----------
 proposals/function-references/Overview.md |  81 ++++++---
 test/core/func.wast                       |  51 +++---
 test/core/local_get.wast                  |  41 ++++-
 17 files changed, 290 insertions(+), 280 deletions(-)

diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 85ad9687d..4af123201 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -323,14 +323,7 @@ let rec instr s =
 
   | 0x16 as b -> illegal s pos b
 
-  | 0x17 ->
-    let bt = block_type s in
-    let locs = locals s in
-    let es = instr_block s in
-    end_ s;
-    let_ bt locs es
-
-  | 0x18 | 0x19 as b -> illegal s pos b
+  | 0x17 | 0x18 | 0x19 as b -> illegal s pos b
 
   | 0x1a -> drop
   | 0x1b -> select None
diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index 4bfb59fb2..5cab624d9 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -189,8 +189,6 @@ struct
       op 0x04; block_type bt; list instr es1;
       if es2 <> [] then op 0x05;
       list instr es2; end_ ()
-    | Let (bt, locs, es) ->
-      op 0x17; block_type bt; locals locs; list instr es; end_ ()
 
     | Br x -> op 0x0c; var x
     | BrIf x -> op 0x0d; var x
diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index d92b25dd0..19074de0b 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -49,7 +49,7 @@ type 'a stack = 'a list
 type frame =
 {
   inst : module_inst;
-  locals : value ref list;
+  locals : value option ref list;
 }
 
 type code = value stack * admin_instr list
@@ -64,7 +64,6 @@ and admin_instr' =
   | ReturningInvoke of value stack * func_inst
   | Breaking of int32 * value stack
   | Label of int * instr list * code
-  | Local of int * value list * code
   | Frame of int * frame * code
 
 type config =
@@ -74,8 +73,8 @@ type config =
   budget : int;  (* to model stack overflow *)
 }
 
-let frame inst = {inst; locals = []}
-let config inst vs es = {frame = frame inst; code = vs, es; budget = 300}
+let frame inst locals = {inst; locals}
+let config inst vs es = {frame = frame inst []; code = vs, es; budget = 300}
 
 let plain e = Plain e.it @@ e.at
 
@@ -184,16 +183,6 @@ let rec step (c : config) : config =
         else
           vs', [Plain (Block (bt, es1)) @@ e.at]
 
-      | Let (bt, locals, es'), vs ->
-        let vs0, vs' = split (List.length locals) vs e.at in
-        let FuncType (ts1, ts2) = block_type c.frame.inst bt e.at in
-        let vs1, vs2 = split (List.length ts1) vs' e.at in
-        vs2, [
-          Local (List.length ts2, List.rev vs0,
-            (vs1, [Plain (Block (bt, es')) @@ e.at])
-          ) @@ e.at
-        ]
-
       | Br x, vs ->
         [], [Breaking (x.it, vs) @@ e.at]
 
@@ -266,14 +255,19 @@ let rec step (c : config) : config =
           v1 :: vs', []
 
       | LocalGet x, vs ->
-        !(local c.frame x) :: vs, []
+        (match !(local c.frame x) with
+        | Some v ->
+          v :: vs, []
+        | None ->
+          Crash.error e.at "read of uninitialized local"
+        )
 
       | LocalSet x, v :: vs' ->
-        local c.frame x := v;
+        local c.frame x := Some v;
         vs', []
 
       | LocalTee x, v :: vs' ->
-        local c.frame x := v;
+        local c.frame x := Some v;
         v :: vs', []
 
       | GlobalGet x, vs ->
@@ -676,18 +670,6 @@ let rec step (c : config) : config =
       let c' = step {c with code = code'} in
       vs, [Label (n, es0, c'.code) @@ e.at]
 
-    | Local (n, vs0, (vs', [])), vs ->
-      vs' @ vs, []
-
-    | Local (n, vs0, (vs', e' :: es')), vs when is_jumping e' ->
-      vs' @ vs, [e']
-
-    | Local (n, vs0, code'), vs ->
-      let frame' = {c.frame with locals = List.map ref vs0 @ c.frame.locals} in
-      let c' = step {c with frame = frame'; code = code'} in
-      let vs0' = List.map (!) (take (List.length vs0) c'.frame.locals e.at) in
-      vs, [Local (n, vs0', c'.code) @@ e.at]
-
     | Frame (n, frame', (vs', [])), vs ->
       vs' @ vs, []
 
@@ -710,17 +692,17 @@ let rec step (c : config) : config =
 
     | Invoke f, vs ->
       let FuncType (ts1, ts2) = Func.type_of f in
-      let args, vs' = split (List.length ts1) vs e.at in
+      let n1, n2 = List.length ts1, List.length ts2 in
+      let args, vs' = split n1 vs e.at in
       (match f with
       | Func.AstFunc (_, inst', func) ->
         let {locals; body; _} = func.it in
         let m = Lib.Promise.value inst' in
         let ts = List.map (fun t -> Types.sem_value_type m.types t.it) locals in
-        let vs0 = List.rev args @ List.map default_value ts in
-        let locals' = List.map (fun t -> t @@ func.at) ts1 @ locals in
-        let bt = VarBlockType (SemVar (alloc (FuncDefType (FuncType ([], ts2))))) in
-        let es0 = [Plain (Let (bt, locals', body)) @@ func.at] in
-        vs', [Frame (List.length ts2, frame m, (List.rev vs0, es0)) @@ e.at]
+        let locals' = List.(rev (map Option.some args) @ map default_value ts) in
+        let frame' = {inst = m; locals = List.map ref locals'} in
+        let instr' = [Label (n2, [], ([], List.map plain body)) @@ func.at] in
+        vs', [Frame (n2, frame', ([], instr')) @@ e.at]
 
       | Func.HostFunc (_, f) ->
         (try List.rev (f (List.rev args)) @ vs', []
diff --git a/interpreter/host/spectest.ml b/interpreter/host/spectest.ml
index 309fa3d16..c76317bb0 100644
--- a/interpreter/host/spectest.ml
+++ b/interpreter/host/spectest.ml
@@ -29,10 +29,10 @@ let print_value v =
   Printf.printf "%s : %s\n"
     (string_of_value v) (string_of_value_type (type_of_value v))
 
-let print (FuncType (_, out)) vs =
+let print _ vs =
   List.iter print_value vs;
   flush_all ();
-  List.map default_value out
+  []
 
 
 let lookup name t =
diff --git a/interpreter/runtime/value.ml b/interpreter/runtime/value.ml
index 48fe64639..e323a1cec 100644
--- a/interpreter/runtime/value.ml
+++ b/interpreter/runtime/value.ml
@@ -133,22 +133,22 @@ let eq v1 v2 =
 (* Defaults *)
 
 let default_num = function
-  | I32Type -> I32 I32.zero
-  | I64Type -> I64 I64.zero
-  | F32Type -> F32 F32.zero
-  | F64Type -> F64 F64.zero
+  | I32Type -> Some (Num (I32 I32.zero))
+  | I64Type -> Some (Num (I64 I64.zero))
+  | F32Type -> Some (Num (F32 F32.zero))
+  | F64Type -> Some (Num (F64 F64.zero))
 
 let default_vec = function
-  | V128Type -> V128 V128.zero
+  | V128Type -> Some (Vec (V128 V128.zero))
 
 let default_ref = function
-  | (Nullable, t) -> NullRef t
-  | (NonNullable, _) -> assert false
+  | (Nullable, t) -> Some (Ref (NullRef t))
+  | (NonNullable, _) -> None
 
 let default_value = function
-  | NumType t' -> Num (default_num t')
-  | VecType t' -> Vec (default_vec t')
-  | RefType t' -> Ref (default_ref t')
+  | NumType t' -> default_num t'
+  | VecType t' -> default_vec t'
+  | RefType t' -> default_ref t'
   | BotType -> assert false
 
 
diff --git a/interpreter/syntax/ast.ml b/interpreter/syntax/ast.ml
index 9552897d6..9503b010d 100644
--- a/interpreter/syntax/ast.ml
+++ b/interpreter/syntax/ast.ml
@@ -148,7 +148,6 @@ and instr' =
   | Block of block_type * instr list  (* execute in sequence *)
   | Loop of block_type * instr list   (* loop header *)
   | If of block_type * instr list * instr list   (* conditional *)
-  | Let of block_type * local list * instr list  (* local bindings *)
   | Br of idx                         (* break to n-th surrounding label *)
   | BrIf of idx                       (* conditional break *)
   | BrTable of idx list * idx         (* indexed break *)
diff --git a/interpreter/syntax/free.ml b/interpreter/syntax/free.ml
index cb8f2f654..66b8b7898 100644
--- a/interpreter/syntax/free.ml
+++ b/interpreter/syntax/free.ml
@@ -108,9 +108,6 @@ let rec instr (e : instr) =
   | Const _ | Test _ | Compare _ | Unary _ | Binary _ | Convert _ -> empty
   | Block (bt, es) | Loop (bt, es) -> block_type bt ++ block es
   | If (bt, es1, es2) -> block_type bt ++ block es1 ++ block es2
-  | Let (bt, ts, es) ->
-    let free = block_type bt ++ block es in
-    {free with locals = Lib.Fun.repeat (List.length ts) shift free.locals}
   | Br x | BrIf x | BrOnNull x | BrOnNonNull x -> labels (idx x)
   | BrTable (xs, x) -> list (fun x -> labels (idx x)) (x::xs)
   | Return | CallRef | ReturnCallRef -> empty
diff --git a/interpreter/syntax/operators.ml b/interpreter/syntax/operators.ml
index de58f2eea..04464e5b1 100644
--- a/interpreter/syntax/operators.ml
+++ b/interpreter/syntax/operators.ml
@@ -21,7 +21,6 @@ let select t = Select t
 let block bt es = Block (bt, es)
 let loop bt es = Loop (bt, es)
 let if_ bt es1 es2 = If (bt, es1, es2)
-let let_ bt ts es = Let (bt, ts, es)
 
 let br x = Br x
 let br_if x = BrIf x
diff --git a/interpreter/syntax/types.ml b/interpreter/syntax/types.ml
index 3e6c93b45..b9766b984 100644
--- a/interpreter/syntax/types.ml
+++ b/interpreter/syntax/types.ml
@@ -1,11 +1,14 @@
 (* Types *)
 
-type name = int list
+type type_idx = int32
+type local_idx = int32
+type name = Utf8.unicode
 
-and syn_var = int32
+and syn_var = type_idx
 and sem_var = def_type Lib.Promise.t
 and var = SynVar of syn_var | SemVar of sem_var
 
+and init = Initialized | Uninitialized
 and nullability = NonNullable | Nullable
 and num_type = I32Type | I64Type | F32Type | F64Type
 and vec_type = V128Type
@@ -16,6 +19,7 @@ and value_type =
   NumType of num_type | VecType of vec_type | RefType of ref_type | BotType
 
 and result_type = value_type list
+and instr_type = result_type * result_type * local_idx list
 and func_type = FuncType of result_type * result_type
 and def_type = FuncDefType of func_type
 
@@ -24,6 +28,7 @@ type mutability = Immutable | Mutable
 type table_type = TableType of Int32.t limits * ref_type
 type memory_type = MemoryType of Int32.t limits
 type global_type = GlobalType of value_type * mutability
+type local_type = LocalType of value_type * init
 type extern_type =
   | ExternFuncType of func_type
   | ExternTableType of table_type
@@ -207,10 +212,12 @@ let string_of_name n =
   List.iter escape n;
   Buffer.contents b
 
+let string_of_idx x = I32.to_string_u x
+
 let rec string_of_var =
   let inner = ref false in
   function
-  | SynVar x -> I32.to_string_u x
+  | SynVar x -> string_of_idx x
   | SemVar x ->
     if !inner then "..." else
     ( inner := true;
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index 2b02848e9..e1a40e438 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -448,9 +448,6 @@ let rec instr e =
     | If (bt, es1, es2) ->
       "if", block_type bt @
         [Node ("then", list instr es1); Node ("else", list instr es2)]
-    | Let (bt, locals, es) ->
-      "let", block_type bt @ decls "local" (List.map Source.it locals) @
-        list instr es
     | Br x -> "br " ^ var x, []
     | BrIf x -> "br_if " ^ var x, []
     | BrTable (xs, x) ->
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index a0ef1210c..2aeb0ac1d 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -142,19 +142,6 @@ let force_locals (c : context) =
   List.fold_right Stdlib.(@@) !(c.deferred_locals) ();
   c.deferred_locals := []
 
-let merge_locals (c : context) (c' : context) at =
-  force_locals c';  (* check that there aren't too many locals locally *)
-  if VarMap.is_empty c'.locals.map then
-    defer_locals c (fun () -> bind "local" c.locals c'.locals.count at)
-  else
-  (
-    force_locals c;
-    let n = c.locals.count in
-    ignore (bind "local" c.locals c'.locals.count at);
-    c.locals.map <- VarMap.union (fun x i1 i2 -> Some i1)
-      c.locals.map (scoped "local" n c'.locals at).map
-  )
-
 
 let lookup category space x =
   try VarMap.find x.it space.map
@@ -241,7 +228,7 @@ let inline_func_type_explicit (c : context) x ft at =
 %token NAT INT FLOAT STRING VAR
 %token NUM_TYPE VEC_TYPE VEC_SHAPE FUNCREF EXTERNREF REF EXTERN NULL MUT
 %token UNREACHABLE NOP DROP SELECT
-%token BLOCK END IF THEN ELSE LOOP LET
+%token BLOCK END IF THEN ELSE LOOP
 %token BR BR_IF BR_TABLE BR_ON_NULL BR_ON_NON_NULL
 %token CALL CALL_REF CALL_INDIRECT RETURN RETURN_CALL_REF
 %token LOCAL_GET LOCAL_SET LOCAL_TEE GLOBAL_GET GLOBAL_SET
@@ -618,10 +605,6 @@ block_instr :
   | IF labeling_opt block ELSE labeling_end_opt instr_list END labeling_end_opt
     { fun c -> let c' = $2 c ($5 @ $8) in
       let ts, es1 = $3 c' in if_ ts es1 ($6 c') }
-  | LET labeling_opt let_block END labeling_end_opt
-    { let at = at () in
-      fun c -> let c' = enter_let ($2 c $5) at in
-      let ts, ls, es = $3 c c' in let_ ts ls es }
 
 block :
   | type_use block_param_body
@@ -653,59 +636,6 @@ block_result_body :
       FuncType (ins, snd $3 c @ out), es }
 
 
-let_block :
-  | type_use let_block_param_body
-    { let at = at () in
-      fun c c' -> let ft, ls, es = $2 c c' in
-      let x = inline_func_type_explicit c ($1 c type_) ft at in
-      VarBlockType (SynVar x.it), ls, es }
-  | let_block_param_body  /* Sugar */
-    { let at = at () in
-      fun c c' -> let ft, ls, es = $1 c c' in
-      let bt =
-        match ft with
-        | FuncType ([], []) -> ValBlockType None
-        | FuncType ([], [t]) -> ValBlockType (Some t)
-        | ft ->  VarBlockType (SynVar (inline_func_type c ft at).it)
-      in bt, ls, es }
-
-let_block_param_body :
-  | let_block_result_body { $1 }
-  | LPAR PARAM value_type_list RPAR let_block_param_body
-    { fun c c' ->
-      let FuncType (ins, out), ls, es = $5 c c' in
-      FuncType (snd $3 c @ ins, out), ls, es }
-
-let_block_result_body :
-  | let_block_local_body
-    { let at = at () in
-      fun c c' -> let ls, es = $1 c c' at in FuncType ([], []), ls, es }
-  | LPAR RESULT value_type_list RPAR let_block_result_body
-    { fun c c' ->
-      let FuncType (ins, out), ls, es = $5 c c' in
-      FuncType (ins, snd $3 c @ out), ls, es }
-
-let_block_local_body :
-  | instr_list
-    { fun c c' at -> merge_locals c' c at; [], $1 c' }
-  | LPAR LOCAL local_type_list RPAR let_block_local_body
-    { let at3 = ati 3 in let at4 = ati 4 in
-      fun c c' at -> ignore (anon_locals c' (fst $3) at3);
-      let at' = {left = at.left; right = at4.right} in
-      let ls, es = $5 c c' at' in snd $3 c @ ls, es }
-  | LPAR LOCAL bind_var local_type RPAR let_block_local_body  /* Sugar */
-    { let at5 = ati 5 in
-      fun c c' at -> ignore (bind_local c' $3);
-      let at' = {left = at.left; right = at5.right} in
-      let ls, es = $6 c c' at' in $4 c :: ls, es }
-
-local_type :
-  | value_type { let at = at () in fun c -> $1 c @@ at }
-
-local_type_list :
-  | /* empty */ { 0l, fun c -> [] }
-  | local_type local_type_list { I32.add (fst $2) 1l, fun c -> $1 c :: snd $2 c }
-
 expr :  /* Sugar */
   | LPAR expr1 RPAR
     { let at = at () in fun c -> let es, e' = $2 c in es @ [e' @@ at] }
@@ -726,10 +656,6 @@ expr1 :  /* Sugar */
   | IF labeling_opt if_block
     { fun c -> let c' = $2 c [] in
       let bt, (es, es1, es2) = $3 c c' in es, if_ bt es1 es2 }
-  | LET labeling_opt let_block
-    { let at = at () in
-      fun c -> let c' = enter_let ($2 c []) at in
-      let bt, ls, es = $3 c c' in [], let_ bt ls es }
 
 select_expr_results :
   | LPAR RESULT value_type_list RPAR select_expr_results
@@ -893,6 +819,13 @@ func_body :
     { fun c -> ignore (bind_local c $3); let f = $6 c in
       {f with locals = $4 c :: f.locals} }
 
+local_type :
+  | value_type { let at = at () in fun c -> $1 c @@ at }
+
+local_type_list :
+  | /* empty */ { 0l, fun c -> [] }
+  | local_type local_type_list { I32.add (fst $2) 1l, fun c -> $1 c :: snd $2 c }
+
 
 /* Tables, Memories & Globals */
 
diff --git a/interpreter/util/lib.ml b/interpreter/util/lib.ml
index b0548100a..1a4ce4257 100644
--- a/interpreter/util/lib.ml
+++ b/interpreter/util/lib.ml
@@ -142,6 +142,12 @@ struct
     | n, _::xs' when n > 0l -> nth xs' (Int32.sub n 1l)
     | _ -> failwith "nth"
 
+  let rec replace xs n y =
+    match n, xs with
+    | 0l, _::xs' -> y::xs'
+    | n, x::xs' when n > 0l -> x :: replace xs' (Int32.sub n 1l) y
+    | _ -> failwith "replace"
+
   let rec take n xs =
     match n, xs with
     | 0l, _ -> []
diff --git a/interpreter/util/lib.mli b/interpreter/util/lib.mli
index 08978cb24..164d4d9aa 100644
--- a/interpreter/util/lib.mli
+++ b/interpreter/util/lib.mli
@@ -35,6 +35,7 @@ sig
   val make : int32 -> 'a -> 'a list
   val length : 'a list -> int32
   val nth : 'a list -> int32 -> 'a (* raises Failure *)
+  val replace : 'a list -> int32 -> 'a -> 'a list (* raises Failure *)
   val take : int32 -> 'a list -> 'a list (* raises Failure *)
   val drop : int32 -> 'a list -> 'a list (* raises Failure *)
   val mapi : (int32 -> 'a -> 'b) -> 'a list -> 'b list
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index 3f8fa53dd..2c4a02192 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -24,7 +24,7 @@ type context =
   globals : global_type list;
   elems : ref_type list;
   datas : unit list;
-  locals : value_type list;
+  locals : local_type list;
   results : value_type list;
   labels : result_type list;
   refs : Free.t;
@@ -51,6 +51,17 @@ let data (c : context) x = lookup "data segment" c.datas x
 let local (c : context) x = lookup "local" c.locals x
 let label (c : context) x = lookup "label" c.labels x
 
+let replace category list x y =
+  try Lib.List32.replace list x.it y with Failure _ ->
+    error x.at ("unknown " ^ category ^ " " ^ I32.to_string_u x.it)
+
+let init_local (c : context) x =
+  let LocalType (t, _) = local c x in
+  {c with locals = replace "local" c.locals x (LocalType (t, Initialized))}
+
+let init_locals (c : context) xs =
+  List.fold_left init_local c xs
+
 let func_type (c : context) x =
   match type_ c x with
   | FuncDefType ft -> ft
@@ -139,7 +150,8 @@ let check_def_type (c : context) (dt : def_type) at =
 
 type ellipses = NoEllipses | Ellipses
 type infer_result_type = ellipses * value_type list
-type op_type = {ins : infer_result_type; outs : infer_result_type}
+type infer_func_type = {ins : infer_result_type; outs : infer_result_type}
+type infer_instr_type = infer_func_type * idx list
 
 let stack ts = (NoEllipses, ts)
 let (-->) ts1 ts2 = {ins = NoEllipses, ts1; outs = NoEllipses, ts2}
@@ -278,7 +290,7 @@ let check_memop (c : context) (memop : ('t, 's) memop) ty_size get_sz at =
  *   e  : instr
  *   es : instr list
  *   v  : value
- *   t  : value_type var
+ *   t  : value_type
  *   ts : result_type
  *   x  : variable
  *
@@ -299,79 +311,70 @@ let check_block_type (c : context) (bt : block_type) at : func_type =
   | VarBlockType (SynVar x) -> func_type c (x @@ at)
   | VarBlockType (SemVar _) -> assert false
 
-let check_local (c : context) (defaults : bool) (t : local) =
+let check_local (c : context) (defaulted : bool) (t : local) : local_type =
   check_value_type c t.it t.at;
-  require (not defaults || defaultable_value_type t.it) t.at
-    "non-defaultable local type"
+  let init =
+    if not defaulted || defaultable_value_type t.it
+    then Initialized else Uninitialized
+  in LocalType (t.it, init)
 
-let rec check_instr (c : context) (e : instr) (s : infer_result_type) : op_type =
+let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_instr_type =
   match e.it with
   | Unreachable ->
-    [] -->... []
+    [] -->... [], []
 
   | Nop ->
-    [] --> []
+    [] --> [], []
 
   | Drop ->
-    [peek 0 s] --> []
+    [peek 0 s] --> [], []
 
   | Select None ->
     let t = peek 1 s in
     require (is_num_type t || is_vec_type t) e.at
       ("type mismatch: instruction requires numeric or vector type" ^
        " but stack has " ^ string_of_value_type t);
-    [t; t; NumType I32Type] --> [t]
+    [t; t; NumType I32Type] --> [t], []
 
   | Select (Some ts) ->
     require (List.length ts = 1) e.at
       "invalid result arity other than 1 is not (yet) allowed";
     check_result_type c ts e.at;
-    (ts @ ts @ [NumType I32Type]) --> ts
+    (ts @ ts @ [NumType I32Type]) --> ts, []
 
   | Block (bt, es) ->
     let FuncType (ts1, ts2) as ft = check_block_type c bt e.at in
     check_block {c with labels = ts2 :: c.labels} es ft e.at;
-    ts1 --> ts2
+    ts1 --> ts2, []
 
   | Loop (bt, es) ->
     let FuncType (ts1, ts2) as ft = check_block_type c bt e.at in
     check_block {c with labels = ts1 :: c.labels} es ft e.at;
-    ts1 --> ts2
+    ts1 --> ts2, []
 
   | If (bt, es1, es2) ->
     let FuncType (ts1, ts2) as ft = check_block_type c bt e.at in
     check_block {c with labels = ts2 :: c.labels} es1 ft e.at;
     check_block {c with labels = ts2 :: c.labels} es2 ft e.at;
-    (ts1 @ [NumType I32Type]) --> ts2
-
-  | Let (bt, locals, es) ->
-    let FuncType (ts1, ts2) as ft = check_block_type c bt e.at in
-    List.iter (check_local c false) locals;
-    let c' =
-      { c with
-        labels = ts2 :: c.labels;
-        locals = List.map Source.it locals @ c.locals;
-      }
-    in check_block c' es ft e.at;
-    (ts1 @ List.map Source.it locals) --> ts2
+    (ts1 @ [NumType I32Type]) --> ts2, []
 
   | Br x ->
-    label c x -->... []
+    label c x -->... [], []
 
   | BrIf x ->
-    (label c x @ [NumType I32Type]) --> label c x
+    (label c x @ [NumType I32Type]) --> label c x, []
 
   | BrTable (xs, x) ->
     let n = List.length (label c x) in
     let ts = Lib.List.table n (fun i -> peek (n - i) s) in
     check_stack c ts (label c x) x.at;
     List.iter (fun x' -> check_stack c ts (label c x') x'.at) xs;
-    (ts @ [NumType I32Type]) -->... []
+    (ts @ [NumType I32Type]) -->... [], []
 
   | BrOnNull x ->
     let (_, t) = peek_ref 0 s e.at in
     (label c x @ [RefType (Nullable, t)]) -->
-      (label c x @ [RefType (NonNullable, t)])
+      (label c x @ [RefType (NonNullable, t)]), []
 
   | BrOnNonNull x ->
     let (_, ht) as rt = peek_ref 0 s e.at in
@@ -383,22 +386,22 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : op_type
     require (match_value_type c.types [] t' t) e.at
       ("type mismatch: instruction requires type " ^ string_of_value_type t' ^
        " but label has " ^ string_of_result_type (label c x));
-    (ts0 @ [RefType rt]) --> ts0
+    (ts0 @ [RefType rt]) --> ts0, []
 
   | Return ->
-    c.results -->... []
+    c.results -->... [], []
 
   | Call x ->
     let FuncType (ts1, ts2) = func c x in
-    ts1 --> ts2
+    ts1 --> ts2, []
 
   | CallRef ->
     (match peek_ref 0 s e.at with
     | (nul, DefHeapType (SynVar x)) ->
       let FuncType (ts1, ts2) = func_type c (x @@ e.at) in
-      (ts1 @ [RefType (nul, DefHeapType (SynVar x))]) --> ts2
+      (ts1 @ [RefType (nul, DefHeapType (SynVar x))]) --> ts2, []
     | (_, BotHeapType) as rt ->
-      [RefType rt] -->... []
+      [RefType rt] -->... [], []
     | rt ->
       error e.at
         ("type mismatch: instruction requires function reference type" ^
@@ -411,7 +414,7 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : op_type
     require (match_ref_type c.types [] t (Nullable, FuncHeapType)) x.at
       ("type mismatch: instruction requires table of function type" ^
        " but table has element type " ^ string_of_ref_type t);
-    (ts1 @ [NumType I32Type]) --> ts2
+    (ts1 @ [NumType I32Type]) --> ts2, []
 
   | ReturnCallRef ->
     (match peek_ref 0 s e.at with
@@ -421,9 +424,9 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : op_type
         ("type mismatch: current function requires result type " ^
          string_of_result_type c.results ^
          " but callee returns " ^ string_of_result_type ts2);
-      (ts1 @ [RefType (nul, DefHeapType (SynVar x))]) -->... []
+      (ts1 @ [RefType (nul, DefHeapType (SynVar x))]) -->... [], []
     | (_, BotHeapType) as rt ->
-      [RefType rt] -->... []
+      [RefType rt] -->... [], []
     | rt ->
       error e.at
         ("type mismatch: instruction requires function reference type" ^
@@ -431,42 +434,46 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : op_type
     )
 
   | LocalGet x ->
-    [] --> [local c x]
+    let LocalType (t, init) = local c x in
+    require (init = Initialized) x.at "uninitialized local";
+    [] --> [t], []
 
   | LocalSet x ->
-    [local c x] --> []
+    let LocalType (t, _) = local c x in
+    [t] --> [], [x]
 
   | LocalTee x ->
-    [local c x] --> [local c x]
+    let LocalType (t, _) = local c x in
+    [t] --> [t], [x]
 
   | GlobalGet x ->
     let GlobalType (t, _mut) = global c x in
-    [] --> [t]
+    [] --> [t], []
 
   | GlobalSet x ->
     let GlobalType (t, mut) = global c x in
     require (mut = Mutable) x.at "global is immutable";
-    [t] --> []
+    [t] --> [], []
 
   | TableGet x ->
     let TableType (_lim, t) = table c x in
-    [NumType I32Type] --> [RefType t]
+    [NumType I32Type] --> [RefType t], []
 
   | TableSet x ->
     let TableType (_lim, t) = table c x in
-    [NumType I32Type; RefType t] --> []
+    [NumType I32Type; RefType t] --> [], []
 
   | TableSize x ->
     let _tt = table c x in
-    [] --> [NumType I32Type]
+    [] --> [NumType I32Type], []
 
   | TableGrow x ->
     let TableType (_lim, t) = table c x in
-    [RefType t; NumType I32Type] --> [NumType I32Type]
+    [RefType t; NumType I32Type] --> [NumType I32Type], []
 
   | TableFill x ->
     let TableType (_lim, t) = table c x in
-    [NumType I32Type; RefType t; NumType I32Type] --> []
+    [NumType I32Type; RefType t; NumType I32Type] --> [], []
 
   | TableCopy (x, y) ->
     let TableType (_lim1, t1) = table c x in
@@ -474,7 +481,7 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : op_type
     require (match_ref_type c.types [] t2 t1) x.at
       ("type mismatch: source element type " ^ string_of_ref_type t1 ^
        " does not match destination element type " ^ string_of_ref_type t2);
-    [NumType I32Type; NumType I32Type; NumType I32Type] --> []
+    [NumType I32Type; NumType I32Type; NumType I32Type] --> [], []
 
   | TableInit (x, y) ->
     let TableType (_lim1, t1) = table c x in
@@ -482,191 +489,191 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : op_type
     require (match_ref_type c.types [] t2 t1) x.at
       ("type mismatch: element segment's type " ^ string_of_ref_type t1 ^
        " does not match table's element type " ^ string_of_ref_type t2);
-    [NumType I32Type; NumType I32Type; NumType I32Type] --> []
+    [NumType I32Type; NumType I32Type; NumType I32Type] --> [], []
 
   | ElemDrop x ->
     ignore (elem c x);
-    [] --> []
+    [] --> [], []
 
   | Load memop ->
     check_memop c memop num_size (Lib.Option.map fst) e.at;
-    [NumType I32Type] --> [NumType memop.ty]
+    [NumType I32Type] --> [NumType memop.ty], []
 
   | Store memop ->
     check_memop c memop num_size (fun sz -> sz) e.at;
-    [NumType I32Type; NumType memop.ty] --> []
+    [NumType I32Type; NumType memop.ty] --> [], []
 
   | VecLoad memop ->
     check_memop c memop vec_size (Lib.Option.map fst) e.at;
-    [NumType I32Type] --> [VecType memop.ty]
+    [NumType I32Type] --> [VecType memop.ty], []
 
   | VecStore memop ->
     check_memop c memop vec_size (fun _ -> None) e.at;
-    [NumType I32Type; VecType memop.ty] --> []
+    [NumType I32Type; VecType memop.ty] --> [], []
 
   | VecLoadLane (memop, i) ->
     check_memop c memop vec_size (fun sz -> Some sz) e.at;
     require (i < vec_size memop.ty / packed_size memop.pack) e.at
       "invalid lane index";
-    [NumType I32Type; VecType memop.ty] -->  [VecType memop.ty]
+    [NumType I32Type; VecType memop.ty] -->  [VecType memop.ty], []
 
   | VecStoreLane (memop, i) ->
     check_memop c memop vec_size (fun sz -> Some sz) e.at;
     require (i < vec_size memop.ty / packed_size memop.pack) e.at
       "invalid lane index";
-    [NumType I32Type; VecType memop.ty] -->  []
+    [NumType I32Type; VecType memop.ty] -->  [], []
 
   | MemorySize ->
     let _mt = memory c (0l @@ e.at) in
-    [] --> [NumType I32Type]
+    [] --> [NumType I32Type], []
 
   | MemoryGrow ->
     let _mt = memory c (0l @@ e.at) in
-    [NumType I32Type] --> [NumType I32Type]
+    [NumType I32Type] --> [NumType I32Type], []
 
   | MemoryFill ->
     ignore (memory c (0l @@ e.at));
-    [NumType I32Type; NumType I32Type; NumType I32Type] --> []
+    [NumType I32Type; NumType I32Type; NumType I32Type] --> [], []
 
   | MemoryCopy ->
     ignore (memory c (0l @@ e.at));
-    [NumType I32Type; NumType I32Type; NumType I32Type] --> []
+    [NumType I32Type; NumType I32Type; NumType I32Type] --> [], []
 
   | MemoryInit x ->
     ignore (memory c (0l @@ e.at));
     ignore (data c x);
-    [NumType I32Type; NumType I32Type; NumType I32Type] --> []
+    [NumType I32Type; NumType I32Type; NumType I32Type] --> [], []
 
   | DataDrop x ->
     ignore (data c x);
-    [] --> []
+    [] --> [], []
 
   | RefNull t ->
     check_heap_type c t e.at;
-    [] --> [RefType (Nullable, t)]
+    [] --> [RefType (Nullable, t)], []
 
   | RefIsNull ->
     let (_, t) = peek_ref 0 s e.at in
-    [RefType (Nullable, t)] --> [NumType I32Type]
+    [RefType (Nullable, t)] --> [NumType I32Type], []
 
   | RefAsNonNull ->
     let (_, t) = peek_ref 0 s e.at in
-    [RefType (Nullable, t)] --> [RefType (NonNullable, t)]
+    [RefType (Nullable, t)] --> [RefType (NonNullable, t)], []
 
   | RefFunc x ->
     let ft = func c x in
     let y = Lib.Option.force (Lib.List32.index_of (FuncDefType ft) c.types) in
     refer_func c x;
-    [] --> [RefType (NonNullable, DefHeapType (SynVar y))]
+    [] --> [RefType (NonNullable, DefHeapType (SynVar y))], []
 
   | Const v ->
     let t = NumType (type_num v.it) in
-    [] --> [t]
+    [] --> [t], []
 
   | Test testop ->
     let t = NumType (type_num testop) in
-    [t] --> [NumType I32Type]
+    [t] --> [NumType I32Type], []
 
   | Compare relop ->
     let t = NumType (type_num relop) in
-    [t; t] --> [NumType I32Type]
+    [t; t] --> [NumType I32Type], []
 
   | Unary unop ->
     check_unop unop e.at;
     let t = NumType (type_num unop) in
-    [t] --> [t]
+    [t] --> [t], []
 
   | Binary binop ->
     let t = NumType (type_num binop) in
-    [t; t] --> [t]
+    [t; t] --> [t], []
 
   | Convert cvtop ->
     let t1, t2 = type_cvtop e.at cvtop in
-    [NumType t1] --> [NumType t2]
+    [NumType t1] --> [NumType t2], []
 
   | VecConst v ->
     let t = VecType (type_vec v.it) in
-    [] --> [t]
+    [] --> [t], []
 
   | VecTest testop ->
     let t = VecType (type_vec testop) in
-    [t] --> [NumType I32Type]
+    [t] --> [NumType I32Type], []
 
   | VecUnary unop ->
     let t = VecType (type_vec unop) in
-    [t] --> [t]
+    [t] --> [t], []
 
   | VecBinary binop ->
     check_vec_binop binop e.at;
     let t = VecType (type_vec binop) in
-    [t; t] --> [t]
+    [t; t] --> [t], []
 
   | VecCompare relop ->
     let t = VecType (type_vec relop) in
-    [t; t] --> [t]
+    [t; t] --> [t], []
 
   | VecConvert cvtop ->
     let t = VecType (type_vec cvtop) in
-    [t] --> [t]
+    [t] --> [t], []
 
   | VecShift shiftop ->
     let t = VecType (type_vec shiftop) in
-    [t; NumType I32Type] --> [VecType V128Type]
+    [t; NumType I32Type] --> [VecType V128Type], []
 
   | VecBitmask bitmaskop ->
     let t = VecType (type_vec bitmaskop) in
-    [t] --> [NumType I32Type]
+    [t] --> [NumType I32Type], []
 
   | VecTestBits vtestop ->
     let t = VecType (type_vec vtestop) in
-    [t] --> [NumType I32Type]
+    [t] --> [NumType I32Type], []
 
   | VecUnaryBits vunop ->
     let t = VecType (type_vec vunop) in
-    [t] --> [t]
+    [t] --> [t], []
 
   | VecBinaryBits vbinop ->
     let t = VecType (type_vec vbinop) in
-    [t; t] --> [t]
+    [t; t] --> [t], []
 
   | VecTernaryBits vternop ->
     let t = VecType (type_vec vternop) in
-    [t; t; t] --> [t]
+    [t; t; t] --> [t], []
 
   | VecSplat splatop ->
     let t1 = type_vec_lane splatop in
     let t2 = VecType (type_vec splatop) in
-    [NumType t1] --> [t2]
+    [NumType t1] --> [t2], []
 
   | VecExtract extractop ->
     let t = VecType (type_vec extractop) in
     let t2 = type_vec_lane extractop in
     require (lane_extractop extractop < num_lanes extractop) e.at
       "invalid lane index";
-    [t] --> [NumType t2]
+    [t] --> [NumType t2], []
 
   | VecReplace replaceop ->
     let t = VecType (type_vec replaceop) in
     let t2 = type_vec_lane replaceop in
     require (lane_replaceop replaceop < num_lanes replaceop) e.at
       "invalid lane index";
-    [t; NumType t2] --> [t]
+    [t; NumType t2] --> [t], []
 
 and check_seq (c : context) (s : infer_result_type) (es : instr list)
-  : infer_result_type =
+  : infer_result_type * idx list =
   match es with
   | [] ->
-    s
+    s, []
 
   | _ ->
     let es', e = Lib.List.split_last es in
-    let s' = check_seq c s es' in
-    let {ins; outs} = check_instr c e s' in
-    push c outs (pop c ins s' e.at)
+    let s', xs = check_seq c s es' in
+    let {ins; outs}, xs' = check_instr (init_locals c xs) e s' in
+    push c outs (pop c ins s' e.at), xs @ xs'
 
 and check_block (c : context) (es : instr list) (ft : func_type) at =
   let FuncType (ts1, ts2) = ft in
-  let s = check_seq c (stack ts1) es in
+  let s, xs = check_seq c (stack ts1) es in
   let s' = pop c (stack ts2) s at in
   require (snd s' = []) at
     ("type mismatch: block requires " ^ string_of_result_type ts2 ^
@@ -690,10 +697,10 @@ and check_block (c : context) (es : instr list) (ft : func_type) at =
 let check_func (c : context) (f : func) =
   let {ftype; locals; body} = f.it in
   let FuncType (ts1, ts2) = func_type c ftype in
-  List.iter (check_local c true) locals;
+  let ts = List.map (check_local c true) locals in
   let c' =
     { c with
-      locals = ts1 @ List.map Source.it locals;
+      locals = List.map (fun t -> LocalType (t, Initialized)) ts1 @ ts;
       results = ts2;
       labels = [ts2]
     }
diff --git a/proposals/function-references/Overview.md b/proposals/function-references/Overview.md
index 5331d714c..4a5fcafb8 100644
--- a/proposals/function-references/Overview.md
+++ b/proposals/function-references/Overview.md
@@ -8,7 +8,7 @@ The proposal distinguished regular and nullable function reference. The former c
 
 The proposal has instructions for producing and consuming (calling) function references. It also includes instruction for testing and converting between regular and nullable references.
 
-Typed references have no canonical default value, because they cannot be null. To enable storing them in locals, which so far depend on default values for initialisation, the proposal also introduces a new instruction `let` for block-scoped locals whose initialisation values are taken from the operand stack.
+Typed references have no canonical default value, because they cannot be null. To enable storing them in locals, which so far depend on default values for initialisation, the proposal also tracks the initialisation status of locals during validation.
 
 
 ### Motivation
@@ -36,7 +36,7 @@ Typed references have no canonical default value, because they cannot be null. T
 
 * Refine the instruction `ref.func $f` to return a typed function reference
 
-* Add a block instruction `let (local t*) ... end` for introducing locals with block scope, in order to handle reference types without default initialisation values
+* Track initialisation status of locals during validation and only allow `local.get` after a `local.set/tee` in the same or a surrounding block.
 
 * Add an optional initialiser expression to table definitions, for element types that do not have an implicit default value.
 
@@ -168,6 +168,33 @@ The following rules, now defined in terms of heap types, replace and extend the
 * TODO: Table definitions with a type that is not defaultable must have an initialiser value. (Imports are not affected.)
 
 
+#### Local Types
+
+* Locals are now recorded in the context with types of the following form:
+  - `localtype ::= set? <valtype>`
+  - the flag `set` records that the local has been initialized
+  - all locals with non-defaultable type start out unset
+
+
+#### Instruction Types
+
+* Instructions and instruction sequences are now typed with types of the following form:
+  - `instrtype ::= <functype> <localidx>*`
+  - the local indices record which locals have been set by the instructions
+  - most typing rules except those for locals and for instruction sequences remain unchanged, since the index list is empty
+
+* There is a natural notion of subtyping on instruction types:
+  - `[t1*] -> [t2*] x1*  <:  [t3*] -> [t4*] x2*`
+    - iff `t1* = t0* t1'*`
+    - and `t2* = t0* t2'*`
+    - and `[t1'*] -> [t2'*] <: [t3*] -> [t4*]*`
+    - and `{x2*} subset {x1*}`
+
+* Block types are instruction types with empty index set.
+
+Note: Extending block types with index sets to allow initialization status to last beyond a block's end is a possible extension.
+
+
 ### Instructions
 
 #### Functions
@@ -215,26 +242,43 @@ The following rules, now defined in terms of heap types, replace and extend the
 * Note: `ref.is_null` already exists via the [reference types proposal](https://github.com/WebAssembly/reference-types)
 
 
-#### Local Bindings
+#### Locals
 
-* `let <blocktype> (local <valtype>)* <instr>* end` locally binds operands to variables
-  - `let bt (local t)* instr* end : [t1* t*] -> [t2*]`
-    - iff `bt = [t1*] -> [t2*]`
-    - and `instr* : bt` under a context with `locals` extended with `t*` and `labels` extended with `[t2*]`
+Typing of local instructions is updated to account for the initialization status of locals.
 
-Note: The latter condition implies that inside the body of the `let`, its locals are prepended to the list of locals. Nesting multiple `let` blocks hence addresses them relatively, similar to labels. Function-level local declarations can be viewed as syntactic sugar for a bunch of zero constant instructions and a `let` wrapping the function body. That is,
-```
-(func ... (local t)* ...)
-```
-is equivalent to
-```
-(func ... (t.default)* (let (local t)* ...))
-```
-where `(t.default)` is `(t.const 0)` for numeric types `t`, and `(ref.null)` for reference types.
+* `local.get $x`
+  - `local.get $x : [] -> [t]`
+    - iff `$x : set t`
+
+* `local.set $x`
+  - `local.set $x : [t] -> [] $x`
+    - iff `$x : set? t`
+
+* `local.tee $x`
+  - `local.tee $x : [t] -> [t] $x`
+    - iff `$x : set? t`
+
+Note: These typing rules do not try to exclude indices for locals that have already been set, but an implementation could.
+
+
+#### Instruction Sequences
+
+Typing of instruction sequences is updated to account for initialization of locals.
+
+* `instr*`
+  - `instr1 instr* : [t1*] -> [t3*] x1* x2*`
+    - iff `instr1 : [t1*] -> [t2*] x1*`
+    - and `instr* : [t2*] -> [t3*] x2*` under a context where `x1*` are changed to `set`
+  - `epsilon : [] -> [] epsilon`
 
-The rule also implies that let-bound locals are mutable.
+Note: These typing rules do not try to eliminate duplicate indices, but an implementation could.
+ 
+A subsumption rule allows to go to a supertype for any instruction:
 
-Like all other block instructions, `let` binds a label
+* `instr`
+  - `instr : [t1*] -> [t2*] x*`
+    - iff `instr : [t1'*] -> [t2'*] x'*`
+    - and `[t1'*] -> [t2'*] x'*  <:  [t1*] -> [t2*] x*`
 
 
 ### Tables
@@ -273,7 +317,6 @@ The opcode for heap types is encoded as an `s33`.
 | ------ | ------------------------ | ---------- |
 | 0x14   | `call_ref`               |            |
 | 0x15   | `return_call_ref`        |            |
-| 0x17   | `let <bt> <locals>`      | `bt : blocktype, locals : (as in functions)` |
 | 0xd3   | `ref.as_non_null`        |            |
 | 0xd4   | `br_on_null $l`          | `$l : u32` |
 | 0xd6   | `br_on_non_null $l`      | `$l : u32` |
diff --git a/test/core/func.wast b/test/core/func.wast
index 46a013831..f2d18cc9f 100644
--- a/test/core/func.wast
+++ b/test/core/func.wast
@@ -657,8 +657,11 @@
 )
 
 (assert_invalid
-  (module (type $t (func)) (func $type-local-no-default (local (ref $t))))
-  "non-defaultable local type"
+  (module
+    (type $t (func))
+    (func $type-local-uninitialized (local $x (ref $t)) (drop (local.get $x)))
+  )
+  "uninitialized local"
 )
 
 
@@ -958,22 +961,28 @@
 
 ;; Duplicate name errors
 
-(assert_malformed (module quote
-  "(func $foo)"
-  "(func $foo)")
-  "duplicate func")
-(assert_malformed (module quote
-  "(import \"\" \"\" (func $foo))"
-  "(func $foo)")
-  "duplicate func")
-(assert_malformed (module quote
-  "(import \"\" \"\" (func $foo))"
-  "(import \"\" \"\" (func $foo))")
-  "duplicate func")
-
-(assert_malformed (module quote "(func (param $foo i32) (param $foo i32))")
-  "duplicate local")
-(assert_malformed (module quote "(func (param $foo i32) (local $foo i32))")
-  "duplicate local")
-(assert_malformed (module quote "(func (local $foo i32) (local $foo i32))")
-  "duplicate local")
+(assert_malformed
+  (module quote "(func $foo)" "(func $foo)")
+  "duplicate func"
+)
+(assert_malformed
+  (module quote "(import \"\" \"\" (func $foo))" "(func $foo)")
+  "duplicate func"
+)
+(assert_malformed
+  (module quote "(import \"\" \"\" (func $foo))" "(import \"\" \"\" (func $foo))")
+  "duplicate func"
+)
+
+(assert_malformed
+  (module quote "(func (param $foo i32) (param $foo i32))")
+  "duplicate local"
+)
+(assert_malformed
+  (module quote "(func (param $foo i32) (local $foo i32))")
+  "duplicate local"
+)
+(assert_malformed
+  (module quote "(func (local $foo i32) (local $foo i32))")
+  "duplicate local"
+)
diff --git a/test/core/local_get.wast b/test/core/local_get.wast
index 6acab3988..b56aeec30 100644
--- a/test/core/local_get.wast
+++ b/test/core/local_get.wast
@@ -175,7 +175,7 @@
 )
 
 
-;; local.set should have retval
+;; Invalid result type
 
 (assert_invalid
   (module (func $type-empty-vs-i32 (local i32) (local.get 0)))
@@ -224,3 +224,42 @@
   "unknown local"
 )
 
+
+;; Uninitialized undefaulted locals
+
+(module
+  (func (export "get-after-set") (param $p (ref extern)) (result (ref extern))
+    (local $x (ref extern))
+    (local.set $x (local.get $p))
+    (local.get $x)
+  )
+  (func (export "get-after-tee") (param $p (ref extern)) (result (ref extern))
+    (local $x (ref extern))
+    (drop (local.tee $x (local.get $p)))
+    (local.get $x)
+  )
+  (func (export "get-in-block-after-set") (param $p (ref extern)) (result (ref extern))
+    (local $x (ref extern))
+    (local.set $x (local.get $p))
+    (block (result (ref extern)) (local.get $x))
+  )
+)
+
+(assert_return (invoke "get-after-set" (ref.extern 1)) (ref.extern 1))
+(assert_return (invoke "get-after-tee" (ref.extern 2)) (ref.extern 2))
+(assert_return (invoke "get-in-block-after-set" (ref.extern 3)) (ref.extern 3))
+
+(assert_invalid
+  (module (func $uninit (local $x (ref extern)) (drop (local.get $x))))
+  "uninitialized local"
+)
+(assert_invalid
+  (module
+    (func $uninit-after-end (param $p (ref extern))
+      (local $x (ref extern))
+      (block (local.set $x (local.get $p)) (drop (local.tee $x (local.get $p))))
+      (drop (local.get $x))
+    )
+  )
+  "uninitialized local"
+)

From 4abaa4515aa65600af0f91e517b0de606cd97479 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Daniel=20Hillerstr=C3=B6m?= <daniel.hillerstrom@ed.ac.uk>
Date: Fri, 22 Jul 2022 23:50:10 +0100
Subject: [PATCH 143/285] Subtyping on vector types & heap bottom check (#66)

---
 document/core/appendix/algorithm.rst |  1 +
 document/core/util/macros.def        |  1 +
 document/core/valid/matching.rst     | 18 ++++++++++++++++++
 document/core/valid/types.rst        | 10 ++++++++++
 4 files changed, 30 insertions(+)

diff --git a/document/core/appendix/algorithm.rst b/document/core/appendix/algorithm.rst
index 4ec2f99d6..8ddbd6317 100644
--- a/document/core/appendix/algorithm.rst
+++ b/document/core/appendix/algorithm.rst
@@ -67,6 +67,7 @@ Equivalence and subtyping checks can be defined on these types.
    func matches(t1 : val_type, t2 : val_type) : bool =
      return
        (is_num t1 && is_num t2 && t1 = t2) ||
+       (is_vec t1 && is_vec t2 && t1 == t2) ||
        (is_ref t1 && is_ref t2 && matches_ref(t1, t2)) ||
        t1 = Bot
 
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index 3fb701f42..c19f2020c 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -929,6 +929,7 @@
 .. |vdashtabletypedefaultable| mathdef:: \xref{valid/types}{valid-defaultable}{\vdash}
 
 .. |vdashnumtypematch| mathdef:: \xref{valid/matching}{match-numtype}{\vdash}
+.. |vdashvectypematch| mathdef:: \xref{valid/matching}{match-vectype}{\vdash}
 .. |vdashheaptypematch| mathdef:: \xref{valid/matching}{match-heaptype}{\vdash}
 .. |vdashreftypematch| mathdef:: \xref{valid/matching}{match-reftype}{\vdash}
 .. |vdashvaltypematch| mathdef:: \xref{valid/matching}{match-valtype}{\vdash}
diff --git a/document/core/valid/matching.rst b/document/core/valid/matching.rst
index 5f502507d..75cd4aedc 100644
--- a/document/core/valid/matching.rst
+++ b/document/core/valid/matching.rst
@@ -26,6 +26,24 @@ A :ref:`number type <syntax-numtype>` :math:`\numtype_1` matches a :ref:`number
    }
 
 
+.. index:: vector type
+.. _match-vectortype:
+
+Vector Types
+~~~~~~~~~~~~
+
+A :ref:`vector type <syntax-vectype>` :math:`\vectype_1` matches a :ref:`vector type <syntax-vectype>` :math:`\vectype_2` if and only if:
+
+* Both :math:`\vectype_1` and :math:`\vectype_2` are the same.
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+   }{
+     C \vdashvectypematch \vectype \matchesvaltype \vectype
+   }
+
+
 .. index:: heap type
 .. _match-heaptype:
 
diff --git a/document/core/valid/types.rst b/document/core/valid/types.rst
index 562a60757..e4f7a7995 100644
--- a/document/core/valid/types.rst
+++ b/document/core/valid/types.rst
@@ -87,6 +87,16 @@ Concrete :ref:`Heap types <syntax-heaptype>` are only valid when the :ref:`type
      C \vdashheaptype \typeidx \ok
    }
 
+:math:`\BOT`
+............
+
+* The heap type is valid.
+
+.. math::
+   \frac{
+   }{
+     C \vdashheaptype \BOT \ok
+   }
 
 .. index:: reference type, heap type
    pair: validation; reference type

From e1fa7528a8e1d8c07646064acc69f3b2d7629ec5 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Sat, 23 Jul 2022 19:53:51 +0200
Subject: [PATCH 144/285] [interpreter] Bring AST closer to spec

---
 interpreter/binary/decode.ml  | 22 +++++++-------
 interpreter/binary/encode.ml  | 27 +++++++++--------
 interpreter/exec/eval.ml      |  6 ++--
 interpreter/host/spectest.ml  | 12 ++++----
 interpreter/runtime/global.ml |  6 ++--
 interpreter/runtime/value.ml  |  8 ++---
 interpreter/script/js.ml      | 10 +++----
 interpreter/script/run.ml     |  4 +--
 interpreter/syntax/ast.ml     | 11 ++++---
 interpreter/syntax/free.ml    |  2 +-
 interpreter/syntax/types.ml   | 28 ++++++++++--------
 interpreter/text/arrange.ml   | 10 +++----
 interpreter/text/parser.mly   | 18 +++++------
 interpreter/valid/match.ml    | 10 +++----
 interpreter/valid/valid.ml    | 56 +++++++++++++++++------------------
 test/core/global.wast         |  4 +--
 16 files changed, 120 insertions(+), 114 deletions(-)

diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 4af123201..eee1d8642 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -178,10 +178,10 @@ let heap_type s =
 let ref_type s =
   let pos = pos s in
   match s7 s with
-  | -0x10 -> (Nullable, FuncHeapType)
-  | -0x11 -> (Nullable, ExternHeapType)
-  | -0x14 -> (Nullable, heap_type s)
-  | -0x15 -> (NonNullable, heap_type s)
+  | -0x10 -> (Null, FuncHeapType)
+  | -0x11 -> (Null, ExternHeapType)
+  | -0x14 -> (Null, heap_type s)
+  | -0x15 -> (NoNull, heap_type s)
   | _ -> error s pos "malformed reference type"
 
 let value_type s =
@@ -221,14 +221,14 @@ let memory_type s =
 
 let mutability s =
   match byte s with
-  | 0 -> Immutable
-  | 1 -> Mutable
+  | 0 -> Cons
+  | 1 -> Var
   | _ -> error s (pos s - 1) "malformed mutability"
 
 let global_type s =
   let t = value_type s in
   let mut = mutability s in
-  GlobalType (t, mut)
+  GlobalType (mut, t)
 
 
 (* Instructions *)
@@ -258,7 +258,7 @@ let block_type s =
 let local s =
   let n = u32 s in
   let t = at value_type s in
-  n, t
+  n, {ltype = t.it} @@ t.at
 
 let locals s =
   let pos = pos s in
@@ -1001,7 +1001,7 @@ let elem_index s =
 
 let elem_kind s =
   match byte s with
-  | 0x00 -> (NonNullable, FuncHeapType)
+  | 0x00 -> (NoNull, FuncHeapType)
   | _ -> error s (pos s - 1) "malformed element kind"
 
 let elem s =
@@ -1009,7 +1009,7 @@ let elem s =
   | 0x00l ->
     let emode = at active_zero s in
     let einit = vec (at elem_index) s in
-    {etype = (NonNullable, FuncHeapType); einit; emode}
+    {etype = (NoNull, FuncHeapType); einit; emode}
   | 0x01l ->
     let emode = at passive s in
     let etype = elem_kind s in
@@ -1028,7 +1028,7 @@ let elem s =
   | 0x04l ->
     let emode = at active_zero s in
     let einit = vec const s in
-    {etype = (NonNullable, FuncHeapType); einit; emode}
+    {etype = (NoNull, FuncHeapType); einit; emode}
   | 0x05l ->
     let emode = at passive s in
     let etype = ref_type s in
diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index 5cab624d9..ac0722cb7 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -115,10 +115,10 @@ struct
     | BotHeapType -> assert false
 
   let ref_type = function
-    | (Nullable, FuncHeapType) -> s7 (-0x10)
-    | (Nullable, ExternHeapType) -> s7 (-0x11)
-    | (Nullable, t) -> s7 (-0x14); heap_type t
-    | (NonNullable, t) -> s7 (-0x15); heap_type t
+    | (Null, FuncHeapType) -> s7 (-0x10)
+    | (Null, ExternHeapType) -> s7 (-0x11)
+    | (Null, t) -> s7 (-0x14); heap_type t
+    | (NoNull, t) -> s7 (-0x15); heap_type t
 
   let value_type = function
     | NumType t -> num_type t
@@ -142,11 +142,11 @@ struct
     | MemoryType lim -> limits u32 lim
 
   let mutability = function
-    | Immutable -> byte 0
-    | Mutable -> byte 1
+    | Cons -> byte 0
+    | Var -> byte 1
 
   let global_type = function
-    | GlobalType (t, mut) -> value_type t; mutability mut
+    | GlobalType (mut, t) -> value_type t; mutability mut
 
 
   (* Instructions *)
@@ -170,12 +170,13 @@ struct
     | VarBlockType (SynVar x) -> s33 x
     | VarBlockType (SemVar _) -> assert false
 
-  let local (t, n) = len n; value_type t.it
+  let local (n, loc) = len n; value_type loc.it.ltype
 
   let locals locs =
-    let combine t = function
-      | (t', n) :: ts when t.it = t'.it -> (t, n + 1) :: ts
-      | ts -> (t, 1) :: ts
+    let combine loc = function
+      | (n, loc') :: nlocs' when loc.it.ltype = loc'.it.ltype ->
+        (n + 1, loc') :: nlocs'
+      | nlocs -> (1, loc) :: nlocs
     in vec local (List.fold_right combine locs [])
 
   let rec instr e =
@@ -880,11 +881,11 @@ struct
   (* Element section *)
 
   let is_elem_kind = function
-    | (NonNullable, FuncHeapType) -> true
+    | (NoNull, FuncHeapType) -> true
     | _ -> false
 
   let elem_kind = function
-    | (NonNullable, FuncHeapType) -> byte 0x00
+    | (NoNull, FuncHeapType) -> byte 0x00
     | _ -> assert false
 
   let is_elem_index e =
diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index 19074de0b..278217b0a 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -698,9 +698,9 @@ let rec step (c : config) : config =
       | Func.AstFunc (_, inst', func) ->
         let {locals; body; _} = func.it in
         let m = Lib.Promise.value inst' in
-        let ts = List.map (fun t -> Types.sem_value_type m.types t.it) locals in
-        let locals' = List.(rev (map Option.some args) @ map default_value ts) in
-        let frame' = {inst = m; locals = List.map ref locals'} in
+        let ts = List.map (fun loc -> Types.sem_value_type m.types loc.it.ltype) locals in
+        let locs' = List.(rev (map Option.some args) @ map default_value ts) in
+        let frame' = {inst = m; locals = List.map ref locs'} in
         let instr' = [Label (n2, [], ([], List.map plain body)) @@ func.at] in
         vs', [Frame (n2, frame', ([], instr')) @@ e.at]
 
diff --git a/interpreter/host/spectest.ml b/interpreter/host/spectest.ml
index c76317bb0..f38a52212 100644
--- a/interpreter/host/spectest.ml
+++ b/interpreter/host/spectest.ml
@@ -7,7 +7,7 @@ open Value
 open Instance
 
 
-let global (GlobalType (t, _) as gt) =
+let global (GlobalType (_, t) as gt) =
   let v =
     match t with
     | NumType I32Type -> Num (I32 666l)
@@ -20,7 +20,7 @@ let global (GlobalType (t, _) as gt) =
   in Global.alloc gt v
 
 let table =
-  Table.alloc (TableType ({min = 10l; max = Some 20l}, (Nullable, FuncHeapType)))
+  Table.alloc (TableType ({min = 10l; max = Some 20l}, (Null, FuncHeapType)))
     (NullRef FuncHeapType)
 let memory = Memory.alloc (MemoryType {min = 1l; max = Some 2l})
 let func f ft = Func.alloc_host (Types.alloc (FuncDefType ft)) (f ft)
@@ -46,10 +46,10 @@ let lookup name t =
     ExternFunc (func print (FuncType ([NumType I32Type; NumType F32Type], [])))
   | "print_f64_f64", _ ->
     ExternFunc (func print (FuncType ([NumType F64Type; NumType F64Type], [])))
-  | "global_i32", _ -> ExternGlobal (global (GlobalType (NumType I32Type, Immutable)))
-  | "global_i64", _ -> ExternGlobal (global (GlobalType (NumType I64Type, Immutable)))
-  | "global_f32", _ -> ExternGlobal (global (GlobalType (NumType F32Type, Immutable)))
-  | "global_f64", _ -> ExternGlobal (global (GlobalType (NumType F64Type, Immutable)))
+  | "global_i32", _ -> ExternGlobal (global (GlobalType (Cons, NumType I32Type)))
+  | "global_i64", _ -> ExternGlobal (global (GlobalType (Cons, NumType I64Type)))
+  | "global_f32", _ -> ExternGlobal (global (GlobalType (Cons, NumType F32Type)))
+  | "global_f64", _ -> ExternGlobal (global (GlobalType (Cons, NumType F64Type)))
   | "table", _ -> ExternTable table
   | "memory", _ -> ExternMemory memory
   | _ -> raise Not_found
diff --git a/interpreter/runtime/global.ml b/interpreter/runtime/global.ml
index b7924c293..36f47e062 100644
--- a/interpreter/runtime/global.ml
+++ b/interpreter/runtime/global.ml
@@ -7,7 +7,7 @@ type t = global
 exception Type
 exception NotMutable
 
-let alloc (GlobalType (t, _) as ty) v =
+let alloc (GlobalType (_mut, t) as ty) v =
   if not (Match.match_value_type [] [] (type_of_value v) t) then raise Type;
   {ty; content = v}
 
@@ -18,7 +18,7 @@ let load glob =
   glob.content
 
 let store glob v =
-  let GlobalType (t, mut) = glob.ty in
-  if mut <> Mutable then raise NotMutable;
+  let GlobalType (mut, t) = glob.ty in
+  if mut <> Var then raise NotMutable;
   if not (Match.match_value_type [] [] (type_of_value v) t) then raise Type;
   glob.content <- v
diff --git a/interpreter/runtime/value.ml b/interpreter/runtime/value.ml
index e323a1cec..2c7342a43 100644
--- a/interpreter/runtime/value.ml
+++ b/interpreter/runtime/value.ml
@@ -99,8 +99,8 @@ let type_of_vec = function
 
 let type_of_ref' = ref (function _ -> assert false)
 let type_of_ref = function
-  | NullRef t -> (Nullable, t)
-  | r -> (NonNullable, !type_of_ref' r)
+  | NullRef t -> (Null, t)
+  | r -> (NoNull, !type_of_ref' r)
 
 let type_of_value = function
   | Num n -> NumType (type_of_num n)
@@ -142,8 +142,8 @@ let default_vec = function
   | V128Type -> Some (Vec (V128 V128.zero))
 
 let default_ref = function
-  | (Nullable, t) -> Some (Ref (NullRef t))
-  | (NonNullable, _) -> None
+  | (Null, t) -> Some (Ref (NullRef t))
+  | (NoNull, _) -> None
 
 let default_value = function
   | NumType t' -> default_num t'
diff --git a/interpreter/script/js.ml b/interpreter/script/js.ml
index 23f3bb65c..07a03ef50 100644
--- a/interpreter/script/js.ml
+++ b/interpreter/script/js.ml
@@ -389,8 +389,8 @@ let assert_return ress ts at =
   in [], List.flatten (List.rev_map test (List.combine ress ts))
 
 let i32_type = NumType I32Type
-let funcref_type = RefType (Nullable, FuncHeapType)
-let externref_type = RefType (Nullable, ExternHeapType)
+let funcref_type = RefType (Null, FuncHeapType)
+let externref_type = RefType (Null, ExternHeapType)
 let func_def_type ins out at = FuncDefType (FuncType (ins, out)) @@ at
 
 let wrap item_name wrap_action wrap_assertion at =
@@ -446,10 +446,10 @@ let is_js_value_type = function
   | BotType -> assert false
 
 let is_js_global_type = function
-  | GlobalType (t, mut) -> is_js_value_type t && mut = Immutable
+  | GlobalType (mut, t) -> is_js_value_type t && mut = Cons
 
 let is_js_func_type = function
-  | FuncType (ins, out) -> List.for_all is_js_value_type (ins @ out)
+  | FuncType (ts1, ts2) -> List.for_all is_js_value_type (ts1 @ ts2)
 
 
 (* Script conversion *)
@@ -567,7 +567,7 @@ let of_action mods act =
     "get(" ^ of_var_opt mods x_opt ^ ", " ^ of_name name ^ ")",
     (match lookup mods x_opt name act.at with
     | ExternGlobalType gt when not (is_js_global_type gt) ->
-      let GlobalType (t, _) = gt in
+      let GlobalType (_, t) = gt in
       Some (of_wrapper mods x_opt name (get gt), [t])
     | _ -> None
     )
diff --git a/interpreter/script/run.ml b/interpreter/script/run.ml
index 98faf4c41..8a5e263da 100644
--- a/interpreter/script/run.ml
+++ b/interpreter/script/run.ml
@@ -232,8 +232,8 @@ let type_of_result r =
   | NumResult (NanPat n) -> Types.NumType (Value.type_of_num n.it)
   | VecResult (VecPat _) -> Types.VecType Types.V128Type
   | RefResult (RefPat r) -> Types.RefType (Value.type_of_ref r.it)
-  | RefResult (RefTypePat t) -> Types.(RefType (NonNullable, t))
-  | RefResult (NullPat) -> Types.(RefType (Nullable, ExternHeapType))
+  | RefResult (RefTypePat t) -> Types.(RefType (NoNull, t))
+  | RefResult (NullPat) -> Types.(RefType (Null, ExternHeapType))
 
 let string_of_num_pat (p : num_pat) =
   match p with
diff --git a/interpreter/syntax/ast.ml b/interpreter/syntax/ast.ml
index 9503b010d..b5b5c03ac 100644
--- a/interpreter/syntax/ast.ml
+++ b/interpreter/syntax/ast.ml
@@ -134,9 +134,6 @@ type num = Value.num Source.phrase
 type vec = Value.vec Source.phrase
 type name = Utf8.unicode
 
-type local = local' Source.phrase
-and local' = value_type
-
 type block_type = VarBlockType of var | ValBlockType of value_type option
 
 type instr = instr' Source.phrase
@@ -210,10 +207,16 @@ and instr' =
   | VecReplace of vec_replaceop       (* replace lane in vector *)
 
 
-(* Globals & Functions *)
+(* Locals, globals & Functions *)
 
 type const = instr list Source.phrase
 
+type local = local' Source.phrase
+and local' =
+{
+  ltype : value_type;
+}
+
 type global = global' Source.phrase
 and global' =
 {
diff --git a/interpreter/syntax/free.ml b/interpreter/syntax/free.ml
index 66b8b7898..b83f4d196 100644
--- a/interpreter/syntax/free.ml
+++ b/interpreter/syntax/free.ml
@@ -87,7 +87,7 @@ let value_type = function
 
 let func_type (FuncType (ins, out)) =
   list value_type ins ++ list value_type out
-let global_type (GlobalType (t, _mut)) = value_type t
+let global_type (GlobalType (_mut, t)) = value_type t
 let table_type (TableType (_lim, t)) = ref_type t
 let memory_type (MemoryType (_lim)) = empty
 
diff --git a/interpreter/syntax/types.ml b/interpreter/syntax/types.ml
index b9766b984..01e86dadd 100644
--- a/interpreter/syntax/types.ml
+++ b/interpreter/syntax/types.ml
@@ -8,8 +8,8 @@ and syn_var = type_idx
 and sem_var = def_type Lib.Promise.t
 and var = SynVar of syn_var | SemVar of sem_var
 
-and init = Initialized | Uninitialized
-and nullability = NonNullable | Nullable
+and init = Set | Unset
+and nullability = NoNull | Null
 and num_type = I32Type | I64Type | F32Type | F64Type
 and vec_type = V128Type
 and ref_type = nullability * heap_type
@@ -24,11 +24,11 @@ and func_type = FuncType of result_type * result_type
 and def_type = FuncDefType of func_type
 
 type 'a limits = {min : 'a; max : 'a option}
-type mutability = Immutable | Mutable
+type mutability = Cons | Var
 type table_type = TableType of Int32.t limits * ref_type
 type memory_type = MemoryType of Int32.t limits
-type global_type = GlobalType of value_type * mutability
-type local_type = LocalType of value_type * init
+type global_type = GlobalType of mutability * value_type
+type local_type = LocalType of init * value_type
 type extern_type =
   | ExternFuncType of func_type
   | ExternTableType of table_type
@@ -90,7 +90,7 @@ let defaultable_vec_type = function
   | _ -> true
 
 let defaultable_ref_type = function
-  | (nul, _) -> nul = Nullable
+  | (nul, _) -> nul = Null
 
 let defaultable_value_type = function
   | NumType t -> defaultable_num_type t
@@ -165,8 +165,8 @@ let sem_memory_type c (MemoryType lim) =
 let sem_table_type c (TableType (lim, t)) =
   TableType (lim, sem_ref_type c t)
 
-let sem_global_type c (GlobalType (t, mut)) =
-  GlobalType (sem_value_type c t, mut)
+let sem_global_type c (GlobalType (mut, t)) =
+  GlobalType (mut, sem_value_type c t)
 
 let sem_func_type c (FuncType (ins, out)) =
   FuncType (sem_stack_type c ins, sem_stack_type c out)
@@ -228,8 +228,8 @@ let rec string_of_var =
     )
 
 and string_of_nullability = function
-  | NonNullable -> ""
-  | Nullable -> "null "
+  | NoNull -> ""
+  | Null -> "null "
 
 and string_of_num_type = function
   | I32Type -> "i32"
@@ -278,8 +278,12 @@ let string_of_table_type = function
   | TableType (lim, t) -> string_of_limits lim ^ " " ^ string_of_ref_type t
 
 let string_of_global_type = function
-  | GlobalType (t, Immutable) -> string_of_value_type t
-  | GlobalType (t, Mutable) -> "(mut " ^ string_of_value_type t ^ ")"
+  | GlobalType (Cons, t) -> string_of_value_type t
+  | GlobalType (Var, t) -> "(mut " ^ string_of_value_type t ^ ")"
+
+let string_of_local_type = function
+  | LocalType (Set, t) -> string_of_value_type t
+  | LocalType (Unset, t) -> "(unset " ^ string_of_value_type t ^ ")"
 
 let string_of_extern_type = function
   | ExternFuncType ft -> "func " ^ string_of_func_type ft
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index e1a40e438..830e8314b 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -74,8 +74,8 @@ let limits nat {min; max} =
   String.concat " " (nat min :: opt nat max)
 
 let global_type = function
-  | GlobalType (t, Immutable) -> atom string_of_value_type t
-  | GlobalType (t, Mutable) -> Node ("mut", [atom string_of_value_type t])
+  | GlobalType (Cons, t) -> atom string_of_value_type t
+  | GlobalType (Var, t) -> Node ("mut", [atom string_of_value_type t])
 
 let pack_size = function
   | Pack8 -> "8"
@@ -524,7 +524,7 @@ let func_with_name name f =
   let {ftype; locals; body} = f.it in
   Node ("func" ^ name,
     [Node ("type " ^ var ftype, [])] @
-    decls "local" (List.map Source.it locals) @
+    decls "local" (List.map (fun loc -> loc.it.ltype) locals) @
     list instr body
   )
 
@@ -548,11 +548,11 @@ let memory off i mem =
   Node ("memory $" ^ nat (off + i) ^ " " ^ limits nat32 lim, [])
 
 let is_elem_kind = function
-  | (NonNullable, FuncHeapType) -> true
+  | (NoNull, FuncHeapType) -> true
   | _ -> false
 
 let elem_kind = function
-  | (NonNullable, FuncHeapType) -> "func"
+  | (NoNull, FuncHeapType) -> "func"
   | _ -> assert false
 
 let is_elem_index e =
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index 2aeb0ac1d..148b081af 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -310,8 +310,8 @@ string_list :
 /* Types */
 
 null_opt :
-  | /* empty */ { NonNullable }
-  | NULL { Nullable }
+  | /* empty */ { NoNull }
+  | NULL { Null }
 
 heap_type :
   | FUNC { fun c -> FuncHeapType }
@@ -320,8 +320,8 @@ heap_type :
 
 ref_type :
   | LPAR REF null_opt heap_type RPAR { fun c -> ($3, $4 c) }
-  | FUNCREF { fun c -> (Nullable, FuncHeapType) }  /* Sugar */
-  | EXTERNREF { fun c -> (Nullable, ExternHeapType) }  /* Sugar */
+  | FUNCREF { fun c -> (Null, FuncHeapType) }  /* Sugar */
+  | EXTERNREF { fun c -> (Null, ExternHeapType) }  /* Sugar */
 
 value_type :
   | NUM_TYPE { fun c -> NumType $1 }
@@ -333,8 +333,8 @@ value_type_list :
   | value_type value_type_list { I32.add (fst $2) 1l, fun c -> $1 c :: snd $2 c }
 
 global_type :
-  | value_type { fun c -> GlobalType ($1 c, Immutable) }
-  | LPAR MUT value_type RPAR { fun c -> GlobalType ($3 c, Mutable) }
+  | value_type { fun c -> GlobalType (Cons, $1 c) }
+  | LPAR MUT value_type RPAR { fun c -> GlobalType (Var, $3 c) }
 
 def_type :
   | LPAR FUNC func_type RPAR { fun c -> FuncDefType ($3 c) }
@@ -820,7 +820,7 @@ func_body :
       {f with locals = $4 c :: f.locals} }
 
 local_type :
-  | value_type { let at = at () in fun c -> $1 c @@ at }
+  | value_type { let at = at () in fun c -> {ltype = $1 c} @@ at }
 
 local_type_list :
   | /* empty */ { 0l, fun c -> [] }
@@ -840,7 +840,7 @@ offset :
   | expr { let at = at () in fun c -> $1 c @@ at }  /* Sugar */
 
 elem_kind :
-  | FUNC { (NonNullable, FuncHeapType) }
+  | FUNC { (NoNull, FuncHeapType) }
 
 elem_expr :
   | LPAR ITEM const_expr RPAR { $3 }
@@ -889,7 +889,7 @@ elem :
     { let at = at () in
       fun c -> ignore ($3 c anon_elem bind_elem);
       fun () ->
-      { etype = (NonNullable, FuncHeapType); einit = $5 c func;
+      { etype = (NoNull, FuncHeapType); einit = $5 c func;
         emode = Active {index = 0l @@ at; offset = $4 c} @@ at } @@ at }
 
 table :
diff --git a/interpreter/valid/match.ml b/interpreter/valid/match.ml
index 3b1dac447..e36c28919 100644
--- a/interpreter/valid/match.ml
+++ b/interpreter/valid/match.ml
@@ -75,7 +75,7 @@ and eq_table_type c a (TableType (lim1, t1)) (TableType (lim2, t2)) =
 and eq_memory_type c a (MemoryType lim1) (MemoryType lim2) =
   eq_limits c a lim1 lim2
 
-and eq_global_type c a (GlobalType (t1, mut1)) (GlobalType (t2, mut2)) =
+and eq_global_type c a (GlobalType (mut1, t1)) (GlobalType (mut2, t2)) =
   eq_mutability c a mut1 mut2 && eq_value_type c a t1 t2
 
 and eq_extern_type c a et1 et2 =
@@ -91,7 +91,7 @@ and eq_extern_type c a et1 et2 =
 
 let match_nullability c a nul1 nul2 =
   match nul1, nul2 with
-  | NonNullable, Nullable -> true
+  | NoNull, Null -> true
   | _, _ -> nul1 = nul2
 
 let match_limits c a lim1 lim2 =
@@ -143,11 +143,11 @@ and match_table_type c a (TableType (lim1, t1)) (TableType (lim2, t2)) =
 and match_memory_type c a (MemoryType lim1) (MemoryType lim2) =
   match_limits c a lim1 lim2
 
-and match_global_type c a (GlobalType (t1, mut1)) (GlobalType (t2, mut2)) =
+and match_global_type c a (GlobalType (mut1, t1)) (GlobalType (mut2, t2)) =
   eq_mutability c [] mut1 mut2 &&
   match mut1 with
-  | Immutable -> match_value_type c a t1 t2
-  | Mutable -> eq_value_type c [] t1 t2
+  | Cons -> match_value_type c a t1 t2
+  | Var -> eq_value_type c [] t1 t2
 
 and match_extern_type c a et1 et2 =
   match et1, et2 with
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index 2c4a02192..c4a660b36 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -56,8 +56,8 @@ let replace category list x y =
     error x.at ("unknown " ^ category ^ " " ^ I32.to_string_u x.it)
 
 let init_local (c : context) x =
-  let LocalType (t, _) = local c x in
-  {c with locals = replace "local" c.locals x (LocalType (t, Initialized))}
+  let LocalType (_, t) = local c x in
+  {c with locals = replace "local" c.locals x (LocalType (Set, t))}
 
 let init_locals (c : context) xs =
   List.fold_left init_local c xs
@@ -128,7 +128,7 @@ let check_memory_type (c : context) (mt : memory_type) at =
     "memory size must be at most 65536 pages (4GiB)"
 
 let check_global_type (c : context) (gt : global_type) at =
-  let GlobalType (t, mut) = gt in
+  let GlobalType (_mut, t) = gt in
   check_value_type c t at
 
 let check_def_type (c : context) (dt : def_type) at =
@@ -183,7 +183,7 @@ let peek i (ell, ts) =
 let peek_ref i (ell, ts) at =
   match peek i (ell, ts) with
   | RefType rt -> rt
-  | BotType -> (NonNullable, BotHeapType)
+  | BotType -> (NoNull, BotHeapType)
   | t ->
     error at
       ("type mismatch: instruction requires reference type" ^
@@ -311,12 +311,10 @@ let check_block_type (c : context) (bt : block_type) at : func_type =
   | VarBlockType (SynVar x) -> func_type c (x @@ at)
   | VarBlockType (SemVar _) -> assert false
 
-let check_local (c : context) (defaulted : bool) (t : local) : local_type =
-  check_value_type c t.it t.at;
-  let init =
-    if not defaulted || defaultable_value_type t.it
-    then Initialized else Uninitialized
-  in LocalType (t.it, init)
+let check_local (c : context) (loc : local) : local_type =
+  check_value_type c loc.it.ltype loc.at;
+  let init = if defaultable_value_type loc.it.ltype then Set else Unset in
+  LocalType (init, loc.it.ltype)
 
 let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_instr_type =
   match e.it with
@@ -373,12 +371,12 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
 
   | BrOnNull x ->
     let (_, t) = peek_ref 0 s e.at in
-    (label c x @ [RefType (Nullable, t)]) -->
-      (label c x @ [RefType (NonNullable, t)]), []
+    (label c x @ [RefType (Null, t)]) -->
+      (label c x @ [RefType (NoNull, t)]), []
 
   | BrOnNonNull x ->
     let (_, ht) as rt = peek_ref 0 s e.at in
-    let t' = RefType (NonNullable, ht) in
+    let t' = RefType (NoNull, ht) in
     require (label c x <> []) e.at
       ("type mismatch: instruction requires type " ^ string_of_value_type t' ^
        " but label has " ^ string_of_result_type (label c x));
@@ -411,7 +409,7 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
   | CallIndirect (x, y) ->
     let TableType (lim, t) = table c x in
     let FuncType (ts1, ts2) = func_type c y in
-    require (match_ref_type c.types [] t (Nullable, FuncHeapType)) x.at
+    require (match_ref_type c.types [] t (Null, FuncHeapType)) x.at
       ("type mismatch: instruction requires table of function type" ^
        " but table has element type " ^ string_of_ref_type t);
     (ts1 @ [NumType I32Type]) --> ts2, []
@@ -434,25 +432,25 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
     )
 
   | LocalGet x ->
-    let LocalType (t, init) = local c x in
-    require (init = Initialized) x.at "uninitialized local";
+    let LocalType (init, t) = local c x in
+    require (init = Set) x.at "uninitialized local";
     [] --> [t], []
 
   | LocalSet x ->
-    let LocalType (t, _) = local c x in
+    let LocalType (_, t) = local c x in
     [t] --> [], [x]
 
   | LocalTee x ->
-    let LocalType (t, _) = local c x in
+    let LocalType (_, t) = local c x in
     [t] --> [t], [x]
 
   | GlobalGet x ->
-    let GlobalType (t, _mut) = global c x in
+    let GlobalType (_mut, t) = global c x in
     [] --> [t], []
 
   | GlobalSet x ->
-    let GlobalType (t, mut) = global c x in
-    require (mut = Mutable) x.at "global is immutable";
+    let GlobalType (mut, t) = global c x in
+    require (mut = Var) x.at "immutable global";
     [t] --> [], []
 
   | TableGet x ->
@@ -550,21 +548,21 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
 
   | RefNull t ->
     check_heap_type c t e.at;
-    [] --> [RefType (Nullable, t)], []
+    [] --> [RefType (Null, t)], []
 
   | RefIsNull ->
     let (_, t) = peek_ref 0 s e.at in
-    [RefType (Nullable, t)] --> [NumType I32Type], []
+    [RefType (Null, t)] --> [NumType I32Type], []
 
   | RefAsNonNull ->
     let (_, t) = peek_ref 0 s e.at in
-    [RefType (Nullable, t)] --> [RefType (NonNullable, t)], []
+    [RefType (Null, t)] --> [RefType (NoNull, t)], []
 
   | RefFunc x ->
     let ft = func c x in
     let y = Lib.Option.force (Lib.List32.index_of (FuncDefType ft) c.types) in
     refer_func c x;
-    [] --> [RefType (NonNullable, DefHeapType (SynVar y))], []
+    [] --> [RefType (NoNull, DefHeapType (SynVar y))], []
 
   | Const v ->
     let t = NumType (type_num v.it) in
@@ -697,10 +695,10 @@ and check_block (c : context) (es : instr list) (ft : func_type) at =
 let check_func (c : context) (f : func) =
   let {ftype; locals; body} = f.it in
   let FuncType (ts1, ts2) = func_type c ftype in
-  let ts = List.map (check_local c true) locals in
+  let lts = List.map (check_local c) locals in
   let c' =
     { c with
-      locals = List.map (fun t -> LocalType (t, Initialized)) ts1 @ ts;
+      locals = List.map (fun t -> LocalType (Set, t)) ts1 @ lts;
       results = ts2;
       labels = [ts2]
     }
@@ -713,7 +711,7 @@ let is_const (c : context) (e : instr) =
   | RefFunc _
   | Const _
   | VecConst _ -> true
-  | GlobalGet x -> let GlobalType (_, mut) = global c x in mut = Immutable
+  | GlobalGet x -> let GlobalType (mut, _t) = global c x in mut = Cons
   | _ -> false
 
 let check_const (c : context) (const : const) (t : value_type) =
@@ -764,7 +762,7 @@ let check_data (c : context) (seg : data_segment) =
 let check_global (c : context) (glob : global) =
   let {gtype; ginit} = glob.it in
   check_global_type c gtype glob.at;
-  let GlobalType (t, mut) = gtype in
+  let GlobalType (_mut, t) = gtype in
   check_const c ginit t
 
 
diff --git a/test/core/global.wast b/test/core/global.wast
index 9fa5e2231..6881b8361 100644
--- a/test/core/global.wast
+++ b/test/core/global.wast
@@ -271,12 +271,12 @@
 
 (assert_invalid
   (module (global f32 (f32.const 0)) (func (global.set 0 (f32.const 1))))
-  "global is immutable"
+  "immutable global"
 )
 
 (assert_invalid
   (module (import "spectest" "global_i32" (global i32)) (func (global.set 0 (i32.const 1))))
-  "global is immutable"
+  "immutable global"
 )
 
 ;; mutable globals can be exported

From e8c05f4b0d3a68bd3b4389b943fbb763a7d3a3ae Mon Sep 17 00:00:00 2001
From: ariez-xyz <41232910+ariez-xyz@users.noreply.github.com>
Date: Sat, 23 Jul 2022 23:18:33 +0200
Subject: [PATCH 145/285] [spec] Fix typo (#1508)

---
 document/core/syntax/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index 6ebb400d9..87f805e5c 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -195,7 +195,7 @@ Occasionally, it is convenient to group operators together according to the foll
 Vector Instructions
 ~~~~~~~~~~~~~~~~~~~
 
-Vector instructions (also known as *SIMD* instructions, single data multiple value) provide basic operations over :ref:`values <syntax-value>` of :ref:`vector type <syntax-vectype>`.
+Vector instructions (also known as *SIMD* instructions, single instruction multiple data) provide basic operations over :ref:`values <syntax-value>` of :ref:`vector type <syntax-vectype>`.
 
 .. math::
    \begin{array}{llcl}

From ef0ca332e7b591e04b29cc040ad9add68cacaaae Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Sun, 24 Jul 2022 15:24:12 +0200
Subject: [PATCH 146/285] WIP

---
 interpreter/binary/decode.ml    |  66 ++--
 interpreter/binary/encode.ml    | 199 ++++++-------
 interpreter/exec/eval.ml        |  77 ++---
 interpreter/exec/eval_num.ml    |  13 +-
 interpreter/exec/eval_vec.ml    |   2 +-
 interpreter/exec/v128.ml        |   8 +-
 interpreter/host/env.ml         |  16 +-
 interpreter/host/spectest.ml    |  52 ++--
 interpreter/runtime/func.ml     |   6 +-
 interpreter/runtime/func.mli    |  12 +-
 interpreter/runtime/global.ml   |  12 +-
 interpreter/runtime/global.mli  |   2 +-
 interpreter/runtime/instance.ml |  14 +-
 interpreter/runtime/memory.ml   |  23 +-
 interpreter/runtime/memory.mli  |   8 +-
 interpreter/runtime/table.ml    |  12 +-
 interpreter/runtime/table.mli   |   2 +-
 interpreter/runtime/value.ml    |  52 ++--
 interpreter/script/import.ml    |   9 +-
 interpreter/script/import.mli   |   2 +-
 interpreter/script/js.ml        |  98 +++---
 interpreter/script/run.ml       |  28 +-
 interpreter/script/script.ml    |   2 +-
 interpreter/syntax/ast.ml       |  31 +-
 interpreter/syntax/free.ml      |  38 ++-
 interpreter/syntax/operators.ml |  92 +++---
 interpreter/syntax/pack.ml      |  17 ++
 interpreter/syntax/types.ml     | 512 ++++++++++++++++----------------
 interpreter/text/arrange.ml     |  28 +-
 interpreter/text/lexer.mll      |  10 +-
 interpreter/text/parser.mly     | 205 +++++++------
 interpreter/valid/match.ml      | 315 +++++++++++---------
 interpreter/valid/match.mli     |  40 ---
 interpreter/valid/valid.ml      | 384 ++++++++++++------------
 34 files changed, 1203 insertions(+), 1184 deletions(-)
 create mode 100644 interpreter/syntax/pack.ml
 delete mode 100644 interpreter/valid/match.mli

diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index eee1d8642..98b8785fe 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -106,7 +106,7 @@ let s33 s = I32_convert.wrap_i64 (sN 33 s)
 let s64 s = sN 64 s
 let f32 s = F32.of_bits (word32 s)
 let f64 s = F64.of_bits (word64 s)
-let v128 s = V128.of_bits (get_string (Types.vec_size Types.V128Type) s)
+let v128 s = V128.of_bits (get_string (Types.vec_size `V128) s)
 
 let len32 s =
   let pos = pos s in
@@ -146,31 +146,31 @@ open Types
 
 let num_type s =
   match s7 s with
-  | -0x01 -> I32Type
-  | -0x02 -> I64Type
-  | -0x03 -> F32Type
-  | -0x04 -> F64Type
+  | -0x01 -> `I32
+  | -0x02 -> `I64
+  | -0x03 -> `F32
+  | -0x04 -> `F64
   | _ -> error s (pos s - 1) "malformed number type"
 
 let vec_type s =
   match s7 s with
-  | -0x05 -> V128Type
+  | -0x05 -> `V128
   | _ -> error s (pos s - 1) "malformed vector type"
 
 let var_type s =
   let pos = pos s in
   match s33 s with
-  | i when i >= 0l -> SynVar i
+  | i when i >= 0l -> i
   | _ -> error s pos "malformed type index"
 
 let heap_type s =
   let pos = pos s in
   either [
-    (fun s -> DefHeapType (var_type s));
+    (fun s -> `Def (var_type s));
     (fun s ->
       match s7 s with
-      | -0x10 -> FuncHeapType
-      | -0x11 -> ExternHeapType
+      | -0x10 -> `Func
+      | -0x11 -> `Extern
       | _ -> error s pos "malformed heap type"
     )
   ] s
@@ -178,29 +178,29 @@ let heap_type s =
 let ref_type s =
   let pos = pos s in
   match s7 s with
-  | -0x10 -> (Null, FuncHeapType)
-  | -0x11 -> (Null, ExternHeapType)
-  | -0x14 -> (Null, heap_type s)
-  | -0x15 -> (NoNull, heap_type s)
+  | -0x10 -> `Ref (`Null, `Func)
+  | -0x11 -> `Ref (`Null, `Extern)
+  | -0x14 -> `Ref (`Null, heap_type s)
+  | -0x15 -> `Ref (`NoNull, heap_type s)
   | _ -> error s pos "malformed reference type"
 
-let value_type s =
+let val_type s =
   either [
-    (fun s -> NumType (num_type s));
-    (fun s -> VecType (vec_type s));
-    (fun s -> RefType (ref_type s));
+    (fun s -> num_type s);
+    (fun s -> vec_type s);
+    (fun s -> ref_type s);
   ] s
 
-let result_type s = vec value_type s
+let result_type s = vec val_type s
 
 let func_type s =
   let ts1 = result_type s in
   let ts2 = result_type s in
-  FuncType (ts1, ts2)
+  `Func (ts1, ts2)
 
 let def_type s =
   match s7 s with
-  | -0x20 -> FuncDefType (func_type s)
+  | -0x20 -> func_type s
   | _ -> error s (pos s - 1) "malformed definition type"
 
 
@@ -213,22 +213,22 @@ let limits uN s =
 let table_type s =
   let t = ref_type s in
   let lim = limits u32 s in
-  TableType (lim, t)
+  `Table (lim, t)
 
 let memory_type s =
   let lim = limits u32 s in
-  MemoryType lim
+  `Memory lim
 
 let mutability s =
   match byte s with
-  | 0 -> Cons
-  | 1 -> Var
+  | 0 -> `Const
+  | 1 -> `Var
   | _ -> error s (pos s - 1) "malformed mutability"
 
 let global_type s =
-  let t = value_type s in
+  let t = val_type s in
   let mut = mutability s in
-  GlobalType (mut, t)
+  `Global (mut, t)
 
 
 (* Instructions *)
@@ -252,12 +252,12 @@ let block_type s =
   either [
     (fun s -> VarBlockType (var_type s));
     (fun s -> expect 0x40 s ""; ValBlockType None);
-    (fun s -> ValBlockType (Some (value_type s)));
+    (fun s -> ValBlockType (Some (val_type s)));
   ] s
 
 let local s =
   let n = u32 s in
-  let t = at value_type s in
+  let t = at val_type s in
   n, {ltype = t.it} @@ t.at
 
 let locals s =
@@ -327,7 +327,7 @@ let rec instr s =
 
   | 0x1a -> drop
   | 0x1b -> select None
-  | 0x1c -> select (Some (vec value_type s))
+  | 0x1c -> select (Some (vec val_type s))
 
   | 0x1d | 0x1e | 0x1f as b -> illegal s pos b
 
@@ -1001,7 +1001,7 @@ let elem_index s =
 
 let elem_kind s =
   match byte s with
-  | 0x00 -> (NoNull, FuncHeapType)
+  | 0x00 -> `Ref (`NoNull, `Func)
   | _ -> error s (pos s - 1) "malformed element kind"
 
 let elem s =
@@ -1009,7 +1009,7 @@ let elem s =
   | 0x00l ->
     let emode = at active_zero s in
     let einit = vec (at elem_index) s in
-    {etype = (NoNull, FuncHeapType); einit; emode}
+    {etype = `Ref (`NoNull, `Func); einit; emode}
   | 0x01l ->
     let emode = at passive s in
     let etype = elem_kind s in
@@ -1028,7 +1028,7 @@ let elem s =
   | 0x04l ->
     let emode = at active_zero s in
     let einit = vec const s in
-    {etype = (NoNull, FuncHeapType); einit; emode}
+    {etype = `Ref (`NoNull, `Func); einit; emode}
   | 0x05l ->
     let emode = at passive s in
     let etype = ref_type s in
diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index ac0722cb7..11215de42 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -96,57 +96,56 @@ struct
   open Types
 
   let var_type = function
-    | SynVar x -> s33 x
-    | SemVar _ -> assert false
+    | x -> s33 x
 
   let num_type = function
-    | I32Type -> s7 (-0x01)
-    | I64Type -> s7 (-0x02)
-    | F32Type -> s7 (-0x03)
-    | F64Type -> s7 (-0x04)
+    | `I32 -> s7 (-0x01)
+    | `I64 -> s7 (-0x02)
+    | `F32 -> s7 (-0x03)
+    | `F64 -> s7 (-0x04)
 
   let vec_type = function
-    | V128Type -> s7 (-0x05)
+    | `V128 -> s7 (-0x05)
 
   let heap_type = function
-    | FuncHeapType -> s7 (-0x10)
-    | ExternHeapType -> s7 (-0x11)
-    | DefHeapType x -> var_type x
-    | BotHeapType -> assert false
+    | `Func -> s7 (-0x10)
+    | `Extern -> s7 (-0x11)
+    | `Def x -> var_type x
+    | `Bot -> assert false
 
   let ref_type = function
-    | (Null, FuncHeapType) -> s7 (-0x10)
-    | (Null, ExternHeapType) -> s7 (-0x11)
-    | (Null, t) -> s7 (-0x14); heap_type t
-    | (NoNull, t) -> s7 (-0x15); heap_type t
+    | `Ref (`Null, `Func) -> s7 (-0x10)
+    | `Ref (`Null, `Extern) -> s7 (-0x11)
+    | `Ref (`Null, t) -> s7 (-0x14); heap_type t
+    | `Ref (`NoNull, t) -> s7 (-0x15); heap_type t
 
-  let value_type = function
-    | NumType t -> num_type t
-    | VecType t -> vec_type t
-    | RefType t -> ref_type t
-    | BotType -> assert false
+  let val_type = function
+    | #num_type as t -> num_type t
+    | #vec_type as t -> vec_type t
+    | #ref_type as t -> ref_type t
+    | `Bot -> assert false
 
   let func_type = function
-    | FuncType (ts1, ts2) -> vec value_type ts1; vec value_type ts2
+    | `Func (ts1, ts2) -> vec val_type ts1; vec val_type ts2
 
   let def_type = function
-    | FuncDefType ft -> s7 (-0x20); func_type ft
+    | #func_type as ft -> s7 (-0x20); func_type ft
 
   let limits vu {min; max} =
     bool (max <> None); vu min; opt vu max
 
   let table_type = function
-    | TableType (lim, t) -> ref_type t; limits u32 lim
+    | `Table (lim, t) -> ref_type t; limits u32 lim
 
   let memory_type = function
-    | MemoryType lim -> limits u32 lim
+    | `Memory lim -> limits u32 lim
 
   let mutability = function
-    | Cons -> byte 0
-    | Var -> byte 1
+    | `Const -> byte 0
+    | `Var -> byte 1
 
   let global_type = function
-    | GlobalType (mut, t) -> value_type t; mutability mut
+    | `Global (mut, t) -> val_type t; mutability mut
 
 
   (* Instructions *)
@@ -155,6 +154,7 @@ struct
   open Ast
   open Value
   open V128
+  open Pack
 
   let op n = byte n
   let vecop n = op 0xfd; u32 n
@@ -166,11 +166,10 @@ struct
 
   let block_type = function
     | ValBlockType None -> s33 (-0x40l)
-    | ValBlockType (Some t) -> value_type t
-    | VarBlockType (SynVar x) -> s33 x
-    | VarBlockType (SemVar _) -> assert false
+    | ValBlockType (Some t) -> val_type t
+    | VarBlockType x -> s33 x
 
-  let local (n, loc) = len n; value_type loc.it.ltype
+  let local (n, loc) = len n; val_type loc.it.ltype
 
   let locals locs =
     let combine loc = function
@@ -204,7 +203,7 @@ struct
 
     | Drop -> op 0x1a
     | Select None -> op 0x1b
-    | Select (Some ts) -> op 0x1c; vec value_type ts
+    | Select (Some ts) -> op 0x1c; vec val_type ts
 
     | LocalGet x -> op 0x20; var x
     | LocalSet x -> op 0x21; var x
@@ -221,101 +220,91 @@ struct
     | TableInit (x, y) -> op 0xfc; u32 0x0cl; var y; var x
     | ElemDrop x -> op 0xfc; u32 0x0dl; var x
 
-    | Load ({ty = I32Type; pack = None; _} as mo) -> op 0x28; memop mo
-    | Load ({ty = I64Type; pack = None; _} as mo) -> op 0x29; memop mo
-    | Load ({ty = F32Type; pack = None; _} as mo) -> op 0x2a; memop mo
-    | Load ({ty = F64Type; pack = None; _} as mo) -> op 0x2b; memop mo
-    | Load ({ty = I32Type; pack = Some (Pack8, SX); _} as mo) ->
-      op 0x2c; memop mo
-    | Load ({ty = I32Type; pack = Some (Pack8, ZX); _} as mo) ->
-      op 0x2d; memop mo
-    | Load ({ty = I32Type; pack = Some (Pack16, SX); _} as mo) ->
-      op 0x2e; memop mo
-    | Load ({ty = I32Type; pack = Some (Pack16, ZX); _} as mo) ->
-      op 0x2f; memop mo
-    | Load {ty = I32Type; pack = Some (Pack32, _); _} ->
+    | Load ({ty = `I32; pack = None; _} as mo) -> op 0x28; memop mo
+    | Load ({ty = `I64; pack = None; _} as mo) -> op 0x29; memop mo
+    | Load ({ty = `F32; pack = None; _} as mo) -> op 0x2a; memop mo
+    | Load ({ty = `F64; pack = None; _} as mo) -> op 0x2b; memop mo
+    | Load ({ty = `I32; pack = Some (Pack8, SX); _} as mo) -> op 0x2c; memop mo
+    | Load ({ty = `I32; pack = Some (Pack8, ZX); _} as mo) -> op 0x2d; memop mo
+    | Load ({ty = `I32; pack = Some (Pack16, SX); _} as mo) -> op 0x2e; memop mo
+    | Load ({ty = `I32; pack = Some (Pack16, ZX); _} as mo) -> op 0x2f; memop mo
+    | Load {ty = `I32; pack = Some (Pack32, _); _} ->
       error e.at "illegal instruction i32.load32"
-    | Load ({ty = I64Type; pack = Some (Pack8, SX); _} as mo) ->
-      op 0x30; memop mo
-    | Load ({ty = I64Type; pack = Some (Pack8, ZX); _} as mo) ->
-      op 0x31; memop mo
-    | Load ({ty = I64Type; pack = Some (Pack16, SX); _} as mo) ->
-      op 0x32; memop mo
-    | Load ({ty = I64Type; pack = Some (Pack16, ZX); _} as mo) ->
-      op 0x33; memop mo
-    | Load ({ty = I64Type; pack = Some (Pack32, SX); _} as mo) ->
-      op 0x34; memop mo
-    | Load ({ty = I64Type; pack = Some (Pack32, ZX); _} as mo) ->
-      op 0x35; memop mo
-    | Load {ty = F32Type | F64Type; pack = Some _; _} ->
+    | Load ({ty = `I64; pack = Some (Pack8, SX); _} as mo) -> op 0x30; memop mo
+    | Load ({ty = `I64; pack = Some (Pack8, ZX); _} as mo) -> op 0x31; memop mo
+    | Load ({ty = `I64; pack = Some (Pack16, SX); _} as mo) -> op 0x32; memop mo
+    | Load ({ty = `I64; pack = Some (Pack16, ZX); _} as mo) -> op 0x33; memop mo
+    | Load ({ty = `I64; pack = Some (Pack32, SX); _} as mo) -> op 0x34; memop mo
+    | Load ({ty = `I64; pack = Some (Pack32, ZX); _} as mo) -> op 0x35; memop mo
+    | Load {ty = `F32 | `F64; pack = Some _; _} ->
       error e.at "illegal instruction fxx.loadN"
-    | Load {ty = I32Type | I64Type; pack = Some (Pack64, _); _} ->
+    | Load {ty = `I32 | `I64; pack = Some (Pack64, _); _} ->
       error e.at "illegal instruction ixx.load64"
 
-    | Store ({ty = I32Type; pack = None; _} as mo) -> op 0x36; memop mo
-    | Store ({ty = I64Type; pack = None; _} as mo) -> op 0x37; memop mo
-    | Store ({ty = F32Type; pack = None; _} as mo) -> op 0x38; memop mo
-    | Store ({ty = F64Type; pack = None; _} as mo) -> op 0x39; memop mo
-    | Store ({ty = I32Type; pack = Some Pack8; _} as mo) -> op 0x3a; memop mo
-    | Store ({ty = I32Type; pack = Some Pack16; _} as mo) -> op 0x3b; memop mo
-    | Store {ty = I32Type; pack = Some Pack32; _} ->
+    | Store ({ty = `I32; pack = None; _} as mo) -> op 0x36; memop mo
+    | Store ({ty = `I64; pack = None; _} as mo) -> op 0x37; memop mo
+    | Store ({ty = `F32; pack = None; _} as mo) -> op 0x38; memop mo
+    | Store ({ty = `F64; pack = None; _} as mo) -> op 0x39; memop mo
+    | Store ({ty = `I32; pack = Some Pack8; _} as mo) -> op 0x3a; memop mo
+    | Store ({ty = `I32; pack = Some Pack16; _} as mo) -> op 0x3b; memop mo
+    | Store {ty = `I32; pack = Some Pack32; _} ->
       error e.at "illegal instruction i32.store32"
-    | Store ({ty = I64Type; pack = Some Pack8; _} as mo) -> op 0x3c; memop mo
-    | Store ({ty = I64Type; pack = Some Pack16; _} as mo) -> op 0x3d; memop mo
-    | Store ({ty = I64Type; pack = Some Pack32; _} as mo) -> op 0x3e; memop mo
-    | Store {ty = F32Type | F64Type; pack = Some _; _} ->
+    | Store ({ty = `I64; pack = Some Pack8; _} as mo) -> op 0x3c; memop mo
+    | Store ({ty = `I64; pack = Some Pack16; _} as mo) -> op 0x3d; memop mo
+    | Store ({ty = `I64; pack = Some Pack32; _} as mo) -> op 0x3e; memop mo
+    | Store {ty = `F32 | `F64; pack = Some _; _} ->
       error e.at "illegal instruction fxx.storeN"
-    | Store {ty = (I32Type | I64Type); pack = Some Pack64; _} ->
+    | Store {ty = (`I32 | `I64); pack = Some Pack64; _} ->
       error e.at "illegal instruction ixx.store64"
 
-    | VecLoad ({ty = V128Type; pack = None; _} as mo) ->
+    | VecLoad ({ty = `V128; pack = None; _} as mo) ->
       vecop 0x00l; memop mo
-    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtLane (Pack8x8, SX)); _} as mo) ->
+    | VecLoad ({ty = `V128; pack = Some (Pack64, ExtLane (Pack8x8, SX)); _} as mo) ->
       vecop 0x01l; memop mo
-    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtLane (Pack8x8, ZX)); _} as mo) ->
+    | VecLoad ({ty = `V128; pack = Some (Pack64, ExtLane (Pack8x8, ZX)); _} as mo) ->
       vecop 0x02l; memop mo
-    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtLane (Pack16x4, SX)); _} as mo) ->
+    | VecLoad ({ty = `V128; pack = Some (Pack64, ExtLane (Pack16x4, SX)); _} as mo) ->
       vecop 0x03l; memop mo
-    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtLane (Pack16x4, ZX)); _} as mo) ->
+    | VecLoad ({ty = `V128; pack = Some (Pack64, ExtLane (Pack16x4, ZX)); _} as mo) ->
       vecop 0x04l; memop mo
-    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtLane (Pack32x2, SX)); _} as mo) ->
+    | VecLoad ({ty = `V128; pack = Some (Pack64, ExtLane (Pack32x2, SX)); _} as mo) ->
       vecop 0x05l; memop mo
-    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtLane (Pack32x2, ZX)); _} as mo) ->
+    | VecLoad ({ty = `V128; pack = Some (Pack64, ExtLane (Pack32x2, ZX)); _} as mo) ->
       vecop 0x06l; memop mo
-    | VecLoad ({ty = V128Type; pack = Some (Pack8, ExtSplat); _} as mo) ->
+    | VecLoad ({ty = `V128; pack = Some (Pack8, ExtSplat); _} as mo) ->
       vecop 0x07l; memop mo
-    | VecLoad ({ty = V128Type; pack = Some (Pack16, ExtSplat); _} as mo) ->
+    | VecLoad ({ty = `V128; pack = Some (Pack16, ExtSplat); _} as mo) ->
       vecop 0x08l; memop mo
-    | VecLoad ({ty = V128Type; pack = Some (Pack32, ExtSplat); _} as mo) ->
+    | VecLoad ({ty = `V128; pack = Some (Pack32, ExtSplat); _} as mo) ->
       vecop 0x09l; memop mo
-    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtSplat); _} as mo) ->
+    | VecLoad ({ty = `V128; pack = Some (Pack64, ExtSplat); _} as mo) ->
       vecop 0x0al; memop mo
-    | VecLoad ({ty = V128Type; pack = Some (Pack32, ExtZero); _} as mo) ->
+    | VecLoad ({ty = `V128; pack = Some (Pack32, ExtZero); _} as mo) ->
       vecop 0x5cl; memop mo
-    | VecLoad ({ty = V128Type; pack = Some (Pack64, ExtZero); _} as mo) ->
+    | VecLoad ({ty = `V128; pack = Some (Pack64, ExtZero); _} as mo) ->
       vecop 0x5dl; memop mo
     | VecLoad _ ->
       error e.at "illegal instruction v128.loadNxM_<ext>"
 
-    | VecLoadLane ({ty = V128Type; pack = Pack8; _} as mo, i) ->
-      vecop 0x54l; memop mo; byte i;
-    | VecLoadLane ({ty = V128Type; pack = Pack16; _} as mo, i) ->
-      vecop 0x55l; memop mo; byte i;
-    | VecLoadLane ({ty = V128Type; pack = Pack32; _} as mo, i) ->
-      vecop 0x56l; memop mo; byte i;
-    | VecLoadLane ({ty = V128Type; pack = Pack64; _} as mo, i) ->
-      vecop 0x57l; memop mo; byte i;
-
-    | VecStore ({ty = V128Type; _} as mo) -> vecop 0x0bl; memop mo
-
-    | VecStoreLane ({ty = V128Type; pack = Pack8; _} as mo, i) ->
-      vecop 0x58l; memop mo; byte i;
-    | VecStoreLane ({ty = V128Type; pack = Pack16; _} as mo, i) ->
-      vecop 0x59l; memop mo; byte i;
-    | VecStoreLane ({ty = V128Type; pack = Pack32; _} as mo, i) ->
-      vecop 0x5al; memop mo; byte i;
-    | VecStoreLane ({ty = V128Type; pack = Pack64; _} as mo, i) ->
-      vecop 0x5bl; memop mo; byte i;
+    | VecLoadLane ({ty = `V128; pack = Pack8; _} as mo, i) ->
+      vecop 0x54l; memop mo; byte i
+    | VecLoadLane ({ty = `V128; pack = Pack16; _} as mo, i) ->
+      vecop 0x55l; memop mo; byte i
+    | VecLoadLane ({ty = `V128; pack = Pack32; _} as mo, i) ->
+      vecop 0x56l; memop mo; byte i
+    | VecLoadLane ({ty = `V128; pack = Pack64; _} as mo, i) ->
+      vecop 0x57l; memop mo; byte i
+
+    | VecStore ({ty = `V128; _} as mo) -> vecop 0x0bl; memop mo
+
+    | VecStoreLane ({ty = `V128; pack = Pack8; _} as mo, i) ->
+      vecop 0x58l; memop mo; byte i
+    | VecStoreLane ({ty = `V128; pack = Pack16; _} as mo, i) ->
+      vecop 0x59l; memop mo; byte i
+    | VecStoreLane ({ty = `V128; pack = Pack32; _} as mo, i) ->
+      vecop 0x5al; memop mo; byte i
+    | VecStoreLane ({ty = `V128; pack = Pack64; _} as mo, i) ->
+      vecop 0x5bl; memop mo; byte i
 
     | MemorySize -> op 0x3f; byte 0x00
     | MemoryGrow -> op 0x40; byte 0x00
@@ -881,11 +870,11 @@ struct
   (* Element section *)
 
   let is_elem_kind = function
-    | (NoNull, FuncHeapType) -> true
+    | `Ref (`NoNull, `Func) -> true
     | _ -> false
 
   let elem_kind = function
-    | (NoNull, FuncHeapType) -> byte 0x00
+    | `Ref (`NoNull, `Func) -> byte 0x00
     | _ -> assert false
 
   let is_elem_index e =
diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index 278217b0a..f8e117ae3 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -1,8 +1,9 @@
-open Types
-open Value
-open Instance
 open Ast
+open Pack
 open Source
+open Types.Sem
+open Value
+open Instance
 
 
 (* Errors *)
@@ -98,22 +99,22 @@ let local (frame : frame) x = lookup "local" frame.locals x
 
 let func_type (inst : module_inst) x = as_func_def_type (def_of (type_ inst x))
 
-let any_ref inst x i at =
+let any_ref (inst : module_inst) x i at =
   try Table.load (table inst x) i with Table.Bounds ->
     Trap.error at ("undefined element " ^ Int32.to_string i)
 
-let func_ref inst x i at =
+let func_ref (inst : module_inst) x i at =
   match any_ref inst x i at with
   | FuncRef f -> f
   | NullRef _ -> Trap.error at ("uninitialized element " ^ Int32.to_string i)
   | _ -> Crash.error at ("type mismatch for element " ^ Int32.to_string i)
 
-let block_type inst bt at =
+let block_type (inst : module_inst) bt at =
   match bt with
-  | ValBlockType None -> FuncType ([], [])
-  | ValBlockType (Some t) -> FuncType ([], [t])
-  | VarBlockType (SynVar x) -> func_type inst (x @@ at)
-  | VarBlockType (SemVar x) -> as_func_def_type (def_of x)
+  | ValBlockType None -> `Instr ([], [], [])
+  | ValBlockType (Some t) -> `Instr ([], [sem_val_type inst.types t], [])
+  | VarBlockType x ->
+    let `Func (ts1, ts2) = func_type inst (x @@ at) in `Instr (ts1, ts2, [])
 
 let take n (vs : 'a stack) at =
   try Lib.List.take n vs with Failure _ -> Crash.error at "stack underflow"
@@ -165,14 +166,14 @@ let rec step (c : config) : config =
         vs, []
 
       | Block (bt, es'), vs ->
-        let FuncType (ts1, ts2) = block_type c.frame.inst bt e.at in
+        let `Instr (ts1, ts2, _xs) = block_type c.frame.inst bt e.at in
         let n1 = List.length ts1 in
         let n2 = List.length ts2 in
         let args, vs' = take n1 vs e.at, drop n1 vs e.at in
         vs', [Label (n2, [], (args, List.map plain es')) @@ e.at]
 
       | Loop (bt, es'), vs ->
-        let FuncType (ts1, ts2) = block_type c.frame.inst bt e.at in
+        let `Instr (ts1, ts2, _xs) = block_type c.frame.inst bt e.at in
         let n1 = List.length ts1 in
         let args, vs' = take n1 vs e.at, drop n1 vs e.at in
         vs', [Label (n1, [e' @@ e.at], (args, List.map plain es')) @@ e.at]
@@ -229,7 +230,7 @@ let rec step (c : config) : config =
       | CallIndirect (x, y), Num (I32 i) :: vs ->
         let f = func_ref c.frame.inst x i e.at in
         if
-          Match.eq_func_type [] [] (func_type c.frame.inst y) (Func.type_of f)
+          Match.Sem.eq_func_type () [] (func_type c.frame.inst y) (Func.type_of f)
         then
           vs, [Invoke f @@ e.at]
         else
@@ -414,16 +415,16 @@ let rec step (c : config) : config =
             match pack with
             | Pack8 ->
               V128.I8x16.replace_lane j v
-                (I32Num.of_num 0 (Memory.load_num_packed Pack8 SX mem addr offset I32Type))
+                (I32Num.of_num 0 (Memory.load_num_packed Pack8 SX mem addr offset `I32))
             | Pack16 ->
               V128.I16x8.replace_lane j v
-                (I32Num.of_num 0 (Memory.load_num_packed Pack16 SX mem addr offset I32Type))
+                (I32Num.of_num 0 (Memory.load_num_packed Pack16 SX mem addr offset `I32))
             | Pack32 ->
               V128.I32x4.replace_lane j v
-                (I32Num.of_num 0 (Memory.load_num mem addr offset I32Type))
+                (I32Num.of_num 0 (Memory.load_num mem addr offset `I32))
             | Pack64 ->
               V128.I64x2.replace_lane j v
-                (I64Num.of_num 0 (Memory.load_num mem addr offset I64Type))
+                (I64Num.of_num 0 (Memory.load_num mem addr offset `I64))
           in Vec (V128 v) :: vs', []
         with exn -> vs', [Trapping (memory_error e.at exn) @@ e.at])
 
@@ -466,7 +467,7 @@ let rec step (c : config) : config =
             Plain (Const (I32 i @@ e.at));
             Plain (Const (k @@ e.at));
             Plain (Store
-              {ty = I32Type; align = 0; offset = 0l; pack = Some Pack8});
+              {ty = `I32; align = 0; offset = 0l; pack = Some Pack8});
             Plain (Const (I32 (I32.add i 1l) @@ e.at));
             Plain (Const (k @@ e.at));
             Plain (Const (I32 (I32.sub n 1l) @@ e.at));
@@ -483,9 +484,9 @@ let rec step (c : config) : config =
             Plain (Const (I32 d @@ e.at));
             Plain (Const (I32 s @@ e.at));
             Plain (Load
-              {ty = I32Type; align = 0; offset = 0l; pack = Some (Pack8, ZX)});
+              {ty = `I32; align = 0; offset = 0l; pack = Some (Pack8, ZX)});
             Plain (Store
-              {ty = I32Type; align = 0; offset = 0l; pack = Some Pack8});
+              {ty = `I32; align = 0; offset = 0l; pack = Some Pack8});
             Plain (Const (I32 (I32.add d 1l) @@ e.at));
             Plain (Const (I32 (I32.add s 1l) @@ e.at));
             Plain (Const (I32 (I32.sub n 1l) @@ e.at));
@@ -500,9 +501,9 @@ let rec step (c : config) : config =
             Plain (Const (I32 d @@ e.at));
             Plain (Const (I32 s @@ e.at));
             Plain (Load
-              {ty = I32Type; align = 0; offset = 0l; pack = Some (Pack8, ZX)});
+              {ty = `I32; align = 0; offset = 0l; pack = Some (Pack8, ZX)});
             Plain (Store
-              {ty = I32Type; align = 0; offset = 0l; pack = Some Pack8});
+              {ty = `I32; align = 0; offset = 0l; pack = Some Pack8});
           ]
 
       | MemoryInit x, Num (I32 n) :: Num (I32 s) :: Num (I32 d) :: vs' ->
@@ -517,7 +518,7 @@ let rec step (c : config) : config =
             Plain (Const (I32 d @@ e.at));
             Plain (Const (I32 b @@ e.at));
             Plain (Store
-              {ty = I32Type; align = 0; offset = 0l; pack = Some Pack8});
+              {ty = `I32; align = 0; offset = 0l; pack = Some Pack8});
             Plain (Const (I32 (I32.add d 1l) @@ e.at));
             Plain (Const (I32 (I32.add s 1l) @@ e.at));
             Plain (Const (I32 (I32.sub n 1l) @@ e.at));
@@ -680,7 +681,7 @@ let rec step (c : config) : config =
       take n vs0 e.at @ vs, []
 
     | Frame (n, frame', (vs', {it = ReturningInvoke (vs0, f); at} :: es')), vs ->
-      let FuncType (ts1, _) = Func.type_of f in
+      let `Func (ts1, _ts2) = Func.type_of f in
       take (List.length ts1) vs0 e.at @ vs, [Invoke f @@ at]
 
     | Frame (n, frame', code'), vs ->
@@ -691,14 +692,14 @@ let rec step (c : config) : config =
       Exhaustion.error e.at "call stack exhausted"
 
     | Invoke f, vs ->
-      let FuncType (ts1, ts2) = Func.type_of f in
+      let `Func (ts1, ts2) = Func.type_of f in
       let n1, n2 = List.length ts1, List.length ts2 in
       let args, vs' = split n1 vs e.at in
       (match f with
       | Func.AstFunc (_, inst', func) ->
         let {locals; body; _} = func.it in
         let m = Lib.Promise.value inst' in
-        let ts = List.map (fun loc -> Types.sem_value_type m.types loc.it.ltype) locals in
+        let ts = List.map (fun loc -> Types.Sem.sem_val_type m.types loc.it.ltype) locals in
         let locs' = List.(rev (map Option.some args) @ map default_value ts) in
         let frame' = {inst = m; locals = List.map ref locs'} in
         let instr' = [Label (n2, [], ([], List.map plain body)) @@ func.at] in
@@ -731,10 +732,10 @@ let at_func = function
 
 let invoke (func : func_inst) (vs : value list) : value list =
   let at = at_func func in
-  let FuncType (ts, _) = Func.type_of func in
-  if List.length vs <> List.length ts then
+  let `Func (ts1, _ts2) = Func.type_of func in
+  if List.length vs <> List.length ts1 then
     Crash.error at "wrong number of arguments";
-  if not (List.for_all2 (fun v -> Match.match_value_type [] [] (type_of_value v)) vs ts) then
+  if not (List.for_all2 (fun v -> Match.Sem.match_val_type () [] (type_of_value v)) vs ts1) then
     Crash.error at "wrong types of arguments";
   let c = config empty_module_inst (List.rev vs) [Invoke func @@ at] in
   try List.rev (eval c) with Stack_overflow ->
@@ -750,24 +751,24 @@ let eval_const (inst : module_inst) (const : const) : value =
 (* Modules *)
 
 let create_type (_ : type_) : type_inst =
-  Types.alloc_uninit ()
+  Types.Sem.alloc_uninit ()
 
 let create_func (inst : module_inst) (f : func) : func_inst =
   Func.alloc (type_ inst f.it.ftype) (Lib.Promise.make ()) f
 
 let create_table (inst : module_inst) (tab : table) : table_inst =
   let {ttype} = tab.it in
-  let TableType (_lim, (_, t)) as tt = Types.sem_table_type inst.types ttype in
+  let `Table (_lim, `Ref (_nul, t)) as tt = Types.Sem.sem_table_type inst.types ttype in
   Table.alloc tt (NullRef t)
 
 let create_memory (inst : module_inst) (mem : memory) : memory_inst =
   let {mtype} = mem.it in
-  Memory.alloc (Types.sem_memory_type inst.types mtype)
+  Memory.alloc (Types.Sem.sem_memory_type inst.types mtype)
 
 let create_global (inst : module_inst) (glob : global) : global_inst =
   let {gtype; ginit} = glob.it in
   let v = eval_const inst ginit in
-  Global.alloc (Types.sem_global_type inst.types gtype) v
+  Global.alloc (Types.Sem.sem_global_type inst.types gtype) v
 
 let create_export (inst : module_inst) (ex : export) : export_inst =
   let {name; edesc} = ex.it in
@@ -791,14 +792,14 @@ let create_data (inst : module_inst) (seg : data_segment) : data_inst =
 let add_import (m : module_) (ext : extern) (im : import) (inst : module_inst)
   : module_inst =
   let it = extern_type_of_import_type (import_type_of m im) in
-  let et = Types.sem_extern_type inst.types it in
+  let et = Types.Sem.sem_extern_type inst.types it in
   let et' = extern_type_of inst.types ext in
-  if not (Match.match_extern_type [] [] et' et) then
+  if not (Match.Sem.match_extern_type () [] et' et) then
     Link.error im.at ("incompatible import type for " ^
       "\"" ^ Utf8.encode im.it.module_name ^ "\" " ^
       "\"" ^ Utf8.encode im.it.item_name ^ "\": " ^
-      "expected " ^ Types.string_of_extern_type et ^
-      ", got " ^ Types.string_of_extern_type et');
+      "expected " ^ Types.Sem.string_of_extern_type et ^
+      ", got " ^ Types.Sem.string_of_extern_type et');
   match ext with
   | ExternFunc func -> {inst with funcs = func :: inst.funcs}
   | ExternTable tab -> {inst with tables = tab :: inst.tables}
@@ -807,7 +808,7 @@ let add_import (m : module_) (ext : extern) (im : import) (inst : module_inst)
 
 
 let init_type (inst : module_inst) (type_ : type_) (x : type_inst) =
-  Types.init x (Types.sem_def_type inst.types type_.it)
+  Types.Sem.init x (Types.Sem.sem_def_type inst.types type_.it)
 
 let init_func (inst : module_inst) (func : func_inst) =
   match func with
diff --git a/interpreter/exec/eval_num.ml b/interpreter/exec/eval_num.ml
index 29730b37b..34cca25b8 100644
--- a/interpreter/exec/eval_num.ml
+++ b/interpreter/exec/eval_num.ml
@@ -1,4 +1,3 @@
-open Types
 open Value
 
 
@@ -14,7 +13,7 @@ struct
       | Clz -> IXX.clz
       | Ctz -> IXX.ctz
       | Popcnt -> IXX.popcnt
-      | ExtendS sz -> IXX.extend_s (8 * packed_size sz)
+      | ExtendS sz -> IXX.extend_s (8 * Pack.packed_size sz)
     in fun v -> to_num (f (of_num 1 v))
 
   let binop op =
@@ -124,8 +123,8 @@ struct
       | TruncSatUF64 -> I32_convert.trunc_sat_f64_u (F64Num.of_num 1 v)
       | TruncSatSF64 -> I32_convert.trunc_sat_f64_s (F64Num.of_num 1 v)
       | ReinterpretFloat -> I32_convert.reinterpret_f32 (F32Num.of_num 1 v)
-      | ExtendUI32 -> raise (TypeError (1, v, I32Type))
-      | ExtendSI32 -> raise (TypeError (1, v, I32Type))
+      | ExtendUI32 -> raise (TypeError (1, v, `I32))
+      | ExtendSI32 -> raise (TypeError (1, v, `I32))
     in I32Num.to_num i
 end
 
@@ -146,7 +145,7 @@ struct
       | TruncSatUF64 -> I64_convert.trunc_sat_f64_u (F64Num.of_num 1 v)
       | TruncSatSF64 -> I64_convert.trunc_sat_f64_s (F64Num.of_num 1 v)
       | ReinterpretFloat -> I64_convert.reinterpret_f64 (F64Num.of_num 1 v)
-      | WrapI64 -> raise (TypeError (1, v, I64Type))
+      | WrapI64 -> raise (TypeError (1, v, `I64))
     in I64Num.to_num i
 end
 
@@ -162,7 +161,7 @@ struct
       | ConvertSI64 -> F32_convert.convert_i64_s (I64Num.of_num 1 v)
       | ConvertUI64 -> F32_convert.convert_i64_u (I64Num.of_num 1 v)
       | ReinterpretInt -> F32_convert.reinterpret_i32 (I32Num.of_num 1 v)
-      | PromoteF32 -> raise (TypeError (1, v, F32Type))
+      | PromoteF32 -> raise (TypeError (1, v, `F32))
     in F32Num.to_num z
 end
 
@@ -178,7 +177,7 @@ struct
       | ConvertSI64 -> F64_convert.convert_i64_s (I64Num.of_num 1 v)
       | ConvertUI64 -> F64_convert.convert_i64_u (I64Num.of_num 1 v)
       | ReinterpretInt -> F64_convert.reinterpret_i64 (I64Num.of_num 1 v)
-      | DemoteF64 -> raise (TypeError (1, v, F64Type))
+      | DemoteF64 -> raise (TypeError (1, v, `F64))
     in F64Num.to_num z
 end
 
diff --git a/interpreter/exec/eval_vec.ml b/interpreter/exec/eval_vec.ml
index 746bbc2b5..a3b9986ff 100644
--- a/interpreter/exec/eval_vec.ml
+++ b/interpreter/exec/eval_vec.ml
@@ -1,4 +1,4 @@
-open Types
+open Pack
 open Value
 
 module V128Op =
diff --git a/interpreter/exec/v128.ml b/interpreter/exec/v128.ml
index 550fd9bfa..1eeed6df5 100644
--- a/interpreter/exec/v128.ml
+++ b/interpreter/exec/v128.ml
@@ -29,10 +29,10 @@ let num_lanes shape =
   | F64x2 _ -> 2
 
 let type_of_lane = function
-  | I8x16 _ | I16x8 _ | I32x4 _ -> Types.I32Type
-  | I64x2 _ -> Types.I64Type
-  | F32x4 _ -> Types.F32Type
-  | F64x2 _ -> Types.F64Type
+  | I8x16 _ | I16x8 _ | I32x4 _ -> `I32
+  | I64x2 _ -> `I64
+  | F32x4 _ -> `F32
+  | F64x2 _ -> `F64
 
 
 (* Shape-based operations *)
diff --git a/interpreter/host/env.ml b/interpreter/host/env.ml
index b73adc591..87f25177f 100644
--- a/interpreter/host/env.ml
+++ b/interpreter/host/env.ml
@@ -4,7 +4,7 @@
  * we have agreement on what libc should look like.
  *)
 
-open Types
+open Types.Sem
 open Value
 open Instance
 
@@ -13,8 +13,8 @@ let error msg = raise (Eval.Crash (Source.no_region, msg))
 
 let type_error v t =
   error
-    ("type error, expected " ^ string_of_value_type t ^
-     ", got " ^ string_of_value_type (type_of_value v))
+    ("type error, expected " ^ string_of_val_type t ^
+     ", got " ^ string_of_val_type (type_of_value v))
 
 let empty = function
   | [] -> ()
@@ -27,7 +27,7 @@ let single = function
 
 let int = function
   | Num (I32 i) -> Int32.to_int i
-  | v -> type_error v (NumType I32Type)
+  | v -> type_error v `I32
 
 
 let abort vs =
@@ -41,8 +41,8 @@ let exit vs =
 
 let lookup name et =
   match Utf8.encode name, et with
-  | "abort", ExternFuncType ft ->
-    ExternFunc (Func.alloc_host (Types.alloc (FuncDefType ft)) abort)
-  | "exit", ExternFuncType ft ->
-    ExternFunc (Func.alloc_host (Types.alloc (FuncDefType ft)) exit)
+  | "abort", (#func_type as ft) ->
+    ExternFunc (Func.alloc_host (Types.Sem.alloc (ft :> def_type)) abort)
+  | "exit", (#func_type as ft) ->
+    ExternFunc (Func.alloc_host (Types.Sem.alloc (ft :> def_type)) exit)
   | _ -> raise Not_found
diff --git a/interpreter/host/spectest.ml b/interpreter/host/spectest.ml
index f38a52212..73e043500 100644
--- a/interpreter/host/spectest.ml
+++ b/interpreter/host/spectest.ml
@@ -2,32 +2,32 @@
  * Simple collection of functions useful for writing test cases.
  *)
 
-open Types
+open Types.Sem
 open Value
 open Instance
 
 
-let global (GlobalType (_, t) as gt) =
+let global (`Global (_, t) as gt) =
   let v =
     match t with
-    | NumType I32Type -> Num (I32 666l)
-    | NumType I64Type -> Num (I64 666L)
-    | NumType F32Type -> Num (F32 (F32.of_float 666.6))
-    | NumType F64Type -> Num (F64 (F64.of_float 666.6))
-    | VecType V128Type -> Vec (V128 (V128.I32x4.of_lanes [666l; 666l; 666l; 666l]))
-    | RefType (_, t) -> Ref (NullRef t)
-    | BotType -> assert false
+    | `I32 -> Num (I32 666l)
+    | `I64 -> Num (I64 666L)
+    | `F32 -> Num (F32 (F32.of_float 666.6))
+    | `F64 -> Num (F64 (F64.of_float 666.6))
+    | `V128 -> Vec (V128 (V128.I32x4.of_lanes [666l; 666l; 666l; 666l]))
+    | `Ref (_, t) -> Ref (NullRef t)
+    | `Bot -> assert false
   in Global.alloc gt v
 
 let table =
-  Table.alloc (TableType ({min = 10l; max = Some 20l}, (Null, FuncHeapType)))
-    (NullRef FuncHeapType)
-let memory = Memory.alloc (MemoryType {min = 1l; max = Some 2l})
-let func f ft = Func.alloc_host (Types.alloc (FuncDefType ft)) (f ft)
+  Table.alloc (`Table ({min = 10l; max = Some 20l}, `Ref (`Null, `Func)))
+    (NullRef `Func)
+let memory = Memory.alloc (`Memory {min = 1l; max = Some 2l})
+let func f ft = Func.alloc_host (Types.Sem.alloc (ft :> def_type)) (f ft)
 
 let print_value v =
   Printf.printf "%s : %s\n"
-    (string_of_value v) (string_of_value_type (type_of_value v))
+    (string_of_value v) (string_of_val_type (type_of_value v))
 
 let print _ vs =
   List.iter print_value vs;
@@ -37,19 +37,17 @@ let print _ vs =
 
 let lookup name t =
   match Utf8.encode name, t with
-  | "print", _ -> ExternFunc (func print (FuncType ([], [])))
-  | "print_i32", _ -> ExternFunc (func print (FuncType ([NumType I32Type], [])))
-  | "print_i64", _ -> ExternFunc (func print (FuncType ([NumType I64Type], [])))
-  | "print_f32", _ -> ExternFunc (func print (FuncType ([NumType F32Type], [])))
-  | "print_f64", _ -> ExternFunc (func print (FuncType ([NumType F64Type], [])))
-  | "print_i32_f32", _ ->
-    ExternFunc (func print (FuncType ([NumType I32Type; NumType F32Type], [])))
-  | "print_f64_f64", _ ->
-    ExternFunc (func print (FuncType ([NumType F64Type; NumType F64Type], [])))
-  | "global_i32", _ -> ExternGlobal (global (GlobalType (Cons, NumType I32Type)))
-  | "global_i64", _ -> ExternGlobal (global (GlobalType (Cons, NumType I64Type)))
-  | "global_f32", _ -> ExternGlobal (global (GlobalType (Cons, NumType F32Type)))
-  | "global_f64", _ -> ExternGlobal (global (GlobalType (Cons, NumType F64Type)))
+  | "print", _ -> ExternFunc (func print (`Func ([], [])))
+  | "print_i32", _ -> ExternFunc (func print (`Func ([`I32], [])))
+  | "print_i64", _ -> ExternFunc (func print (`Func ([`I64], [])))
+  | "print_f32", _ -> ExternFunc (func print (`Func ([`F32], [])))
+  | "print_f64", _ -> ExternFunc (func print (`Func ([`F64], [])))
+  | "print_i32_f32", _ -> ExternFunc (func print (`Func ([`I32; `F32], [])))
+  | "print_f64_f64", _ -> ExternFunc (func print (`Func ([`F64; `F64], [])))
+  | "global_i32", _ -> ExternGlobal (global (`Global (`Const, `I32)))
+  | "global_i64", _ -> ExternGlobal (global (`Global (`Const, `I64)))
+  | "global_f32", _ -> ExternGlobal (global (`Global (`Const, `F32)))
+  | "global_f64", _ -> ExternGlobal (global (`Global (`Const, `F64)))
   | "table", _ -> ExternTable table
   | "memory", _ -> ExternMemory memory
   | _ -> raise Not_found
diff --git a/interpreter/runtime/func.ml b/interpreter/runtime/func.ml
index 929b0e5c0..93bed037f 100644
--- a/interpreter/runtime/func.ml
+++ b/interpreter/runtime/func.ml
@@ -1,10 +1,10 @@
-open Types
+open Types.Sem
 open Value
 
 type 'inst t = 'inst func
 and 'inst func =
-  | AstFunc of sem_var * 'inst * Ast.func
-  | HostFunc of sem_var * (value list -> value list)
+  | AstFunc of var * 'inst * Ast.func
+  | HostFunc of var * (value list -> value list)
 
 let alloc x inst f = AstFunc (x, inst, f)
 let alloc_host x f = HostFunc (x, f)
diff --git a/interpreter/runtime/func.mli b/interpreter/runtime/func.mli
index 982db2a0b..8fe126c86 100644
--- a/interpreter/runtime/func.mli
+++ b/interpreter/runtime/func.mli
@@ -1,13 +1,13 @@
-open Types
+open Types.Sem
 open Value
 
 type 'inst t = 'inst func
 and 'inst func =
-  | AstFunc of sem_var * 'inst * Ast.func
-  | HostFunc of sem_var * (value list -> value list)
+  | AstFunc of var * 'inst * Ast.func
+  | HostFunc of var * (value list -> value list)
 
-val alloc : sem_var -> 'inst -> Ast.func -> 'inst func
-val alloc_host : sem_var -> (value list -> value list) -> 'inst func
+val alloc : var -> 'inst -> Ast.func -> 'inst func
+val alloc_host : var -> (value list -> value list) -> 'inst func
 
 val type_of : 'inst func -> func_type
-val type_inst_of : 'inst func -> sem_var
+val type_inst_of : 'inst func -> var
diff --git a/interpreter/runtime/global.ml b/interpreter/runtime/global.ml
index 36f47e062..a9784acc6 100644
--- a/interpreter/runtime/global.ml
+++ b/interpreter/runtime/global.ml
@@ -1,4 +1,4 @@
-open Types
+open Types.Sem
 open Value
 
 type global = {ty : global_type; mutable content : value}
@@ -7,8 +7,8 @@ type t = global
 exception Type
 exception NotMutable
 
-let alloc (GlobalType (_mut, t) as ty) v =
-  if not (Match.match_value_type [] [] (type_of_value v) t) then raise Type;
+let alloc (`Global (_mut, t) as ty) v =
+  if not (Match.Sem.match_val_type () [] (type_of_value v) t) then raise Type;
   {ty; content = v}
 
 let type_of glob =
@@ -18,7 +18,7 @@ let load glob =
   glob.content
 
 let store glob v =
-  let GlobalType (mut, t) = glob.ty in
-  if mut <> Var then raise NotMutable;
-  if not (Match.match_value_type [] [] (type_of_value v) t) then raise Type;
+  let `Global (mut, t) = glob.ty in
+  if mut <> `Var then raise NotMutable;
+  if not (Match.Sem.match_val_type () [] (type_of_value v) t) then raise Type;
   glob.content <- v
diff --git a/interpreter/runtime/global.mli b/interpreter/runtime/global.mli
index bf93c1a8c..47c905e4d 100644
--- a/interpreter/runtime/global.mli
+++ b/interpreter/runtime/global.mli
@@ -1,4 +1,4 @@
-open Types
+open Types.Sem
 open Value
 
 type global
diff --git a/interpreter/runtime/instance.ml b/interpreter/runtime/instance.ml
index 79317afd7..8ce173903 100644
--- a/interpreter/runtime/instance.ml
+++ b/interpreter/runtime/instance.ml
@@ -1,4 +1,4 @@
-open Types
+open Types.Sem
 
 type module_inst =
 {
@@ -12,7 +12,7 @@ type module_inst =
   datas : data_inst list;
 }
 
-and type_inst = Types.sem_var
+and type_inst = var
 and func_inst = module_inst Lib.Promise.t Func.t
 and table_inst = Table.t
 and memory_inst = Memory.t
@@ -35,7 +35,7 @@ type Value.ref_ += FuncRef of func_inst
 let () =
   let type_of_ref' = !Value.type_of_ref' in
   Value.type_of_ref' := function
-    | FuncRef f -> DefHeapType (SemVar (Func.type_inst_of f))
+    | FuncRef f -> `Def (Func.type_inst_of f)
     | r -> type_of_ref' r
 
 let () =
@@ -59,10 +59,10 @@ let empty_module_inst =
     exports = []; elems = []; datas = [] }
 
 let extern_type_of c = function
-  | ExternFunc func -> ExternFuncType (Func.type_of func)
-  | ExternTable tab -> ExternTableType (Table.type_of tab)
-  | ExternMemory mem -> ExternMemoryType (Memory.type_of mem)
-  | ExternGlobal glob -> ExternGlobalType (Global.type_of glob)
+  | ExternFunc func -> (Func.type_of func :> extern_type)
+  | ExternTable tab -> (Table.type_of tab :> extern_type)
+  | ExternMemory mem -> (Memory.type_of mem :> extern_type)
+  | ExternGlobal glob -> (Global.type_of glob :> extern_type)
 
 let export inst name =
   try Some (List.assoc name inst.exports) with Not_found -> None
diff --git a/interpreter/runtime/memory.ml b/interpreter/runtime/memory.ml
index 55b703dc8..5c6810183 100644
--- a/interpreter/runtime/memory.ml
+++ b/interpreter/runtime/memory.ml
@@ -1,4 +1,5 @@
-open Types
+open Types.Sem
+open Pack
 open Value
 open Bigarray
 open Lib.Bigarray
@@ -34,7 +35,7 @@ let create n =
     mem
   with Out_of_memory -> raise OutOfMemory
 
-let alloc (MemoryType lim as ty) =
+let alloc (`Memory lim as ty) =
   if not (valid_limits lim) then raise Type;
   {ty; content = create lim.min}
 
@@ -48,7 +49,7 @@ let type_of mem =
   mem.ty
 
 let grow mem delta =
-  let MemoryType lim = mem.ty in
+  let `Memory lim = mem.ty in
   assert (lim.min = size mem);
   let old_size = lim.min in
   let new_size = Int32.add old_size delta in
@@ -58,7 +59,7 @@ let grow mem delta =
   let after = create new_size in
   let dim = Array1_64.dim mem.content in
   Array1.blit (Array1_64.sub mem.content 0L dim) (Array1_64.sub after 0L dim);
-  mem.ty <- MemoryType lim';
+  mem.ty <- `Memory lim';
   mem.content <- after
 
 let load_byte mem a =
@@ -105,10 +106,10 @@ let storen mem a o n x =
 let load_num mem a o t =
   let n = loadn mem a o (Types.num_size t) in
   match t with
-  | I32Type -> I32 (Int64.to_int32 n)
-  | I64Type -> I64 n
-  | F32Type -> F32 (F32.of_bits (Int64.to_int32 n))
-  | F64Type -> F64 (F64.of_bits n)
+  | `I32 -> I32 (Int64.to_int32 n)
+  | `I64 -> I64 n
+  | `F32 -> F32 (F32.of_bits (Int64.to_int32 n))
+  | `F64 -> F64 (F64.of_bits n)
 
 let store_num mem a o n =
   let store = storen mem a o (Types.num_size (Value.type_of_num n)) in
@@ -127,8 +128,8 @@ let load_num_packed sz ext mem a o t =
   let w = packed_size sz in
   let x = extend (loadn mem a o w) w ext in
   match t with
-  | I32Type -> I32 (Int64.to_int32 x)
-  | I64Type -> I64 x
+  | `I32 -> I32 (Int64.to_int32 x)
+  | `I64 -> I64 x
   | _ -> raise Type
 
 let store_num_packed sz mem a o n =
@@ -143,7 +144,7 @@ let store_num_packed sz mem a o n =
 
 let load_vec mem a o t =
   match t with
-  | V128Type ->
+  | `V128 ->
     V128 (V128.of_bits (load_bytes mem (effective_address a o) (Types.vec_size t)))
 
 let store_vec mem a o n =
diff --git a/interpreter/runtime/memory.mli b/interpreter/runtime/memory.mli
index 79fafbceb..a6d103775 100644
--- a/interpreter/runtime/memory.mli
+++ b/interpreter/runtime/memory.mli
@@ -1,4 +1,4 @@
-open Types
+open Types.Sem
 open Value
 
 type memory
@@ -34,10 +34,10 @@ val load_num :
 val store_num :
   memory -> address -> offset -> num -> unit (* raises Bounds *)
 val load_num_packed :
-  pack_size -> extension -> memory -> address -> offset -> num_type -> num
+  Pack.pack_size -> Pack.extension -> memory -> address -> offset -> num_type -> num
     (* raises Type, Bounds *)
 val store_num_packed :
-  pack_size -> memory -> address -> offset -> num -> unit
+  Pack.pack_size -> memory -> address -> offset -> num -> unit
     (* raises Type, Bounds *)
 
 val load_vec :
@@ -46,5 +46,5 @@ val store_vec :
   memory -> address -> offset -> vec -> unit
     (* raises Type, Bounds *)
 val load_vec_packed :
-  pack_size -> vec_extension -> memory -> address -> offset -> vec_type -> vec
+  Pack.pack_size -> Pack.vec_extension -> memory -> address -> offset -> vec_type -> vec
     (* raises Type, Bounds *)
diff --git a/interpreter/runtime/table.ml b/interpreter/runtime/table.ml
index 57f3aba81..1c607ba92 100644
--- a/interpreter/runtime/table.ml
+++ b/interpreter/runtime/table.ml
@@ -1,4 +1,4 @@
-open Types
+open Types.Sem
 open Value
 
 type size = int32
@@ -23,7 +23,7 @@ let create size r =
   try Lib.Array32.make size r
   with Out_of_memory | Invalid_argument _ -> raise OutOfMemory
 
-let alloc (TableType (lim, _) as ty) r =
+let alloc (`Table (lim, _) as ty) r =
   if not (valid_limits lim) then raise Type;
   {ty; content = create lim.min r}
 
@@ -34,7 +34,7 @@ let type_of tab =
   tab.ty
 
 let grow tab delta r =
-  let TableType (lim, t) = tab.ty in
+  let `Table (lim, t) = tab.ty in
   assert (lim.min = size tab);
   let old_size = lim.min in
   let new_size = Int32.add old_size delta in
@@ -43,15 +43,15 @@ let grow tab delta r =
   if not (valid_limits lim') then raise SizeLimit else
   let after = create new_size r in
   Array.blit tab.content 0 after 0 (Array.length tab.content);
-  tab.ty <- TableType (lim', t);
+  tab.ty <- `Table (lim', t);
   tab.content <- after
 
 let load tab i =
   try Lib.Array32.get tab.content i with Invalid_argument _ -> raise Bounds
 
 let store tab i r =
-  let TableType (lim, t) = tab.ty in
-  if not (Match.match_ref_type [] [] (type_of_ref r) t) then raise Type;
+  let `Table (lim, t) = tab.ty in
+  if not (Match.Sem.match_ref_type () [] (type_of_ref r) t) then raise Type;
   try Lib.Array32.set tab.content i r with Invalid_argument _ -> raise Bounds
 
 let blit tab offset rs =
diff --git a/interpreter/runtime/table.mli b/interpreter/runtime/table.mli
index 2d95b7411..e2d59abba 100644
--- a/interpreter/runtime/table.mli
+++ b/interpreter/runtime/table.mli
@@ -1,4 +1,4 @@
-open Types
+open Types.Sem
 open Value
 
 type table
diff --git a/interpreter/runtime/value.ml b/interpreter/runtime/value.ml
index 2c7342a43..b804ac541 100644
--- a/interpreter/runtime/value.ml
+++ b/interpreter/runtime/value.ml
@@ -1,4 +1,4 @@
-open Types
+open Types.Sem
 
 
 (* Values and operators *)
@@ -47,28 +47,28 @@ module I32Num =
 struct
   type t = I32.t
   let to_num i = I32 i
-  let of_num n = function I32 i -> i | v -> raise (TypeError (n, v, I32Type))
+  let of_num n = function I32 i -> i | v -> raise (TypeError (n, v, `I32))
 end
 
 module I64Num =
 struct
   type t = I64.t
   let to_num i = I64 i
-  let of_num n = function I64 i -> i | v -> raise (TypeError (n, v, I64Type))
+  let of_num n = function I64 i -> i | v -> raise (TypeError (n, v, `I64))
 end
 
 module F32Num =
 struct
   type t = F32.t
   let to_num i = F32 i
-  let of_num n = function F32 z -> z | v -> raise (TypeError (n, v, F32Type))
+  let of_num n = function F32 z -> z | v -> raise (TypeError (n, v, `F32))
 end
 
 module F64Num =
 struct
   type t = F64.t
   let to_num i = F64 i
-  let of_num n = function F64 z -> z | v -> raise (TypeError (n, v, F64Type))
+  let of_num n = function F64 z -> z | v -> raise (TypeError (n, v, `F64))
 end
 
 module type VecType =
@@ -89,23 +89,23 @@ end
 (* Typing *)
 
 let type_of_num = function
-  | I32 _ -> I32Type
-  | I64 _ -> I64Type
-  | F32 _ -> F32Type
-  | F64 _ -> F64Type
+  | I32 _ -> `I32
+  | I64 _ -> `I64
+  | F32 _ -> `F32
+  | F64 _ -> `F64
 
 let type_of_vec = function
-  | V128 _ -> V128Type
+  | V128 _ -> `V128
 
 let type_of_ref' = ref (function _ -> assert false)
 let type_of_ref = function
-  | NullRef t -> (Null, t)
-  | r -> (NoNull, !type_of_ref' r)
+  | NullRef t -> `Ref (`Null, t)
+  | r -> `Ref (`NoNull, !type_of_ref' r)
 
 let type_of_value = function
-  | Num n -> NumType (type_of_num n)
-  | Vec i -> VecType (type_of_vec i)
-  | Ref r -> RefType (type_of_ref r)
+  | Num n -> type_of_num n
+  | Vec i -> type_of_vec i
+  | Ref r -> type_of_ref r
 
 
 (* Comparison *)
@@ -133,23 +133,23 @@ let eq v1 v2 =
 (* Defaults *)
 
 let default_num = function
-  | I32Type -> Some (Num (I32 I32.zero))
-  | I64Type -> Some (Num (I64 I64.zero))
-  | F32Type -> Some (Num (F32 F32.zero))
-  | F64Type -> Some (Num (F64 F64.zero))
+  | `I32 -> Some (Num (I32 I32.zero))
+  | `I64 -> Some (Num (I64 I64.zero))
+  | `F32 -> Some (Num (F32 F32.zero))
+  | `F64 -> Some (Num (F64 F64.zero))
 
 let default_vec = function
-  | V128Type -> Some (Vec (V128 V128.zero))
+  | `V128 -> Some (Vec (V128 V128.zero))
 
 let default_ref = function
-  | (Null, t) -> Some (Ref (NullRef t))
-  | (NoNull, _) -> None
+  | `Ref (`Null, t) -> Some (Ref (NullRef t))
+  | `Ref (`NoNull, _) -> None
 
 let default_value = function
-  | NumType t' -> default_num t'
-  | VecType t' -> default_vec t'
-  | RefType t' -> default_ref t'
-  | BotType -> assert false
+  | #num_type as t -> default_num t
+  | #vec_type as t -> default_vec t
+  | #ref_type as t -> default_ref t
+  | `Bot -> assert false
 
 
 (* Conversion *)
diff --git a/interpreter/script/import.ml b/interpreter/script/import.ml
index 5d86ca7c4..9a012b4bd 100644
--- a/interpreter/script/import.ml
+++ b/interpreter/script/import.ml
@@ -1,6 +1,5 @@
 open Source
 open Ast
-open Types
 
 module Unknown = Error.Make ()
 exception Unknown = Unknown.Error  (* indicates unknown import name *)
@@ -10,12 +9,12 @@ let registry = ref Registry.empty
 
 let register name lookup = registry := Registry.add name lookup !registry
 
-let lookup (ImportType (et, module_name, item_name)) at : Instance.extern =
+let lookup (`Import (et, module_name, item_name)) at : Instance.extern =
   try Registry.find module_name !registry item_name et with Not_found ->
     Unknown.error at
-      ("unknown import \"" ^ string_of_name module_name ^
-        "\".\"" ^ string_of_name item_name ^ "\"")
+      ("unknown import \"" ^ Types.string_of_name module_name ^
+        "\".\"" ^ Types.string_of_name item_name ^ "\"")
 
 let link m =
-  let ModuleType (_, its, _) = Types.sem_module_type (module_type_of m) in
+  let `Module (_, its, _) = Types.Sem.sem_module_type (module_type_of m) in
   List.map2 lookup its (List.map Source.at m.it.imports)
diff --git a/interpreter/script/import.mli b/interpreter/script/import.mli
index 7919297e1..b9587f1b2 100644
--- a/interpreter/script/import.mli
+++ b/interpreter/script/import.mli
@@ -4,5 +4,5 @@ val link : Ast.module_ -> Instance.extern list (* raises Unknown *)
 
 val register :
   Ast.name ->
-  (Ast.name -> Types.extern_type -> Instance.extern (* raises Not_found *)) ->
+  (Ast.name -> Types.Sem.extern_type -> Instance.extern (* raises Not_found *)) ->
   unit
diff --git a/interpreter/script/js.ml b/interpreter/script/js.ml
index 07a03ef50..0fa52caa7 100644
--- a/interpreter/script/js.ml
+++ b/interpreter/script/js.ml
@@ -203,7 +203,7 @@ type modules = {mutable env : exports Map.t; mutable current : int}
 
 let exports m : exports =
   let ets = List.map (export_type_of m) m.it.exports in
-  List.fold_left (fun map (ExportType (et, name)) -> NameMap.add name et map)
+  List.fold_left (fun map (`Export (et, name)) -> NameMap.add name et map)
     NameMap.empty ets
 
 let modules () : modules = {env = Map.empty; current = 0}
@@ -241,40 +241,47 @@ let _eq_funcref_idx = 5l
 let subject_type_idx = 6l
 
 let eq_of = function
-  | I32Type -> I32 I32Op.Eq
-  | I64Type -> I64 I64Op.Eq
-  | F32Type -> F32 F32Op.Eq
-  | F64Type -> F64 F64Op.Eq
+  | `I32 -> I32 I32Op.Eq
+  | `I64 -> I64 I64Op.Eq
+  | `F32 -> F32 F32Op.Eq
+  | `F64 -> F64 F64Op.Eq
 
 let and_of = function
-  | I32Type | F32Type -> I32 I32Op.And
-  | I64Type | F64Type -> I64 I64Op.And
+  | `I32 | `F32 -> I32 I32Op.And
+  | `I64 | `F64 -> I64 I64Op.And
 
 let reinterpret_of = function
-  | I32Type -> I32Type, Nop
-  | I64Type -> I64Type, Nop
-  | F32Type -> I32Type, Convert (I32 I32Op.ReinterpretFloat)
-  | F64Type -> I64Type, Convert (I64 I64Op.ReinterpretFloat)
+  | `I32 -> `I32, Nop
+  | `I64 -> `I64, Nop
+  | `F32 -> `I32, Convert (I32 I32Op.ReinterpretFloat)
+  | `F64 -> `I64, Convert (I64 I64Op.ReinterpretFloat)
 
 let canonical_nan_of = function
-  | I32Type | F32Type -> I32 (F32.to_bits F32.pos_nan)
-  | I64Type | F64Type -> I64 (F64.to_bits F64.pos_nan)
+  | `I32 | `F32 -> I32 (F32.to_bits F32.pos_nan)
+  | `I64 | `F64 -> I64 (F64.to_bits F64.pos_nan)
 
 let abs_mask_of = function
-  | I32Type | F32Type -> I32 Int32.max_int
-  | I64Type | F64Type -> I64 Int64.max_int
+  | `I32 | `F32 -> I32 Int32.max_int
+  | `I64 | `F64 -> I64 Int64.max_int
+
+let null_heap_type_of = function
+  | (`Func | `Extern) as t -> t
+  | `Bot -> assert false
+  | `Def x ->
+    match Types.Sem.def_of x with
+    | #Types.Sem.func_type -> `Func
 
 let value v =
   match v.it with
   | Num n -> [Const (n @@ v.at) @@ v.at]
   | Vec s -> [VecConst (s @@ v.at) @@ v.at]
-  | Ref (NullRef t) -> [RefNull t @@ v.at]
+  | Ref (NullRef t) -> [RefNull (null_heap_type_of t) @@ v.at]
   | Ref (ExternRef n) ->
     [Const (I32 n @@ v.at) @@ v.at; Call (externref_idx @@ v.at) @@ v.at]
   | Ref _ -> assert false
 
 let invoke ft vs at =
-  [FuncDefType ft @@ at], FuncImport (subject_type_idx @@ at) @@ at,
+  [(ft :> def_type) @@ at], FuncImport (subject_type_idx @@ at) @@ at,
   List.concat (List.map value vs) @ [Call (subject_idx @@ at) @@ at]
 
 let get t at =
@@ -323,9 +330,9 @@ let assert_return ress ts at =
         | NumPat {it = F64 f; _} ->
           I64 (Int64.minus_one), I64 (I64_convert.reinterpret_f64 f)
         | NanPat {it = F32 nan; _} ->
-          nan_bitmask_of nan I32Type, canonical_nan_of I32Type
+          nan_bitmask_of nan `I32, canonical_nan_of `I32
         | NanPat {it = F64 nan; _} ->
-          nan_bitmask_of nan I64Type, canonical_nan_of I64Type
+          nan_bitmask_of nan `I64, canonical_nan_of `I64
         | _ -> .
       in
       let masks, canons =
@@ -371,38 +378,37 @@ let assert_return ress ts at =
     | RefResult (RefTypePat t) ->
       let is_ref_idx =
         match t with
-        | FuncHeapType -> is_funcref_idx
-        | ExternHeapType -> is_externref_idx
-        | DefHeapType _ -> is_funcref_idx
-        | BotHeapType -> assert false
+        | `Func -> is_funcref_idx
+        | `Extern -> is_externref_idx
+        | `Def _ -> is_funcref_idx
+        | `Bot -> assert false
       in
       [ Call (is_ref_idx @@ at) @@ at;
         Test (I32 I32Op.Eqz) @@ at;
         BrIf (0l @@ at) @@ at ]
     | RefResult NullPat ->
       (match t with
-      | RefType _ ->
+      | `Ref _ ->
         [ BrOnNull (0l @@ at) @@ at ]
       | _ ->
         [ Br (0l @@ at) @@ at ]
       )
   in [], List.flatten (List.rev_map test (List.combine ress ts))
 
-let i32_type = NumType I32Type
-let funcref_type = RefType (Null, FuncHeapType)
-let externref_type = RefType (Null, ExternHeapType)
-let func_def_type ins out at = FuncDefType (FuncType (ins, out)) @@ at
+let funcref = `Ref (`Null, `Func)
+let externref = `Ref (`Null, `Extern)
+let func_def_type ts1 ts2 at = `Func (ts1, ts2) @@ at
 
 let wrap item_name wrap_action wrap_assertion at =
   let itypes, idesc, action = wrap_action at in
   let locals, assertion = wrap_assertion at in
   let types =
     func_def_type [] [] at ::
-    func_def_type [i32_type] [externref_type] at ::
-    func_def_type [externref_type] [i32_type] at ::
-    func_def_type [funcref_type] [i32_type] at ::
-    func_def_type [externref_type; externref_type] [i32_type] at ::
-    func_def_type [funcref_type; funcref_type] [i32_type] at ::
+    func_def_type [`I32] [externref] at ::
+    func_def_type [externref] [`I32] at ::
+    func_def_type [funcref] [`I32] at ::
+    func_def_type [externref; externref] [`I32] at ::
+    func_def_type [funcref; funcref] [`I32] at ::
     itypes
   in
   let imports =
@@ -436,20 +442,20 @@ let wrap item_name wrap_action wrap_assertion at =
 
 
 let is_js_num_type = function
-  | I32Type -> true
-  | I64Type | F32Type | F64Type -> false
+  | `I32 -> true
+  | `I64 | `F32 | `F64 -> false
 
-let is_js_value_type = function
-  | NumType t -> is_js_num_type t
-  | VecType t -> false
-  | RefType t -> true
-  | BotType -> assert false
+let is_js_val_type = function
+  | #num_type as t -> is_js_num_type t
+  | #vec_type -> false
+  | #ref_type -> true
+  | `Bot -> assert false
 
 let is_js_global_type = function
-  | GlobalType (mut, t) -> is_js_value_type t && mut = Cons
+  | `Global (mut, t) -> is_js_val_type t && mut = `Const
 
 let is_js_func_type = function
-  | FuncType (ts1, ts2) -> List.for_all is_js_value_type (ts1 @ ts2)
+  | `Func (ts1, ts2) -> List.for_all is_js_val_type (ts1 @ ts2)
 
 
 (* Script conversion *)
@@ -558,16 +564,16 @@ let of_action mods act =
     "call(" ^ of_var_opt mods x_opt ^ ", " ^ of_name name ^ ", " ^
       "[" ^ String.concat ", " (List.map of_value vs) ^ "])",
     (match lookup mods x_opt name act.at with
-    | ExternFuncType ft when not (is_js_func_type ft) ->
-      let FuncType (_, out) = ft in
+    | #func_type as ft when not (is_js_func_type ft) ->
+      let `Func (_, out) = ft in
       Some (of_wrapper mods x_opt name (invoke ft vs), out)
     | _ -> None
     )
   | Get (x_opt, name) ->
     "get(" ^ of_var_opt mods x_opt ^ ", " ^ of_name name ^ ")",
     (match lookup mods x_opt name act.at with
-    | ExternGlobalType gt when not (is_js_global_type gt) ->
-      let GlobalType (_, t) = gt in
+    | #global_type as gt when not (is_js_global_type gt) ->
+      let `Global (_, t) = gt in
       Some (of_wrapper mods x_opt name (get gt), [t])
     | _ -> None
     )
diff --git a/interpreter/script/run.ml b/interpreter/script/run.ml
index 8a5e263da..3834ee083 100644
--- a/interpreter/script/run.ml
+++ b/interpreter/script/run.ml
@@ -220,7 +220,7 @@ let print_module x_opt m =
 let print_values vs =
   let ts = List.map Value.type_of_value vs in
   Printf.printf "%s : %s\n%!"
-    (Value.string_of_values vs) (Types.string_of_result_type ts)
+    (Value.string_of_values vs) (Types.Sem.string_of_result_type ts)
 
 let string_of_nan = function
   | CanonicalNan -> "nan:canonical"
@@ -228,12 +228,12 @@ let string_of_nan = function
 
 let type_of_result r =
   match r with
-  | NumResult (NumPat n) -> Types.NumType (Value.type_of_num n.it)
-  | NumResult (NanPat n) -> Types.NumType (Value.type_of_num n.it)
-  | VecResult (VecPat _) -> Types.VecType Types.V128Type
-  | RefResult (RefPat r) -> Types.RefType (Value.type_of_ref r.it)
-  | RefResult (RefTypePat t) -> Types.(RefType (NoNull, t))
-  | RefResult (NullPat) -> Types.(RefType (Null, ExternHeapType))
+  | NumResult (NumPat n) -> Value.type_of_num n.it
+  | NumResult (NanPat n) -> Value.type_of_num n.it
+  | VecResult (VecPat v) -> Value.type_of_vec v
+  | RefResult (RefPat r) -> Value.type_of_ref r.it
+  | RefResult (RefTypePat t) -> `Ref (`NoNull, Types.Sem.sem_heap_type [] t)
+  | RefResult (NullPat) -> `Ref (`Null, `Extern)
 
 let string_of_num_pat (p : num_pat) =
   match p with
@@ -267,7 +267,7 @@ let string_of_results = function
 let print_results rs =
   let ts = List.map type_of_result rs in
   Printf.printf "%s : %s\n%!"
-    (string_of_results rs) (Types.string_of_result_type ts)
+    (string_of_results rs) (Types.Sem.string_of_result_type ts)
 
 
 (* Configuration *)
@@ -324,13 +324,13 @@ let run_action act : Value.t list =
     let inst = lookup_instance x_opt act.at in
     (match Instance.export inst name with
     | Some (Instance.ExternFunc f) ->
-      let Types.FuncType (ins, out) = Func.type_of f in
-      if List.length vs <> List.length ins then
+      let `Func (ts1, _ts2) = Func.type_of f in
+      if List.length vs <> List.length ts1 then
         Script.error act.at "wrong number of arguments";
       List.iter2 (fun v t ->
-        if not (Match.match_value_type [] [] (Value.type_of_value v.it) t) then
+        if not (Match.Sem.match_val_type () [] (Value.type_of_value v.it) t) then
           Script.error v.at "wrong type of argument"
-      ) vs ins;
+      ) vs ts1;
       Eval.invoke f (List.map (fun v -> v.it) vs)
     | Some _ -> Assert.error act.at "export is not a function"
     | None -> Assert.error act.at "undefined export"
@@ -381,8 +381,8 @@ let assert_vec_pat v p =
 let assert_ref_pat r p =
   match r, p with
   | r, RefPat r' -> Value.eq_ref r r'.it
-  | Instance.FuncRef _, RefTypePat Types.FuncHeapType
-  | ExternRef _, RefTypePat Types.ExternHeapType -> true
+  | Instance.FuncRef _, RefTypePat `Func
+  | ExternRef _, RefTypePat `Extern -> true
   | Value.NullRef _, NullPat -> true
   | _ -> false
 
diff --git a/interpreter/script/script.ml b/interpreter/script/script.ml
index 2d6c430f8..6847c5cf8 100644
--- a/interpreter/script/script.ml
+++ b/interpreter/script/script.ml
@@ -70,7 +70,7 @@ exception Syntax of Source.region * string
 let () =
   let type_of_ref' = !Value.type_of_ref' in
   Value.type_of_ref' := function
-    | ExternRef _ -> Types.ExternHeapType
+    | ExternRef _ -> `Extern
     | r -> type_of_ref' r
 
 let () =
diff --git a/interpreter/syntax/ast.ml b/interpreter/syntax/ast.ml
index b5b5c03ac..80bb02c62 100644
--- a/interpreter/syntax/ast.ml
+++ b/interpreter/syntax/ast.ml
@@ -9,7 +9,7 @@
  *   f : func
  *   m : module_
  *
- *   t : value_type
+ *   t : val_type
  *   s : func_type
  *   c : context / config
  *
@@ -19,6 +19,7 @@
 (* Types *)
 
 open Types
+open Pack
 
 type void = Lib.void
 
@@ -134,14 +135,14 @@ type num = Value.num Source.phrase
 type vec = Value.vec Source.phrase
 type name = Utf8.unicode
 
-type block_type = VarBlockType of var | ValBlockType of value_type option
+type block_type = VarBlockType of var | ValBlockType of val_type option
 
 type instr = instr' Source.phrase
 and instr' =
   | Unreachable                       (* trap unconditionally *)
   | Nop                               (* do nothing *)
   | Drop                              (* forget a value *)
-  | Select of value_type list option  (* branchless conditional *)
+  | Select of val_type list option    (* branchless conditional *)
   | Block of block_type * instr list  (* execute in sequence *)
   | Loop of block_type * instr list   (* loop header *)
   | If of block_type * instr list * instr list   (* conditional *)
@@ -214,7 +215,7 @@ type const = instr list Source.phrase
 type local = local' Source.phrase
 and local' =
 {
-  ltype : value_type;
+  ltype : val_type;
 }
 
 type global = global' Source.phrase
@@ -349,11 +350,11 @@ let import_type_of (m : module_) (im : import) : import_type =
   let {idesc; module_name; item_name} = im.it in
   let et =
     match idesc.it with
-    | FuncImport x -> ExternFuncType (func_type_of m x)
-    | TableImport t -> ExternTableType t
-    | MemoryImport t -> ExternMemoryType t
-    | GlobalImport t -> ExternGlobalType t
-  in ImportType (et, module_name, item_name)
+    | FuncImport x -> (func_type_of m x :> extern_type)
+    | TableImport t -> (t :> extern_type)
+    | MemoryImport t -> (t :> extern_type)
+    | GlobalImport t -> (t :> extern_type)
+  in `Import (et, module_name, item_name)
 
 let export_type_of (m : module_) (ex : export) : export_type =
   let {edesc; name} = ex.it in
@@ -365,20 +366,20 @@ let export_type_of (m : module_) (ex : export) : export_type =
     | FuncExport x ->
       let fts =
         funcs ets @ List.map (fun f -> func_type_of m f.it.ftype) m.it.funcs
-      in ExternFuncType (nth fts x.it)
+      in (nth fts x.it :> extern_type)
     | TableExport x ->
       let tts = tables ets @ List.map (fun t -> t.it.ttype) m.it.tables in
-      ExternTableType (nth tts x.it)
+      (nth tts x.it :> extern_type)
     | MemoryExport x ->
       let mts = memories ets @ List.map (fun m -> m.it.mtype) m.it.memories in
-      ExternMemoryType (nth mts x.it)
+      (nth mts x.it :> extern_type)
     | GlobalExport x ->
       let gts = globals ets @ List.map (fun g -> g.it.gtype) m.it.globals in
-      ExternGlobalType (nth gts x.it)
-  in ExportType (et, name)
+      (nth gts x.it :> extern_type)
+  in `Export (et, name)
 
 let module_type_of (m : module_) : module_type =
   let dts = List.map Source.it m.it.types in
   let its = List.map (import_type_of m) m.it.imports in
   let ets = List.map (export_type_of m) m.it.exports in
-  ModuleType (dts, its, ets)
+  `Module (dts, its, ets)
diff --git a/interpreter/syntax/free.ml b/interpreter/syntax/free.ml
index b83f4d196..8fc15a1ce 100644
--- a/interpreter/syntax/free.ml
+++ b/interpreter/syntax/free.ml
@@ -63,45 +63,43 @@ let opt free xo = Lib.Option.get (Option.map free xo) empty
 let list free xs = List.fold_left union empty (List.map free xs)
 
 let var_type = function
-  | SynVar x -> types (idx' x)
-  | SemVar _ -> assert false
+  | x -> types (idx' x)
 
 let num_type = function
-  | I32Type | I64Type | F32Type | F64Type -> empty
+  | `I32 | `I64 | `F32 | `F64 -> empty
 
 let vec_type = function
-  | V128Type -> empty
+  | `V128 -> empty
 
 let heap_type = function
-  | FuncHeapType | ExternHeapType | BotHeapType -> empty
-  | DefHeapType x -> var_type x
+  | `Func | `Extern | `Bot -> empty
+  | `Def x -> var_type x
 
 let ref_type = function
-  | (_, t) -> heap_type t
+  | `Ref (_, t) -> heap_type t
 
-let value_type = function
-  | NumType t -> num_type t
-  | VecType t -> vec_type t
-  | RefType t -> ref_type t
-  | BotType -> empty
+let val_type = function
+  | #num_type as t -> num_type t
+  | #vec_type as t -> vec_type t
+  | #ref_type as t -> ref_type t
+  | `Bot -> empty
 
-let func_type (FuncType (ins, out)) =
-  list value_type ins ++ list value_type out
-let global_type (GlobalType (_mut, t)) = value_type t
-let table_type (TableType (_lim, t)) = ref_type t
-let memory_type (MemoryType (_lim)) = empty
+let func_type (`Func (ins, out)) = list val_type ins ++ list val_type out
+let global_type (`Global (_mut, t)) = val_type t
+let table_type (`Table (_lim, t)) = ref_type t
+let memory_type (`Memory (_lim)) = empty
 
 let def_type = function
-  | FuncDefType ft -> func_type ft
+  | #func_type as ft -> func_type ft
 
 let block_type = function
   | VarBlockType x -> var_type x
-  | ValBlockType t -> opt value_type t
+  | ValBlockType t -> opt val_type t
 
 let rec instr (e : instr) =
   match e.it with
   | Unreachable | Nop | Drop -> empty
-  | Select tso -> list value_type (Lib.Option.get tso [])
+  | Select tso -> list val_type (Lib.Option.get tso [])
   | RefIsNull | RefAsNonNull -> empty
   | RefNull t -> heap_type t
   | RefFunc x -> funcs (idx x)
diff --git a/interpreter/syntax/operators.ml b/interpreter/syntax/operators.ml
index 04464e5b1..33a72ae31 100644
--- a/interpreter/syntax/operators.ml
+++ b/interpreter/syntax/operators.ml
@@ -1,8 +1,8 @@
 open Source
-open Types
 open Value
 open V128
 open Ast
+open Pack
 
 
 let i32_const n = Const (I32 n.it @@ n.at)
@@ -49,45 +49,45 @@ let table_copy x y = TableCopy (x, y)
 let table_init x y = TableInit (x, y)
 let elem_drop x = ElemDrop x
 
-let i32_load align offset = Load {ty = I32Type; align; offset; pack = None}
-let i64_load align offset = Load {ty = I64Type; align; offset; pack = None}
-let f32_load align offset = Load {ty = F32Type; align; offset; pack = None}
-let f64_load align offset = Load {ty = F64Type; align; offset; pack = None}
+let i32_load align offset = Load {ty = `I32; align; offset; pack = None}
+let i64_load align offset = Load {ty = `I64; align; offset; pack = None}
+let f32_load align offset = Load {ty = `F32; align; offset; pack = None}
+let f64_load align offset = Load {ty = `F64; align; offset; pack = None}
 let i32_load8_s align offset =
-  Load {ty = I32Type; align; offset; pack = Some (Pack8, SX)}
+  Load {ty = `I32; align; offset; pack = Some (Pack8, SX)}
 let i32_load8_u align offset =
-  Load {ty = I32Type; align; offset; pack = Some (Pack8, ZX)}
+  Load {ty = `I32; align; offset; pack = Some (Pack8, ZX)}
 let i32_load16_s align offset =
-  Load {ty = I32Type; align; offset; pack = Some (Pack16, SX)}
+  Load {ty = `I32; align; offset; pack = Some (Pack16, SX)}
 let i32_load16_u align offset =
-  Load {ty = I32Type; align; offset; pack = Some (Pack16, ZX)}
+  Load {ty = `I32; align; offset; pack = Some (Pack16, ZX)}
 let i64_load8_s align offset =
-  Load {ty = I64Type; align; offset; pack = Some (Pack8, SX)}
+  Load {ty = `I64; align; offset; pack = Some (Pack8, SX)}
 let i64_load8_u align offset =
-  Load {ty = I64Type; align; offset; pack = Some (Pack8, ZX)}
+  Load {ty = `I64; align; offset; pack = Some (Pack8, ZX)}
 let i64_load16_s align offset =
-  Load {ty = I64Type; align; offset; pack = Some (Pack16, SX)}
+  Load {ty = `I64; align; offset; pack = Some (Pack16, SX)}
 let i64_load16_u align offset =
-  Load {ty = I64Type; align; offset; pack = Some (Pack16, ZX)}
+  Load {ty = `I64; align; offset; pack = Some (Pack16, ZX)}
 let i64_load32_s align offset =
-  Load {ty = I64Type; align; offset; pack = Some (Pack32, SX)}
+  Load {ty = `I64; align; offset; pack = Some (Pack32, SX)}
 let i64_load32_u align offset =
-  Load {ty = I64Type; align; offset; pack = Some (Pack32, ZX)}
+  Load {ty = `I64; align; offset; pack = Some (Pack32, ZX)}
 
-let i32_store align offset = Store {ty = I32Type; align; offset; pack = None}
-let i64_store align offset = Store {ty = I64Type; align; offset; pack = None}
-let f32_store align offset = Store {ty = F32Type; align; offset; pack = None}
-let f64_store align offset = Store {ty = F64Type; align; offset; pack = None}
+let i32_store align offset = Store {ty = `I32; align; offset; pack = None}
+let i64_store align offset = Store {ty = `I64; align; offset; pack = None}
+let f32_store align offset = Store {ty = `F32; align; offset; pack = None}
+let f64_store align offset = Store {ty = `F64; align; offset; pack = None}
 let i32_store8 align offset =
-  Store {ty = I32Type; align; offset; pack = Some Pack8}
+  Store {ty = `I32; align; offset; pack = Some Pack8}
 let i32_store16 align offset =
-  Store {ty = I32Type; align; offset; pack = Some Pack16}
+  Store {ty = `I32; align; offset; pack = Some Pack16}
 let i64_store8 align offset =
-  Store {ty = I64Type; align; offset; pack = Some Pack8}
+  Store {ty = `I64; align; offset; pack = Some Pack8}
 let i64_store16 align offset =
-  Store {ty = I64Type; align; offset; pack = Some Pack16}
+  Store {ty = `I64; align; offset; pack = Some Pack16}
 let i64_store32 align offset =
-  Store {ty = I64Type; align; offset; pack = Some Pack32}
+  Store {ty = `I64; align; offset; pack = Some Pack32}
 
 let memory_size = MemorySize
 let memory_grow = MemoryGrow
@@ -241,51 +241,51 @@ let i64_reinterpret_f64 = Convert (I64 I64Op.ReinterpretFloat)
 let f32_reinterpret_i32 = Convert (F32 F32Op.ReinterpretInt)
 let f64_reinterpret_i64 = Convert (F64 F64Op.ReinterpretInt)
 
-let v128_load align offset = VecLoad {ty = V128Type; align; offset; pack = None}
+let v128_load align offset = VecLoad {ty = `V128; align; offset; pack = None}
 let v128_load8x8_s align offset =
-  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtLane (Pack8x8, SX))}
+  VecLoad {ty = `V128; align; offset; pack = Some (Pack64, ExtLane (Pack8x8, SX))}
 let v128_load8x8_u align offset =
-  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtLane (Pack8x8, ZX))}
+  VecLoad {ty = `V128; align; offset; pack = Some (Pack64, ExtLane (Pack8x8, ZX))}
 let v128_load16x4_s align offset =
-  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtLane (Pack16x4, SX))}
+  VecLoad {ty = `V128; align; offset; pack = Some (Pack64, ExtLane (Pack16x4, SX))}
 let v128_load16x4_u align offset =
-  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtLane (Pack16x4, ZX))}
+  VecLoad {ty = `V128; align; offset; pack = Some (Pack64, ExtLane (Pack16x4, ZX))}
 let v128_load32x2_s align offset =
-  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtLane (Pack32x2, SX))}
+  VecLoad {ty = `V128; align; offset; pack = Some (Pack64, ExtLane (Pack32x2, SX))}
 let v128_load32x2_u align offset =
-  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtLane (Pack32x2, ZX))}
+  VecLoad {ty = `V128; align; offset; pack = Some (Pack64, ExtLane (Pack32x2, ZX))}
 let v128_load8_splat align offset =
-  VecLoad {ty = V128Type; align; offset; pack = Some (Pack8, ExtSplat)}
+  VecLoad {ty = `V128; align; offset; pack = Some (Pack8, ExtSplat)}
 let v128_load16_splat align offset =
-  VecLoad {ty = V128Type; align; offset; pack = Some (Pack16, ExtSplat)}
+  VecLoad {ty = `V128; align; offset; pack = Some (Pack16, ExtSplat)}
 let v128_load32_splat align offset =
-  VecLoad {ty = V128Type; align; offset; pack = Some (Pack32, ExtSplat)}
+  VecLoad {ty = `V128; align; offset; pack = Some (Pack32, ExtSplat)}
 let v128_load64_splat align offset =
-  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtSplat)}
+  VecLoad {ty = `V128; align; offset; pack = Some (Pack64, ExtSplat)}
 let v128_load32_zero align offset =
-  VecLoad {ty = V128Type; align; offset; pack = Some (Pack32, ExtZero)}
+  VecLoad {ty = `V128; align; offset; pack = Some (Pack32, ExtZero)}
 let v128_load64_zero align offset =
-  VecLoad {ty = V128Type; align; offset; pack = Some (Pack64, ExtZero)}
+  VecLoad {ty = `V128; align; offset; pack = Some (Pack64, ExtZero)}
 
-let v128_store align offset = VecStore {ty = V128Type; align; offset; pack = ()}
+let v128_store align offset = VecStore {ty = `V128; align; offset; pack = ()}
 
 let v128_load8_lane align offset i =
-  VecLoadLane ({ty = V128Type; align; offset; pack = Pack8}, i)
+  VecLoadLane ({ty = `V128; align; offset; pack = Pack8}, i)
 let v128_load16_lane align offset i =
-  VecLoadLane ({ty = V128Type; align; offset; pack = Pack16}, i)
+  VecLoadLane ({ty = `V128; align; offset; pack = Pack16}, i)
 let v128_load32_lane align offset i =
-  VecLoadLane ({ty = V128Type; align; offset; pack = Pack32}, i)
+  VecLoadLane ({ty = `V128; align; offset; pack = Pack32}, i)
 let v128_load64_lane align offset i =
-  VecLoadLane ({ty = V128Type; align; offset; pack = Pack64}, i)
+  VecLoadLane ({ty = `V128; align; offset; pack = Pack64}, i)
 
 let v128_store8_lane align offset i =
-  VecStoreLane ({ty = V128Type; align; offset; pack = Pack8}, i)
+  VecStoreLane ({ty = `V128; align; offset; pack = Pack8}, i)
 let v128_store16_lane align offset i =
-  VecStoreLane ({ty = V128Type; align; offset; pack = Pack16}, i)
+  VecStoreLane ({ty = `V128; align; offset; pack = Pack16}, i)
 let v128_store32_lane align offset i =
-  VecStoreLane ({ty = V128Type; align; offset; pack = Pack32}, i)
+  VecStoreLane ({ty = `V128; align; offset; pack = Pack32}, i)
 let v128_store64_lane align offset i =
-  VecStoreLane ({ty = V128Type; align; offset; pack = Pack64}, i)
+  VecStoreLane ({ty = `V128; align; offset; pack = Pack64}, i)
 
 let v128_not = VecUnaryBits (V128 V128Op.Not)
 let v128_and = VecBinaryBits (V128 V128Op.And)
diff --git a/interpreter/syntax/pack.ml b/interpreter/syntax/pack.ml
new file mode 100644
index 000000000..edc1b8d5b
--- /dev/null
+++ b/interpreter/syntax/pack.ml
@@ -0,0 +1,17 @@
+type pack_size = Pack8 | Pack16 | Pack32 | Pack64
+type extension = SX | ZX
+
+type pack_shape = Pack8x8 | Pack16x4 | Pack32x2
+type vec_extension =
+  | ExtLane of pack_shape * extension
+  | ExtSplat
+  | ExtZero
+
+let packed_size = function
+  | Pack8 -> 1
+  | Pack16 -> 2
+  | Pack32 -> 4
+  | Pack64 -> 8
+
+let packed_shape_size = function
+  | Pack8x8 | Pack16x4 | Pack32x2 -> 8
diff --git a/interpreter/syntax/types.ml b/interpreter/syntax/types.ml
index 01e86dadd..154b78905 100644
--- a/interpreter/syntax/types.ml
+++ b/interpreter/syntax/types.ml
@@ -1,307 +1,321 @@
-(* Types *)
+(* Indices and Names *)
 
 type type_idx = int32
 type local_idx = int32
 type name = Utf8.unicode
 
-and syn_var = type_idx
-and sem_var = def_type Lib.Promise.t
-and var = SynVar of syn_var | SemVar of sem_var
-
-and init = Set | Unset
-and nullability = NoNull | Null
-and num_type = I32Type | I64Type | F32Type | F64Type
-and vec_type = V128Type
-and ref_type = nullability * heap_type
-and heap_type =
-  FuncHeapType | ExternHeapType | DefHeapType of var | BotHeapType
-and value_type =
-  NumType of num_type | VecType of vec_type | RefType of ref_type | BotType
-
-and result_type = value_type list
-and instr_type = result_type * result_type * local_idx list
-and func_type = FuncType of result_type * result_type
-and def_type = FuncDefType of func_type
+let string_of_idx x =
+  I32.to_string_u x
 
-type 'a limits = {min : 'a; max : 'a option}
-type mutability = Cons | Var
-type table_type = TableType of Int32.t limits * ref_type
-type memory_type = MemoryType of Int32.t limits
-type global_type = GlobalType of mutability * value_type
-type local_type = LocalType of init * value_type
-type extern_type =
-  | ExternFuncType of func_type
-  | ExternTableType of table_type
-  | ExternMemoryType of memory_type
-  | ExternGlobalType of global_type
+let string_of_name n =
+  let b = Buffer.create 16 in
+  let escape uc =
+    if uc < 0x20 || uc >= 0x7f then
+      Buffer.add_string b (Printf.sprintf "\\u{%02x}" uc)
+    else begin
+      let c = Char.chr uc in
+      if c = '\"' || c = '\\' then Buffer.add_char b '\\';
+      Buffer.add_char b c
+    end
+  in
+  List.iter escape n;
+  Buffer.contents b
 
-type export_type = ExportType of extern_type * name
-type import_type = ImportType of extern_type * name * name
-type module_type =
-  ModuleType of def_type list * import_type list * export_type list
 
-(* TODO: these types should move somewhere else *)
-type pack_size = Pack8 | Pack16 | Pack32 | Pack64
-type extension = SX | ZX
-type pack_shape = Pack8x8 | Pack16x4 | Pack32x2
-type vec_extension =
-  | ExtLane of pack_shape * extension
-  | ExtSplat
-  | ExtZero
+(* Generic Types *)
 
+module type Var =
+sig
+  type var
+  val eq_var : var -> var -> bool
+  val string_of_var : var -> string
+end
 
-(* Attributes *)
+module Make (Var : Var) =
+struct
+  include Var
 
-let num_size = function
-  | I32Type | F32Type -> 4
-  | I64Type | F64Type -> 8
+  type init = [`Set | `Unset]
+  type nullability = [`NoNull | `Null]
+  type num_type = [`I32 | `I64 | `F32 | `F64]
+  type vec_type = [`V128]
+  type heap_type = [`Func | `Extern | `Def of var | `Bot]
+  type ref_type = [`Ref of nullability * heap_type]
+  type val_type = [num_type | vec_type | ref_type | `Bot]
 
-let vec_size = function
-  | V128Type -> 16
+  type result_type = val_type list
+  type instr_type = [`Instr of result_type * result_type * local_idx list]
+  type func_type = [`Func of result_type * result_type]
+  type def_type = func_type
 
-let packed_size = function
-  | Pack8 -> 1
-  | Pack16 -> 2
-  | Pack32 -> 4
-  | Pack64 -> 8
+  type 'a limits = {min : 'a; max : 'a option}
+  type mutability = [`Const | `Var]
+  type table_type = [`Table of Int32.t limits * ref_type]
+  type memory_type = [`Memory of Int32.t limits]
+  type global_type = [`Global of mutability * val_type]
+  type local_type = [`Local of init * val_type]
+  type extern_type = [func_type | table_type | memory_type | global_type]
 
-let packed_shape_size = function
-  | Pack8x8 | Pack16x4 | Pack32x2 -> 8
+  type export_type = [`Export of extern_type * name]
+  type import_type = [`Import of extern_type * name * name]
+  type module_type =
+    [`Module of def_type list * import_type list * export_type list]
 
-let is_syn_var = function SynVar _ -> true | SemVar _ -> false
-let is_sem_var = function SemVar _ -> true | SynVar _ -> false
 
-let is_num_type = function
-  | NumType _ | BotType -> true
-  | _ -> false
+  (* Attributes *)
 
-let is_vec_type = function
-  | VecType _ | BotType -> true
-  | _ -> false
+  let num_size : num_type -> int = function
+    | `I32 | `F32 -> 4
+    | `I64 | `F64 -> 8
 
-let is_ref_type = function
-  | RefType _ | BotType -> true
-  | _ -> false
+  let vec_size : vec_type -> int = function
+    | `V128 -> 16
 
-let defaultable_num_type = function
-  | _ -> true
+  let is_num_type : val_type -> bool = function
+    | #num_type | `Bot -> true
+    | _ -> false
 
-let defaultable_vec_type = function
-  | _ -> true
+  let is_vec_type : val_type -> bool = function
+    | #vec_type | `Bot -> true
+    | _ -> false
 
-let defaultable_ref_type = function
-  | (nul, _) -> nul = Null
+  let is_ref_type : val_type -> bool = function
+    | #ref_type | `Bot -> true
+    | _ -> false
 
-let defaultable_value_type = function
-  | NumType t -> defaultable_num_type t
-  | VecType t -> defaultable_vec_type t
-  | RefType t -> defaultable_ref_type t
-  | BotType -> assert false
+  let defaultable : [< val_type] -> bool = function
+    | #num_type -> true
+    | #vec_type -> true
+    | `Ref (nul, _) -> nul = `Null
+    | `Bot -> assert false
 
 
-(* Projections *)
+  (* Projections *)
 
-let as_func_def_type (dt : def_type) : func_type =
-  match dt with
-  | FuncDefType ft -> ft
+  let as_func_def_type (dt : def_type) : func_type =
+    match dt with
+    | #func_type as ft -> ft
 
-let extern_type_of_import_type (ImportType (et, _, _)) = et
-let extern_type_of_export_type (ExportType (et, _)) = et
+  let extern_type_of_import_type (`Import (et, _, _)) = et
+  let extern_type_of_export_type (`Export (et, _)) = et
 
 
-(* Filters *)
+  (* Filters *)
 
-let funcs =
-  Lib.List.map_filter (function ExternFuncType t -> Some t | _ -> None)
-let tables =
-  Lib.List.map_filter (function ExternTableType t -> Some t | _ -> None)
-let memories =
-  Lib.List.map_filter (function ExternMemoryType t -> Some t | _ -> None)
-let globals =
-  Lib.List.map_filter (function ExternGlobalType t -> Some t | _ -> None)
+  let funcs (ets : extern_type list) : func_type list =
+    Lib.List.map_filter (function #func_type as ft -> Some ft | _ -> None) ets
+  let tables (ets : extern_type list) : table_type list =
+    Lib.List.map_filter (function #table_type as tt -> Some tt | _ -> None) ets
+  let memories (ets : extern_type list) : memory_type list =
+    Lib.List.map_filter (function #memory_type as mt -> Some mt | _ -> None) ets
+  let globals (ets : extern_type list) : global_type list =
+    Lib.List.map_filter (function #global_type as gt -> Some gt | _ -> None) ets
 
 
-(* Allocation *)
+  (* String conversion *)
 
-let alloc_uninit () = Lib.Promise.make ()
-let init p dt = Lib.Promise.fulfill p dt
-let alloc dt = let p = alloc_uninit () in init p dt; p
+  let string_of_nullability : nullability -> string = function
+    | `NoNull -> ""
+    | `Null -> "null "
 
-let def_of x = Lib.Promise.value x
+  let string_of_num_type : num_type -> string = function
+    | `I32 -> "i32"
+    | `I64 -> "i64"
+    | `F32 -> "f32"
+    | `F64 -> "f64"
 
+  let string_of_vec_type : vec_type -> string = function
+    | `V128 -> "v128"
 
-(* Conversion *)
+  let string_of_heap_type : heap_type -> string = function
+    | `Func -> "func"
+    | `Extern -> "extern"
+    | `Def x -> string_of_var x
+    | `Bot -> "something"
 
-let sem_var_type c = function
-  | SynVar x -> SemVar (Lib.List32.nth c x)
-  | SemVar _ -> assert false
+  let string_of_ref_type : ref_type -> string = function
+    | `Ref (nul, t) ->
+      "(ref " ^ string_of_nullability nul ^ string_of_heap_type t ^ ")"
 
-let sem_num_type c t = t
+  let string_of_val_type : val_type -> string = function
+    | #num_type as t -> string_of_num_type t
+    | #vec_type as t -> string_of_vec_type t
+    | #ref_type as t -> string_of_ref_type t
+    | `Bot -> "(something)"
 
-let sem_vec_type c t = t
+  let string_of_result_type : result_type -> string = function
+    | ts -> "[" ^ String.concat " " (List.map string_of_val_type ts) ^ "]"
 
-let sem_heap_type c = function
-  | FuncHeapType -> FuncHeapType
-  | ExternHeapType -> ExternHeapType
-  | DefHeapType x -> DefHeapType (sem_var_type c x)
-  | BotHeapType -> BotHeapType
+  let string_of_func_type : func_type -> string = function
+    | `Func (ts1, ts2) ->
+      string_of_result_type ts1 ^ " -> " ^ string_of_result_type ts2
 
-let sem_ref_type c = function
-  | (nul, t) -> (nul, sem_heap_type c t)
+  let string_of_def_type : def_type -> string = function
+    | #func_type as ft -> "func " ^ string_of_func_type ft
 
-let sem_value_type c = function
-  | NumType t -> NumType (sem_num_type c t)
-  | VecType t -> VecType (sem_vec_type c t)
-  | RefType t -> RefType (sem_ref_type c t)
-  | BotType -> BotType
 
-let sem_stack_type c ts =
- List.map (sem_value_type c) ts
+  let string_of_limits : I32.t limits -> string = function
+    | {min; max} ->
+      I32.to_string_u min ^
+      (match max with None -> "" | Some n -> " " ^ I32.to_string_u n)
 
+  let string_of_memory_type : memory_type -> string = function
+    | `Memory lim -> string_of_limits lim
 
-let sem_memory_type c (MemoryType lim) =
-  MemoryType lim
+  let string_of_table_type : table_type -> string = function
+    | `Table (lim, t) -> string_of_limits lim ^ " " ^ string_of_ref_type t
 
-let sem_table_type c (TableType (lim, t)) =
-  TableType (lim, sem_ref_type c t)
+  let string_of_global_type : global_type -> string = function
+    | `Global (`Const, t) -> string_of_val_type t
+    | `Global (`Var, t) -> "(mut " ^ string_of_val_type t ^ ")"
 
-let sem_global_type c (GlobalType (mut, t)) =
-  GlobalType (mut, sem_value_type c t)
+  let string_of_local_type : local_type -> string = function
+    | `Local (`Set, t) -> string_of_val_type t
+    | `Local (`Unset, t) -> "(unset " ^ string_of_val_type t ^ ")"
 
-let sem_func_type c (FuncType (ins, out)) =
-  FuncType (sem_stack_type c ins, sem_stack_type c out)
+  let string_of_extern_type : extern_type -> string = function
+    | #func_type as ft -> "func " ^ string_of_func_type ft
+    | #table_type as tt -> "table " ^ string_of_table_type tt
+    | #memory_type as mt -> "memory " ^ string_of_memory_type mt
+    | #global_type as gt -> "global " ^ string_of_global_type gt
 
-let sem_extern_type c = function
-  | ExternFuncType ft -> ExternFuncType (sem_func_type c ft)
-  | ExternTableType tt -> ExternTableType (sem_table_type c tt)
-  | ExternMemoryType mt -> ExternMemoryType (sem_memory_type c mt)
-  | ExternGlobalType gt -> ExternGlobalType (sem_global_type c gt)
 
+  let string_of_export_type : export_type -> string = function
+    | `Export (et, name) ->
+      "\"" ^ string_of_name name ^ "\" : " ^ string_of_extern_type et
 
-let sem_def_type c = function
-  | FuncDefType ft -> FuncDefType (sem_func_type c ft)
+  let string_of_import_type : import_type -> string = function
+    | `Import (et, module_name, name) ->
+      "\"" ^ string_of_name module_name ^ "\" \"" ^
+        string_of_name name ^ "\" : " ^ string_of_extern_type et
 
+  let string_of_module_type : module_type -> string = function
+    | `Module (dts, its, ets) ->
+      String.concat "" (
+        List.mapi (fun i dt -> "type " ^ string_of_int i ^ " = " ^ string_of_def_type dt ^ "\n") dts @
+        List.map (fun it -> "import " ^ string_of_import_type it ^ "\n") its @
+        List.map (fun et -> "export " ^ string_of_export_type et ^ "\n") ets
+      )
+end
 
-let sem_export_type c (ExportType (et, name)) =
-  ExportType (sem_extern_type c et, name)
 
-let sem_import_type c (ImportType (et, module_name, name)) =
-  ImportType (sem_extern_type c et, module_name, name)
+(* Syntactic Types *)
 
-let sem_module_type (ModuleType (dts, its, ets)) =
-  let c = List.map (fun _ -> alloc_uninit ()) dts in
-  List.iter2 (fun x dt -> init x (sem_def_type c dt)) c dts;
-  let its = List.map (sem_import_type c) its in
-  let ets = List.map (sem_export_type c) ets in
-  ModuleType ([], its, ets)
+module SynVar =
+struct
+  type var = type_idx
+  let eq_var = (=)
+  let string_of_var = string_of_idx
+end
 
+module Syn = Make (SynVar)
 
-(* String conversion *)
+include Syn
 
-let string_of_name n =
-  let b = Buffer.create 16 in
-  let escape uc =
-    if uc < 0x20 || uc >= 0x7f then
-      Buffer.add_string b (Printf.sprintf "\\u{%02x}" uc)
-    else begin
-      let c = Char.chr uc in
-      if c = '\"' || c = '\\' then Buffer.add_char b '\\';
-      Buffer.add_char b c
-    end
-  in
-  List.iter escape n;
-  Buffer.contents b
 
-let string_of_idx x = I32.to_string_u x
-
-let rec string_of_var =
-  let inner = ref false in
-  function
-  | SynVar x -> string_of_idx x
-  | SemVar x ->
-    if !inner then "..." else
-    ( inner := true;
-      try
-        let s = string_of_def_type (def_of x) in
-        inner := false; "(" ^ s ^ ")"
-      with exn -> inner := false; raise exn
-    )
-
-and string_of_nullability = function
-  | NoNull -> ""
-  | Null -> "null "
-
-and string_of_num_type = function
-  | I32Type -> "i32"
-  | I64Type -> "i64"
-  | F32Type -> "f32"
-  | F64Type -> "f64"
-
-and string_of_vec_type = function
-  | V128Type -> "v128"
-
-and string_of_heap_type = function
-  | FuncHeapType -> "func"
-  | ExternHeapType -> "extern"
-  | DefHeapType x -> string_of_var x
-  | BotHeapType -> "something"
-
-and string_of_ref_type = function
-  | (nul, t) ->
-    "(ref " ^ string_of_nullability nul ^ string_of_heap_type t ^ ")"
-
-and string_of_value_type = function
-  | NumType t -> string_of_num_type t
-  | VecType t -> string_of_vec_type t
-  | RefType t -> string_of_ref_type t
-  | BotType -> "(something)"
-
-and string_of_result_type ts =
-  "[" ^ String.concat " " (List.map string_of_value_type ts) ^ "]"
-
-and string_of_func_type = function
-  | FuncType (ins, out) ->
-    string_of_result_type ins ^ " -> " ^ string_of_result_type out
-
-and string_of_def_type = function
-  | FuncDefType ft -> "func " ^ string_of_func_type ft
-
-
-let string_of_limits {min; max} =
-  I32.to_string_u min ^
-  (match max with None -> "" | Some n -> " " ^ I32.to_string_u n)
-
-let string_of_memory_type = function
-  | MemoryType lim -> string_of_limits lim
-
-let string_of_table_type = function
-  | TableType (lim, t) -> string_of_limits lim ^ " " ^ string_of_ref_type t
-
-let string_of_global_type = function
-  | GlobalType (Cons, t) -> string_of_value_type t
-  | GlobalType (Var, t) -> "(mut " ^ string_of_value_type t ^ ")"
-
-let string_of_local_type = function
-  | LocalType (Set, t) -> string_of_value_type t
-  | LocalType (Unset, t) -> "(unset " ^ string_of_value_type t ^ ")"
-
-let string_of_extern_type = function
-  | ExternFuncType ft -> "func " ^ string_of_func_type ft
-  | ExternTableType tt -> "table " ^ string_of_table_type tt
-  | ExternMemoryType mt -> "memory " ^ string_of_memory_type mt
-  | ExternGlobalType gt -> "global " ^ string_of_global_type gt
-
-
-let string_of_export_type (ExportType (et, name)) =
-  "\"" ^ string_of_name name ^ "\" : " ^ string_of_extern_type et
-
-let string_of_import_type (ImportType (et, module_name, name)) =
-  "\"" ^ string_of_name module_name ^ "\" \"" ^
-    string_of_name name ^ "\" : " ^ string_of_extern_type et
-
-let string_of_module_type (ModuleType (dts, its, ets)) =
-  String.concat "" (
-    List.mapi (fun i dt -> "type " ^ string_of_int i ^ " = " ^ string_of_def_type dt ^ "\n") dts @
-    List.map (fun it -> "import " ^ string_of_import_type it ^ "\n") its @
-    List.map (fun et -> "export " ^ string_of_export_type et ^ "\n") ets
-  )
+(* Semantic Types *)
+
+module SemVar =
+struct
+  (* Use extensible type, since recursive modules won't work *)
+  type var = ..
+
+  let eq_var = (==)
+
+  let string_of_var' = ref (fun (x : var) -> assert false)
+  let string_of_var x = !string_of_var' x
+end
+
+module Sem =
+struct
+  include Make (SemVar)
+
+  type SemVar.var += Var of def_type Lib.Promise.t
+
+  let unwrap = function
+    | Var p -> p
+    | _ -> assert false
+
+  let alloc_uninit () = Var (Lib.Promise.make ())
+  let init x dt = Lib.Promise.fulfill (unwrap x) dt
+  let alloc dt = let x = alloc_uninit () in init x dt; x
+  let def_of x = Lib.Promise.value (unwrap x)
+
+  let () = SemVar.string_of_var' :=
+    let inner = ref false in
+    fun x ->
+      if !inner then "..." else
+      ( inner := true;
+        try
+          let s = string_of_def_type (def_of x) in
+          inner := false; "(" ^ s ^ ")"
+        with exn -> inner := false; raise exn
+      )
+
+  (* Conversion *)
+
+  let sem_var_type c (x : Syn.var) : var = Lib.List32.nth c x
+
+  let sem_num_type c : Syn.num_type -> num_type = function
+    | t -> t
+
+  let sem_vec_type c : Syn.vec_type -> vec_type = function
+    | t -> t
+
+  let sem_heap_type c : Syn.heap_type -> heap_type = function
+    | `Func -> `Func
+    | `Extern -> `Extern
+    | `Def x -> `Def (sem_var_type c x)
+    | `Bot -> `Bot
+
+  let sem_ref_type c : Syn.ref_type -> ref_type = function
+    | `Ref (nul, t) -> `Ref (nul, sem_heap_type c t)
+
+  let sem_val_type c : Syn.val_type -> val_type = function
+    | #Syn.num_type as t -> (sem_num_type c t :> val_type)
+    | #Syn.vec_type as t -> (sem_vec_type c t :> val_type)
+    | #Syn.ref_type as t -> (sem_ref_type c t :> val_type)
+    | `Bot -> `Bot
+
+  let sem_result_type c : Syn.result_type -> result_type = function
+    | ts -> List.map (sem_val_type c) ts
+
+  let sem_func_type c : Syn.func_type -> func_type = function
+    | `Func (ts1, ts2) -> `Func (sem_result_type c ts1, sem_result_type c ts2)
+
+  let sem_def_type c : Syn.def_type -> def_type = function
+    | #Syn.func_type as ft -> (sem_func_type c ft :> def_type)
+
+  let sem_limits c : 'a Syn.limits -> 'a limits = function
+    | {min; max} -> {min; max}
+
+  let sem_memory_type c : Syn.memory_type -> memory_type = function
+    | `Memory lim -> `Memory (sem_limits c lim)
+
+  let sem_table_type c : Syn.table_type -> table_type = function
+    | `Table (lim, t) -> `Table (sem_limits c lim, sem_ref_type c t)
+
+  let sem_global_type c : Syn.global_type -> global_type = function
+    | `Global (mut, t) -> `Global (mut, sem_val_type c t)
+
+  let sem_extern_type c : Syn.extern_type -> extern_type = function
+    | #Syn.func_type as ft -> (sem_func_type c ft :> extern_type)
+    | #Syn.table_type as tt -> (sem_table_type c tt :> extern_type)
+    | #Syn.memory_type as mt -> (sem_memory_type c mt :> extern_type)
+    | #Syn.global_type as gt -> (sem_global_type c gt :> extern_type)
+
+  let sem_export_type c : Syn.export_type -> export_type = function
+    | `Export (et, name) -> `Export (sem_extern_type c et, name)
+
+  let sem_import_type c : Syn.import_type -> import_type = function
+    | `Import (et, module_name, name) ->
+      `Import (sem_extern_type c et, module_name, name)
+
+  let sem_module_type : Syn.module_type -> module_type = function
+    | `Module (dts, its, ets) ->
+      let c = List.map (fun _ -> alloc_uninit ()) dts in
+      List.iter2 (fun x dt -> init x (sem_def_type c dt)) c dts;
+      let its = List.map (sem_import_type c) its in
+      let ets = List.map (sem_export_type c) ets in
+      `Module ([], its, ets)
+end
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index 830e8314b..7f8547a18 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -1,5 +1,6 @@
 open Source
 open Ast
+open Pack
 open Script
 open Value
 open Types
@@ -59,23 +60,23 @@ let num_type t = string_of_num_type t
 let vec_type t = string_of_vec_type t
 let ref_type t = string_of_ref_type t
 let heap_type t = string_of_heap_type t
-let value_type t = string_of_value_type t
+let val_type t = string_of_val_type t
 
-let decls kind ts = tab kind (atom value_type) ts
+let decls kind ts = tab kind (atom val_type) ts
 
-let func_type (FuncType (ins, out)) =
-  Node ("func", decls "param" ins @ decls "result" out)
+let func_type (`Func (ts1, ts2)) =
+  Node ("func", decls "param" ts1 @ decls "result" ts2)
 
 let def_type dt =
   match dt with
-  | FuncDefType ft -> func_type ft
+  | #func_type as ft -> func_type ft
 
 let limits nat {min; max} =
   String.concat " " (nat min :: opt nat max)
 
 let global_type = function
-  | GlobalType (Cons, t) -> atom string_of_value_type t
-  | GlobalType (Var, t) -> Node ("mut", [atom string_of_value_type t])
+  | `Global (`Const, t) -> atom string_of_val_type t
+  | `Global (`Var, t) -> Node ("mut", [atom string_of_val_type t])
 
 let pack_size = function
   | Pack8 -> "8"
@@ -430,8 +431,7 @@ let constop v = num_type (type_of_num v) ^ ".const"
 let vec_constop v = vec_type (type_of_vec v) ^ ".const i32x4"
 
 let block_type = function
-  | VarBlockType (SynVar x) -> [Node ("type " ^ nat32 x, [])]
-  | VarBlockType (SemVar _) -> assert false
+  | VarBlockType x -> [Node ("type " ^ nat32 x, [])]
   | ValBlockType ts -> decls "result" (list_of_opt ts)
 
 let rec instr e =
@@ -538,21 +538,21 @@ let func f =
 (* Tables & memories *)
 
 let table off i tab =
-  let {ttype = TableType (lim, t)} = tab.it in
+  let {ttype = `Table (lim, t)} = tab.it in
   Node ("table $" ^ nat (off + i) ^ " " ^ limits nat32 lim,
     [atom ref_type t]
   )
 
 let memory off i mem =
-  let {mtype = MemoryType lim} = mem.it in
+  let {mtype = `Memory lim} = mem.it in
   Node ("memory $" ^ nat (off + i) ^ " " ^ limits nat32 lim, [])
 
 let is_elem_kind = function
-  | (NoNull, FuncHeapType) -> true
+  | `Ref (`NoNull, `Func) -> true
   | _ -> false
 
 let elem_kind = function
-  | (NoNull, FuncHeapType) -> "func"
+  | `Ref (`NoNull, `Func) -> "func"
   | _ -> assert false
 
 let is_elem_index e =
@@ -669,7 +669,7 @@ let num mode = if mode = `Binary then hex_string_of_num else string_of_num
 let vec mode = if mode = `Binary then hex_string_of_vec else string_of_vec
 
 let ref_ = function
-  | NullRef t -> Node ("ref.null " ^ heap_type t, [])
+  | NullRef t -> Node ("ref.null " ^ Types.Sem.string_of_heap_type t, [])
   | Script.ExternRef n -> Node ("ref.extern " ^ nat32 n, [])
   | _ -> assert false
 
diff --git a/interpreter/text/lexer.mll b/interpreter/text/lexer.mll
index ddf586f4d..1aabfbf11 100644
--- a/interpreter/text/lexer.mll
+++ b/interpreter/text/lexer.mll
@@ -134,11 +134,11 @@ rule token = parse
 
   | keyword as s
     { match s with
-      | "i32" -> NUM_TYPE Types.I32Type
-      | "i64" -> NUM_TYPE Types.I64Type
-      | "f32" -> NUM_TYPE Types.F32Type
-      | "f64" -> NUM_TYPE Types.F64Type
-      | "v128" -> VEC_TYPE Types.V128Type
+      | "i32" -> NUM_TYPE `I32
+      | "i64" -> NUM_TYPE `I64
+      | "f32" -> NUM_TYPE `F32
+      | "f64" -> NUM_TYPE `F64
+      | "v128" -> VEC_TYPE `V128
       | "i8x16" -> VEC_SHAPE (V128.I8x16 ())
       | "i16x8" -> VEC_SHAPE (V128.I16x8 ())
       | "i32x4" -> VEC_SHAPE (V128.I32x4 ())
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index 148b081af..f66bc861a 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -159,7 +159,7 @@ let label (c : context) x = lookup "label " c.labels x
 
 let func_type (c : context) x =
   match (Lib.List32.nth c.types.list x.it).it with
-  | FuncDefType ft -> ft
+  | #func_type as ft -> ft
   | exception Failure _ -> error x.at ("unknown type " ^ Int32.to_string x.it)
 
 
@@ -203,7 +203,7 @@ let anon_label (c : context) at = bind "label" c.labels 1l at
 
 
 let inline_func_type (c : context) ft at =
-  let dt = FuncDefType ft in
+  let dt = (ft :> def_type) in
   match Lib.List.index_where (fun ty -> ty.it = dt) c.types.list with
   | Some i -> Int32.of_int i @@ at
   | None ->
@@ -211,12 +211,12 @@ let inline_func_type (c : context) ft at =
     i @@ at
 
 let inline_func_type_explicit (c : context) x ft at =
-  if ft = FuncType ([], []) then
+  if ft = `Func ([], []) then
     (* Deferring ensures that type lookup is only triggered when
        symbolic identifiers are used, and not for desugared functions *)
     defer_locals c (fun () ->
-      let FuncType (ts, _) = func_type c x in
-      bind "local" c.locals (Lib.List32.length ts) at
+      let `Func (ts1, _ts2) = func_type c x in
+      bind "local" c.locals (Lib.List32.length ts1) at
     )
   else if ft <> func_type c x then
     error at "inline function type does not match explicit type";
@@ -310,56 +310,56 @@ string_list :
 /* Types */
 
 null_opt :
-  | /* empty */ { NoNull }
-  | NULL { Null }
+  | /* empty */ { `NoNull }
+  | NULL { `Null }
 
 heap_type :
-  | FUNC { fun c -> FuncHeapType }
-  | EXTERN { fun c -> ExternHeapType }
-  | var { fun c -> DefHeapType (SynVar ($1 c type_).it) }
+  | FUNC { fun c -> `Func }
+  | EXTERN { fun c -> `Extern }
+  | var { fun c -> `Def ($1 c type_).it }
 
 ref_type :
-  | LPAR REF null_opt heap_type RPAR { fun c -> ($3, $4 c) }
-  | FUNCREF { fun c -> (Null, FuncHeapType) }  /* Sugar */
-  | EXTERNREF { fun c -> (Null, ExternHeapType) }  /* Sugar */
+  | LPAR REF null_opt heap_type RPAR { fun c -> `Ref ($3, $4 c) }
+  | FUNCREF { fun c -> `Ref (`Null, `Func) }  /* Sugar */
+  | EXTERNREF { fun c -> `Ref (`Null, `Extern) }  /* Sugar */
 
-value_type :
-  | NUM_TYPE { fun c -> NumType $1 }
-  | VEC_TYPE { fun c -> VecType $1 }
-  | ref_type { fun c -> RefType ($1 c) }
+val_type :
+  | NUM_TYPE { fun c -> ($1 :> val_type) }
+  | VEC_TYPE { fun c -> ($1 :> val_type) }
+  | ref_type { fun c -> ($1 c :> val_type) }
 
-value_type_list :
+val_type_list :
   | /* empty */ { 0l, fun c -> [] }
-  | value_type value_type_list { I32.add (fst $2) 1l, fun c -> $1 c :: snd $2 c }
+  | val_type val_type_list { I32.add (fst $2) 1l, fun c -> $1 c :: snd $2 c }
 
 global_type :
-  | value_type { fun c -> GlobalType (Cons, $1 c) }
-  | LPAR MUT value_type RPAR { fun c -> GlobalType (Var, $3 c) }
+  | val_type { fun c -> `Global (`Const, $1 c) }
+  | LPAR MUT val_type RPAR { fun c -> `Global (`Var, $3 c) }
 
 def_type :
-  | LPAR FUNC func_type RPAR { fun c -> FuncDefType ($3 c) }
+  | LPAR FUNC func_type RPAR { fun c -> ($3 c :> def_type) }
 
 func_type :
   | func_type_result
-    { fun c -> FuncType ([], $1 c) }
-  | LPAR PARAM value_type_list RPAR func_type
-    { fun c -> let FuncType (ins, out) = $5 c in
-      FuncType (snd $3 c @ ins, out) }
-  | LPAR PARAM bind_var value_type RPAR func_type  /* Sugar */
-    { fun c -> let FuncType (ins, out) = $6 c in
-      FuncType ($4 c :: ins, out) }
+    { fun c -> `Func ([], $1 c) }
+  | LPAR PARAM val_type_list RPAR func_type
+    { fun c -> let `Func (ts1, ts2) = $5 c in
+      `Func (snd $3 c @ ts1, ts2) }
+  | LPAR PARAM bind_var val_type RPAR func_type  /* Sugar */
+    { fun c -> let `Func (ts1, ts2) = $6 c in
+      `Func ($4 c :: ts1, ts2) }
 
 func_type_result :
   | /* empty */
     { fun c -> [] }
-  | LPAR RESULT value_type_list RPAR func_type_result
+  | LPAR RESULT val_type_list RPAR func_type_result
     { fun c -> snd $3 c @ $5 c }
 
 table_type :
-  | limits ref_type { fun c -> TableType ($1, $2 c) }
+  | limits ref_type { fun c -> `Table ($1, $2 c) }
 
 memory_type :
-  | limits { fun c -> MemoryType $1 }
+  | limits { fun c -> `Memory $1 }
 
 limits :
   | NAT { {min = nat32 $1 (ati 1); max = None} }
@@ -514,7 +514,7 @@ select_instr :
       select (if b then (Some ts) else None) @@ at }
 
 select_instr_results :
-  | LPAR RESULT value_type_list RPAR select_instr_results
+  | LPAR RESULT val_type_list RPAR select_instr_results
     { fun c -> let _, ts = $5 c in true, snd $3 c @ ts }
   | /* empty */
     { fun c -> false, [] }
@@ -526,7 +526,7 @@ select_instr_instr :
       select (if b then (Some ts) else None) @@ at1, es }
 
 select_instr_results_instr :
-  | LPAR RESULT value_type_list RPAR select_instr_results_instr
+  | LPAR RESULT val_type_list RPAR select_instr_results_instr
     { fun c -> let _, ts, es = $5 c in true, snd $3 c @ ts, es }
   | instr
     { fun c -> false, [], $1 c }
@@ -543,20 +543,19 @@ call_instr_type :
     { let at1 = ati 1 in
       fun c ->
       match $2 c with
-      | FuncType ([], []) -> $1 c type_
+      | `Func ([], []) -> $1 c type_
       | ft -> inline_func_type_explicit c ($1 c type_) ft at1 }
   | call_instr_params
     { let at = at () in fun c -> inline_func_type c ($1 c) at }
 
 call_instr_params :
-  | LPAR PARAM value_type_list RPAR call_instr_params
-    { fun c -> let FuncType (ts1, ts2) = $5 c in
-      FuncType (snd $3 c @ ts1, ts2) }
+  | LPAR PARAM val_type_list RPAR call_instr_params
+    { fun c -> let `Func (ts1, ts2) = $5 c in `Func (snd $3 c @ ts1, ts2) }
   | call_instr_results
-    { fun c -> FuncType ([], $1 c) }
+    { fun c -> `Func ([], $1 c) }
 
 call_instr_results :
-  | LPAR RESULT value_type_list RPAR call_instr_results
+  | LPAR RESULT val_type_list RPAR call_instr_results
     { fun c -> snd $3 c @ $5 c }
   | /* empty */
     { fun c -> [] }
@@ -575,21 +574,21 @@ call_instr_type_instr :
     { let at1 = ati 1 in
       fun c ->
       match $2 c with
-      | FuncType ([], []), es -> $1 c type_, es
+      | `Func ([], []), es -> $1 c type_, es
       | ft, es -> inline_func_type_explicit c ($1 c type_) ft at1, es }
   | call_instr_params_instr
     { let at = at () in
       fun c -> let ft, es = $1 c in inline_func_type c ft at, es }
 
 call_instr_params_instr :
-  | LPAR PARAM value_type_list RPAR call_instr_params_instr
-    { fun c -> let FuncType (ts1, ts2), es = $5 c in
-      FuncType (snd $3 c @ ts1, ts2), es }
+  | LPAR PARAM val_type_list RPAR call_instr_params_instr
+    { fun c -> let `Func (ts1, ts2), es = $5 c in
+      `Func (snd $3 c @ ts1, ts2), es }
   | call_instr_results_instr
-    { fun c -> let ts, es = $1 c in FuncType ([], ts), es }
+    { fun c -> let ts, es = $1 c in `Func ([], ts), es }
 
 call_instr_results_instr :
-  | LPAR RESULT value_type_list RPAR call_instr_results_instr
+  | LPAR RESULT val_type_list RPAR call_instr_results_instr
     { fun c -> let ts, es = $5 c in snd $3 c @ ts, es }
   | instr
     { fun c -> [], $1 c }
@@ -611,29 +610,28 @@ block :
     { let at1 = ati 1 in
       fun c -> let ft, es = $2 c in
       let x = inline_func_type_explicit c ($1 c type_) ft at1 in
-      VarBlockType (SynVar x.it), es }
+      VarBlockType x.it, es }
   | block_param_body  /* Sugar */
     { let at = at () in
       fun c -> let ft, es = $1 c in
       let bt =
         match ft with
-        | FuncType ([], []) -> ValBlockType None
-        | FuncType ([], [t]) -> ValBlockType (Some t)
-        | ft ->  VarBlockType (SynVar (inline_func_type c ft at).it)
+        | `Func ([], []) -> ValBlockType None
+        | `Func ([], [t]) -> ValBlockType (Some t)
+        | ft ->  VarBlockType (inline_func_type c ft at).it
       in bt, es }
 
 block_param_body :
   | block_result_body { $1 }
-  | LPAR PARAM value_type_list RPAR block_param_body
-    { fun c -> let FuncType (ins, out), es = $5 c in
-      FuncType (snd $3 c @ ins, out), es }
+  | LPAR PARAM val_type_list RPAR block_param_body
+    { fun c -> let `Func (ts1, ts2), es = $5 c in
+      `Func (snd $3 c @ ts1, ts2), es }
 
 block_result_body :
-  | instr_list { fun c -> FuncType ([], []), $1 c }
-  | LPAR RESULT value_type_list RPAR block_result_body
-    { fun c ->
-      let FuncType (ins, out), es = $5 c in
-      FuncType (ins, snd $3 c @ out), es }
+  | instr_list { fun c -> `Func ([], []), $1 c }
+  | LPAR RESULT val_type_list RPAR block_result_body
+    { fun c -> let `Func (ts1, ts2), es = $5 c in
+      `Func (ts1, snd $3 c @ ts2), es }
 
 
 expr :  /* Sugar */
@@ -658,7 +656,7 @@ expr1 :  /* Sugar */
       let bt, (es, es1, es2) = $3 c c' in es, if_ bt es1 es2 }
 
 select_expr_results :
-  | LPAR RESULT value_type_list RPAR select_expr_results
+  | LPAR RESULT val_type_list RPAR select_expr_results
     { fun c -> let _, ts, es = $5 c in true, snd $3 c @ ts, es }
   | expr_list
     { fun c -> false, [], $1 c }
@@ -668,21 +666,21 @@ call_expr_type :
     { let at1 = ati 1 in
       fun c ->
       match $2 c with
-      | FuncType ([], []), es -> $1 c type_, es
+      | `Func ([], []), es -> $1 c type_, es
       | ft, es -> inline_func_type_explicit c ($1 c type_) ft at1, es }
   | call_expr_params
     { let at1 = ati 1 in
       fun c -> let ft, es = $1 c in inline_func_type c ft at1, es }
 
 call_expr_params :
-  | LPAR PARAM value_type_list RPAR call_expr_params
-    { fun c -> let FuncType (ts1, ts2), es = $5 c in
-      FuncType (snd $3 c @ ts1, ts2), es }
+  | LPAR PARAM val_type_list RPAR call_expr_params
+    { fun c -> let `Func (ts1, ts2), es = $5 c in
+      `Func (snd $3 c @ ts1, ts2), es }
   | call_expr_results
-    { fun c -> let ts, es = $1 c in FuncType ([], ts), es }
+    { fun c -> let ts, es = $1 c in `Func ([], ts), es }
 
 call_expr_results :
-  | LPAR RESULT value_type_list RPAR call_expr_results
+  | LPAR RESULT val_type_list RPAR call_expr_results
     { fun c -> let ts, es = $5 c in snd $3 c @ ts, es }
   | expr_list
     { fun c -> [], $1 c }
@@ -693,30 +691,28 @@ if_block :
     { let at = at () in
       fun c c' -> let ft, es = $2 c c' in
       let x = inline_func_type_explicit c ($1 c type_) ft at in
-      VarBlockType (SynVar x.it), es }
+      VarBlockType x.it, es }
   | if_block_param_body  /* Sugar */
     { let at = at () in
       fun c c' -> let ft, es = $1 c c' in
       let bt =
         match ft with
-        | FuncType ([], []) -> ValBlockType None
-        | FuncType ([], [t]) -> ValBlockType (Some t)
-        | ft ->  VarBlockType (SynVar (inline_func_type c ft at).it)
+        | `Func ([], []) -> ValBlockType None
+        | `Func ([], [t]) -> ValBlockType (Some t)
+        | ft ->  VarBlockType (inline_func_type c ft at).it
       in bt, es }
 
 if_block_param_body :
   | if_block_result_body { $1 }
-  | LPAR PARAM value_type_list RPAR if_block_param_body
-    { fun c c' ->
-      let FuncType (ins, out), es = $5 c c' in
-      FuncType (snd $3 c @ ins, out), es }
+  | LPAR PARAM val_type_list RPAR if_block_param_body
+    { fun c c' -> let `Func (ts1, ts2), es = $5 c c' in
+      `Func (snd $3 c @ ts1, ts2), es }
 
 if_block_result_body :
-  | if_ { fun c c' -> FuncType ([], []), $1 c c' }
-  | LPAR RESULT value_type_list RPAR if_block_result_body
-    { fun c c' ->
-      let FuncType (ins, out), es = $5 c c' in
-      FuncType (ins, snd $3 c @ out), es }
+  | if_ { fun c c' -> `Func ([], []), $1 c c' }
+  | LPAR RESULT val_type_list RPAR if_block_result_body
+    { fun c c' -> let `Func (ts1, ts2), es = $5 c c' in
+      `Func (ts1, snd $3 c @ ts2), es }
 
 if_ :
   | expr if_
@@ -777,33 +773,33 @@ func_fields :
 
 func_fields_import :  /* Sugar */
   | func_fields_import_result { $1 }
-  | LPAR PARAM value_type_list RPAR func_fields_import
-    { fun c -> let FuncType (ins, out) = $5 c in FuncType (snd $3 c @ ins, out) }
-  | LPAR PARAM bind_var value_type RPAR func_fields_import  /* Sugar */
-    { fun c -> let FuncType (ins, out) = $6 c in FuncType ($4 c :: ins, out) }
+  | LPAR PARAM val_type_list RPAR func_fields_import
+    { fun c -> let `Func (ts1, ts2) = $5 c in `Func (snd $3 c @ ts1, ts2) }
+  | LPAR PARAM bind_var val_type RPAR func_fields_import  /* Sugar */
+    { fun c -> let `Func (ts1, ts2) = $6 c in `Func ($4 c :: ts1, ts2) }
 
 func_fields_import_result :  /* Sugar */
-  | /* empty */ { fun c -> FuncType ([], []) }
-  | LPAR RESULT value_type_list RPAR func_fields_import_result
-    { fun c -> let FuncType (ins, out) = $5 c in FuncType (ins, snd $3 c @ out) }
+  | /* empty */ { fun c -> `Func ([], []) }
+  | LPAR RESULT val_type_list RPAR func_fields_import_result
+    { fun c -> let `Func (ts1, ts2) = $5 c in `Func (ts1, snd $3 c @ ts2) }
 
 func_fields_body :
   | func_result_body { $1 }
-  | LPAR PARAM value_type_list RPAR func_fields_body
+  | LPAR PARAM val_type_list RPAR func_fields_body
     { let at3 = ati 3 in
-      (fun c -> let FuncType (ins, out) = fst $5 c in
-        FuncType (snd $3 c @ ins, out)),
+      (fun c -> let `Func (ts1, ts2) = fst $5 c in
+        `Func (snd $3 c @ ts1, ts2)),
       (fun c -> anon_locals c (fst $3) at3; snd $5 c) }
-  | LPAR PARAM bind_var value_type RPAR func_fields_body  /* Sugar */
-    { (fun c -> let FuncType (ins, out) = fst $6 c in
-        FuncType ($4 c :: ins, out)),
+  | LPAR PARAM bind_var val_type RPAR func_fields_body  /* Sugar */
+    { (fun c -> let `Func (ts1, ts2) = fst $6 c in
+        `Func ($4 c :: ts1, ts2)),
       (fun c -> ignore (bind_local c $3); snd $6 c) }
 
 func_result_body :
-  | func_body { (fun c -> FuncType ([], [])), $1 }
-  | LPAR RESULT value_type_list RPAR func_result_body
-    { (fun c -> let FuncType (ins, out) = fst $5 c in
-        FuncType (ins, snd $3 c @ out)),
+  | func_body { (fun c -> `Func ([], [])), $1 }
+  | LPAR RESULT val_type_list RPAR func_result_body
+    { (fun c -> let `Func (ts1, ts2) = fst $5 c in
+        `Func (ts1, snd $3 c @ ts2)),
       snd $5 }
 
 func_body :
@@ -820,7 +816,7 @@ func_body :
       {f with locals = $4 c :: f.locals} }
 
 local_type :
-  | value_type { let at = at () in fun c -> {ltype = $1 c} @@ at }
+  | val_type { let at = at () in fun c -> {ltype = $1 c} @@ at }
 
 local_type_list :
   | /* empty */ { 0l, fun c -> [] }
@@ -840,7 +836,7 @@ offset :
   | expr { let at = at () in fun c -> $1 c @@ at }  /* Sugar */
 
 elem_kind :
-  | FUNC { (NoNull, FuncHeapType) }
+  | FUNC { `Ref (`NoNull, `Func) }
 
 elem_expr :
   | LPAR ITEM const_expr RPAR { $3 }
@@ -889,7 +885,7 @@ elem :
     { let at = at () in
       fun c -> ignore ($3 c anon_elem bind_elem);
       fun () ->
-      { etype = (NoNull, FuncHeapType); einit = $5 c func;
+      { etype = `Ref (`NoNull, `Func); einit = $5 c func;
         emode = Active {index = 0l @@ at; offset = $4 c} @@ at } @@ at }
 
 table :
@@ -916,7 +912,7 @@ table_fields :
       let size = Lib.List32.length einit in
       let emode = Active {index = x; offset} @@ at in
       let etype = $1 c in
-      [{ttype = TableType ({min = size; max = Some size}, etype)} @@ at],
+      [{ttype = `Table ({min = size; max = Some size}, etype)} @@ at],
       [{etype; einit; emode} @@ at],
       [], [] }
   | ref_type LPAR ELEM elem_expr elem_expr_list RPAR  /* Sugar */
@@ -926,7 +922,7 @@ table_fields :
       let size = Lib.List32.length einit in
       let emode = Active {index = x; offset} @@ at in
       let etype = $1 c in
-      [{ttype = TableType ({min = size; max = Some size}, etype)} @@ at],
+      [{ttype = `Table ({min = size; max = Some size}, etype)} @@ at],
       [{etype; einit; emode} @@ at],
       [], [] }
 
@@ -967,7 +963,7 @@ memory_fields :
     { fun c x at ->
       let offset = [i32_const (0l @@ at) @@ at] @@ at in
       let size = Int32.(div (add (of_int (String.length $3)) 65535l) 65536l) in
-      [{mtype = MemoryType {min = size; max = Some size}} @@ at],
+      [{mtype = `Memory {min = size; max = Some size}} @@ at],
       [{dinit = $3; dmode = Active {index = x; offset} @@ at} @@ at],
       [], [] }
 
@@ -1192,7 +1188,8 @@ literal_vec :
   | LPAR VEC_CONST VEC_SHAPE num_list RPAR { snd (vec $2 $3 $4 (at ())) }
 
 literal_ref :
-  | LPAR REF_NULL heap_type RPAR { Value.NullRef ($3 (empty_context ())) }
+  | LPAR REF_NULL heap_type RPAR
+    { Value.NullRef (Types.Sem.sem_heap_type [] ($3 (empty_context ()))) }
   | LPAR REF_EXTERN NAT RPAR { Script.ExternRef (nat32 $3 (ati 3)) }
 
 literal :
@@ -1216,8 +1213,8 @@ result :
   | literal_num { NumResult (NumPat ($1 @@ at())) @@ at () }
   | LPAR CONST NAN RPAR { NumResult (NanPat (nanop $2 ($3 @@ ati 3))) @@ at () }
   | literal_ref { RefResult (RefPat ($1 @@ at ())) @@ at () }
-  | LPAR REF_FUNC RPAR { RefResult (RefTypePat FuncHeapType) @@ at () }
-  | LPAR REF_EXTERN RPAR { RefResult (RefTypePat ExternHeapType) @@ at () }
+  | LPAR REF_FUNC RPAR { RefResult (RefTypePat `Func) @@ at () }
+  | LPAR REF_EXTERN RPAR { RefResult (RefTypePat `Extern) @@ at () }
   | LPAR REF_NULL RPAR { RefResult NullPat @@ at () }
   | LPAR VEC_CONST VEC_SHAPE numpat_list RPAR {
     if V128.num_lanes $3 <> List.length $4 then
diff --git a/interpreter/valid/match.ml b/interpreter/valid/match.ml
index e36c28919..d091490f1 100644
--- a/interpreter/valid/match.ml
+++ b/interpreter/valid/match.ml
@@ -1,166 +1,205 @@
-open Types
+(* Generic Matching *)
 
-type context = Types.def_type list
-type assump = (var * var) list
+module type Context =
+sig
+  type var
+  type def_type
+  type context
+  val lookup : context -> var -> def_type
+end
 
+module Make
+  (Var : Types.Var)
+  (Context : Context
+    with type var = Var.var
+    with type def_type = Types.Make(Var).def_type
+  ) =
+struct
 
-let lookup c = function
-  | SynVar x -> Lib.List32.nth c x
-  | SemVar x -> def_of x
+  open Types.Make(Var)
+  open Context
 
-let equal_var x y =
-  match x, y with
-  | SynVar x', SynVar y' -> x' = y'
-  | SemVar x', SemVar y' -> x' == y'
-  | _ -> assert false
 
-let assuming a (x1, x2) =
-  List.find_opt (fun (y1, y2) -> equal_var x1 y1 && equal_var x2 y2) a <> None
+  (* Assumptions *)
 
+  type assump = (var * var) list
 
-(* Equivalence *)
+  let assuming a (x1, x2) =
+    List.find_opt (fun (y1, y2) -> eq_var x1 y1 && eq_var x2 y2) a <> None
 
-let eq_nullability c a nul1 nul2 =
-  nul1 = nul2
 
-let eq_mutability c a mut1 mut2 =
-  mut1 = mut2
+  (* Equivalence *)
 
-let eq_limits c a lim1 lim2 =
-  lim1.min = lim2.min && lim1.max = lim2.max
+  let eq_nullability c a nul1 nul2 =
+    nul1 = nul2
 
-let rec eq_num_type c a t1 t2 =
-  t1 = t2
+  let eq_mutability c a mut1 mut2 =
+    mut1 = mut2
 
-and eq_vec_type c a t1 t2 =
-  t1 = t2
+  let eq_limits c a lim1 lim2 =
+    lim1.min = lim2.min && lim1.max = lim2.max
 
-and eq_heap_type c a t1 t2 =
-  match t1, t2 with
-  | DefHeapType x1, DefHeapType x2 -> eq_var_type c a x1 x2
-  | _, _ -> t1 = t2
+  let eq_num_type c a t1 t2 =
+    t1 = t2
 
-and eq_ref_type c a t1 t2 =
-  match t1, t2 with
-  | (nul1, t1'), (nul2, t2') ->
-    eq_nullability c a nul1 nul2 && eq_heap_type c a t1' t2'
+  let eq_vec_type c a t1 t2 =
+    t1 = t2
 
-and eq_value_type c a t1 t2 =
-  match t1, t2 with
-  | NumType t1', NumType t2' -> eq_num_type c a t1' t2'
-  | VecType t1', VecType t2' -> eq_vec_type c a t1' t2'
-  | RefType t1', RefType t2' -> eq_ref_type c a t1' t2'
-  | BotType, BotType -> true
-  | _, _ -> false
+  let rec eq_heap_type c a t1 t2 =
+    match t1, t2 with
+    | `Def x1, `Def x2 -> eq_var_type c a x1 x2
+    | _, _ -> t1 = t2
 
-and eq_result_type c a ts1 ts2 =
-  List.length ts1 = List.length ts2 &&
-  List.for_all2 (eq_value_type c a) ts1 ts2
+  and eq_ref_type c a t1 t2 =
+    match t1, t2 with
+    | `Ref (nul1, t1'), `Ref (nul2, t2') ->
+      eq_nullability c a nul1 nul2 && eq_heap_type c a t1' t2'
 
-and eq_func_type c a (FuncType (ts11, ts12)) (FuncType (ts21, ts22)) =
-  eq_result_type c a ts11 ts21 && eq_result_type c a ts12 ts22
+  and eq_val_type c a t1 t2 =
+    match t1, t2 with
+    | (#num_type as t1'), (#num_type as t2') -> eq_num_type c a t1' t2'
+    | (#vec_type as t1'), (#vec_type as t2') -> eq_vec_type c a t1' t2'
+    | (#ref_type as t1'), (#ref_type as t2') -> eq_ref_type c a t1' t2'
+    | `Bot, `Bot -> true
+    | _, _ -> false
 
-and eq_def_type c a dt1 dt2 =
-  match dt1, dt2 with
-  | FuncDefType ft1, FuncDefType ft2 -> eq_func_type c a ft1 ft2
+  and eq_result_type c a ts1 ts2 =
+    List.length ts1 = List.length ts2 &&
+    List.for_all2 (eq_val_type c a) ts1 ts2
 
-and eq_var_type c a x1 x2 =
-  equal_var x1 x2 || assuming a (x1, x2) ||
-  eq_def_type c ((x1, x2)::a) (lookup c x1) (lookup c x2)
+  and eq_func_type c a (`Func (ts11, ts12)) (`Func (ts21, ts22)) =
+    eq_result_type c a ts11 ts21 && eq_result_type c a ts12 ts22
 
+  and eq_def_type c a dt1 dt2 =
+    match dt1, dt2 with
+    | (#func_type as ft1), (#func_type as ft2) -> eq_func_type c a ft1 ft2
+
+  and eq_var_type c a x1 x2 =
+    eq_var x1 x2 || assuming a (x1, x2) ||
+    eq_def_type c ((x1, x2)::a) (lookup c x1) (lookup c x2)
 
-and eq_table_type c a (TableType (lim1, t1)) (TableType (lim2, t2)) =
-  eq_limits c a lim1 lim2 && eq_ref_type c a t1 t2
 
-and eq_memory_type c a (MemoryType lim1) (MemoryType lim2) =
-  eq_limits c a lim1 lim2
+  let eq_table_type c a (`Table (lim1, t1)) (`Table (lim2, t2)) =
+    eq_limits c a lim1 lim2 && eq_ref_type c a t1 t2
 
-and eq_global_type c a (GlobalType (mut1, t1)) (GlobalType (mut2, t2)) =
-  eq_mutability c a mut1 mut2 && eq_value_type c a t1 t2
+  let eq_memory_type c a (`Memory lim1) (`Memory lim2) =
+    eq_limits c a lim1 lim2
 
-and eq_extern_type c a et1 et2 =
-  match et1, et2 with
-  | ExternFuncType ft1, ExternFuncType ft2 -> eq_func_type c a ft1 ft2
-  | ExternTableType tt1, ExternTableType tt2 -> eq_table_type c a tt1 tt2
-  | ExternMemoryType mt1, ExternMemoryType mt2 -> eq_memory_type c a mt1 mt2
-  | ExternGlobalType gt1, ExternGlobalType gt2 -> eq_global_type c a gt1 gt2
-  | _, _ -> false
+  let eq_global_type c a (`Global (mut1, t1)) (`Global (mut2, t2)) =
+    eq_mutability c a mut1 mut2 && eq_val_type c a t1 t2
 
+  let eq_extern_type c a et1 et2 =
+    match et1, et2 with
+    | (#func_type as ft1), (#func_type as ft2) -> eq_func_type c a ft1 ft2
+    | (#table_type as tt1), (#table_type as tt2) -> eq_table_type c a tt1 tt2
+    | (#memory_type as mt1), (#memory_type as mt2) -> eq_memory_type c a mt1 mt2
+    | (#global_type as gt1), (#global_type as gt2) -> eq_global_type c a gt1 gt2
+    | _, _ -> false
 
-(* Subtyping *)
 
-let match_nullability c a nul1 nul2 =
-  match nul1, nul2 with
-  | NoNull, Null -> true
-  | _, _ -> nul1 = nul2
+  (* Subtyping *)
 
-let match_limits c a lim1 lim2 =
-  I32.ge_u lim1.min lim2.min &&
-  match lim1.max, lim2.max with
-  | _, None -> true
-  | None, Some _ -> false
-  | Some i, Some j -> I32.le_u i j
-
-let rec match_num_type c a t1 t2 =
-  t1 = t2
-
-and match_vec_type c a t1 t2 =
-  t1 = t2
-
-and match_heap_type c a t1 t2 =
-  match t1, t2 with
-  | DefHeapType x1, FuncHeapType ->
-    (match lookup c x1 with
-    | FuncDefType _ -> true
-    )
-  | DefHeapType x1, DefHeapType x2 -> match_var_type c a x1 x2
-  | BotHeapType, _ -> true
-  | _, _ -> eq_heap_type c [] t1 t2
-
-and match_ref_type c a t1 t2 =
-  match t1, t2 with
-  | (nul1, t1'), (nul2, t2') ->
-    match_nullability c a nul1 nul2 && match_heap_type c a t1' t2'
-
-and match_value_type c a t1 t2 =
-  match t1, t2 with
-  | NumType t1', NumType t2' -> match_num_type c a t1' t2'
-  | VecType t1', VecType t2' -> match_vec_type c a t1' t2'
-  | RefType t1', RefType t2' -> match_ref_type c a t1' t2'
-  | BotType, _ -> true
-  | _, _ -> false
-
-and match_result_type c a ts1 ts2 =
-  List.length ts1 = List.length ts2 &&
-  List.for_all2 (match_value_type c a) ts1 ts2
-
-and match_func_type c a ft1 ft2 =
-  eq_func_type c [] ft1 ft2
-
-and match_table_type c a (TableType (lim1, t1)) (TableType (lim2, t2)) =
-  match_limits c a lim1 lim2 && eq_ref_type c [] t1 t2
-
-and match_memory_type c a (MemoryType lim1) (MemoryType lim2) =
-  match_limits c a lim1 lim2
-
-and match_global_type c a (GlobalType (mut1, t1)) (GlobalType (mut2, t2)) =
-  eq_mutability c [] mut1 mut2 &&
-  match mut1 with
-  | Cons -> match_value_type c a t1 t2
-  | Var -> eq_value_type c [] t1 t2
-
-and match_extern_type c a et1 et2 =
-  match et1, et2 with
-  | ExternFuncType ft1, ExternFuncType ft2 -> match_func_type c a ft1 ft2
-  | ExternTableType tt1, ExternTableType tt2 -> match_table_type c a tt1 tt2
-  | ExternMemoryType mt1, ExternMemoryType mt2 -> match_memory_type c a mt1 mt2
-  | ExternGlobalType gt1, ExternGlobalType gt2 -> match_global_type c a gt1 gt2
-  | _, _ -> false
-
-and match_def_type c a dt1 dt2 =
-  match dt1, dt2 with
-  | FuncDefType ft1, FuncDefType ft2 -> match_func_type c a ft1 ft2
-
-and match_var_type c a x1 x2 =
-  equal_var x1 x2 || assuming a (x1, x2) ||
-  match_def_type c ((x1, x2)::a) (lookup c x1) (lookup c x2)
+  let match_nullability c a nul1 nul2 =
+    match nul1, nul2 with
+    | `NoNull, `Null -> true
+    | _, _ -> nul1 = nul2
+
+  let match_limits c a lim1 lim2 =
+    I32.ge_u lim1.min lim2.min &&
+    match lim1.max, lim2.max with
+    | _, None -> true
+    | None, Some _ -> false
+    | Some i, Some j -> I32.le_u i j
+
+  let match_num_type c a t1 t2 =
+    t1 = t2
+
+  let match_vec_type c a t1 t2 =
+    t1 = t2
+
+  let rec match_heap_type c a t1 t2 =
+    match t1, t2 with
+    | `Def x1, `Func ->
+      (match lookup c x1 with
+      | `Func _ -> true
+      )
+    | `Def x1, `Def x2 -> match_var_type c a x1 x2
+    | `Bot, _ -> true
+    | _, _ -> eq_heap_type c [] t1 t2
+
+  and match_ref_type c a t1 t2 =
+    match t1, t2 with
+    | `Ref (nul1, t1'), `Ref (nul2, t2') ->
+      match_nullability c a nul1 nul2 && match_heap_type c a t1' t2'
+
+  and match_val_type c a t1 t2 =
+    match t1, t2 with
+    | (#num_type as t1'), (#num_type as t2') -> match_num_type c a t1' t2'
+    | (#vec_type as t1'), (#vec_type as t2') -> match_vec_type c a t1' t2'
+    | (#ref_type as t1'), (#ref_type as t2') -> match_ref_type c a t1' t2'
+    | `Bot, _ -> true
+    | _, _ -> false
+
+  and match_result_type c a ts1 ts2 =
+    List.length ts1 = List.length ts2 &&
+    List.for_all2 (match_val_type c a) ts1 ts2
+
+  and match_func_type c a ft1 ft2 =
+    eq_func_type c [] ft1 ft2
+
+  and match_def_type c a dt1 dt2 =
+    match dt1, dt2 with
+    | (#func_type as ft1), (#func_type as ft2) -> match_func_type c a ft1 ft2
+
+  and match_var_type c a x1 x2 =
+    eq_var x1 x2 || assuming a (x1, x2) ||
+    match_def_type c ((x1, x2)::a) (lookup c x1) (lookup c x2)
+
+  let match_table_type c a (`Table (lim1, t1)) (`Table (lim2, t2)) =
+    match_limits c a lim1 lim2 && eq_ref_type c [] t1 t2
+
+  let match_memory_type c a (`Memory lim1) (`Memory lim2) =
+    match_limits c a lim1 lim2
+
+  let match_global_type c a (`Global (mut1, t1)) (`Global (mut2, t2)) =
+    eq_mutability c [] mut1 mut2 &&
+    match mut1 with
+    | `Const -> match_val_type c a t1 t2
+    | `Var -> eq_val_type c [] t1 t2
+
+  let match_extern_type c a et1 et2 =
+    match et1, et2 with
+    | (#func_type as ft1), (#func_type as ft2) -> match_func_type c a ft1 ft2
+    | (#table_type as tt1), (#table_type as tt2) -> match_table_type c a tt1 tt2
+    | (#memory_type as mt1), (#memory_type as mt2) -> match_memory_type c a mt1 mt2
+    | (#global_type as gt1), (#global_type as gt2) -> match_global_type c a gt1 gt2
+    | _, _ -> false
+end
+
+
+(* Syntactic Matching *)
+
+module SynContext =
+struct
+  type var = Types.Syn.var
+  type def_type = Types.Syn.def_type
+  type context = def_type list
+  let lookup c x = Lib.List32.nth c x
+end
+
+module Syn = Make (Types.SynVar) (SynContext)
+
+include Syn
+
+
+(* Semantic Matching *)
+
+module SemContext =
+struct
+  type var = Types.Sem.var
+  type def_type = Types.Sem.def_type
+  type context = unit
+  let lookup c x = Types.Sem.def_of x
+end
+
+module Sem = Make (Types.SemVar) (SemContext)
diff --git a/interpreter/valid/match.mli b/interpreter/valid/match.mli
deleted file mode 100644
index d258af5d4..000000000
--- a/interpreter/valid/match.mli
+++ /dev/null
@@ -1,40 +0,0 @@
-open Types
-
-type context = def_type list
-type assump = (var * var) list
-
-
-(* Equivalence *)
-
-val eq_num_type : context -> assump -> num_type -> num_type -> bool
-val eq_ref_type : context -> assump -> ref_type -> ref_type -> bool
-val eq_value_type : context -> assump -> value_type -> value_type -> bool
-
-val eq_result_type : context -> assump -> result_type -> result_type -> bool
-
-val eq_func_type : context -> assump -> func_type -> func_type -> bool
-val eq_table_type : context -> assump -> table_type -> table_type -> bool
-val eq_memory_type : context -> assump -> memory_type -> memory_type -> bool
-val eq_global_type : context -> assump -> global_type -> global_type -> bool
-
-val eq_extern_type : context -> assump -> extern_type -> extern_type -> bool
-
-val eq_def_type : context -> assump -> def_type -> def_type -> bool
-
-
-(* Subtyping *)
-
-val match_num_type : context -> assump -> num_type -> num_type -> bool
-val match_ref_type : context -> assump -> ref_type -> ref_type -> bool
-val match_value_type : context -> assump -> value_type -> value_type -> bool
-
-val match_result_type : context -> assump -> result_type -> result_type -> bool
-
-val match_func_type : context -> assump -> func_type -> func_type -> bool
-val match_table_type : context -> assump -> table_type -> table_type -> bool
-val match_memory_type : context -> assump -> memory_type -> memory_type -> bool
-val match_global_type : context -> assump -> global_type -> global_type -> bool
-
-val match_extern_type : context -> assump -> extern_type -> extern_type -> bool
-
-val match_def_type : context -> assump -> def_type -> def_type -> bool
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index c4a660b36..0106be98c 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -25,7 +25,7 @@ type context =
   elems : ref_type list;
   datas : unit list;
   locals : local_type list;
-  results : value_type list;
+  results : val_type list;
   labels : result_type list;
   refs : Free.t;
 }
@@ -56,15 +56,15 @@ let replace category list x y =
     error x.at ("unknown " ^ category ^ " " ^ I32.to_string_u x.it)
 
 let init_local (c : context) x =
-  let LocalType (_, t) = local c x in
-  {c with locals = replace "local" c.locals x (LocalType (Set, t))}
+  let `Local (_init, t) = local c x in
+  {c with locals = replace "local" c.locals x (`Local (`Set, t))}
 
 let init_locals (c : context) xs =
   List.fold_left init_local c xs
 
 let func_type (c : context) x =
   match type_ c x with
-  | FuncDefType ft -> ft
+  | #func_type as ft -> ft
 
 let refer category (s : Free.Set.t) x =
   if not (Free.Set.mem x.it s) then
@@ -93,47 +93,48 @@ let check_vec_type (c : context) (t : vec_type) at =
 
 let check_heap_type (c : context) (t : heap_type) at =
   match t with
-  | FuncHeapType | ExternHeapType -> ()
-  | DefHeapType (SynVar x) -> ignore (type_ c (x @@ at))
-  | DefHeapType (SemVar _) | BotHeapType -> assert false
+  | `Func -> ()
+  | `Extern -> ()
+  | `Def x -> ignore (type_ c (x @@ at))
+  | `Bot -> assert false
 
 let check_ref_type (c : context) (t : ref_type) at =
   match t with
-  | (_nul, t') -> check_heap_type c t' at
+  | `Ref (_nul, t') -> check_heap_type c t' at
 
-let check_value_type (c : context) (t : value_type) at =
+let check_val_type (c : context) (t : val_type) at =
   match t with
-  | NumType t' -> check_num_type c t' at
-  | VecType t' -> check_vec_type c t' at
-  | RefType t' -> check_ref_type c t' at
-  | BotType -> ()
+  | #num_type as t' -> check_num_type c t' at
+  | #vec_type as t' -> check_vec_type c t' at
+  | #ref_type as t' -> check_ref_type c t' at
+  | `Bot -> assert false
 
 let check_result_type (c : context) (ts : result_type) at =
-  List.iter (fun t -> check_value_type c t at) ts
+  List.iter (fun t -> check_val_type c t at) ts
 
 let check_func_type (c : context) (ft : func_type) at =
-  let FuncType (ts1, ts2) = ft in
+  let `Func (ts1, ts2) = ft in
   check_result_type c ts1 at;
   check_result_type c ts2 at
 
 let check_table_type (c : context) (tt : table_type) at =
-  let TableType (lim, t) = tt in
+  let `Table (lim, t) = tt in
   check_limits lim 0xffff_ffffl at "table size must be at most 2^32-1";
   check_ref_type c t at;
-  require (defaultable_ref_type t) at "non-defaultable element type"
+  require (defaultable t) at "non-defaultable element type"
 
 let check_memory_type (c : context) (mt : memory_type) at =
-  let MemoryType lim = mt in
+  let `Memory lim = mt in
   check_limits lim 0x1_0000l at
     "memory size must be at most 65536 pages (4GiB)"
 
 let check_global_type (c : context) (gt : global_type) at =
-  let GlobalType (_mut, t) = gt in
-  check_value_type c t at
+  let `Global (_mut, t) = gt in
+  check_val_type c t at
 
 let check_def_type (c : context) (dt : def_type) at =
   match dt with
-  | FuncDefType ft -> check_func_type c ft at
+  | #func_type as ft -> check_func_type c ft at
 
 
 
@@ -149,7 +150,7 @@ let check_def_type (c : context) (dt : def_type) at =
  *)
 
 type ellipses = NoEllipses | Ellipses
-type infer_result_type = ellipses * value_type list
+type infer_result_type = ellipses * val_type list
 type infer_func_type = {ins : infer_result_type; outs : infer_result_type}
 type infer_instr_type = infer_func_type * idx list
 
@@ -160,7 +161,7 @@ let (-->...) ts1 ts2 = {ins = Ellipses, ts1; outs = Ellipses, ts2}
 let check_stack (c : context) ts1 ts2 at =
   require
     (List.length ts1 = List.length ts2 &&
-      List.for_all2 (match_value_type c.types []) ts1 ts2) at
+      List.for_all2 (match_val_type c.types []) ts1 ts2) at
     ("type mismatch: instruction requires " ^ string_of_result_type ts2 ^
      " but stack has " ^ string_of_result_type ts1)
 
@@ -169,7 +170,7 @@ let pop c (ell1, ts1) (ell2, ts2) at =
   let n2 = List.length ts2 in
   let n = min n1 n2 in
   let n3 = if ell2 = Ellipses then (n1 - n) else 0 in
-  check_stack c (Lib.List.make n3 BotType @ Lib.List.drop (n2 - n) ts2) ts1 at;
+  check_stack c (Lib.List.make n3 `Bot @ Lib.List.drop (n2 - n) ts2) ts1 at;
   (ell2, if ell1 = Ellipses then [] else Lib.List.take (n2 - n) ts2)
 
 let push c (ell1, ts1) (ell2, ts2) =
@@ -178,16 +179,16 @@ let push c (ell1, ts1) (ell2, ts2) =
   ts2 @ ts1
 
 let peek i (ell, ts) =
-  try List.nth (List.rev ts) i with Failure _ -> BotType
+  try List.nth (List.rev ts) i with Failure _ -> `Bot
 
 let peek_ref i (ell, ts) at =
   match peek i (ell, ts) with
-  | RefType rt -> rt
-  | BotType -> (NoNull, BotHeapType)
+  | #ref_type as rt -> rt
+  | `Bot -> `Ref (`NoNull, `Bot)
   | t ->
     error at
       ("type mismatch: instruction requires reference type" ^
-       " but stack has " ^ string_of_value_type t)
+       " but stack has " ^ string_of_val_type t)
 
 
 (* Type Synthesis *)
@@ -195,43 +196,43 @@ let peek_ref i (ell, ts) at =
 let type_num = Value.type_of_num
 let type_vec = Value.type_of_vec
 let type_vec_lane = function
-  | Value.V128 laneop -> V128.type_of_lane laneop
+  | Value.V128 laneop -> (V128.type_of_lane laneop :> val_type)
 
 let type_cvtop at = function
   | Value.I32 cvtop ->
     let open I32Op in
     (match cvtop with
     | ExtendSI32 | ExtendUI32 -> error at "invalid conversion"
-    | WrapI64 -> I64Type
+    | WrapI64 -> `I64
     | TruncSF32 | TruncUF32 | TruncSatSF32 | TruncSatUF32
-    | ReinterpretFloat -> F32Type
-    | TruncSF64 | TruncUF64 | TruncSatSF64 | TruncSatUF64 -> F64Type
-    ), I32Type
+    | ReinterpretFloat -> `F32
+    | TruncSF64 | TruncUF64 | TruncSatSF64 | TruncSatUF64 -> `F64
+    ), `I32
   | Value.I64 cvtop ->
     let open I64Op in
     (match cvtop with
-    | ExtendSI32 | ExtendUI32 -> I32Type
+    | ExtendSI32 | ExtendUI32 -> `I32
     | WrapI64 -> error at "invalid conversion"
-    | TruncSF32 | TruncUF32 | TruncSatSF32 | TruncSatUF32 -> F32Type
+    | TruncSF32 | TruncUF32 | TruncSatSF32 | TruncSatUF32 -> `F32
     | TruncSF64 | TruncUF64 | TruncSatSF64 | TruncSatUF64
-    | ReinterpretFloat -> F64Type
-    ), I64Type
+    | ReinterpretFloat -> `F64
+    ), `I64
   | Value.F32 cvtop ->
     let open F32Op in
     (match cvtop with
-    | ConvertSI32 | ConvertUI32 | ReinterpretInt -> I32Type
-    | ConvertSI64 | ConvertUI64 -> I64Type
+    | ConvertSI32 | ConvertUI32 | ReinterpretInt -> `I32
+    | ConvertSI64 | ConvertUI64 -> `I64
     | PromoteF32 -> error at "invalid conversion"
-    | DemoteF64 -> F64Type
-    ), F32Type
+    | DemoteF64 -> `F64
+    ), `F32
   | Value.F64 cvtop ->
     let open F64Op in
     (match cvtop with
-    | ConvertSI32 | ConvertUI32 -> I32Type
-    | ConvertSI64 | ConvertUI64 | ReinterpretInt -> I64Type
-    | PromoteF32 -> F32Type
+    | ConvertSI32 | ConvertUI32 -> `I32
+    | ConvertSI64 | ConvertUI64 | ReinterpretInt -> `I64
+    | PromoteF32 -> `F32
     | DemoteF64 -> error at "invalid conversion"
-    ), F64Type
+    ), `F64
 
 let num_lanes = function
   | Value.V128 laneop -> V128.num_lanes laneop
@@ -256,7 +257,7 @@ let lane_replaceop = function
 (* Expressions *)
 
 let check_pack sz t_sz at =
-  require (packed_size sz < t_sz) at "invalid sign extension"
+  require (Pack.packed_size sz < t_sz) at "invalid sign extension"
 
 let check_unop unop at =
   match unop with
@@ -278,7 +279,7 @@ let check_memop (c : context) (memop : ('t, 's) memop) ty_size get_sz at =
     | None -> ty_size memop.ty
     | Some sz ->
       check_pack sz (ty_size memop.ty) at;
-      packed_size sz
+      Pack.packed_size sz
   in
   require (1 lsl memop.align <= size) at
     "alignment must not be larger than natural"
@@ -290,7 +291,7 @@ let check_memop (c : context) (memop : ('t, 's) memop) ty_size get_sz at =
  *   e  : instr
  *   es : instr list
  *   v  : value
- *   t  : value_type
+ *   t  : val_type
  *   ts : result_type
  *   x  : variable
  *
@@ -304,17 +305,17 @@ let check_memop (c : context) (memop : ('t, 's) memop) ty_size get_sz at =
  * declarative typing rules.
  *)
 
-let check_block_type (c : context) (bt : block_type) at : func_type =
+let check_block_type (c : context) (bt : block_type) at : instr_type =
   match bt with
-  | ValBlockType None -> FuncType ([], [])
-  | ValBlockType (Some t) -> check_value_type c t at; FuncType ([], [t])
-  | VarBlockType (SynVar x) -> func_type c (x @@ at)
-  | VarBlockType (SemVar _) -> assert false
+  | ValBlockType None -> `Instr ([], [], [])
+  | ValBlockType (Some t) -> check_val_type c t at; `Instr ([], [t], [])
+  | VarBlockType x ->
+    let `Func (ts1, ts2) = func_type c (x @@ at) in `Instr (ts1, ts2, [])
 
 let check_local (c : context) (loc : local) : local_type =
-  check_value_type c loc.it.ltype loc.at;
-  let init = if defaultable_value_type loc.it.ltype then Set else Unset in
-  LocalType (init, loc.it.ltype)
+  check_val_type c loc.it.ltype loc.at;
+  let init = if defaultable loc.it.ltype then `Set else `Unset in
+  `Local (init, loc.it.ltype)
 
 let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_instr_type =
   match e.it with
@@ -331,163 +332,162 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
     let t = peek 1 s in
     require (is_num_type t || is_vec_type t) e.at
       ("type mismatch: instruction requires numeric or vector type" ^
-       " but stack has " ^ string_of_value_type t);
-    [t; t; NumType I32Type] --> [t], []
+       " but stack has " ^ string_of_val_type t);
+    [t; t; `I32] --> [t], []
 
   | Select (Some ts) ->
     require (List.length ts = 1) e.at
       "invalid result arity other than 1 is not (yet) allowed";
     check_result_type c ts e.at;
-    (ts @ ts @ [NumType I32Type]) --> ts, []
+    (ts @ ts @ [`I32]) --> ts, []
 
   | Block (bt, es) ->
-    let FuncType (ts1, ts2) as ft = check_block_type c bt e.at in
-    check_block {c with labels = ts2 :: c.labels} es ft e.at;
-    ts1 --> ts2, []
+    let `Instr (ts1, ts2, xs) as it = check_block_type c bt e.at in
+    check_block {c with labels = ts2 :: c.labels} es it e.at;
+    ts1 --> ts2, List.map (fun x -> x @@ e.at) xs
 
   | Loop (bt, es) ->
-    let FuncType (ts1, ts2) as ft = check_block_type c bt e.at in
-    check_block {c with labels = ts1 :: c.labels} es ft e.at;
-    ts1 --> ts2, []
+    let `Instr (ts1, ts2, xs) as it = check_block_type c bt e.at in
+    check_block {c with labels = ts1 :: c.labels} es it e.at;
+    ts1 --> ts2, List.map (fun x -> x @@ e.at) xs
 
   | If (bt, es1, es2) ->
-    let FuncType (ts1, ts2) as ft = check_block_type c bt e.at in
-    check_block {c with labels = ts2 :: c.labels} es1 ft e.at;
-    check_block {c with labels = ts2 :: c.labels} es2 ft e.at;
-    (ts1 @ [NumType I32Type]) --> ts2, []
+    let `Instr (ts1, ts2, xs) as it = check_block_type c bt e.at in
+    check_block {c with labels = ts2 :: c.labels} es1 it e.at;
+    check_block {c with labels = ts2 :: c.labels} es2 it e.at;
+    (ts1 @ [`I32]) --> ts2, List.map (fun x -> x @@ e.at) xs
 
   | Br x ->
     label c x -->... [], []
 
   | BrIf x ->
-    (label c x @ [NumType I32Type]) --> label c x, []
+    (label c x @ [`I32]) --> label c x, []
 
   | BrTable (xs, x) ->
     let n = List.length (label c x) in
     let ts = Lib.List.table n (fun i -> peek (n - i) s) in
     check_stack c ts (label c x) x.at;
     List.iter (fun x' -> check_stack c ts (label c x') x'.at) xs;
-    (ts @ [NumType I32Type]) -->... [], []
+    (ts @ [`I32]) -->... [], []
 
   | BrOnNull x ->
-    let (_, t) = peek_ref 0 s e.at in
-    (label c x @ [RefType (Null, t)]) -->
-      (label c x @ [RefType (NoNull, t)]), []
+    let `Ref (_, ht) = peek_ref 0 s e.at in
+    (label c x @ [`Ref (`Null, ht)]) --> (label c x @ [`Ref (`NoNull, ht)]), []
 
   | BrOnNonNull x ->
-    let (_, ht) as rt = peek_ref 0 s e.at in
-    let t' = RefType (NoNull, ht) in
+    let `Ref (_, ht) as t = peek_ref 0 s e.at in
+    let t' = `Ref (`NoNull, ht) in
     require (label c x <> []) e.at
-      ("type mismatch: instruction requires type " ^ string_of_value_type t' ^
+      ("type mismatch: instruction requires type " ^ string_of_val_type t' ^
        " but label has " ^ string_of_result_type (label c x));
-    let ts0, t = Lib.List.split_last (label c x) in
-    require (match_value_type c.types [] t' t) e.at
-      ("type mismatch: instruction requires type " ^ string_of_value_type t' ^
+    let ts0, t1 = Lib.List.split_last (label c x) in
+    require (match_val_type c.types [] t' t1) e.at
+      ("type mismatch: instruction requires type " ^ string_of_val_type t' ^
        " but label has " ^ string_of_result_type (label c x));
-    (ts0 @ [RefType rt]) --> ts0, []
+    (ts0 @ [t]) --> ts0, []
 
   | Return ->
     c.results -->... [], []
 
   | Call x ->
-    let FuncType (ts1, ts2) = func c x in
+    let `Func (ts1, ts2) = func c x in
     ts1 --> ts2, []
 
   | CallRef ->
     (match peek_ref 0 s e.at with
-    | (nul, DefHeapType (SynVar x)) ->
-      let FuncType (ts1, ts2) = func_type c (x @@ e.at) in
-      (ts1 @ [RefType (nul, DefHeapType (SynVar x))]) --> ts2, []
-    | (_, BotHeapType) as rt ->
-      [RefType rt] -->... [], []
-    | rt ->
+    | `Ref (nul, `Def x) ->
+      let `Func (ts1, ts2) = func_type c (x @@ e.at) in
+      (ts1 @ [`Ref (nul, `Def x)]) --> ts2, []
+    | `Ref (_, `Bot) as t ->
+      [t] -->... [], []
+    | t ->
       error e.at
         ("type mismatch: instruction requires function reference type" ^
-         " but stack has " ^ string_of_value_type (RefType rt))
+         " but stack has " ^ string_of_val_type t)
     )
 
   | CallIndirect (x, y) ->
-    let TableType (lim, t) = table c x in
-    let FuncType (ts1, ts2) = func_type c y in
-    require (match_ref_type c.types [] t (Null, FuncHeapType)) x.at
+    let `Table (_lim, t) = table c x in
+    let `Func (ts1, ts2) = func_type c y in
+    require (match_ref_type c.types [] t (`Ref (`Null, `Func))) x.at
       ("type mismatch: instruction requires table of function type" ^
        " but table has element type " ^ string_of_ref_type t);
-    (ts1 @ [NumType I32Type]) --> ts2, []
+    (ts1 @ [`I32]) --> ts2, []
 
   | ReturnCallRef ->
     (match peek_ref 0 s e.at with
-    | (nul, DefHeapType (SynVar x)) ->
-      let FuncType (ts1, ts2) = func_type c (x @@ e.at) in
+    | `Ref (nul, `Def x) ->
+      let `Func (ts1, ts2) = func_type c (x @@ e.at) in
       require (match_result_type c.types [] ts2 c.results) e.at
         ("type mismatch: current function requires result type " ^
          string_of_result_type c.results ^
          " but callee returns " ^ string_of_result_type ts2);
-      (ts1 @ [RefType (nul, DefHeapType (SynVar x))]) -->... [], []
-    | (_, BotHeapType) as rt ->
-      [RefType rt] -->... [], []
-    | rt ->
+      (ts1 @ [`Ref (nul, `Def x)]) -->... [], []
+    | `Ref (_, `Bot) as t ->
+      [t] -->... [], []
+    | t ->
       error e.at
         ("type mismatch: instruction requires function reference type" ^
-         " but stack has " ^ string_of_value_type (RefType rt))
+         " but stack has " ^ string_of_val_type t)
     )
 
   | LocalGet x ->
-    let LocalType (init, t) = local c x in
-    require (init = Set) x.at "uninitialized local";
+    let `Local (init, t) = local c x in
+    require (init = `Set) x.at "uninitialized local";
     [] --> [t], []
 
   | LocalSet x ->
-    let LocalType (_, t) = local c x in
+    let `Local (_init, t) = local c x in
     [t] --> [], [x]
 
   | LocalTee x ->
-    let LocalType (_, t) = local c x in
+    let `Local (_init, t) = local c x in
     [t] --> [t], [x]
 
   | GlobalGet x ->
-    let GlobalType (_mut, t) = global c x in
+    let `Global (_mut, t) = global c x in
     [] --> [t], []
 
   | GlobalSet x ->
-    let GlobalType (mut, t) = global c x in
-    require (mut = Var) x.at "immutable global";
+    let `Global (mut, t) = global c x in
+    require (mut = `Var) x.at "immutable global";
     [t] --> [], []
 
   | TableGet x ->
-    let TableType (_lim, t) = table c x in
-    [NumType I32Type] --> [RefType t], []
+    let `Table (_lim, t) = table c x in
+    [`I32] --> [(t :> val_type)], []
 
   | TableSet x ->
-    let TableType (_lim, t) = table c x in
-    [NumType I32Type; RefType t] --> [], []
+    let `Table (_lim, t) = table c x in
+    [`I32; (t :> val_type)] --> [], []
 
   | TableSize x ->
     let _tt = table c x in
-    [] --> [NumType I32Type], []
+    [] --> [`I32], []
 
   | TableGrow x ->
-    let TableType (_lim, t) = table c x in
-    [RefType t; NumType I32Type] --> [NumType I32Type], []
+    let `Table (_lim, t) = table c x in
+    [(t :> val_type); `I32] --> [`I32], []
 
   | TableFill x ->
-    let TableType (_lim, t) = table c x in
-    [NumType I32Type; RefType t; NumType I32Type] --> [], []
+    let `Table (_lim, t) = table c x in
+    [`I32; (t :> val_type); `I32] --> [], []
 
   | TableCopy (x, y) ->
-    let TableType (_lim1, t1) = table c x in
-    let TableType (_lim2, t2) = table c y in
+    let `Table (_lim1, t1) = table c x in
+    let `Table (_lim2, t2) = table c y in
     require (match_ref_type c.types [] t2 t1) x.at
       ("type mismatch: source element type " ^ string_of_ref_type t1 ^
        " does not match destination element type " ^ string_of_ref_type t2);
-    [NumType I32Type; NumType I32Type; NumType I32Type] --> [], []
+    [`I32; `I32; `I32] --> [], []
 
   | TableInit (x, y) ->
-    let TableType (_lim1, t1) = table c x in
+    let `Table (_lim1, t1) = table c x in
     let t2 = elem c y in
     require (match_ref_type c.types [] t2 t1) x.at
       ("type mismatch: element segment's type " ^ string_of_ref_type t1 ^
        " does not match table's element type " ^ string_of_ref_type t2);
-    [NumType I32Type; NumType I32Type; NumType I32Type] --> [], []
+    [`I32; `I32; `I32] --> [], []
 
   | ElemDrop x ->
     ignore (elem c x);
@@ -495,167 +495,167 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
 
   | Load memop ->
     check_memop c memop num_size (Lib.Option.map fst) e.at;
-    [NumType I32Type] --> [NumType memop.ty], []
+    [`I32] --> [(memop.ty :> val_type)], []
 
   | Store memop ->
     check_memop c memop num_size (fun sz -> sz) e.at;
-    [NumType I32Type; NumType memop.ty] --> [], []
+    [`I32; (memop.ty :> val_type)] --> [], []
 
   | VecLoad memop ->
     check_memop c memop vec_size (Lib.Option.map fst) e.at;
-    [NumType I32Type] --> [VecType memop.ty], []
+    [`I32] --> [(memop.ty :> val_type)], []
 
   | VecStore memop ->
     check_memop c memop vec_size (fun _ -> None) e.at;
-    [NumType I32Type; VecType memop.ty] --> [], []
+    [`I32; (memop.ty :> val_type)] --> [], []
 
   | VecLoadLane (memop, i) ->
     check_memop c memop vec_size (fun sz -> Some sz) e.at;
-    require (i < vec_size memop.ty / packed_size memop.pack) e.at
+    require (i < vec_size memop.ty / Pack.packed_size memop.pack) e.at
       "invalid lane index";
-    [NumType I32Type; VecType memop.ty] -->  [VecType memop.ty], []
+    [`I32; (memop.ty :> val_type)] -->  [(memop.ty :> val_type)], []
 
   | VecStoreLane (memop, i) ->
     check_memop c memop vec_size (fun sz -> Some sz) e.at;
-    require (i < vec_size memop.ty / packed_size memop.pack) e.at
+    require (i < vec_size memop.ty / Pack.packed_size memop.pack) e.at
       "invalid lane index";
-    [NumType I32Type; VecType memop.ty] -->  [], []
+    [`I32; (memop.ty :> val_type)] -->  [], []
 
   | MemorySize ->
     let _mt = memory c (0l @@ e.at) in
-    [] --> [NumType I32Type], []
+    [] --> [`I32], []
 
   | MemoryGrow ->
     let _mt = memory c (0l @@ e.at) in
-    [NumType I32Type] --> [NumType I32Type], []
+    [`I32] --> [`I32], []
 
   | MemoryFill ->
-    ignore (memory c (0l @@ e.at));
-    [NumType I32Type; NumType I32Type; NumType I32Type] --> [], []
+    let _mt = memory c (0l @@ e.at) in
+    [`I32; `I32; `I32] --> [], []
 
   | MemoryCopy ->
-    ignore (memory c (0l @@ e.at));
-    [NumType I32Type; NumType I32Type; NumType I32Type] --> [], []
+    let _mt = memory c (0l @@ e.at) in
+    [`I32; `I32; `I32] --> [], []
 
   | MemoryInit x ->
-    ignore (memory c (0l @@ e.at));
-    ignore (data c x);
-    [NumType I32Type; NumType I32Type; NumType I32Type] --> [], []
+    let _mt = memory c (0l @@ e.at) in
+    let () = data c x in
+    [`I32; `I32; `I32] --> [], []
 
   | DataDrop x ->
-    ignore (data c x);
+    let () = data c x in
     [] --> [], []
 
   | RefNull t ->
     check_heap_type c t e.at;
-    [] --> [RefType (Null, t)], []
+    [] --> [`Ref (`Null, t)], []
 
   | RefIsNull ->
-    let (_, t) = peek_ref 0 s e.at in
-    [RefType (Null, t)] --> [NumType I32Type], []
+    let `Ref (_, t) = peek_ref 0 s e.at in
+    [`Ref (`Null, t)] --> [`I32], []
 
   | RefAsNonNull ->
-    let (_, t) = peek_ref 0 s e.at in
-    [RefType (Null, t)] --> [RefType (NoNull, t)], []
+    let `Ref (_, t) = peek_ref 0 s e.at in
+    [`Ref (`Null, t)] --> [`Ref (`NoNull, t)], []
 
   | RefFunc x ->
     let ft = func c x in
-    let y = Lib.Option.force (Lib.List32.index_of (FuncDefType ft) c.types) in
+    let y = Lib.Option.force (Lib.List32.index_of (ft :> def_type) c.types) in
     refer_func c x;
-    [] --> [RefType (NoNull, DefHeapType (SynVar y))], []
+    [] --> [`Ref (`NoNull, `Def y)], []
 
   | Const v ->
-    let t = NumType (type_num v.it) in
+    let t = type_num v.it in
     [] --> [t], []
 
   | Test testop ->
-    let t = NumType (type_num testop) in
-    [t] --> [NumType I32Type], []
+    let t = type_num testop in
+    [t] --> [`I32], []
 
   | Compare relop ->
-    let t = NumType (type_num relop) in
-    [t; t] --> [NumType I32Type], []
+    let t = type_num relop in
+    [t; t] --> [`I32], []
 
   | Unary unop ->
     check_unop unop e.at;
-    let t = NumType (type_num unop) in
+    let t = type_num unop in
     [t] --> [t], []
 
   | Binary binop ->
-    let t = NumType (type_num binop) in
+    let t = type_num binop in
     [t; t] --> [t], []
 
   | Convert cvtop ->
     let t1, t2 = type_cvtop e.at cvtop in
-    [NumType t1] --> [NumType t2], []
+    [t1] --> [t2], []
 
   | VecConst v ->
-    let t = VecType (type_vec v.it) in
+    let t = type_vec v.it in
     [] --> [t], []
 
   | VecTest testop ->
-    let t = VecType (type_vec testop) in
-    [t] --> [NumType I32Type], []
+    let t = type_vec testop in
+    [t] --> [`I32], []
 
   | VecUnary unop ->
-    let t = VecType (type_vec unop) in
+    let t = type_vec unop in
     [t] --> [t], []
 
   | VecBinary binop ->
     check_vec_binop binop e.at;
-    let t = VecType (type_vec binop) in
+    let t = type_vec binop in
     [t; t] --> [t], []
 
   | VecCompare relop ->
-    let t = VecType (type_vec relop) in
+    let t = type_vec relop in
     [t; t] --> [t], []
 
   | VecConvert cvtop ->
-    let t = VecType (type_vec cvtop) in
+    let t = type_vec cvtop in
     [t] --> [t], []
 
   | VecShift shiftop ->
-    let t = VecType (type_vec shiftop) in
-    [t; NumType I32Type] --> [VecType V128Type], []
+    let t = type_vec shiftop in
+    [t; `I32] --> [t], []
 
   | VecBitmask bitmaskop ->
-    let t = VecType (type_vec bitmaskop) in
-    [t] --> [NumType I32Type], []
+    let t = type_vec bitmaskop in
+    [t] --> [`I32], []
 
   | VecTestBits vtestop ->
-    let t = VecType (type_vec vtestop) in
-    [t] --> [NumType I32Type], []
+    let t = type_vec vtestop in
+    [t] --> [`I32], []
 
   | VecUnaryBits vunop ->
-    let t = VecType (type_vec vunop) in
+    let t = type_vec vunop in
     [t] --> [t], []
 
   | VecBinaryBits vbinop ->
-    let t = VecType (type_vec vbinop) in
+    let t = type_vec vbinop in
     [t; t] --> [t], []
 
   | VecTernaryBits vternop ->
-    let t = VecType (type_vec vternop) in
+    let t = type_vec vternop in
     [t; t; t] --> [t], []
 
   | VecSplat splatop ->
     let t1 = type_vec_lane splatop in
-    let t2 = VecType (type_vec splatop) in
-    [NumType t1] --> [t2], []
+    let t2 = type_vec splatop in
+    [t1] --> [t2], []
 
   | VecExtract extractop ->
-    let t = VecType (type_vec extractop) in
+    let t1 = type_vec extractop in
     let t2 = type_vec_lane extractop in
     require (lane_extractop extractop < num_lanes extractop) e.at
       "invalid lane index";
-    [t] --> [NumType t2], []
+    [t1] --> [t2], []
 
   | VecReplace replaceop ->
-    let t = VecType (type_vec replaceop) in
+    let t1 = type_vec replaceop in
     let t2 = type_vec_lane replaceop in
     require (lane_replaceop replaceop < num_lanes replaceop) e.at
       "invalid lane index";
-    [t; NumType t2] --> [t], []
+    [t1; t2] --> [t1], []
 
 and check_seq (c : context) (s : infer_result_type) (es : instr list)
   : infer_result_type * idx list =
@@ -669,9 +669,9 @@ and check_seq (c : context) (s : infer_result_type) (es : instr list)
     let {ins; outs}, xs' = check_instr (init_locals c xs) e s' in
     push c outs (pop c ins s' e.at), xs @ xs'
 
-and check_block (c : context) (es : instr list) (ft : func_type) at =
-  let FuncType (ts1, ts2) = ft in
-  let s, xs = check_seq c (stack ts1) es in
+and check_block (c : context) (es : instr list) (it : instr_type) at =
+  let `Instr (ts1, ts2, _xs) = it in
+  let s, xs' = check_seq c (stack ts1) es in
   let s' = pop c (stack ts2) s at in
   require (snd s' = []) at
     ("type mismatch: block requires " ^ string_of_result_type ts2 ^
@@ -687,22 +687,22 @@ and check_block (c : context) (es : instr list) (ft : func_type) at =
  *   f : func
  *   e : instr
  *   v : value
- *   t : value_type
+ *   t : val_type
  *   s : func_type
  *   x : variable
  *)
 
 let check_func (c : context) (f : func) =
   let {ftype; locals; body} = f.it in
-  let FuncType (ts1, ts2) = func_type c ftype in
+  let `Func (ts1, ts2) = func_type c ftype in
   let lts = List.map (check_local c) locals in
   let c' =
     { c with
-      locals = List.map (fun t -> LocalType (Set, t)) ts1 @ lts;
+      locals = List.map (fun t -> `Local (`Set, t)) ts1 @ lts;
       results = ts2;
       labels = [ts2]
     }
-  in check_block c' body (FuncType ([], ts2)) f.at
+  in check_block c' body (`Instr ([], ts2, [])) f.at
 
 
 let is_const (c : context) (e : instr) =
@@ -711,13 +711,13 @@ let is_const (c : context) (e : instr) =
   | RefFunc _
   | Const _
   | VecConst _ -> true
-  | GlobalGet x -> let GlobalType (mut, _t) = global c x in mut = Cons
+  | GlobalGet x -> let `Global (mut, _t) = global c x in mut = `Const
   | _ -> false
 
-let check_const (c : context) (const : const) (t : value_type) =
+let check_const (c : context) (const : const) (t : val_type) =
   require (List.for_all (is_const c) const.it) const.at
     "constant expression required";
-  check_block c const.it (FuncType ([], [t])) const.at
+  check_block c const.it (`Instr ([], [t], [])) const.at
 
 
 (* Tables, Memories, & Globals *)
@@ -734,17 +734,17 @@ let check_elem_mode (c : context) (t : ref_type) (mode : segment_mode) =
   match mode.it with
   | Passive -> ()
   | Active {index; offset} ->
-    let TableType (_, et) = table c index in
+    let `Table (_lim, et) = table c index in
     require (match_ref_type c.types [] t et) mode.at
       ("type mismatch: element segment's type " ^ string_of_ref_type t ^
        " does not match table's element type " ^ string_of_ref_type et);
-    check_const c offset (NumType I32Type)
+    check_const c offset `I32
   | Declarative -> ()
 
 let check_elem (c : context) (seg : elem_segment) =
   let {etype; einit; emode} = seg.it in
   check_ref_type c etype seg.at;
-  List.iter (fun const -> check_const c const (RefType etype)) einit;
+  List.iter (fun const -> check_const c const (etype :> val_type)) einit;
   check_elem_mode c etype emode
 
 let check_data_mode (c : context) (mode : segment_mode) =
@@ -752,7 +752,7 @@ let check_data_mode (c : context) (mode : segment_mode) =
   | Passive -> ()
   | Active {index; offset} ->
     ignore (memory c index);
-    check_const c offset (NumType I32Type)
+    check_const c offset `I32
   | Declarative -> assert false
 
 let check_data (c : context) (seg : data_segment) =
@@ -762,7 +762,7 @@ let check_data (c : context) (seg : data_segment) =
 let check_global (c : context) (glob : global) =
   let {gtype; ginit} = glob.it in
   check_global_type c gtype glob.at;
-  let GlobalType (_mut, t) = gtype in
+  let `Global (_mut, t) = gtype in
   check_const c ginit t
 
 
@@ -770,7 +770,7 @@ let check_global (c : context) (glob : global) =
 
 let check_start (c : context) (start : start) =
   let {sfunc} = start.it in
-  require (func c sfunc = FuncType ([], [])) start.at
+  require (func c sfunc = `Func ([], [])) start.at
     "start function must not have parameters or results"
 
 let check_type (c : context) (ty : type_) : context =

From eee30051e5dd60508a0133d0a7f6e01269e7bb28 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 28 Jul 2022 17:04:26 +0200
Subject: [PATCH 147/285] Remove polymorphic variants

---
 interpreter/binary/decode.ml    |  52 ++---
 interpreter/binary/encode.ml    | 154 +++++++--------
 interpreter/exec/eval.ml        |  55 +++---
 interpreter/exec/eval_num.ml    |  11 +-
 interpreter/exec/v128.ml        |   8 +-
 interpreter/host/env.ml         |  10 +-
 interpreter/host/spectest.ml    |  46 ++---
 interpreter/runtime/global.ml   |   6 +-
 interpreter/runtime/instance.ml |  10 +-
 interpreter/runtime/memory.ml   |  28 +--
 interpreter/runtime/table.ml    |   8 +-
 interpreter/runtime/value.ml    |  59 +++---
 interpreter/script/import.ml    |   5 +-
 interpreter/script/js.ml        | 103 +++++-----
 interpreter/script/run.ml       |  19 +-
 interpreter/script/script.ml    |   2 +-
 interpreter/syntax/ast.ml       |  22 +--
 interpreter/syntax/free.ml      |  28 +--
 interpreter/syntax/operators.ml |  92 ++++-----
 interpreter/syntax/types.ml     | 278 ++++++++++++++-------------
 interpreter/text/arrange.ml     |  22 +--
 interpreter/text/lexer.mll      |  11 +-
 interpreter/text/parser.mly     | 136 ++++++-------
 interpreter/valid/match.ml      |  72 +++----
 interpreter/valid/valid.ml      | 330 ++++++++++++++++----------------
 25 files changed, 802 insertions(+), 765 deletions(-)

diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 98b8785fe..28bbbfb08 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -106,7 +106,7 @@ let s33 s = I32_convert.wrap_i64 (sN 33 s)
 let s64 s = sN 64 s
 let f32 s = F32.of_bits (word32 s)
 let f64 s = F64.of_bits (word64 s)
-let v128 s = V128.of_bits (get_string (Types.vec_size `V128) s)
+let v128 s = V128.of_bits (get_string 16 s)
 
 let len32 s =
   let pos = pos s in
@@ -146,15 +146,15 @@ open Types
 
 let num_type s =
   match s7 s with
-  | -0x01 -> `I32
-  | -0x02 -> `I64
-  | -0x03 -> `F32
-  | -0x04 -> `F64
+  | -0x01 -> I32T
+  | -0x02 -> I64T
+  | -0x03 -> F32T
+  | -0x04 -> F64T
   | _ -> error s (pos s - 1) "malformed number type"
 
 let vec_type s =
   match s7 s with
-  | -0x05 -> `V128
+  | -0x05 -> V128T
   | _ -> error s (pos s - 1) "malformed vector type"
 
 let var_type s =
@@ -166,11 +166,11 @@ let var_type s =
 let heap_type s =
   let pos = pos s in
   either [
-    (fun s -> `Def (var_type s));
+    (fun s -> DefHT (var_type s));
     (fun s ->
       match s7 s with
-      | -0x10 -> `Func
-      | -0x11 -> `Extern
+      | -0x10 -> FuncHT
+      | -0x11 -> ExternHT
       | _ -> error s pos "malformed heap type"
     )
   ] s
@@ -178,17 +178,17 @@ let heap_type s =
 let ref_type s =
   let pos = pos s in
   match s7 s with
-  | -0x10 -> `Ref (`Null, `Func)
-  | -0x11 -> `Ref (`Null, `Extern)
-  | -0x14 -> `Ref (`Null, heap_type s)
-  | -0x15 -> `Ref (`NoNull, heap_type s)
+  | -0x10 -> (Null, FuncHT)
+  | -0x11 -> (Null, ExternHT)
+  | -0x14 -> (Null, heap_type s)
+  | -0x15 -> (NoNull, heap_type s)
   | _ -> error s pos "malformed reference type"
 
 let val_type s =
   either [
-    (fun s -> num_type s);
-    (fun s -> vec_type s);
-    (fun s -> ref_type s);
+    (fun s -> NumT (num_type s));
+    (fun s -> VecT (vec_type s));
+    (fun s -> RefT (ref_type s));
   ] s
 
 let result_type s = vec val_type s
@@ -196,11 +196,11 @@ let result_type s = vec val_type s
 let func_type s =
   let ts1 = result_type s in
   let ts2 = result_type s in
-  `Func (ts1, ts2)
+  FuncT (ts1, ts2)
 
 let def_type s =
   match s7 s with
-  | -0x20 -> func_type s
+  | -0x20 -> DefFuncT (func_type s)
   | _ -> error s (pos s - 1) "malformed definition type"
 
 
@@ -213,22 +213,22 @@ let limits uN s =
 let table_type s =
   let t = ref_type s in
   let lim = limits u32 s in
-  `Table (lim, t)
+  TableT (lim, t)
 
 let memory_type s =
   let lim = limits u32 s in
-  `Memory lim
+  MemoryT lim
 
 let mutability s =
   match byte s with
-  | 0 -> `Const
-  | 1 -> `Var
+  | 0 -> Cons
+  | 1 -> Var
   | _ -> error s (pos s - 1) "malformed mutability"
 
 let global_type s =
   let t = val_type s in
   let mut = mutability s in
-  `Global (mut, t)
+  GlobalT (mut, t)
 
 
 (* Instructions *)
@@ -1001,7 +1001,7 @@ let elem_index s =
 
 let elem_kind s =
   match byte s with
-  | 0x00 -> `Ref (`NoNull, `Func)
+  | 0x00 -> (NoNull, FuncHT)
   | _ -> error s (pos s - 1) "malformed element kind"
 
 let elem s =
@@ -1009,7 +1009,7 @@ let elem s =
   | 0x00l ->
     let emode = at active_zero s in
     let einit = vec (at elem_index) s in
-    {etype = `Ref (`NoNull, `Func); einit; emode}
+    {etype = (NoNull, FuncHT); einit; emode}
   | 0x01l ->
     let emode = at passive s in
     let etype = elem_kind s in
@@ -1028,7 +1028,7 @@ let elem s =
   | 0x04l ->
     let emode = at active_zero s in
     let einit = vec const s in
-    {etype = `Ref (`NoNull, `Func); einit; emode}
+    {etype = (NoNull, FuncHT); einit; emode}
   | 0x05l ->
     let emode = at passive s in
     let etype = ref_type s in
diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index 11215de42..e5e439df4 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -99,53 +99,53 @@ struct
     | x -> s33 x
 
   let num_type = function
-    | `I32 -> s7 (-0x01)
-    | `I64 -> s7 (-0x02)
-    | `F32 -> s7 (-0x03)
-    | `F64 -> s7 (-0x04)
+    | I32T -> s7 (-0x01)
+    | I64T -> s7 (-0x02)
+    | F32T -> s7 (-0x03)
+    | F64T -> s7 (-0x04)
 
   let vec_type = function
-    | `V128 -> s7 (-0x05)
+    | V128T -> s7 (-0x05)
 
   let heap_type = function
-    | `Func -> s7 (-0x10)
-    | `Extern -> s7 (-0x11)
-    | `Def x -> var_type x
-    | `Bot -> assert false
+    | FuncHT -> s7 (-0x10)
+    | ExternHT -> s7 (-0x11)
+    | DefHT x -> var_type x
+    | BotHT -> assert false
 
   let ref_type = function
-    | `Ref (`Null, `Func) -> s7 (-0x10)
-    | `Ref (`Null, `Extern) -> s7 (-0x11)
-    | `Ref (`Null, t) -> s7 (-0x14); heap_type t
-    | `Ref (`NoNull, t) -> s7 (-0x15); heap_type t
+    | (Null, FuncHT) -> s7 (-0x10)
+    | (Null, ExternHT) -> s7 (-0x11)
+    | (Null, t) -> s7 (-0x14); heap_type t
+    | (NoNull, t) -> s7 (-0x15); heap_type t
 
   let val_type = function
-    | #num_type as t -> num_type t
-    | #vec_type as t -> vec_type t
-    | #ref_type as t -> ref_type t
-    | `Bot -> assert false
+    | NumT t -> num_type t
+    | VecT t -> vec_type t
+    | RefT t -> ref_type t
+    | BotT -> assert false
 
   let func_type = function
-    | `Func (ts1, ts2) -> vec val_type ts1; vec val_type ts2
+    | FuncT (ts1, ts2) -> vec val_type ts1; vec val_type ts2
 
   let def_type = function
-    | #func_type as ft -> s7 (-0x20); func_type ft
+    | DefFuncT ft -> s7 (-0x20); func_type ft
 
   let limits vu {min; max} =
     bool (max <> None); vu min; opt vu max
 
   let table_type = function
-    | `Table (lim, t) -> ref_type t; limits u32 lim
+    | TableT (lim, t) -> ref_type t; limits u32 lim
 
   let memory_type = function
-    | `Memory lim -> limits u32 lim
+    | MemoryT lim -> limits u32 lim
 
   let mutability = function
-    | `Const -> byte 0
-    | `Var -> byte 1
+    | Cons -> byte 0
+    | Var -> byte 1
 
   let global_type = function
-    | `Global (mut, t) -> val_type t; mutability mut
+    | GlobalT (mut, t) -> val_type t; mutability mut
 
 
   (* Instructions *)
@@ -220,90 +220,90 @@ struct
     | TableInit (x, y) -> op 0xfc; u32 0x0cl; var y; var x
     | ElemDrop x -> op 0xfc; u32 0x0dl; var x
 
-    | Load ({ty = `I32; pack = None; _} as mo) -> op 0x28; memop mo
-    | Load ({ty = `I64; pack = None; _} as mo) -> op 0x29; memop mo
-    | Load ({ty = `F32; pack = None; _} as mo) -> op 0x2a; memop mo
-    | Load ({ty = `F64; pack = None; _} as mo) -> op 0x2b; memop mo
-    | Load ({ty = `I32; pack = Some (Pack8, SX); _} as mo) -> op 0x2c; memop mo
-    | Load ({ty = `I32; pack = Some (Pack8, ZX); _} as mo) -> op 0x2d; memop mo
-    | Load ({ty = `I32; pack = Some (Pack16, SX); _} as mo) -> op 0x2e; memop mo
-    | Load ({ty = `I32; pack = Some (Pack16, ZX); _} as mo) -> op 0x2f; memop mo
-    | Load {ty = `I32; pack = Some (Pack32, _); _} ->
+    | Load ({ty = I32T; pack = None; _} as mo) -> op 0x28; memop mo
+    | Load ({ty = I64T; pack = None; _} as mo) -> op 0x29; memop mo
+    | Load ({ty = F32T; pack = None; _} as mo) -> op 0x2a; memop mo
+    | Load ({ty = F64T; pack = None; _} as mo) -> op 0x2b; memop mo
+    | Load ({ty = I32T; pack = Some (Pack8, SX); _} as mo) -> op 0x2c; memop mo
+    | Load ({ty = I32T; pack = Some (Pack8, ZX); _} as mo) -> op 0x2d; memop mo
+    | Load ({ty = I32T; pack = Some (Pack16, SX); _} as mo) -> op 0x2e; memop mo
+    | Load ({ty = I32T; pack = Some (Pack16, ZX); _} as mo) -> op 0x2f; memop mo
+    | Load {ty = I32T; pack = Some (Pack32, _); _} ->
       error e.at "illegal instruction i32.load32"
-    | Load ({ty = `I64; pack = Some (Pack8, SX); _} as mo) -> op 0x30; memop mo
-    | Load ({ty = `I64; pack = Some (Pack8, ZX); _} as mo) -> op 0x31; memop mo
-    | Load ({ty = `I64; pack = Some (Pack16, SX); _} as mo) -> op 0x32; memop mo
-    | Load ({ty = `I64; pack = Some (Pack16, ZX); _} as mo) -> op 0x33; memop mo
-    | Load ({ty = `I64; pack = Some (Pack32, SX); _} as mo) -> op 0x34; memop mo
-    | Load ({ty = `I64; pack = Some (Pack32, ZX); _} as mo) -> op 0x35; memop mo
-    | Load {ty = `F32 | `F64; pack = Some _; _} ->
+    | Load ({ty = I64T; pack = Some (Pack8, SX); _} as mo) -> op 0x30; memop mo
+    | Load ({ty = I64T; pack = Some (Pack8, ZX); _} as mo) -> op 0x31; memop mo
+    | Load ({ty = I64T; pack = Some (Pack16, SX); _} as mo) -> op 0x32; memop mo
+    | Load ({ty = I64T; pack = Some (Pack16, ZX); _} as mo) -> op 0x33; memop mo
+    | Load ({ty = I64T; pack = Some (Pack32, SX); _} as mo) -> op 0x34; memop mo
+    | Load ({ty = I64T; pack = Some (Pack32, ZX); _} as mo) -> op 0x35; memop mo
+    | Load {ty = F32T | F64T; pack = Some _; _} ->
       error e.at "illegal instruction fxx.loadN"
-    | Load {ty = `I32 | `I64; pack = Some (Pack64, _); _} ->
+    | Load {ty = I32T | I64T; pack = Some (Pack64, _); _} ->
       error e.at "illegal instruction ixx.load64"
 
-    | Store ({ty = `I32; pack = None; _} as mo) -> op 0x36; memop mo
-    | Store ({ty = `I64; pack = None; _} as mo) -> op 0x37; memop mo
-    | Store ({ty = `F32; pack = None; _} as mo) -> op 0x38; memop mo
-    | Store ({ty = `F64; pack = None; _} as mo) -> op 0x39; memop mo
-    | Store ({ty = `I32; pack = Some Pack8; _} as mo) -> op 0x3a; memop mo
-    | Store ({ty = `I32; pack = Some Pack16; _} as mo) -> op 0x3b; memop mo
-    | Store {ty = `I32; pack = Some Pack32; _} ->
+    | Store ({ty = I32T; pack = None; _} as mo) -> op 0x36; memop mo
+    | Store ({ty = I64T; pack = None; _} as mo) -> op 0x37; memop mo
+    | Store ({ty = F32T; pack = None; _} as mo) -> op 0x38; memop mo
+    | Store ({ty = F64T; pack = None; _} as mo) -> op 0x39; memop mo
+    | Store ({ty = I32T; pack = Some Pack8; _} as mo) -> op 0x3a; memop mo
+    | Store ({ty = I32T; pack = Some Pack16; _} as mo) -> op 0x3b; memop mo
+    | Store {ty = I32T; pack = Some Pack32; _} ->
       error e.at "illegal instruction i32.store32"
-    | Store ({ty = `I64; pack = Some Pack8; _} as mo) -> op 0x3c; memop mo
-    | Store ({ty = `I64; pack = Some Pack16; _} as mo) -> op 0x3d; memop mo
-    | Store ({ty = `I64; pack = Some Pack32; _} as mo) -> op 0x3e; memop mo
-    | Store {ty = `F32 | `F64; pack = Some _; _} ->
+    | Store ({ty = I64T; pack = Some Pack8; _} as mo) -> op 0x3c; memop mo
+    | Store ({ty = I64T; pack = Some Pack16; _} as mo) -> op 0x3d; memop mo
+    | Store ({ty = I64T; pack = Some Pack32; _} as mo) -> op 0x3e; memop mo
+    | Store {ty = F32T | F64T; pack = Some _; _} ->
       error e.at "illegal instruction fxx.storeN"
-    | Store {ty = (`I32 | `I64); pack = Some Pack64; _} ->
+    | Store {ty = I32T | I64T; pack = Some Pack64; _} ->
       error e.at "illegal instruction ixx.store64"
 
-    | VecLoad ({ty = `V128; pack = None; _} as mo) ->
+    | VecLoad ({ty = V128T; pack = None; _} as mo) ->
       vecop 0x00l; memop mo
-    | VecLoad ({ty = `V128; pack = Some (Pack64, ExtLane (Pack8x8, SX)); _} as mo) ->
+    | VecLoad ({ty = V128T; pack = Some (Pack64, ExtLane (Pack8x8, SX)); _} as mo) ->
       vecop 0x01l; memop mo
-    | VecLoad ({ty = `V128; pack = Some (Pack64, ExtLane (Pack8x8, ZX)); _} as mo) ->
+    | VecLoad ({ty = V128T; pack = Some (Pack64, ExtLane (Pack8x8, ZX)); _} as mo) ->
       vecop 0x02l; memop mo
-    | VecLoad ({ty = `V128; pack = Some (Pack64, ExtLane (Pack16x4, SX)); _} as mo) ->
+    | VecLoad ({ty = V128T; pack = Some (Pack64, ExtLane (Pack16x4, SX)); _} as mo) ->
       vecop 0x03l; memop mo
-    | VecLoad ({ty = `V128; pack = Some (Pack64, ExtLane (Pack16x4, ZX)); _} as mo) ->
+    | VecLoad ({ty = V128T; pack = Some (Pack64, ExtLane (Pack16x4, ZX)); _} as mo) ->
       vecop 0x04l; memop mo
-    | VecLoad ({ty = `V128; pack = Some (Pack64, ExtLane (Pack32x2, SX)); _} as mo) ->
+    | VecLoad ({ty = V128T; pack = Some (Pack64, ExtLane (Pack32x2, SX)); _} as mo) ->
       vecop 0x05l; memop mo
-    | VecLoad ({ty = `V128; pack = Some (Pack64, ExtLane (Pack32x2, ZX)); _} as mo) ->
+    | VecLoad ({ty = V128T; pack = Some (Pack64, ExtLane (Pack32x2, ZX)); _} as mo) ->
       vecop 0x06l; memop mo
-    | VecLoad ({ty = `V128; pack = Some (Pack8, ExtSplat); _} as mo) ->
+    | VecLoad ({ty = V128T; pack = Some (Pack8, ExtSplat); _} as mo) ->
       vecop 0x07l; memop mo
-    | VecLoad ({ty = `V128; pack = Some (Pack16, ExtSplat); _} as mo) ->
+    | VecLoad ({ty = V128T; pack = Some (Pack16, ExtSplat); _} as mo) ->
       vecop 0x08l; memop mo
-    | VecLoad ({ty = `V128; pack = Some (Pack32, ExtSplat); _} as mo) ->
+    | VecLoad ({ty = V128T; pack = Some (Pack32, ExtSplat); _} as mo) ->
       vecop 0x09l; memop mo
-    | VecLoad ({ty = `V128; pack = Some (Pack64, ExtSplat); _} as mo) ->
+    | VecLoad ({ty = V128T; pack = Some (Pack64, ExtSplat); _} as mo) ->
       vecop 0x0al; memop mo
-    | VecLoad ({ty = `V128; pack = Some (Pack32, ExtZero); _} as mo) ->
+    | VecLoad ({ty = V128T; pack = Some (Pack32, ExtZero); _} as mo) ->
       vecop 0x5cl; memop mo
-    | VecLoad ({ty = `V128; pack = Some (Pack64, ExtZero); _} as mo) ->
+    | VecLoad ({ty = V128T; pack = Some (Pack64, ExtZero); _} as mo) ->
       vecop 0x5dl; memop mo
     | VecLoad _ ->
       error e.at "illegal instruction v128.loadNxM_<ext>"
 
-    | VecLoadLane ({ty = `V128; pack = Pack8; _} as mo, i) ->
+    | VecLoadLane ({ty = V128T; pack = Pack8; _} as mo, i) ->
       vecop 0x54l; memop mo; byte i
-    | VecLoadLane ({ty = `V128; pack = Pack16; _} as mo, i) ->
+    | VecLoadLane ({ty = V128T; pack = Pack16; _} as mo, i) ->
       vecop 0x55l; memop mo; byte i
-    | VecLoadLane ({ty = `V128; pack = Pack32; _} as mo, i) ->
+    | VecLoadLane ({ty = V128T; pack = Pack32; _} as mo, i) ->
       vecop 0x56l; memop mo; byte i
-    | VecLoadLane ({ty = `V128; pack = Pack64; _} as mo, i) ->
+    | VecLoadLane ({ty = V128T; pack = Pack64; _} as mo, i) ->
       vecop 0x57l; memop mo; byte i
 
-    | VecStore ({ty = `V128; _} as mo) -> vecop 0x0bl; memop mo
+    | VecStore ({ty = V128T; _} as mo) -> vecop 0x0bl; memop mo
 
-    | VecStoreLane ({ty = `V128; pack = Pack8; _} as mo, i) ->
+    | VecStoreLane ({ty = V128T; pack = Pack8; _} as mo, i) ->
       vecop 0x58l; memop mo; byte i
-    | VecStoreLane ({ty = `V128; pack = Pack16; _} as mo, i) ->
+    | VecStoreLane ({ty = V128T; pack = Pack16; _} as mo, i) ->
       vecop 0x59l; memop mo; byte i
-    | VecStoreLane ({ty = `V128; pack = Pack32; _} as mo, i) ->
+    | VecStoreLane ({ty = V128T; pack = Pack32; _} as mo, i) ->
       vecop 0x5al; memop mo; byte i
-    | VecStoreLane ({ty = `V128; pack = Pack64; _} as mo, i) ->
+    | VecStoreLane ({ty = V128T; pack = Pack64; _} as mo, i) ->
       vecop 0x5bl; memop mo; byte i
 
     | MemorySize -> op 0x3f; byte 0x00
@@ -870,11 +870,11 @@ struct
   (* Element section *)
 
   let is_elem_kind = function
-    | `Ref (`NoNull, `Func) -> true
+    | (NoNull, FuncHT) -> true
     | _ -> false
 
   let elem_kind = function
-    | `Ref (`NoNull, `Func) -> byte 0x00
+    | (NoNull, FuncHT) -> byte 0x00
     | _ -> assert false
 
   let is_elem_index e =
diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index f8e117ae3..310a1ac80 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -75,7 +75,7 @@ type config =
 }
 
 let frame inst locals = {inst; locals}
-let config inst vs es = {frame = frame inst []; code = vs, es; budget = 300}
+let config inst vs es = {frame = frame inst []; code = vs, es; budget = 250}
 
 let plain e = Plain e.it @@ e.at
 
@@ -111,10 +111,10 @@ let func_ref (inst : module_inst) x i at =
 
 let block_type (inst : module_inst) bt at =
   match bt with
-  | ValBlockType None -> `Instr ([], [], [])
-  | ValBlockType (Some t) -> `Instr ([], [sem_val_type inst.types t], [])
+  | ValBlockType None -> InstrT ([], [], [])
+  | ValBlockType (Some t) -> InstrT ([], [sem_val_type inst.types t], [])
   | VarBlockType x ->
-    let `Func (ts1, ts2) = func_type inst (x @@ at) in `Instr (ts1, ts2, [])
+    let FuncT (ts1, ts2) = func_type inst (x @@ at) in InstrT (ts1, ts2, [])
 
 let take n (vs : 'a stack) at =
   try Lib.List.take n vs with Failure _ -> Crash.error at "stack underflow"
@@ -166,14 +166,14 @@ let rec step (c : config) : config =
         vs, []
 
       | Block (bt, es'), vs ->
-        let `Instr (ts1, ts2, _xs) = block_type c.frame.inst bt e.at in
+        let InstrT (ts1, ts2, _xs) = block_type c.frame.inst bt e.at in
         let n1 = List.length ts1 in
         let n2 = List.length ts2 in
         let args, vs' = take n1 vs e.at, drop n1 vs e.at in
         vs', [Label (n2, [], (args, List.map plain es')) @@ e.at]
 
       | Loop (bt, es'), vs ->
-        let `Instr (ts1, ts2, _xs) = block_type c.frame.inst bt e.at in
+        let InstrT (ts1, ts2, _xs) = block_type c.frame.inst bt e.at in
         let n1 = List.length ts1 in
         let args, vs' = take n1 vs e.at, drop n1 vs e.at in
         vs', [Label (n1, [e' @@ e.at], (args, List.map plain es')) @@ e.at]
@@ -368,11 +368,12 @@ let rec step (c : config) : config =
       | Load {offset; ty; pack; _}, Num (I32 i) :: vs' ->
         let mem = memory c.frame.inst (0l @@ e.at) in
         let a = I64_convert.extend_i32_u i in
+        let t = sem_num_type [] ty in
         (try
           let n =
             match pack with
-            | None -> Memory.load_num mem a offset ty
-            | Some (sz, ext) -> Memory.load_num_packed sz ext mem a offset ty
+            | None -> Memory.load_num mem a offset t
+            | Some (sz, ext) -> Memory.load_num_packed sz ext mem a offset t
           in Num n :: vs', []
         with exn -> vs', [Trapping (memory_error e.at exn) @@ e.at])
 
@@ -389,13 +390,13 @@ let rec step (c : config) : config =
 
       | VecLoad {offset; ty; pack; _}, Num (I32 i) :: vs' ->
         let mem = memory c.frame.inst (0l @@ e.at) in
-        let addr = I64_convert.extend_i32_u i in
+        let a = I64_convert.extend_i32_u i in
+        let t = sem_vec_type [] ty in
         (try
           let v =
             match pack with
-            | None -> Memory.load_vec mem addr offset ty
-            | Some (sz, ext) ->
-              Memory.load_vec_packed sz ext mem addr offset ty
+            | None -> Memory.load_vec mem a offset t
+            | Some (sz, ext) -> Memory.load_vec_packed sz ext mem a offset t
           in Vec v :: vs', []
         with exn -> vs', [Trapping (memory_error e.at exn) @@ e.at])
 
@@ -415,16 +416,16 @@ let rec step (c : config) : config =
             match pack with
             | Pack8 ->
               V128.I8x16.replace_lane j v
-                (I32Num.of_num 0 (Memory.load_num_packed Pack8 SX mem addr offset `I32))
+                (I32Num.of_num 0 (Memory.load_num_packed Pack8 SX mem addr offset I32T))
             | Pack16 ->
               V128.I16x8.replace_lane j v
-                (I32Num.of_num 0 (Memory.load_num_packed Pack16 SX mem addr offset `I32))
+                (I32Num.of_num 0 (Memory.load_num_packed Pack16 SX mem addr offset I32T))
             | Pack32 ->
               V128.I32x4.replace_lane j v
-                (I32Num.of_num 0 (Memory.load_num mem addr offset `I32))
+                (I32Num.of_num 0 (Memory.load_num mem addr offset I32T))
             | Pack64 ->
               V128.I64x2.replace_lane j v
-                (I64Num.of_num 0 (Memory.load_num mem addr offset `I64))
+                (I64Num.of_num 0 (Memory.load_num mem addr offset I64T))
           in Vec (V128 v) :: vs', []
         with exn -> vs', [Trapping (memory_error e.at exn) @@ e.at])
 
@@ -467,7 +468,7 @@ let rec step (c : config) : config =
             Plain (Const (I32 i @@ e.at));
             Plain (Const (k @@ e.at));
             Plain (Store
-              {ty = `I32; align = 0; offset = 0l; pack = Some Pack8});
+              {ty = Types.I32T; align = 0; offset = 0l; pack = Some Pack8});
             Plain (Const (I32 (I32.add i 1l) @@ e.at));
             Plain (Const (k @@ e.at));
             Plain (Const (I32 (I32.sub n 1l) @@ e.at));
@@ -484,9 +485,9 @@ let rec step (c : config) : config =
             Plain (Const (I32 d @@ e.at));
             Plain (Const (I32 s @@ e.at));
             Plain (Load
-              {ty = `I32; align = 0; offset = 0l; pack = Some (Pack8, ZX)});
+              {ty = Types.I32T; align = 0; offset = 0l; pack = Some (Pack8, ZX)});
             Plain (Store
-              {ty = `I32; align = 0; offset = 0l; pack = Some Pack8});
+              {ty = Types.I32T; align = 0; offset = 0l; pack = Some Pack8});
             Plain (Const (I32 (I32.add d 1l) @@ e.at));
             Plain (Const (I32 (I32.add s 1l) @@ e.at));
             Plain (Const (I32 (I32.sub n 1l) @@ e.at));
@@ -501,9 +502,9 @@ let rec step (c : config) : config =
             Plain (Const (I32 d @@ e.at));
             Plain (Const (I32 s @@ e.at));
             Plain (Load
-              {ty = `I32; align = 0; offset = 0l; pack = Some (Pack8, ZX)});
+              {ty = Types.I32T; align = 0; offset = 0l; pack = Some (Pack8, ZX)});
             Plain (Store
-              {ty = `I32; align = 0; offset = 0l; pack = Some Pack8});
+              {ty = Types.I32T; align = 0; offset = 0l; pack = Some Pack8});
           ]
 
       | MemoryInit x, Num (I32 n) :: Num (I32 s) :: Num (I32 d) :: vs' ->
@@ -518,7 +519,7 @@ let rec step (c : config) : config =
             Plain (Const (I32 d @@ e.at));
             Plain (Const (I32 b @@ e.at));
             Plain (Store
-              {ty = `I32; align = 0; offset = 0l; pack = Some Pack8});
+              {ty = Types.I32T; align = 0; offset = 0l; pack = Some Pack8});
             Plain (Const (I32 (I32.add d 1l) @@ e.at));
             Plain (Const (I32 (I32.add s 1l) @@ e.at));
             Plain (Const (I32 (I32.sub n 1l) @@ e.at));
@@ -681,7 +682,7 @@ let rec step (c : config) : config =
       take n vs0 e.at @ vs, []
 
     | Frame (n, frame', (vs', {it = ReturningInvoke (vs0, f); at} :: es')), vs ->
-      let `Func (ts1, _ts2) = Func.type_of f in
+      let FuncT (ts1, _ts2) = Func.type_of f in
       take (List.length ts1) vs0 e.at @ vs, [Invoke f @@ at]
 
     | Frame (n, frame', code'), vs ->
@@ -692,7 +693,7 @@ let rec step (c : config) : config =
       Exhaustion.error e.at "call stack exhausted"
 
     | Invoke f, vs ->
-      let `Func (ts1, ts2) = Func.type_of f in
+      let FuncT (ts1, ts2) = Func.type_of f in
       let n1, n2 = List.length ts1, List.length ts2 in
       let args, vs' = split n1 vs e.at in
       (match f with
@@ -732,7 +733,7 @@ let at_func = function
 
 let invoke (func : func_inst) (vs : value list) : value list =
   let at = at_func func in
-  let `Func (ts1, _ts2) = Func.type_of func in
+  let FuncT (ts1, _ts2) = Func.type_of func in
   if List.length vs <> List.length ts1 then
     Crash.error at "wrong number of arguments";
   if not (List.for_all2 (fun v -> Match.Sem.match_val_type () [] (type_of_value v)) vs ts1) then
@@ -758,7 +759,7 @@ let create_func (inst : module_inst) (f : func) : func_inst =
 
 let create_table (inst : module_inst) (tab : table) : table_inst =
   let {ttype} = tab.it in
-  let `Table (_lim, `Ref (_nul, t)) as tt = Types.Sem.sem_table_type inst.types ttype in
+  let TableT (_lim, (_nul, t)) as tt = Types.Sem.sem_table_type inst.types ttype in
   Table.alloc tt (NullRef t)
 
 let create_memory (inst : module_inst) (mem : memory) : memory_inst =
@@ -791,7 +792,7 @@ let create_data (inst : module_inst) (seg : data_segment) : data_inst =
 
 let add_import (m : module_) (ext : extern) (im : import) (inst : module_inst)
   : module_inst =
-  let it = extern_type_of_import_type (import_type_of m im) in
+  let it = Types.extern_type_of_import_type (import_type_of m im) in
   let et = Types.Sem.sem_extern_type inst.types it in
   let et' = extern_type_of inst.types ext in
   if not (Match.Sem.match_extern_type () [] et' et) then
diff --git a/interpreter/exec/eval_num.ml b/interpreter/exec/eval_num.ml
index 34cca25b8..dba3b3814 100644
--- a/interpreter/exec/eval_num.ml
+++ b/interpreter/exec/eval_num.ml
@@ -1,4 +1,5 @@
 open Value
+open Types.Sem
 
 
 (* Int operators *)
@@ -123,8 +124,8 @@ struct
       | TruncSatUF64 -> I32_convert.trunc_sat_f64_u (F64Num.of_num 1 v)
       | TruncSatSF64 -> I32_convert.trunc_sat_f64_s (F64Num.of_num 1 v)
       | ReinterpretFloat -> I32_convert.reinterpret_f32 (F32Num.of_num 1 v)
-      | ExtendUI32 -> raise (TypeError (1, v, `I32))
-      | ExtendSI32 -> raise (TypeError (1, v, `I32))
+      | ExtendUI32 -> raise (TypeError (1, v, I32T))
+      | ExtendSI32 -> raise (TypeError (1, v, I32T))
     in I32Num.to_num i
 end
 
@@ -145,7 +146,7 @@ struct
       | TruncSatUF64 -> I64_convert.trunc_sat_f64_u (F64Num.of_num 1 v)
       | TruncSatSF64 -> I64_convert.trunc_sat_f64_s (F64Num.of_num 1 v)
       | ReinterpretFloat -> I64_convert.reinterpret_f64 (F64Num.of_num 1 v)
-      | WrapI64 -> raise (TypeError (1, v, `I64))
+      | WrapI64 -> raise (TypeError (1, v, I64T))
     in I64Num.to_num i
 end
 
@@ -161,7 +162,7 @@ struct
       | ConvertSI64 -> F32_convert.convert_i64_s (I64Num.of_num 1 v)
       | ConvertUI64 -> F32_convert.convert_i64_u (I64Num.of_num 1 v)
       | ReinterpretInt -> F32_convert.reinterpret_i32 (I32Num.of_num 1 v)
-      | PromoteF32 -> raise (TypeError (1, v, `F32))
+      | PromoteF32 -> raise (TypeError (1, v, F32T))
     in F32Num.to_num z
 end
 
@@ -177,7 +178,7 @@ struct
       | ConvertSI64 -> F64_convert.convert_i64_s (I64Num.of_num 1 v)
       | ConvertUI64 -> F64_convert.convert_i64_u (I64Num.of_num 1 v)
       | ReinterpretInt -> F64_convert.reinterpret_i64 (I64Num.of_num 1 v)
-      | DemoteF64 -> raise (TypeError (1, v, `F64))
+      | DemoteF64 -> raise (TypeError (1, v, F64T))
     in F64Num.to_num z
 end
 
diff --git a/interpreter/exec/v128.ml b/interpreter/exec/v128.ml
index 1eeed6df5..c8c3f1fe3 100644
--- a/interpreter/exec/v128.ml
+++ b/interpreter/exec/v128.ml
@@ -29,10 +29,10 @@ let num_lanes shape =
   | F64x2 _ -> 2
 
 let type_of_lane = function
-  | I8x16 _ | I16x8 _ | I32x4 _ -> `I32
-  | I64x2 _ -> `I64
-  | F32x4 _ -> `F32
-  | F64x2 _ -> `F64
+  | I8x16 _ | I16x8 _ | I32x4 _ -> Types.I32T
+  | I64x2 _ -> Types.I64T
+  | F32x4 _ -> Types.F32T
+  | F64x2 _ -> Types.F64T
 
 
 (* Shape-based operations *)
diff --git a/interpreter/host/env.ml b/interpreter/host/env.ml
index 87f25177f..85a436b3b 100644
--- a/interpreter/host/env.ml
+++ b/interpreter/host/env.ml
@@ -27,7 +27,7 @@ let single = function
 
 let int = function
   | Num (I32 i) -> Int32.to_int i
-  | v -> type_error v `I32
+  | v -> type_error v (NumT I32T)
 
 
 let abort vs =
@@ -41,8 +41,8 @@ let exit vs =
 
 let lookup name et =
   match Utf8.encode name, et with
-  | "abort", (#func_type as ft) ->
-    ExternFunc (Func.alloc_host (Types.Sem.alloc (ft :> def_type)) abort)
-  | "exit", (#func_type as ft) ->
-    ExternFunc (Func.alloc_host (Types.Sem.alloc (ft :> def_type)) exit)
+  | "abort", ExternFuncT ft ->
+    ExternFunc (Func.alloc_host (Types.Sem.alloc (DefFuncT ft)) abort)
+  | "exit", ExternFuncT ft ->
+    ExternFunc (Func.alloc_host (Types.Sem.alloc (DefFuncT ft)) exit)
   | _ -> raise Not_found
diff --git a/interpreter/host/spectest.ml b/interpreter/host/spectest.ml
index 73e043500..53249a6f2 100644
--- a/interpreter/host/spectest.ml
+++ b/interpreter/host/spectest.ml
@@ -7,23 +7,23 @@ open Value
 open Instance
 
 
-let global (`Global (_, t) as gt) =
+let global (GlobalT (_, t) as gt) =
   let v =
     match t with
-    | `I32 -> Num (I32 666l)
-    | `I64 -> Num (I64 666L)
-    | `F32 -> Num (F32 (F32.of_float 666.6))
-    | `F64 -> Num (F64 (F64.of_float 666.6))
-    | `V128 -> Vec (V128 (V128.I32x4.of_lanes [666l; 666l; 666l; 666l]))
-    | `Ref (_, t) -> Ref (NullRef t)
-    | `Bot -> assert false
+    | NumT I32T -> Num (I32 666l)
+    | NumT I64T -> Num (I64 666L)
+    | NumT F32T -> Num (F32 (F32.of_float 666.6))
+    | NumT F64T -> Num (F64 (F64.of_float 666.6))
+    | VecT V128T -> Vec (V128 (V128.I32x4.of_lanes [666l; 666l; 666l; 666l]))
+    | RefT (_, t) -> Ref (NullRef t)
+    | BotT -> assert false
   in Global.alloc gt v
 
 let table =
-  Table.alloc (`Table ({min = 10l; max = Some 20l}, `Ref (`Null, `Func)))
-    (NullRef `Func)
-let memory = Memory.alloc (`Memory {min = 1l; max = Some 2l})
-let func f ft = Func.alloc_host (Types.Sem.alloc (ft :> def_type)) (f ft)
+  Table.alloc (TableT ({min = 10l; max = Some 20l}, (Null, FuncHT)))
+    (NullRef FuncHT)
+let memory = Memory.alloc (MemoryT {min = 1l; max = Some 2l})
+let func f ft = Func.alloc_host (Types.Sem.alloc (DefFuncT ft)) (f ft)
 
 let print_value v =
   Printf.printf "%s : %s\n"
@@ -37,17 +37,17 @@ let print _ vs =
 
 let lookup name t =
   match Utf8.encode name, t with
-  | "print", _ -> ExternFunc (func print (`Func ([], [])))
-  | "print_i32", _ -> ExternFunc (func print (`Func ([`I32], [])))
-  | "print_i64", _ -> ExternFunc (func print (`Func ([`I64], [])))
-  | "print_f32", _ -> ExternFunc (func print (`Func ([`F32], [])))
-  | "print_f64", _ -> ExternFunc (func print (`Func ([`F64], [])))
-  | "print_i32_f32", _ -> ExternFunc (func print (`Func ([`I32; `F32], [])))
-  | "print_f64_f64", _ -> ExternFunc (func print (`Func ([`F64; `F64], [])))
-  | "global_i32", _ -> ExternGlobal (global (`Global (`Const, `I32)))
-  | "global_i64", _ -> ExternGlobal (global (`Global (`Const, `I64)))
-  | "global_f32", _ -> ExternGlobal (global (`Global (`Const, `F32)))
-  | "global_f64", _ -> ExternGlobal (global (`Global (`Const, `F64)))
+  | "print", _ -> ExternFunc (func print (FuncT ([], [])))
+  | "print_i32", _ -> ExternFunc (func print (FuncT ([NumT I32T], [])))
+  | "print_i64", _ -> ExternFunc (func print (FuncT ([NumT I64T], [])))
+  | "print_f32", _ -> ExternFunc (func print (FuncT ([NumT F32T], [])))
+  | "print_f64", _ -> ExternFunc (func print (FuncT ([NumT F64T], [])))
+  | "print_i32_f32", _ -> ExternFunc (func print (FuncT ([NumT I32T; NumT F32T], [])))
+  | "print_f64_f64", _ -> ExternFunc (func print (FuncT ([NumT F64T; NumT F64T], [])))
+  | "global_i32", _ -> ExternGlobal (global (GlobalT (Cons, NumT I32T)))
+  | "global_i64", _ -> ExternGlobal (global (GlobalT (Cons, NumT I64T)))
+  | "global_f32", _ -> ExternGlobal (global (GlobalT (Cons, NumT F32T)))
+  | "global_f64", _ -> ExternGlobal (global (GlobalT (Cons, NumT F64T)))
   | "table", _ -> ExternTable table
   | "memory", _ -> ExternMemory memory
   | _ -> raise Not_found
diff --git a/interpreter/runtime/global.ml b/interpreter/runtime/global.ml
index a9784acc6..3da86fd84 100644
--- a/interpreter/runtime/global.ml
+++ b/interpreter/runtime/global.ml
@@ -7,7 +7,7 @@ type t = global
 exception Type
 exception NotMutable
 
-let alloc (`Global (_mut, t) as ty) v =
+let alloc (GlobalT (_mut, t) as ty) v =
   if not (Match.Sem.match_val_type () [] (type_of_value v) t) then raise Type;
   {ty; content = v}
 
@@ -18,7 +18,7 @@ let load glob =
   glob.content
 
 let store glob v =
-  let `Global (mut, t) = glob.ty in
-  if mut <> `Var then raise NotMutable;
+  let GlobalT (mut, t) = glob.ty in
+  if mut <> Var then raise NotMutable;
   if not (Match.Sem.match_val_type () [] (type_of_value v) t) then raise Type;
   glob.content <- v
diff --git a/interpreter/runtime/instance.ml b/interpreter/runtime/instance.ml
index 8ce173903..a7fa55e8e 100644
--- a/interpreter/runtime/instance.ml
+++ b/interpreter/runtime/instance.ml
@@ -35,7 +35,7 @@ type Value.ref_ += FuncRef of func_inst
 let () =
   let type_of_ref' = !Value.type_of_ref' in
   Value.type_of_ref' := function
-    | FuncRef f -> `Def (Func.type_inst_of f)
+    | FuncRef f -> DefHT (Func.type_inst_of f)
     | r -> type_of_ref' r
 
 let () =
@@ -59,10 +59,10 @@ let empty_module_inst =
     exports = []; elems = []; datas = [] }
 
 let extern_type_of c = function
-  | ExternFunc func -> (Func.type_of func :> extern_type)
-  | ExternTable tab -> (Table.type_of tab :> extern_type)
-  | ExternMemory mem -> (Memory.type_of mem :> extern_type)
-  | ExternGlobal glob -> (Global.type_of glob :> extern_type)
+  | ExternFunc func -> ExternFuncT (Func.type_of func)
+  | ExternTable tab -> ExternTableT (Table.type_of tab)
+  | ExternMemory mem -> ExternMemoryT (Memory.type_of mem)
+  | ExternGlobal glob -> ExternGlobalT (Global.type_of glob)
 
 let export inst name =
   try Some (List.assoc name inst.exports) with Not_found -> None
diff --git a/interpreter/runtime/memory.ml b/interpreter/runtime/memory.ml
index 5c6810183..226a8f51e 100644
--- a/interpreter/runtime/memory.ml
+++ b/interpreter/runtime/memory.ml
@@ -35,7 +35,7 @@ let create n =
     mem
   with Out_of_memory -> raise OutOfMemory
 
-let alloc (`Memory lim as ty) =
+let alloc (MemoryT lim as ty) =
   if not (valid_limits lim) then raise Type;
   {ty; content = create lim.min}
 
@@ -49,7 +49,7 @@ let type_of mem =
   mem.ty
 
 let grow mem delta =
-  let `Memory lim = mem.ty in
+  let MemoryT lim = mem.ty in
   assert (lim.min = size mem);
   let old_size = lim.min in
   let new_size = Int32.add old_size delta in
@@ -59,7 +59,7 @@ let grow mem delta =
   let after = create new_size in
   let dim = Array1_64.dim mem.content in
   Array1.blit (Array1_64.sub mem.content 0L dim) (Array1_64.sub after 0L dim);
-  mem.ty <- `Memory lim';
+  mem.ty <- MemoryT lim';
   mem.content <- after
 
 let load_byte mem a =
@@ -104,15 +104,15 @@ let storen mem a o n x =
   in loop (effective_address a o) n x
 
 let load_num mem a o t =
-  let n = loadn mem a o (Types.num_size t) in
+  let n = loadn mem a o (num_size t) in
   match t with
-  | `I32 -> I32 (Int64.to_int32 n)
-  | `I64 -> I64 n
-  | `F32 -> F32 (F32.of_bits (Int64.to_int32 n))
-  | `F64 -> F64 (F64.of_bits n)
+  | I32T -> I32 (Int64.to_int32 n)
+  | I64T -> I64 n
+  | F32T -> F32 (F32.of_bits (Int64.to_int32 n))
+  | F64T -> F64 (F64.of_bits n)
 
 let store_num mem a o n =
-  let store = storen mem a o (Types.num_size (Value.type_of_num n)) in
+  let store = storen mem a o (num_size (Value.type_of_num n)) in
   match n with
   | I32 x -> store (Int64.of_int32 x)
   | I64 x -> store x
@@ -128,12 +128,12 @@ let load_num_packed sz ext mem a o t =
   let w = packed_size sz in
   let x = extend (loadn mem a o w) w ext in
   match t with
-  | `I32 -> I32 (Int64.to_int32 x)
-  | `I64 -> I64 x
+  | I32T -> I32 (Int64.to_int32 x)
+  | I64T -> I64 x
   | _ -> raise Type
 
 let store_num_packed sz mem a o n =
-  assert (packed_size sz <= Types.num_size (Value.type_of_num n));
+  assert (packed_size sz <= num_size (Value.type_of_num n));
   let w = packed_size sz in
   let x =
     match n with
@@ -144,8 +144,8 @@ let store_num_packed sz mem a o n =
 
 let load_vec mem a o t =
   match t with
-  | `V128 ->
-    V128 (V128.of_bits (load_bytes mem (effective_address a o) (Types.vec_size t)))
+  | V128T ->
+    V128 (V128.of_bits (load_bytes mem (effective_address a o) (vec_size t)))
 
 let store_vec mem a o n =
   match n with
diff --git a/interpreter/runtime/table.ml b/interpreter/runtime/table.ml
index 1c607ba92..def7bbb13 100644
--- a/interpreter/runtime/table.ml
+++ b/interpreter/runtime/table.ml
@@ -23,7 +23,7 @@ let create size r =
   try Lib.Array32.make size r
   with Out_of_memory | Invalid_argument _ -> raise OutOfMemory
 
-let alloc (`Table (lim, _) as ty) r =
+let alloc (TableT (lim, _t) as ty) r =
   if not (valid_limits lim) then raise Type;
   {ty; content = create lim.min r}
 
@@ -34,7 +34,7 @@ let type_of tab =
   tab.ty
 
 let grow tab delta r =
-  let `Table (lim, t) = tab.ty in
+  let TableT (lim, t) = tab.ty in
   assert (lim.min = size tab);
   let old_size = lim.min in
   let new_size = Int32.add old_size delta in
@@ -43,14 +43,14 @@ let grow tab delta r =
   if not (valid_limits lim') then raise SizeLimit else
   let after = create new_size r in
   Array.blit tab.content 0 after 0 (Array.length tab.content);
-  tab.ty <- `Table (lim', t);
+  tab.ty <- TableT (lim', t);
   tab.content <- after
 
 let load tab i =
   try Lib.Array32.get tab.content i with Invalid_argument _ -> raise Bounds
 
 let store tab i r =
-  let `Table (lim, t) = tab.ty in
+  let TableT (lim, t) = tab.ty in
   if not (Match.Sem.match_ref_type () [] (type_of_ref r) t) then raise Type;
   try Lib.Array32.set tab.content i r with Invalid_argument _ -> raise Bounds
 
diff --git a/interpreter/runtime/value.ml b/interpreter/runtime/value.ml
index b804ac541..6dcaf209d 100644
--- a/interpreter/runtime/value.ml
+++ b/interpreter/runtime/value.ml
@@ -47,28 +47,28 @@ module I32Num =
 struct
   type t = I32.t
   let to_num i = I32 i
-  let of_num n = function I32 i -> i | v -> raise (TypeError (n, v, `I32))
+  let of_num n = function I32 i -> i | v -> raise (TypeError (n, v, I32T))
 end
 
 module I64Num =
 struct
   type t = I64.t
   let to_num i = I64 i
-  let of_num n = function I64 i -> i | v -> raise (TypeError (n, v, `I64))
+  let of_num n = function I64 i -> i | v -> raise (TypeError (n, v, I64T))
 end
 
 module F32Num =
 struct
   type t = F32.t
   let to_num i = F32 i
-  let of_num n = function F32 z -> z | v -> raise (TypeError (n, v, `F32))
+  let of_num n = function F32 z -> z | v -> raise (TypeError (n, v, F32T))
 end
 
 module F64Num =
 struct
   type t = F64.t
   let to_num i = F64 i
-  let of_num n = function F64 z -> z | v -> raise (TypeError (n, v, `F64))
+  let of_num n = function F64 z -> z | v -> raise (TypeError (n, v, F64T))
 end
 
 module type VecType =
@@ -88,24 +88,33 @@ end
 
 (* Typing *)
 
+let type_of_op = function
+  | I32 _ -> Types.I32T
+  | I64 _ -> Types.I64T
+  | F32 _ -> Types.F32T
+  | F64 _ -> Types.F64T
+
+let type_of_vecop = function
+  | V128 _ -> Types.V128T
+
 let type_of_num = function
-  | I32 _ -> `I32
-  | I64 _ -> `I64
-  | F32 _ -> `F32
-  | F64 _ -> `F64
+  | I32 _ -> I32T
+  | I64 _ -> I64T
+  | F32 _ -> F32T
+  | F64 _ -> F64T
 
 let type_of_vec = function
-  | V128 _ -> `V128
+  | V128 _ -> V128T
 
 let type_of_ref' = ref (function _ -> assert false)
 let type_of_ref = function
-  | NullRef t -> `Ref (`Null, t)
-  | r -> `Ref (`NoNull, !type_of_ref' r)
+  | NullRef t -> (Null, t)
+  | r -> (NoNull, !type_of_ref' r)
 
 let type_of_value = function
-  | Num n -> type_of_num n
-  | Vec i -> type_of_vec i
-  | Ref r -> type_of_ref r
+  | Num n -> NumT (type_of_num n)
+  | Vec i -> VecT (type_of_vec i)
+  | Ref r -> RefT (type_of_ref r)
 
 
 (* Comparison *)
@@ -133,23 +142,23 @@ let eq v1 v2 =
 (* Defaults *)
 
 let default_num = function
-  | `I32 -> Some (Num (I32 I32.zero))
-  | `I64 -> Some (Num (I64 I64.zero))
-  | `F32 -> Some (Num (F32 F32.zero))
-  | `F64 -> Some (Num (F64 F64.zero))
+  | I32T -> Some (Num (I32 I32.zero))
+  | I64T -> Some (Num (I64 I64.zero))
+  | F32T -> Some (Num (F32 F32.zero))
+  | F64T -> Some (Num (F64 F64.zero))
 
 let default_vec = function
-  | `V128 -> Some (Vec (V128 V128.zero))
+  | V128T -> Some (Vec (V128 V128.zero))
 
 let default_ref = function
-  | `Ref (`Null, t) -> Some (Ref (NullRef t))
-  | `Ref (`NoNull, _) -> None
+  | (Null, t) -> Some (Ref (NullRef t))
+  | (NoNull, _) -> None
 
 let default_value = function
-  | #num_type as t -> default_num t
-  | #vec_type as t -> default_vec t
-  | #ref_type as t -> default_ref t
-  | `Bot -> assert false
+  | NumT t -> default_num t
+  | VecT t -> default_vec t
+  | RefT t -> default_ref t
+  | BotT -> assert false
 
 
 (* Conversion *)
diff --git a/interpreter/script/import.ml b/interpreter/script/import.ml
index 9a012b4bd..67405b81f 100644
--- a/interpreter/script/import.ml
+++ b/interpreter/script/import.ml
@@ -1,5 +1,6 @@
 open Source
 open Ast
+open Types.Sem
 
 module Unknown = Error.Make ()
 exception Unknown = Unknown.Error  (* indicates unknown import name *)
@@ -9,12 +10,12 @@ let registry = ref Registry.empty
 
 let register name lookup = registry := Registry.add name lookup !registry
 
-let lookup (`Import (et, module_name, item_name)) at : Instance.extern =
+let lookup (ImportT (et, module_name, item_name)) at : Instance.extern =
   try Registry.find module_name !registry item_name et with Not_found ->
     Unknown.error at
       ("unknown import \"" ^ Types.string_of_name module_name ^
         "\".\"" ^ Types.string_of_name item_name ^ "\"")
 
 let link m =
-  let `Module (_, its, _) = Types.Sem.sem_module_type (module_type_of m) in
+  let ModuleT (_, its, _) = Types.Sem.sem_module_type (module_type_of m) in
   List.map2 lookup its (List.map Source.at m.it.imports)
diff --git a/interpreter/script/js.ml b/interpreter/script/js.ml
index 0fa52caa7..b6155483c 100644
--- a/interpreter/script/js.ml
+++ b/interpreter/script/js.ml
@@ -203,7 +203,7 @@ type modules = {mutable env : exports Map.t; mutable current : int}
 
 let exports m : exports =
   let ets = List.map (export_type_of m) m.it.exports in
-  List.fold_left (fun map (`Export (et, name)) -> NameMap.add name et map)
+  List.fold_left (fun map (ExportT (et, name)) -> NameMap.add name et map)
     NameMap.empty ets
 
 let modules () : modules = {env = Map.empty; current = 0}
@@ -241,35 +241,36 @@ let _eq_funcref_idx = 5l
 let subject_type_idx = 6l
 
 let eq_of = function
-  | `I32 -> I32 I32Op.Eq
-  | `I64 -> I64 I64Op.Eq
-  | `F32 -> F32 F32Op.Eq
-  | `F64 -> F64 F64Op.Eq
+  | I32T -> I32 I32Op.Eq
+  | I64T -> I64 I64Op.Eq
+  | F32T -> F32 F32Op.Eq
+  | F64T -> F64 F64Op.Eq
 
 let and_of = function
-  | `I32 | `F32 -> I32 I32Op.And
-  | `I64 | `F64 -> I64 I64Op.And
+  | I32T | F32T -> I32 I32Op.And
+  | I64T | F64T -> I64 I64Op.And
 
 let reinterpret_of = function
-  | `I32 -> `I32, Nop
-  | `I64 -> `I64, Nop
-  | `F32 -> `I32, Convert (I32 I32Op.ReinterpretFloat)
-  | `F64 -> `I64, Convert (I64 I64Op.ReinterpretFloat)
+  | I32T -> I32T, Nop
+  | I64T -> I64T, Nop
+  | F32T -> I32T, Convert (I32 I32Op.ReinterpretFloat)
+  | F64T -> I64T, Convert (I64 I64Op.ReinterpretFloat)
 
 let canonical_nan_of = function
-  | `I32 | `F32 -> I32 (F32.to_bits F32.pos_nan)
-  | `I64 | `F64 -> I64 (F64.to_bits F64.pos_nan)
+  | I32T | F32T -> I32 (F32.to_bits F32.pos_nan)
+  | I64T | F64T -> I64 (F64.to_bits F64.pos_nan)
 
 let abs_mask_of = function
-  | `I32 | `F32 -> I32 Int32.max_int
-  | `I64 | `F64 -> I64 Int64.max_int
+  | I32T | F32T -> I32 Int32.max_int
+  | I64T | F64T -> I64 Int64.max_int
 
 let null_heap_type_of = function
-  | (`Func | `Extern) as t -> t
-  | `Bot -> assert false
-  | `Def x ->
+  | Types.Sem.FuncHT -> FuncHT
+  | Types.Sem.ExternHT -> ExternHT
+  | Types.Sem.BotHT -> assert false
+  | Types.Sem.DefHT x ->
     match Types.Sem.def_of x with
-    | #Types.Sem.func_type -> `Func
+    | Types.Sem.DefFuncT _ -> FuncHT
 
 let value v =
   match v.it with
@@ -281,7 +282,7 @@ let value v =
   | Ref _ -> assert false
 
 let invoke ft vs at =
-  [(ft :> def_type) @@ at], FuncImport (subject_type_idx @@ at) @@ at,
+  [DefFuncT ft @@ at], FuncImport (subject_type_idx @@ at) @@ at,
   List.concat (List.map value vs) @ [Call (subject_idx @@ at) @@ at]
 
 let get t at =
@@ -298,7 +299,7 @@ let assert_return ress ts at =
   let test (res, t) =
     match res.it with
     | NumResult (NumPat {it = num; at = at'}) ->
-      let t', reinterpret = reinterpret_of (Value.type_of_num num) in
+      let t', reinterpret = reinterpret_of (Value.type_of_op num) in
       [ reinterpret @@ at;
         Const (num @@ at')  @@ at;
         reinterpret @@ at;
@@ -311,8 +312,7 @@ let assert_return ress ts at =
         | Value.I32 _ | Value.I64 _ -> .
         | Value.F32 n | Value.F64 n -> n
       in
-      let t = Value.type_of_num nanop.it in
-      let t', reinterpret = reinterpret_of t in
+      let t', reinterpret = reinterpret_of (Value.type_of_op nanop.it) in
       [ reinterpret @@ at;
         Const (nan_bitmask_of nan t' @@ at) @@ at;
         Binary (and_of t') @@ at;
@@ -330,9 +330,9 @@ let assert_return ress ts at =
         | NumPat {it = F64 f; _} ->
           I64 (Int64.minus_one), I64 (I64_convert.reinterpret_f64 f)
         | NanPat {it = F32 nan; _} ->
-          nan_bitmask_of nan `I32, canonical_nan_of `I32
+          nan_bitmask_of nan I32T, canonical_nan_of I32T
         | NanPat {it = F64 nan; _} ->
-          nan_bitmask_of nan `I64, canonical_nan_of `I64
+          nan_bitmask_of nan I64T, canonical_nan_of I64T
         | _ -> .
       in
       let masks, canons =
@@ -378,37 +378,38 @@ let assert_return ress ts at =
     | RefResult (RefTypePat t) ->
       let is_ref_idx =
         match t with
-        | `Func -> is_funcref_idx
-        | `Extern -> is_externref_idx
-        | `Def _ -> is_funcref_idx
-        | `Bot -> assert false
+        | FuncHT -> is_funcref_idx
+        | ExternHT -> is_externref_idx
+        | DefHT _ -> is_funcref_idx
+        | BotHT -> assert false
       in
       [ Call (is_ref_idx @@ at) @@ at;
         Test (I32 I32Op.Eqz) @@ at;
         BrIf (0l @@ at) @@ at ]
     | RefResult NullPat ->
       (match t with
-      | `Ref _ ->
+      | RefT _ ->
         [ BrOnNull (0l @@ at) @@ at ]
       | _ ->
         [ Br (0l @@ at) @@ at ]
       )
   in [], List.flatten (List.rev_map test (List.combine ress ts))
 
-let funcref = `Ref (`Null, `Func)
-let externref = `Ref (`Null, `Extern)
-let func_def_type ts1 ts2 at = `Func (ts1, ts2) @@ at
+let i32 = NumT I32T
+let funcref = RefT (Null, FuncHT)
+let externref = RefT (Null, ExternHT)
+let func_def_type ts1 ts2 at = DefFuncT (FuncT (ts1, ts2)) @@ at
 
 let wrap item_name wrap_action wrap_assertion at =
   let itypes, idesc, action = wrap_action at in
   let locals, assertion = wrap_assertion at in
   let types =
     func_def_type [] [] at ::
-    func_def_type [`I32] [externref] at ::
-    func_def_type [externref] [`I32] at ::
-    func_def_type [funcref] [`I32] at ::
-    func_def_type [externref; externref] [`I32] at ::
-    func_def_type [funcref; funcref] [`I32] at ::
+    func_def_type [i32] [externref] at ::
+    func_def_type [externref] [i32] at ::
+    func_def_type [funcref] [i32] at ::
+    func_def_type [externref; externref] [i32] at ::
+    func_def_type [funcref; funcref] [i32] at ::
     itypes
   in
   let imports =
@@ -442,20 +443,20 @@ let wrap item_name wrap_action wrap_assertion at =
 
 
 let is_js_num_type = function
-  | `I32 -> true
-  | `I64 | `F32 | `F64 -> false
+  | I32T -> true
+  | I64T | F32T | F64T -> false
 
 let is_js_val_type = function
-  | #num_type as t -> is_js_num_type t
-  | #vec_type -> false
-  | #ref_type -> true
-  | `Bot -> assert false
+  | NumT t -> is_js_num_type t
+  | VecT _ -> false
+  | RefT _ -> true
+  | BotT -> assert false
 
 let is_js_global_type = function
-  | `Global (mut, t) -> is_js_val_type t && mut = `Const
+  | GlobalT (mut, t) -> is_js_val_type t && mut = Cons
 
 let is_js_func_type = function
-  | `Func (ts1, ts2) -> List.for_all is_js_val_type (ts1 @ ts2)
+  | FuncT (ts1, ts2) -> List.for_all is_js_val_type (ts1 @ ts2)
 
 
 (* Script conversion *)
@@ -564,16 +565,16 @@ let of_action mods act =
     "call(" ^ of_var_opt mods x_opt ^ ", " ^ of_name name ^ ", " ^
       "[" ^ String.concat ", " (List.map of_value vs) ^ "])",
     (match lookup mods x_opt name act.at with
-    | #func_type as ft when not (is_js_func_type ft) ->
-      let `Func (_, out) = ft in
-      Some (of_wrapper mods x_opt name (invoke ft vs), out)
+    | ExternFuncT ft when not (is_js_func_type ft) ->
+      let FuncT (_, ts) = ft in
+      Some (of_wrapper mods x_opt name (invoke ft vs), ts)
     | _ -> None
     )
   | Get (x_opt, name) ->
     "get(" ^ of_var_opt mods x_opt ^ ", " ^ of_name name ^ ")",
     (match lookup mods x_opt name act.at with
-    | #global_type as gt when not (is_js_global_type gt) ->
-      let `Global (_, t) = gt in
+    | ExternGlobalT gt when not (is_js_global_type gt) ->
+      let GlobalT (_, t) = gt in
       Some (of_wrapper mods x_opt name (get gt), [t])
     | _ -> None
     )
diff --git a/interpreter/script/run.ml b/interpreter/script/run.ml
index 3834ee083..31883822e 100644
--- a/interpreter/script/run.ml
+++ b/interpreter/script/run.ml
@@ -227,13 +227,14 @@ let string_of_nan = function
   | ArithmeticNan -> "nan:arithmetic"
 
 let type_of_result r =
+  let open Types.Sem in
   match r with
-  | NumResult (NumPat n) -> Value.type_of_num n.it
-  | NumResult (NanPat n) -> Value.type_of_num n.it
-  | VecResult (VecPat v) -> Value.type_of_vec v
-  | RefResult (RefPat r) -> Value.type_of_ref r.it
-  | RefResult (RefTypePat t) -> `Ref (`NoNull, Types.Sem.sem_heap_type [] t)
-  | RefResult (NullPat) -> `Ref (`Null, `Extern)
+  | NumResult (NumPat n) -> NumT (Value.type_of_num n.it)
+  | NumResult (NanPat n) -> NumT (Value.type_of_num n.it)
+  | VecResult (VecPat v) -> VecT (Value.type_of_vec v)
+  | RefResult (RefPat r) -> RefT (Value.type_of_ref r.it)
+  | RefResult (RefTypePat t) -> RefT (NoNull, sem_heap_type [] t)
+  | RefResult (NullPat) -> RefT (Null, ExternHT)
 
 let string_of_num_pat (p : num_pat) =
   match p with
@@ -324,7 +325,7 @@ let run_action act : Value.t list =
     let inst = lookup_instance x_opt act.at in
     (match Instance.export inst name with
     | Some (Instance.ExternFunc f) ->
-      let `Func (ts1, _ts2) = Func.type_of f in
+      let Types.Sem.FuncT (ts1, _ts2) = Func.type_of f in
       if List.length vs <> List.length ts1 then
         Script.error act.at "wrong number of arguments";
       List.iter2 (fun v t ->
@@ -381,8 +382,8 @@ let assert_vec_pat v p =
 let assert_ref_pat r p =
   match r, p with
   | r, RefPat r' -> Value.eq_ref r r'.it
-  | Instance.FuncRef _, RefTypePat `Func
-  | ExternRef _, RefTypePat `Extern -> true
+  | Instance.FuncRef _, RefTypePat Types.FuncHT
+  | ExternRef _, RefTypePat Types.ExternHT -> true
   | Value.NullRef _, NullPat -> true
   | _ -> false
 
diff --git a/interpreter/script/script.ml b/interpreter/script/script.ml
index 6847c5cf8..0d110505a 100644
--- a/interpreter/script/script.ml
+++ b/interpreter/script/script.ml
@@ -70,7 +70,7 @@ exception Syntax of Source.region * string
 let () =
   let type_of_ref' = !Value.type_of_ref' in
   Value.type_of_ref' := function
-    | ExternRef _ -> `Extern
+    | ExternRef _ -> Types.Sem.ExternHT
     | r -> type_of_ref' r
 
 let () =
diff --git a/interpreter/syntax/ast.ml b/interpreter/syntax/ast.ml
index 80bb02c62..b8356acf1 100644
--- a/interpreter/syntax/ast.ml
+++ b/interpreter/syntax/ast.ml
@@ -350,11 +350,11 @@ let import_type_of (m : module_) (im : import) : import_type =
   let {idesc; module_name; item_name} = im.it in
   let et =
     match idesc.it with
-    | FuncImport x -> (func_type_of m x :> extern_type)
-    | TableImport t -> (t :> extern_type)
-    | MemoryImport t -> (t :> extern_type)
-    | GlobalImport t -> (t :> extern_type)
-  in `Import (et, module_name, item_name)
+    | FuncImport x -> ExternFuncT (func_type_of m x)
+    | TableImport t -> ExternTableT t
+    | MemoryImport t -> ExternMemoryT t
+    | GlobalImport t -> ExternGlobalT t
+  in ImportT (et, module_name, item_name)
 
 let export_type_of (m : module_) (ex : export) : export_type =
   let {edesc; name} = ex.it in
@@ -366,20 +366,20 @@ let export_type_of (m : module_) (ex : export) : export_type =
     | FuncExport x ->
       let fts =
         funcs ets @ List.map (fun f -> func_type_of m f.it.ftype) m.it.funcs
-      in (nth fts x.it :> extern_type)
+      in ExternFuncT (nth fts x.it)
     | TableExport x ->
       let tts = tables ets @ List.map (fun t -> t.it.ttype) m.it.tables in
-      (nth tts x.it :> extern_type)
+      ExternTableT (nth tts x.it)
     | MemoryExport x ->
       let mts = memories ets @ List.map (fun m -> m.it.mtype) m.it.memories in
-      (nth mts x.it :> extern_type)
+      ExternMemoryT (nth mts x.it)
     | GlobalExport x ->
       let gts = globals ets @ List.map (fun g -> g.it.gtype) m.it.globals in
-      (nth gts x.it :> extern_type)
-  in `Export (et, name)
+      ExternGlobalT (nth gts x.it)
+  in ExportT (et, name)
 
 let module_type_of (m : module_) : module_type =
   let dts = List.map Source.it m.it.types in
   let its = List.map (import_type_of m) m.it.imports in
   let ets = List.map (export_type_of m) m.it.exports in
-  `Module (dts, its, ets)
+  ModuleT (dts, its, ets)
diff --git a/interpreter/syntax/free.ml b/interpreter/syntax/free.ml
index 8fc15a1ce..8793e28b2 100644
--- a/interpreter/syntax/free.ml
+++ b/interpreter/syntax/free.ml
@@ -66,31 +66,31 @@ let var_type = function
   | x -> types (idx' x)
 
 let num_type = function
-  | `I32 | `I64 | `F32 | `F64 -> empty
+  | I32T | I64T | F32T | F64T -> empty
 
 let vec_type = function
-  | `V128 -> empty
+  | V128T -> empty
 
 let heap_type = function
-  | `Func | `Extern | `Bot -> empty
-  | `Def x -> var_type x
+  | FuncHT | ExternHT | BotHT -> empty
+  | DefHT x -> var_type x
 
 let ref_type = function
-  | `Ref (_, t) -> heap_type t
+  | (_, t) -> heap_type t
 
 let val_type = function
-  | #num_type as t -> num_type t
-  | #vec_type as t -> vec_type t
-  | #ref_type as t -> ref_type t
-  | `Bot -> empty
+  | NumT t -> num_type t
+  | VecT t -> vec_type t
+  | RefT t -> ref_type t
+  | BotT -> empty
 
-let func_type (`Func (ins, out)) = list val_type ins ++ list val_type out
-let global_type (`Global (_mut, t)) = val_type t
-let table_type (`Table (_lim, t)) = ref_type t
-let memory_type (`Memory (_lim)) = empty
+let func_type (FuncT (ins, out)) = list val_type ins ++ list val_type out
+let global_type (GlobalT (_mut, t)) = val_type t
+let table_type (TableT (_lim, t)) = ref_type t
+let memory_type (MemoryT (_lim)) = empty
 
 let def_type = function
-  | #func_type as ft -> func_type ft
+  | DefFuncT ft -> func_type ft
 
 let block_type = function
   | VarBlockType x -> var_type x
diff --git a/interpreter/syntax/operators.ml b/interpreter/syntax/operators.ml
index 33a72ae31..ecc86a9ba 100644
--- a/interpreter/syntax/operators.ml
+++ b/interpreter/syntax/operators.ml
@@ -2,8 +2,10 @@ open Source
 open Value
 open V128
 open Ast
+open Types
 open Pack
 
+(* Instructions *)
 
 let i32_const n = Const (I32 n.it @@ n.at)
 let i64_const n = Const (I64 n.it @@ n.at)
@@ -49,45 +51,45 @@ let table_copy x y = TableCopy (x, y)
 let table_init x y = TableInit (x, y)
 let elem_drop x = ElemDrop x
 
-let i32_load align offset = Load {ty = `I32; align; offset; pack = None}
-let i64_load align offset = Load {ty = `I64; align; offset; pack = None}
-let f32_load align offset = Load {ty = `F32; align; offset; pack = None}
-let f64_load align offset = Load {ty = `F64; align; offset; pack = None}
+let i32_load align offset = Load {ty = I32T; align; offset; pack = None}
+let i64_load align offset = Load {ty = I64T; align; offset; pack = None}
+let f32_load align offset = Load {ty = F32T; align; offset; pack = None}
+let f64_load align offset = Load {ty = F64T; align; offset; pack = None}
 let i32_load8_s align offset =
-  Load {ty = `I32; align; offset; pack = Some (Pack8, SX)}
+  Load {ty = I32T; align; offset; pack = Some (Pack8, SX)}
 let i32_load8_u align offset =
-  Load {ty = `I32; align; offset; pack = Some (Pack8, ZX)}
+  Load {ty = I32T; align; offset; pack = Some (Pack8, ZX)}
 let i32_load16_s align offset =
-  Load {ty = `I32; align; offset; pack = Some (Pack16, SX)}
+  Load {ty = I32T; align; offset; pack = Some (Pack16, SX)}
 let i32_load16_u align offset =
-  Load {ty = `I32; align; offset; pack = Some (Pack16, ZX)}
+  Load {ty = I32T; align; offset; pack = Some (Pack16, ZX)}
 let i64_load8_s align offset =
-  Load {ty = `I64; align; offset; pack = Some (Pack8, SX)}
+  Load {ty = I64T; align; offset; pack = Some (Pack8, SX)}
 let i64_load8_u align offset =
-  Load {ty = `I64; align; offset; pack = Some (Pack8, ZX)}
+  Load {ty = I64T; align; offset; pack = Some (Pack8, ZX)}
 let i64_load16_s align offset =
-  Load {ty = `I64; align; offset; pack = Some (Pack16, SX)}
+  Load {ty = I64T; align; offset; pack = Some (Pack16, SX)}
 let i64_load16_u align offset =
-  Load {ty = `I64; align; offset; pack = Some (Pack16, ZX)}
+  Load {ty = I64T; align; offset; pack = Some (Pack16, ZX)}
 let i64_load32_s align offset =
-  Load {ty = `I64; align; offset; pack = Some (Pack32, SX)}
+  Load {ty = I64T; align; offset; pack = Some (Pack32, SX)}
 let i64_load32_u align offset =
-  Load {ty = `I64; align; offset; pack = Some (Pack32, ZX)}
+  Load {ty = I64T; align; offset; pack = Some (Pack32, ZX)}
 
-let i32_store align offset = Store {ty = `I32; align; offset; pack = None}
-let i64_store align offset = Store {ty = `I64; align; offset; pack = None}
-let f32_store align offset = Store {ty = `F32; align; offset; pack = None}
-let f64_store align offset = Store {ty = `F64; align; offset; pack = None}
+let i32_store align offset = Store {ty = I32T; align; offset; pack = None}
+let i64_store align offset = Store {ty = I64T; align; offset; pack = None}
+let f32_store align offset = Store {ty = F32T; align; offset; pack = None}
+let f64_store align offset = Store {ty = F64T; align; offset; pack = None}
 let i32_store8 align offset =
-  Store {ty = `I32; align; offset; pack = Some Pack8}
+  Store {ty = I32T; align; offset; pack = Some Pack8}
 let i32_store16 align offset =
-  Store {ty = `I32; align; offset; pack = Some Pack16}
+  Store {ty = I32T; align; offset; pack = Some Pack16}
 let i64_store8 align offset =
-  Store {ty = `I64; align; offset; pack = Some Pack8}
+  Store {ty = I64T; align; offset; pack = Some Pack8}
 let i64_store16 align offset =
-  Store {ty = `I64; align; offset; pack = Some Pack16}
+  Store {ty = I64T; align; offset; pack = Some Pack16}
 let i64_store32 align offset =
-  Store {ty = `I64; align; offset; pack = Some Pack32}
+  Store {ty = I64T; align; offset; pack = Some Pack32}
 
 let memory_size = MemorySize
 let memory_grow = MemoryGrow
@@ -241,51 +243,51 @@ let i64_reinterpret_f64 = Convert (I64 I64Op.ReinterpretFloat)
 let f32_reinterpret_i32 = Convert (F32 F32Op.ReinterpretInt)
 let f64_reinterpret_i64 = Convert (F64 F64Op.ReinterpretInt)
 
-let v128_load align offset = VecLoad {ty = `V128; align; offset; pack = None}
+let v128_load align offset = VecLoad {ty = V128T; align; offset; pack = None}
 let v128_load8x8_s align offset =
-  VecLoad {ty = `V128; align; offset; pack = Some (Pack64, ExtLane (Pack8x8, SX))}
+  VecLoad {ty = V128T; align; offset; pack = Some (Pack64, ExtLane (Pack8x8, SX))}
 let v128_load8x8_u align offset =
-  VecLoad {ty = `V128; align; offset; pack = Some (Pack64, ExtLane (Pack8x8, ZX))}
+  VecLoad {ty = V128T; align; offset; pack = Some (Pack64, ExtLane (Pack8x8, ZX))}
 let v128_load16x4_s align offset =
-  VecLoad {ty = `V128; align; offset; pack = Some (Pack64, ExtLane (Pack16x4, SX))}
+  VecLoad {ty = V128T; align; offset; pack = Some (Pack64, ExtLane (Pack16x4, SX))}
 let v128_load16x4_u align offset =
-  VecLoad {ty = `V128; align; offset; pack = Some (Pack64, ExtLane (Pack16x4, ZX))}
+  VecLoad {ty = V128T; align; offset; pack = Some (Pack64, ExtLane (Pack16x4, ZX))}
 let v128_load32x2_s align offset =
-  VecLoad {ty = `V128; align; offset; pack = Some (Pack64, ExtLane (Pack32x2, SX))}
+  VecLoad {ty = V128T; align; offset; pack = Some (Pack64, ExtLane (Pack32x2, SX))}
 let v128_load32x2_u align offset =
-  VecLoad {ty = `V128; align; offset; pack = Some (Pack64, ExtLane (Pack32x2, ZX))}
+  VecLoad {ty = V128T; align; offset; pack = Some (Pack64, ExtLane (Pack32x2, ZX))}
 let v128_load8_splat align offset =
-  VecLoad {ty = `V128; align; offset; pack = Some (Pack8, ExtSplat)}
+  VecLoad {ty = V128T; align; offset; pack = Some (Pack8, ExtSplat)}
 let v128_load16_splat align offset =
-  VecLoad {ty = `V128; align; offset; pack = Some (Pack16, ExtSplat)}
+  VecLoad {ty = V128T; align; offset; pack = Some (Pack16, ExtSplat)}
 let v128_load32_splat align offset =
-  VecLoad {ty = `V128; align; offset; pack = Some (Pack32, ExtSplat)}
+  VecLoad {ty = V128T; align; offset; pack = Some (Pack32, ExtSplat)}
 let v128_load64_splat align offset =
-  VecLoad {ty = `V128; align; offset; pack = Some (Pack64, ExtSplat)}
+  VecLoad {ty = V128T; align; offset; pack = Some (Pack64, ExtSplat)}
 let v128_load32_zero align offset =
-  VecLoad {ty = `V128; align; offset; pack = Some (Pack32, ExtZero)}
+  VecLoad {ty = V128T; align; offset; pack = Some (Pack32, ExtZero)}
 let v128_load64_zero align offset =
-  VecLoad {ty = `V128; align; offset; pack = Some (Pack64, ExtZero)}
+  VecLoad {ty = V128T; align; offset; pack = Some (Pack64, ExtZero)}
 
-let v128_store align offset = VecStore {ty = `V128; align; offset; pack = ()}
+let v128_store align offset = VecStore {ty = V128T; align; offset; pack = ()}
 
 let v128_load8_lane align offset i =
-  VecLoadLane ({ty = `V128; align; offset; pack = Pack8}, i)
+  VecLoadLane ({ty = V128T; align; offset; pack = Pack8}, i)
 let v128_load16_lane align offset i =
-  VecLoadLane ({ty = `V128; align; offset; pack = Pack16}, i)
+  VecLoadLane ({ty = V128T; align; offset; pack = Pack16}, i)
 let v128_load32_lane align offset i =
-  VecLoadLane ({ty = `V128; align; offset; pack = Pack32}, i)
+  VecLoadLane ({ty = V128T; align; offset; pack = Pack32}, i)
 let v128_load64_lane align offset i =
-  VecLoadLane ({ty = `V128; align; offset; pack = Pack64}, i)
+  VecLoadLane ({ty = V128T; align; offset; pack = Pack64}, i)
 
 let v128_store8_lane align offset i =
-  VecStoreLane ({ty = `V128; align; offset; pack = Pack8}, i)
+  VecStoreLane ({ty = V128T; align; offset; pack = Pack8}, i)
 let v128_store16_lane align offset i =
-  VecStoreLane ({ty = `V128; align; offset; pack = Pack16}, i)
+  VecStoreLane ({ty = V128T; align; offset; pack = Pack16}, i)
 let v128_store32_lane align offset i =
-  VecStoreLane ({ty = `V128; align; offset; pack = Pack32}, i)
+  VecStoreLane ({ty = V128T; align; offset; pack = Pack32}, i)
 let v128_store64_lane align offset i =
-  VecStoreLane ({ty = `V128; align; offset; pack = Pack64}, i)
+  VecStoreLane ({ty = V128T; align; offset; pack = Pack64}, i)
 
 let v128_not = VecUnaryBits (V128 V128Op.Not)
 let v128_and = VecBinaryBits (V128 V128Op.And)
diff --git a/interpreter/syntax/types.ml b/interpreter/syntax/types.ml
index 154b78905..05f7833f5 100644
--- a/interpreter/syntax/types.ml
+++ b/interpreter/syntax/types.ml
@@ -1,27 +1,3 @@
-(* Indices and Names *)
-
-type type_idx = int32
-type local_idx = int32
-type name = Utf8.unicode
-
-let string_of_idx x =
-  I32.to_string_u x
-
-let string_of_name n =
-  let b = Buffer.create 16 in
-  let escape uc =
-    if uc < 0x20 || uc >= 0x7f then
-      Buffer.add_string b (Printf.sprintf "\\u{%02x}" uc)
-    else begin
-      let c = Char.chr uc in
-      if c = '\"' || c = '\\' then Buffer.add_char b '\\';
-      Buffer.add_char b c
-    end
-  in
-  List.iter escape n;
-  Buffer.contents b
-
-
 (* Generic Types *)
 
 module type Var =
@@ -35,123 +11,149 @@ module Make (Var : Var) =
 struct
   include Var
 
-  type init = [`Set | `Unset]
-  type nullability = [`NoNull | `Null]
-  type num_type = [`I32 | `I64 | `F32 | `F64]
-  type vec_type = [`V128]
-  type heap_type = [`Func | `Extern | `Def of var | `Bot]
-  type ref_type = [`Ref of nullability * heap_type]
-  type val_type = [num_type | vec_type | ref_type | `Bot]
-
-  type result_type = val_type list
-  type instr_type = [`Instr of result_type * result_type * local_idx list]
-  type func_type = [`Func of result_type * result_type]
-  type def_type = func_type
+  type type_idx = int32
+  type local_idx = int32
+  type name = Utf8.unicode
 
+  type null = NoNull | Null
+  type mut = Cons | Var
+  type init = Set | Unset
   type 'a limits = {min : 'a; max : 'a option}
-  type mutability = [`Const | `Var]
-  type table_type = [`Table of Int32.t limits * ref_type]
-  type memory_type = [`Memory of Int32.t limits]
-  type global_type = [`Global of mutability * val_type]
-  type local_type = [`Local of init * val_type]
-  type extern_type = [func_type | table_type | memory_type | global_type]
-
-  type export_type = [`Export of extern_type * name]
-  type import_type = [`Import of extern_type * name * name]
+
+  type num_type = I32T | I64T | F32T | F64T
+  type vec_type = V128T
+  type heap_type = FuncHT | ExternHT | DefHT of var | BotHT
+  type ref_type = null * heap_type
+  type val_type = NumT of num_type | VecT of vec_type | RefT of ref_type | BotT
+
+  type result_type = val_type list
+  type instr_type = InstrT of result_type * result_type * local_idx list
+  type func_type = FuncT of result_type * result_type
+  type def_type = DefFuncT of func_type
+
+  type table_type = TableT of Int32.t limits * ref_type
+  type memory_type = MemoryT of Int32.t limits
+  type global_type = GlobalT of mut * val_type
+  type local_type = LocalT of init * val_type
+  type extern_type =
+    | ExternFuncT of func_type
+    | ExternTableT of table_type
+    | ExternMemoryT of memory_type
+    | ExternGlobalT of global_type
+
+  type export_type = ExportT of extern_type * name
+  type import_type = ImportT of extern_type * name * name
   type module_type =
-    [`Module of def_type list * import_type list * export_type list]
+    | ModuleT of def_type list * import_type list * export_type list
 
 
   (* Attributes *)
 
   let num_size : num_type -> int = function
-    | `I32 | `F32 -> 4
-    | `I64 | `F64 -> 8
+    | I32T | F32T -> 4
+    | I64T | F64T -> 8
 
   let vec_size : vec_type -> int = function
-    | `V128 -> 16
+    | V128T -> 16
 
   let is_num_type : val_type -> bool = function
-    | #num_type | `Bot -> true
+    | NumT _ | BotT -> true
     | _ -> false
 
   let is_vec_type : val_type -> bool = function
-    | #vec_type | `Bot -> true
+    | VecT _ | BotT -> true
     | _ -> false
 
   let is_ref_type : val_type -> bool = function
-    | #ref_type | `Bot -> true
+    | RefT _ | BotT -> true
     | _ -> false
 
-  let defaultable : [< val_type] -> bool = function
-    | #num_type -> true
-    | #vec_type -> true
-    | `Ref (nul, _) -> nul = `Null
-    | `Bot -> assert false
+  let defaultable : val_type -> bool = function
+    | NumT _ -> true
+    | VecT _ -> true
+    | RefT (nul, _) -> nul = Null
+    | BotT -> assert false
 
 
   (* Projections *)
 
   let as_func_def_type (dt : def_type) : func_type =
     match dt with
-    | #func_type as ft -> ft
+    | DefFuncT ft -> ft
 
-  let extern_type_of_import_type (`Import (et, _, _)) = et
-  let extern_type_of_export_type (`Export (et, _)) = et
+  let extern_type_of_import_type (ImportT (et, _, _)) = et
+  let extern_type_of_export_type (ExportT (et, _)) = et
 
 
   (* Filters *)
 
   let funcs (ets : extern_type list) : func_type list =
-    Lib.List.map_filter (function #func_type as ft -> Some ft | _ -> None) ets
+    Lib.List.map_filter (function ExternFuncT ft -> Some ft | _ -> None) ets
   let tables (ets : extern_type list) : table_type list =
-    Lib.List.map_filter (function #table_type as tt -> Some tt | _ -> None) ets
+    Lib.List.map_filter (function ExternTableT tt -> Some tt | _ -> None) ets
   let memories (ets : extern_type list) : memory_type list =
-    Lib.List.map_filter (function #memory_type as mt -> Some mt | _ -> None) ets
+    Lib.List.map_filter (function ExternMemoryT mt -> Some mt | _ -> None) ets
   let globals (ets : extern_type list) : global_type list =
-    Lib.List.map_filter (function #global_type as gt -> Some gt | _ -> None) ets
+    Lib.List.map_filter (function ExternGlobalT gt -> Some gt | _ -> None) ets
 
 
   (* String conversion *)
 
-  let string_of_nullability : nullability -> string = function
-    | `NoNull -> ""
-    | `Null -> "null "
+  let string_of_idx x =
+    I32.to_string_u x
+
+  let string_of_name n =
+    let b = Buffer.create 16 in
+    let escape uc =
+      if uc < 0x20 || uc >= 0x7f then
+        Buffer.add_string b (Printf.sprintf "\\u{%02x}" uc)
+      else begin
+        let c = Char.chr uc in
+        if c = '\"' || c = '\\' then Buffer.add_char b '\\';
+        Buffer.add_char b c
+      end
+    in
+    List.iter escape n;
+    Buffer.contents b
+
+  let string_of_null : null -> string = function
+    | NoNull -> ""
+    | Null -> "null "
 
   let string_of_num_type : num_type -> string = function
-    | `I32 -> "i32"
-    | `I64 -> "i64"
-    | `F32 -> "f32"
-    | `F64 -> "f64"
+    | I32T -> "i32"
+    | I64T -> "i64"
+    | F32T -> "f32"
+    | F64T -> "f64"
 
   let string_of_vec_type : vec_type -> string = function
-    | `V128 -> "v128"
+    | V128T -> "v128"
 
   let string_of_heap_type : heap_type -> string = function
-    | `Func -> "func"
-    | `Extern -> "extern"
-    | `Def x -> string_of_var x
-    | `Bot -> "something"
+    | FuncHT -> "func"
+    | ExternHT -> "extern"
+    | DefHT x -> string_of_var x
+    | BotHT -> "something"
 
   let string_of_ref_type : ref_type -> string = function
-    | `Ref (nul, t) ->
-      "(ref " ^ string_of_nullability nul ^ string_of_heap_type t ^ ")"
+    | (nul, t) ->
+      "(ref " ^ string_of_null nul ^ string_of_heap_type t ^ ")"
 
   let string_of_val_type : val_type -> string = function
-    | #num_type as t -> string_of_num_type t
-    | #vec_type as t -> string_of_vec_type t
-    | #ref_type as t -> string_of_ref_type t
-    | `Bot -> "(something)"
+    | NumT t -> string_of_num_type t
+    | VecT t -> string_of_vec_type t
+    | RefT t -> string_of_ref_type t
+    | BotT -> "(something)"
 
   let string_of_result_type : result_type -> string = function
     | ts -> "[" ^ String.concat " " (List.map string_of_val_type ts) ^ "]"
 
   let string_of_func_type : func_type -> string = function
-    | `Func (ts1, ts2) ->
+    | FuncT (ts1, ts2) ->
       string_of_result_type ts1 ^ " -> " ^ string_of_result_type ts2
 
   let string_of_def_type : def_type -> string = function
-    | #func_type as ft -> "func " ^ string_of_func_type ft
+    | DefFuncT ft -> "func " ^ string_of_func_type ft
 
 
   let string_of_limits : I32.t limits -> string = function
@@ -160,37 +162,37 @@ struct
       (match max with None -> "" | Some n -> " " ^ I32.to_string_u n)
 
   let string_of_memory_type : memory_type -> string = function
-    | `Memory lim -> string_of_limits lim
+    | MemoryT lim -> string_of_limits lim
 
   let string_of_table_type : table_type -> string = function
-    | `Table (lim, t) -> string_of_limits lim ^ " " ^ string_of_ref_type t
+    | TableT (lim, t) -> string_of_limits lim ^ " " ^ string_of_ref_type t
 
   let string_of_global_type : global_type -> string = function
-    | `Global (`Const, t) -> string_of_val_type t
-    | `Global (`Var, t) -> "(mut " ^ string_of_val_type t ^ ")"
+    | GlobalT (Cons, t) -> string_of_val_type t
+    | GlobalT (Var, t) -> "(mut " ^ string_of_val_type t ^ ")"
 
   let string_of_local_type : local_type -> string = function
-    | `Local (`Set, t) -> string_of_val_type t
-    | `Local (`Unset, t) -> "(unset " ^ string_of_val_type t ^ ")"
+    | LocalT (Set, t) -> string_of_val_type t
+    | LocalT (Unset, t) -> "(unset " ^ string_of_val_type t ^ ")"
 
   let string_of_extern_type : extern_type -> string = function
-    | #func_type as ft -> "func " ^ string_of_func_type ft
-    | #table_type as tt -> "table " ^ string_of_table_type tt
-    | #memory_type as mt -> "memory " ^ string_of_memory_type mt
-    | #global_type as gt -> "global " ^ string_of_global_type gt
+    | ExternFuncT ft -> "func " ^ string_of_func_type ft
+    | ExternTableT tt -> "table " ^ string_of_table_type tt
+    | ExternMemoryT mt -> "memory " ^ string_of_memory_type mt
+    | ExternGlobalT gt -> "global " ^ string_of_global_type gt
 
 
   let string_of_export_type : export_type -> string = function
-    | `Export (et, name) ->
+    | ExportT (et, name) ->
       "\"" ^ string_of_name name ^ "\" : " ^ string_of_extern_type et
 
   let string_of_import_type : import_type -> string = function
-    | `Import (et, module_name, name) ->
+    | ImportT (et, module_name, name) ->
       "\"" ^ string_of_name module_name ^ "\" \"" ^
         string_of_name name ^ "\" : " ^ string_of_extern_type et
 
   let string_of_module_type : module_type -> string = function
-    | `Module (dts, its, ets) ->
+    | ModuleT (dts, its, ets) ->
       String.concat "" (
         List.mapi (fun i dt -> "type " ^ string_of_int i ^ " = " ^ string_of_def_type dt ^ "\n") dts @
         List.map (fun it -> "import " ^ string_of_import_type it ^ "\n") its @
@@ -203,9 +205,9 @@ end
 
 module SynVar =
 struct
-  type var = type_idx
+  type var = int32
   let eq_var = (=)
-  let string_of_var = string_of_idx
+  let string_of_var = I32.to_string_u
 end
 
 module Syn = Make (SynVar)
@@ -230,13 +232,13 @@ module Sem =
 struct
   include Make (SemVar)
 
-  type SemVar.var += Var of def_type Lib.Promise.t
+  type SemVar.var += Addr of def_type Lib.Promise.t
 
   let unwrap = function
-    | Var p -> p
+    | Addr p -> p
     | _ -> assert false
 
-  let alloc_uninit () = Var (Lib.Promise.make ())
+  let alloc_uninit () = Addr (Lib.Promise.make ())
   let init x dt = Lib.Promise.fulfill (unwrap x) dt
   let alloc dt = let x = alloc_uninit () in init x dt; x
   let def_of x = Lib.Promise.value (unwrap x)
@@ -254,68 +256,86 @@ struct
 
   (* Conversion *)
 
+  let sem_null c : Syn.null -> null = function
+    | Syn.Null -> Null
+    | Syn.NoNull -> NoNull
+
+  let sem_mut c : Syn.mut -> mut = function
+    | Syn.Cons -> Cons
+    | Syn.Var -> Var
+
+  let sem_init c : Syn.init -> init = function
+    | Syn.Set -> Set
+    | Syn.Unset -> Unset
+
+  let sem_limits c : 'a Syn.limits -> 'a limits = function
+    | Syn.{min; max} -> {min; max}
+
   let sem_var_type c (x : Syn.var) : var = Lib.List32.nth c x
 
   let sem_num_type c : Syn.num_type -> num_type = function
-    | t -> t
+    | Syn.I32T -> I32T
+    | Syn.I64T -> I64T
+    | Syn.F32T -> F32T
+    | Syn.F64T -> F64T
 
   let sem_vec_type c : Syn.vec_type -> vec_type = function
-    | t -> t
+    | Syn.V128T -> V128T
 
   let sem_heap_type c : Syn.heap_type -> heap_type = function
-    | `Func -> `Func
-    | `Extern -> `Extern
-    | `Def x -> `Def (sem_var_type c x)
-    | `Bot -> `Bot
+    | Syn.FuncHT -> FuncHT
+    | Syn.ExternHT -> ExternHT
+    | Syn.DefHT x -> DefHT (sem_var_type c x)
+    | Syn.BotHT -> BotHT
 
   let sem_ref_type c : Syn.ref_type -> ref_type = function
-    | `Ref (nul, t) -> `Ref (nul, sem_heap_type c t)
+    | (nul, t) -> (sem_null c nul, sem_heap_type c t)
 
   let sem_val_type c : Syn.val_type -> val_type = function
-    | #Syn.num_type as t -> (sem_num_type c t :> val_type)
-    | #Syn.vec_type as t -> (sem_vec_type c t :> val_type)
-    | #Syn.ref_type as t -> (sem_ref_type c t :> val_type)
-    | `Bot -> `Bot
+    | Syn.NumT t -> NumT (sem_num_type c t)
+    | Syn.VecT t -> VecT (sem_vec_type c t)
+    | Syn.RefT t -> RefT (sem_ref_type c t)
+    | Syn.BotT -> BotT
 
   let sem_result_type c : Syn.result_type -> result_type = function
     | ts -> List.map (sem_val_type c) ts
 
   let sem_func_type c : Syn.func_type -> func_type = function
-    | `Func (ts1, ts2) -> `Func (sem_result_type c ts1, sem_result_type c ts2)
+    | Syn.FuncT (ts1, ts2) -> FuncT (sem_result_type c ts1, sem_result_type c ts2)
 
   let sem_def_type c : Syn.def_type -> def_type = function
-    | #Syn.func_type as ft -> (sem_func_type c ft :> def_type)
+    | Syn.DefFuncT ft -> DefFuncT (sem_func_type c ft)
 
-  let sem_limits c : 'a Syn.limits -> 'a limits = function
-    | {min; max} -> {min; max}
+  let sem_local_type c : Syn.local_type -> local_type = function
+    | Syn.LocalT (init, t) -> LocalT (sem_init c init, sem_val_type c t)
 
   let sem_memory_type c : Syn.memory_type -> memory_type = function
-    | `Memory lim -> `Memory (sem_limits c lim)
+    | Syn.MemoryT lim -> MemoryT (sem_limits c lim)
 
   let sem_table_type c : Syn.table_type -> table_type = function
-    | `Table (lim, t) -> `Table (sem_limits c lim, sem_ref_type c t)
+    | Syn.TableT (lim, t) -> TableT (sem_limits c lim, sem_ref_type c t)
 
   let sem_global_type c : Syn.global_type -> global_type = function
-    | `Global (mut, t) -> `Global (mut, sem_val_type c t)
+    | Syn.GlobalT (mut, t) -> GlobalT (sem_mut c mut, sem_val_type c t)
 
   let sem_extern_type c : Syn.extern_type -> extern_type = function
-    | #Syn.func_type as ft -> (sem_func_type c ft :> extern_type)
-    | #Syn.table_type as tt -> (sem_table_type c tt :> extern_type)
-    | #Syn.memory_type as mt -> (sem_memory_type c mt :> extern_type)
-    | #Syn.global_type as gt -> (sem_global_type c gt :> extern_type)
+    | Syn.ExternFuncT ft -> ExternFuncT (sem_func_type c ft)
+    | Syn.ExternTableT tt -> ExternTableT (sem_table_type c tt)
+    | Syn.ExternMemoryT mt -> ExternMemoryT (sem_memory_type c mt)
+    | Syn.ExternGlobalT gt -> ExternGlobalT (sem_global_type c gt)
 
   let sem_export_type c : Syn.export_type -> export_type = function
-    | `Export (et, name) -> `Export (sem_extern_type c et, name)
+    | Syn.ExportT (et, name) -> ExportT (sem_extern_type c et, name)
 
   let sem_import_type c : Syn.import_type -> import_type = function
-    | `Import (et, module_name, name) ->
-      `Import (sem_extern_type c et, module_name, name)
+    | Syn.ImportT (et, module_name, name) ->
+      ImportT (sem_extern_type c et, module_name, name)
 
   let sem_module_type : Syn.module_type -> module_type = function
-    | `Module (dts, its, ets) ->
+    | Syn.ModuleT (dts, its, ets) ->
       let c = List.map (fun _ -> alloc_uninit ()) dts in
       List.iter2 (fun x dt -> init x (sem_def_type c dt)) c dts;
       let its = List.map (sem_import_type c) its in
       let ets = List.map (sem_export_type c) ets in
-      `Module ([], its, ets)
+      ModuleT ([], its, ets)
 end
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index 7f8547a18..3fae93b98 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -64,19 +64,19 @@ let val_type t = string_of_val_type t
 
 let decls kind ts = tab kind (atom val_type) ts
 
-let func_type (`Func (ts1, ts2)) =
+let func_type (FuncT (ts1, ts2)) =
   Node ("func", decls "param" ts1 @ decls "result" ts2)
 
 let def_type dt =
   match dt with
-  | #func_type as ft -> func_type ft
+  | DefFuncT ft -> func_type ft
 
 let limits nat {min; max} =
   String.concat " " (nat min :: opt nat max)
 
 let global_type = function
-  | `Global (`Const, t) -> atom string_of_val_type t
-  | `Global (`Var, t) -> Node ("mut", [atom string_of_val_type t])
+  | GlobalT (Cons, t) -> atom string_of_val_type t
+  | GlobalT (Var, t) -> Node ("mut", [atom string_of_val_type t])
 
 let pack_size = function
   | Pack8 -> "8"
@@ -355,7 +355,7 @@ struct
 end
 
 let oper (iop, fop) op =
-  num_type (type_of_num op) ^ "." ^
+  Sem.string_of_num_type (type_of_num op) ^ "." ^
   (match op with
   | I32 o -> iop "32" o
   | I64 o -> iop "64" o
@@ -427,8 +427,8 @@ let vec_laneop instr (op, i) =
 let var x = nat32 x.it
 let num v = string_of_num v.it
 let vec v = string_of_vec v.it
-let constop v = num_type (type_of_num v) ^ ".const"
-let vec_constop v = vec_type (type_of_vec v) ^ ".const i32x4"
+let constop v = Sem.string_of_num_type (type_of_num v) ^ ".const"
+let vec_constop v = Sem.string_of_vec_type (type_of_vec v) ^ ".const i32x4"
 
 let block_type = function
   | VarBlockType x -> [Node ("type " ^ nat32 x, [])]
@@ -538,21 +538,21 @@ let func f =
 (* Tables & memories *)
 
 let table off i tab =
-  let {ttype = `Table (lim, t)} = tab.it in
+  let {ttype = TableT (lim, t)} = tab.it in
   Node ("table $" ^ nat (off + i) ^ " " ^ limits nat32 lim,
     [atom ref_type t]
   )
 
 let memory off i mem =
-  let {mtype = `Memory lim} = mem.it in
+  let {mtype = MemoryT lim} = mem.it in
   Node ("memory $" ^ nat (off + i) ^ " " ^ limits nat32 lim, [])
 
 let is_elem_kind = function
-  | `Ref (`NoNull, `Func) -> true
+  | (NoNull, FuncHT) -> true
   | _ -> false
 
 let elem_kind = function
-  | `Ref (`NoNull, `Func) -> "func"
+  | (NoNull, FuncHT) -> "func"
   | _ -> assert false
 
 let is_elem_index e =
diff --git a/interpreter/text/lexer.mll b/interpreter/text/lexer.mll
index 1aabfbf11..ccbce712e 100644
--- a/interpreter/text/lexer.mll
+++ b/interpreter/text/lexer.mll
@@ -1,6 +1,7 @@
 {
 open Parser
 open Operators
+open Types
 open Source
 
 let convert_pos pos =
@@ -134,11 +135,11 @@ rule token = parse
 
   | keyword as s
     { match s with
-      | "i32" -> NUM_TYPE `I32
-      | "i64" -> NUM_TYPE `I64
-      | "f32" -> NUM_TYPE `F32
-      | "f64" -> NUM_TYPE `F64
-      | "v128" -> VEC_TYPE `V128
+      | "i32" -> NUM_TYPE I32T
+      | "i64" -> NUM_TYPE I64T
+      | "f32" -> NUM_TYPE F32T
+      | "f64" -> NUM_TYPE F64T
+      | "v128" -> VEC_TYPE V128T
       | "i8x16" -> VEC_SHAPE (V128.I8x16 ())
       | "i16x8" -> VEC_SHAPE (V128.I16x8 ())
       | "i32x4" -> VEC_SHAPE (V128.I32x4 ())
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index f66bc861a..469e61048 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -159,7 +159,7 @@ let label (c : context) x = lookup "label " c.labels x
 
 let func_type (c : context) x =
   match (Lib.List32.nth c.types.list x.it).it with
-  | #func_type as ft -> ft
+  | DefFuncT ft -> ft
   | exception Failure _ -> error x.at ("unknown type " ^ Int32.to_string x.it)
 
 
@@ -203,7 +203,7 @@ let anon_label (c : context) at = bind "label" c.labels 1l at
 
 
 let inline_func_type (c : context) ft at =
-  let dt = (ft :> def_type) in
+  let dt = DefFuncT ft in
   match Lib.List.index_where (fun ty -> ty.it = dt) c.types.list with
   | Some i -> Int32.of_int i @@ at
   | None ->
@@ -211,11 +211,11 @@ let inline_func_type (c : context) ft at =
     i @@ at
 
 let inline_func_type_explicit (c : context) x ft at =
-  if ft = `Func ([], []) then
+  if ft = FuncT ([], []) then
     (* Deferring ensures that type lookup is only triggered when
        symbolic identifiers are used, and not for desugared functions *)
     defer_locals c (fun () ->
-      let `Func (ts1, _ts2) = func_type c x in
+      let FuncT (ts1, _ts2) = func_type c x in
       bind "local" c.locals (Lib.List32.length ts1) at
     )
   else if ft <> func_type c x then
@@ -310,44 +310,44 @@ string_list :
 /* Types */
 
 null_opt :
-  | /* empty */ { `NoNull }
-  | NULL { `Null }
+  | /* empty */ { NoNull }
+  | NULL { Null }
 
 heap_type :
-  | FUNC { fun c -> `Func }
-  | EXTERN { fun c -> `Extern }
-  | var { fun c -> `Def ($1 c type_).it }
+  | FUNC { fun c -> FuncHT }
+  | EXTERN { fun c -> ExternHT }
+  | var { fun c -> DefHT ($1 c type_).it }
 
 ref_type :
-  | LPAR REF null_opt heap_type RPAR { fun c -> `Ref ($3, $4 c) }
-  | FUNCREF { fun c -> `Ref (`Null, `Func) }  /* Sugar */
-  | EXTERNREF { fun c -> `Ref (`Null, `Extern) }  /* Sugar */
+  | LPAR REF null_opt heap_type RPAR { fun c -> ($3, $4 c) }
+  | FUNCREF { fun c -> (Null, FuncHT) }  /* Sugar */
+  | EXTERNREF { fun c -> (Null, ExternHT) }  /* Sugar */
 
 val_type :
-  | NUM_TYPE { fun c -> ($1 :> val_type) }
-  | VEC_TYPE { fun c -> ($1 :> val_type) }
-  | ref_type { fun c -> ($1 c :> val_type) }
+  | NUM_TYPE { fun c -> NumT $1 }
+  | VEC_TYPE { fun c -> VecT $1 }
+  | ref_type { fun c -> RefT ($1 c) }
 
 val_type_list :
   | /* empty */ { 0l, fun c -> [] }
   | val_type val_type_list { I32.add (fst $2) 1l, fun c -> $1 c :: snd $2 c }
 
 global_type :
-  | val_type { fun c -> `Global (`Const, $1 c) }
-  | LPAR MUT val_type RPAR { fun c -> `Global (`Var, $3 c) }
+  | val_type { fun c -> GlobalT (Cons, $1 c) }
+  | LPAR MUT val_type RPAR { fun c -> GlobalT (Var, $3 c) }
 
 def_type :
-  | LPAR FUNC func_type RPAR { fun c -> ($3 c :> def_type) }
+  | LPAR FUNC func_type RPAR { fun c -> DefFuncT ($3 c) }
 
 func_type :
   | func_type_result
-    { fun c -> `Func ([], $1 c) }
+    { fun c -> FuncT ([], $1 c) }
   | LPAR PARAM val_type_list RPAR func_type
-    { fun c -> let `Func (ts1, ts2) = $5 c in
-      `Func (snd $3 c @ ts1, ts2) }
+    { fun c -> let FuncT (ts1, ts2) = $5 c in
+      FuncT (snd $3 c @ ts1, ts2) }
   | LPAR PARAM bind_var val_type RPAR func_type  /* Sugar */
-    { fun c -> let `Func (ts1, ts2) = $6 c in
-      `Func ($4 c :: ts1, ts2) }
+    { fun c -> let FuncT (ts1, ts2) = $6 c in
+      FuncT ($4 c :: ts1, ts2) }
 
 func_type_result :
   | /* empty */
@@ -356,10 +356,10 @@ func_type_result :
     { fun c -> snd $3 c @ $5 c }
 
 table_type :
-  | limits ref_type { fun c -> `Table ($1, $2 c) }
+  | limits ref_type { fun c -> TableT ($1, $2 c) }
 
 memory_type :
-  | limits { fun c -> `Memory $1 }
+  | limits { fun c -> MemoryT $1 }
 
 limits :
   | NAT { {min = nat32 $1 (ati 1); max = None} }
@@ -543,16 +543,16 @@ call_instr_type :
     { let at1 = ati 1 in
       fun c ->
       match $2 c with
-      | `Func ([], []) -> $1 c type_
+      | FuncT ([], []) -> $1 c type_
       | ft -> inline_func_type_explicit c ($1 c type_) ft at1 }
   | call_instr_params
     { let at = at () in fun c -> inline_func_type c ($1 c) at }
 
 call_instr_params :
   | LPAR PARAM val_type_list RPAR call_instr_params
-    { fun c -> let `Func (ts1, ts2) = $5 c in `Func (snd $3 c @ ts1, ts2) }
+    { fun c -> let FuncT (ts1, ts2) = $5 c in FuncT (snd $3 c @ ts1, ts2) }
   | call_instr_results
-    { fun c -> `Func ([], $1 c) }
+    { fun c -> FuncT ([], $1 c) }
 
 call_instr_results :
   | LPAR RESULT val_type_list RPAR call_instr_results
@@ -574,7 +574,7 @@ call_instr_type_instr :
     { let at1 = ati 1 in
       fun c ->
       match $2 c with
-      | `Func ([], []), es -> $1 c type_, es
+      | FuncT ([], []), es -> $1 c type_, es
       | ft, es -> inline_func_type_explicit c ($1 c type_) ft at1, es }
   | call_instr_params_instr
     { let at = at () in
@@ -582,10 +582,10 @@ call_instr_type_instr :
 
 call_instr_params_instr :
   | LPAR PARAM val_type_list RPAR call_instr_params_instr
-    { fun c -> let `Func (ts1, ts2), es = $5 c in
-      `Func (snd $3 c @ ts1, ts2), es }
+    { fun c -> let FuncT (ts1, ts2), es = $5 c in
+      FuncT (snd $3 c @ ts1, ts2), es }
   | call_instr_results_instr
-    { fun c -> let ts, es = $1 c in `Func ([], ts), es }
+    { fun c -> let ts, es = $1 c in FuncT ([], ts), es }
 
 call_instr_results_instr :
   | LPAR RESULT val_type_list RPAR call_instr_results_instr
@@ -616,22 +616,22 @@ block :
       fun c -> let ft, es = $1 c in
       let bt =
         match ft with
-        | `Func ([], []) -> ValBlockType None
-        | `Func ([], [t]) -> ValBlockType (Some t)
+        | FuncT ([], []) -> ValBlockType None
+        | FuncT ([], [t]) -> ValBlockType (Some t)
         | ft ->  VarBlockType (inline_func_type c ft at).it
       in bt, es }
 
 block_param_body :
   | block_result_body { $1 }
   | LPAR PARAM val_type_list RPAR block_param_body
-    { fun c -> let `Func (ts1, ts2), es = $5 c in
-      `Func (snd $3 c @ ts1, ts2), es }
+    { fun c -> let FuncT (ts1, ts2), es = $5 c in
+      FuncT (snd $3 c @ ts1, ts2), es }
 
 block_result_body :
-  | instr_list { fun c -> `Func ([], []), $1 c }
+  | instr_list { fun c -> FuncT ([], []), $1 c }
   | LPAR RESULT val_type_list RPAR block_result_body
-    { fun c -> let `Func (ts1, ts2), es = $5 c in
-      `Func (ts1, snd $3 c @ ts2), es }
+    { fun c -> let FuncT (ts1, ts2), es = $5 c in
+      FuncT (ts1, snd $3 c @ ts2), es }
 
 
 expr :  /* Sugar */
@@ -666,7 +666,7 @@ call_expr_type :
     { let at1 = ati 1 in
       fun c ->
       match $2 c with
-      | `Func ([], []), es -> $1 c type_, es
+      | FuncT ([], []), es -> $1 c type_, es
       | ft, es -> inline_func_type_explicit c ($1 c type_) ft at1, es }
   | call_expr_params
     { let at1 = ati 1 in
@@ -674,10 +674,10 @@ call_expr_type :
 
 call_expr_params :
   | LPAR PARAM val_type_list RPAR call_expr_params
-    { fun c -> let `Func (ts1, ts2), es = $5 c in
-      `Func (snd $3 c @ ts1, ts2), es }
+    { fun c -> let FuncT (ts1, ts2), es = $5 c in
+      FuncT (snd $3 c @ ts1, ts2), es }
   | call_expr_results
-    { fun c -> let ts, es = $1 c in `Func ([], ts), es }
+    { fun c -> let ts, es = $1 c in FuncT ([], ts), es }
 
 call_expr_results :
   | LPAR RESULT val_type_list RPAR call_expr_results
@@ -697,22 +697,22 @@ if_block :
       fun c c' -> let ft, es = $1 c c' in
       let bt =
         match ft with
-        | `Func ([], []) -> ValBlockType None
-        | `Func ([], [t]) -> ValBlockType (Some t)
+        | FuncT ([], []) -> ValBlockType None
+        | FuncT ([], [t]) -> ValBlockType (Some t)
         | ft ->  VarBlockType (inline_func_type c ft at).it
       in bt, es }
 
 if_block_param_body :
   | if_block_result_body { $1 }
   | LPAR PARAM val_type_list RPAR if_block_param_body
-    { fun c c' -> let `Func (ts1, ts2), es = $5 c c' in
-      `Func (snd $3 c @ ts1, ts2), es }
+    { fun c c' -> let FuncT (ts1, ts2), es = $5 c c' in
+      FuncT (snd $3 c @ ts1, ts2), es }
 
 if_block_result_body :
-  | if_ { fun c c' -> `Func ([], []), $1 c c' }
+  | if_ { fun c c' -> FuncT ([], []), $1 c c' }
   | LPAR RESULT val_type_list RPAR if_block_result_body
-    { fun c c' -> let `Func (ts1, ts2), es = $5 c c' in
-      `Func (ts1, snd $3 c @ ts2), es }
+    { fun c c' -> let FuncT (ts1, ts2), es = $5 c c' in
+      FuncT (ts1, snd $3 c @ ts2), es }
 
 if_ :
   | expr if_
@@ -774,32 +774,32 @@ func_fields :
 func_fields_import :  /* Sugar */
   | func_fields_import_result { $1 }
   | LPAR PARAM val_type_list RPAR func_fields_import
-    { fun c -> let `Func (ts1, ts2) = $5 c in `Func (snd $3 c @ ts1, ts2) }
+    { fun c -> let FuncT (ts1, ts2) = $5 c in FuncT (snd $3 c @ ts1, ts2) }
   | LPAR PARAM bind_var val_type RPAR func_fields_import  /* Sugar */
-    { fun c -> let `Func (ts1, ts2) = $6 c in `Func ($4 c :: ts1, ts2) }
+    { fun c -> let FuncT (ts1, ts2) = $6 c in FuncT ($4 c :: ts1, ts2) }
 
 func_fields_import_result :  /* Sugar */
-  | /* empty */ { fun c -> `Func ([], []) }
+  | /* empty */ { fun c -> FuncT ([], []) }
   | LPAR RESULT val_type_list RPAR func_fields_import_result
-    { fun c -> let `Func (ts1, ts2) = $5 c in `Func (ts1, snd $3 c @ ts2) }
+    { fun c -> let FuncT (ts1, ts2) = $5 c in FuncT (ts1, snd $3 c @ ts2) }
 
 func_fields_body :
   | func_result_body { $1 }
   | LPAR PARAM val_type_list RPAR func_fields_body
     { let at3 = ati 3 in
-      (fun c -> let `Func (ts1, ts2) = fst $5 c in
-        `Func (snd $3 c @ ts1, ts2)),
+      (fun c -> let FuncT (ts1, ts2) = fst $5 c in
+        FuncT (snd $3 c @ ts1, ts2)),
       (fun c -> anon_locals c (fst $3) at3; snd $5 c) }
   | LPAR PARAM bind_var val_type RPAR func_fields_body  /* Sugar */
-    { (fun c -> let `Func (ts1, ts2) = fst $6 c in
-        `Func ($4 c :: ts1, ts2)),
+    { (fun c -> let FuncT (ts1, ts2) = fst $6 c in
+        FuncT ($4 c :: ts1, ts2)),
       (fun c -> ignore (bind_local c $3); snd $6 c) }
 
 func_result_body :
-  | func_body { (fun c -> `Func ([], [])), $1 }
+  | func_body { (fun c -> FuncT ([], [])), $1 }
   | LPAR RESULT val_type_list RPAR func_result_body
-    { (fun c -> let `Func (ts1, ts2) = fst $5 c in
-        `Func (ts1, snd $3 c @ ts2)),
+    { (fun c -> let FuncT (ts1, ts2) = fst $5 c in
+        FuncT (ts1, snd $3 c @ ts2)),
       snd $5 }
 
 func_body :
@@ -836,7 +836,7 @@ offset :
   | expr { let at = at () in fun c -> $1 c @@ at }  /* Sugar */
 
 elem_kind :
-  | FUNC { `Ref (`NoNull, `Func) }
+  | FUNC { (NoNull, FuncHT) }
 
 elem_expr :
   | LPAR ITEM const_expr RPAR { $3 }
@@ -885,7 +885,7 @@ elem :
     { let at = at () in
       fun c -> ignore ($3 c anon_elem bind_elem);
       fun () ->
-      { etype = `Ref (`NoNull, `Func); einit = $5 c func;
+      { etype = (NoNull, FuncHT); einit = $5 c func;
         emode = Active {index = 0l @@ at; offset = $4 c} @@ at } @@ at }
 
 table :
@@ -912,7 +912,7 @@ table_fields :
       let size = Lib.List32.length einit in
       let emode = Active {index = x; offset} @@ at in
       let etype = $1 c in
-      [{ttype = `Table ({min = size; max = Some size}, etype)} @@ at],
+      [{ttype = TableT ({min = size; max = Some size}, etype)} @@ at],
       [{etype; einit; emode} @@ at],
       [], [] }
   | ref_type LPAR ELEM elem_expr elem_expr_list RPAR  /* Sugar */
@@ -922,7 +922,7 @@ table_fields :
       let size = Lib.List32.length einit in
       let emode = Active {index = x; offset} @@ at in
       let etype = $1 c in
-      [{ttype = `Table ({min = size; max = Some size}, etype)} @@ at],
+      [{ttype = TableT ({min = size; max = Some size}, etype)} @@ at],
       [{etype; einit; emode} @@ at],
       [], [] }
 
@@ -963,7 +963,7 @@ memory_fields :
     { fun c x at ->
       let offset = [i32_const (0l @@ at) @@ at] @@ at in
       let size = Int32.(div (add (of_int (String.length $3)) 65535l) 65536l) in
-      [{mtype = `Memory {min = size; max = Some size}} @@ at],
+      [{mtype = MemoryT {min = size; max = Some size}} @@ at],
       [{dinit = $3; dmode = Active {index = x; offset} @@ at} @@ at],
       [], [] }
 
@@ -1213,8 +1213,8 @@ result :
   | literal_num { NumResult (NumPat ($1 @@ at())) @@ at () }
   | LPAR CONST NAN RPAR { NumResult (NanPat (nanop $2 ($3 @@ ati 3))) @@ at () }
   | literal_ref { RefResult (RefPat ($1 @@ at ())) @@ at () }
-  | LPAR REF_FUNC RPAR { RefResult (RefTypePat `Func) @@ at () }
-  | LPAR REF_EXTERN RPAR { RefResult (RefTypePat `Extern) @@ at () }
+  | LPAR REF_FUNC RPAR { RefResult (RefTypePat FuncHT) @@ at () }
+  | LPAR REF_EXTERN RPAR { RefResult (RefTypePat ExternHT) @@ at () }
   | LPAR REF_NULL RPAR { RefResult NullPat @@ at () }
   | LPAR VEC_CONST VEC_SHAPE numpat_list RPAR {
     if V128.num_lanes $3 <> List.length $4 then
diff --git a/interpreter/valid/match.ml b/interpreter/valid/match.ml
index d091490f1..5849967f1 100644
--- a/interpreter/valid/match.ml
+++ b/interpreter/valid/match.ml
@@ -47,53 +47,53 @@ struct
 
   let rec eq_heap_type c a t1 t2 =
     match t1, t2 with
-    | `Def x1, `Def x2 -> eq_var_type c a x1 x2
+    | DefHT x1, DefHT x2 -> eq_var_type c a x1 x2
     | _, _ -> t1 = t2
 
   and eq_ref_type c a t1 t2 =
     match t1, t2 with
-    | `Ref (nul1, t1'), `Ref (nul2, t2') ->
+    | (nul1, t1'), (nul2, t2') ->
       eq_nullability c a nul1 nul2 && eq_heap_type c a t1' t2'
 
   and eq_val_type c a t1 t2 =
     match t1, t2 with
-    | (#num_type as t1'), (#num_type as t2') -> eq_num_type c a t1' t2'
-    | (#vec_type as t1'), (#vec_type as t2') -> eq_vec_type c a t1' t2'
-    | (#ref_type as t1'), (#ref_type as t2') -> eq_ref_type c a t1' t2'
-    | `Bot, `Bot -> true
+    | NumT t1', NumT t2' -> eq_num_type c a t1' t2'
+    | VecT t1', VecT t2' -> eq_vec_type c a t1' t2'
+    | RefT t1', RefT t2' -> eq_ref_type c a t1' t2'
+    | BotT, BotT -> true
     | _, _ -> false
 
   and eq_result_type c a ts1 ts2 =
     List.length ts1 = List.length ts2 &&
     List.for_all2 (eq_val_type c a) ts1 ts2
 
-  and eq_func_type c a (`Func (ts11, ts12)) (`Func (ts21, ts22)) =
+  and eq_func_type c a (FuncT (ts11, ts12)) (FuncT (ts21, ts22)) =
     eq_result_type c a ts11 ts21 && eq_result_type c a ts12 ts22
 
   and eq_def_type c a dt1 dt2 =
     match dt1, dt2 with
-    | (#func_type as ft1), (#func_type as ft2) -> eq_func_type c a ft1 ft2
+    | DefFuncT ft1, DefFuncT ft2 -> eq_func_type c a ft1 ft2
 
   and eq_var_type c a x1 x2 =
     eq_var x1 x2 || assuming a (x1, x2) ||
     eq_def_type c ((x1, x2)::a) (lookup c x1) (lookup c x2)
 
 
-  let eq_table_type c a (`Table (lim1, t1)) (`Table (lim2, t2)) =
+  let eq_table_type c a (TableT (lim1, t1)) (TableT (lim2, t2)) =
     eq_limits c a lim1 lim2 && eq_ref_type c a t1 t2
 
-  let eq_memory_type c a (`Memory lim1) (`Memory lim2) =
+  let eq_memory_type c a (MemoryT lim1) (MemoryT lim2) =
     eq_limits c a lim1 lim2
 
-  let eq_global_type c a (`Global (mut1, t1)) (`Global (mut2, t2)) =
+  let eq_global_type c a (GlobalT (mut1, t1)) (GlobalT (mut2, t2)) =
     eq_mutability c a mut1 mut2 && eq_val_type c a t1 t2
 
   let eq_extern_type c a et1 et2 =
     match et1, et2 with
-    | (#func_type as ft1), (#func_type as ft2) -> eq_func_type c a ft1 ft2
-    | (#table_type as tt1), (#table_type as tt2) -> eq_table_type c a tt1 tt2
-    | (#memory_type as mt1), (#memory_type as mt2) -> eq_memory_type c a mt1 mt2
-    | (#global_type as gt1), (#global_type as gt2) -> eq_global_type c a gt1 gt2
+    | ExternFuncT ft1, ExternFuncT ft2 -> eq_func_type c a ft1 ft2
+    | ExternTableT tt1, ExternTableT tt2 -> eq_table_type c a tt1 tt2
+    | ExternMemoryT mt1, ExternMemoryT mt2 -> eq_memory_type c a mt1 mt2
+    | ExternGlobalT gt1, ExternGlobalT gt2 -> eq_global_type c a gt1 gt2
     | _, _ -> false
 
 
@@ -101,7 +101,7 @@ struct
 
   let match_nullability c a nul1 nul2 =
     match nul1, nul2 with
-    | `NoNull, `Null -> true
+    | NoNull, Null -> true
     | _, _ -> nul1 = nul2
 
   let match_limits c a lim1 lim2 =
@@ -119,25 +119,25 @@ struct
 
   let rec match_heap_type c a t1 t2 =
     match t1, t2 with
-    | `Def x1, `Func ->
+    | DefHT x1, FuncHT ->
       (match lookup c x1 with
-      | `Func _ -> true
+      | DefFuncT _ -> true
       )
-    | `Def x1, `Def x2 -> match_var_type c a x1 x2
-    | `Bot, _ -> true
+    | DefHT x1, DefHT x2 -> match_var_type c a x1 x2
+    | BotHT, _ -> true
     | _, _ -> eq_heap_type c [] t1 t2
 
   and match_ref_type c a t1 t2 =
     match t1, t2 with
-    | `Ref (nul1, t1'), `Ref (nul2, t2') ->
+    | (nul1, t1'), (nul2, t2') ->
       match_nullability c a nul1 nul2 && match_heap_type c a t1' t2'
 
   and match_val_type c a t1 t2 =
     match t1, t2 with
-    | (#num_type as t1'), (#num_type as t2') -> match_num_type c a t1' t2'
-    | (#vec_type as t1'), (#vec_type as t2') -> match_vec_type c a t1' t2'
-    | (#ref_type as t1'), (#ref_type as t2') -> match_ref_type c a t1' t2'
-    | `Bot, _ -> true
+    | NumT t1', NumT t2' -> match_num_type c a t1' t2'
+    | VecT t1', VecT t2' -> match_vec_type c a t1' t2'
+    | RefT t1', RefT t2' -> match_ref_type c a t1' t2'
+    | BotT, _ -> true
     | _, _ -> false
 
   and match_result_type c a ts1 ts2 =
@@ -149,30 +149,30 @@ struct
 
   and match_def_type c a dt1 dt2 =
     match dt1, dt2 with
-    | (#func_type as ft1), (#func_type as ft2) -> match_func_type c a ft1 ft2
+    | DefFuncT ft1, DefFuncT ft2 -> match_func_type c a ft1 ft2
 
   and match_var_type c a x1 x2 =
     eq_var x1 x2 || assuming a (x1, x2) ||
     match_def_type c ((x1, x2)::a) (lookup c x1) (lookup c x2)
 
-  let match_table_type c a (`Table (lim1, t1)) (`Table (lim2, t2)) =
+  let match_table_type c a (TableT (lim1, t1)) (TableT (lim2, t2)) =
     match_limits c a lim1 lim2 && eq_ref_type c [] t1 t2
 
-  let match_memory_type c a (`Memory lim1) (`Memory lim2) =
+  let match_memory_type c a (MemoryT lim1) (MemoryT lim2) =
     match_limits c a lim1 lim2
 
-  let match_global_type c a (`Global (mut1, t1)) (`Global (mut2, t2)) =
+  let match_global_type c a (GlobalT (mut1, t1)) (GlobalT (mut2, t2)) =
     eq_mutability c [] mut1 mut2 &&
     match mut1 with
-    | `Const -> match_val_type c a t1 t2
-    | `Var -> eq_val_type c [] t1 t2
+    | Cons -> match_val_type c a t1 t2
+    | Var -> eq_val_type c [] t1 t2
 
   let match_extern_type c a et1 et2 =
     match et1, et2 with
-    | (#func_type as ft1), (#func_type as ft2) -> match_func_type c a ft1 ft2
-    | (#table_type as tt1), (#table_type as tt2) -> match_table_type c a tt1 tt2
-    | (#memory_type as mt1), (#memory_type as mt2) -> match_memory_type c a mt1 mt2
-    | (#global_type as gt1), (#global_type as gt2) -> match_global_type c a gt1 gt2
+    | ExternFuncT ft1, ExternFuncT ft2 -> match_func_type c a ft1 ft2
+    | ExternTableT tt1, ExternTableT tt2 -> match_table_type c a tt1 tt2
+    | ExternMemoryT mt1, ExternMemoryT mt2 -> match_memory_type c a mt1 mt2
+    | ExternGlobalT gt1, ExternGlobalT gt2 -> match_global_type c a gt1 gt2
     | _, _ -> false
 end
 
@@ -199,7 +199,7 @@ struct
   type var = Types.Sem.var
   type def_type = Types.Sem.def_type
   type context = unit
-  let lookup c x = Types.Sem.def_of x
+  let lookup _c x = Types.Sem.def_of x
 end
 
 module Sem = Make (Types.SemVar) (SemContext)
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index 0106be98c..b5db1a5fb 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -56,15 +56,15 @@ let replace category list x y =
     error x.at ("unknown " ^ category ^ " " ^ I32.to_string_u x.it)
 
 let init_local (c : context) x =
-  let `Local (_init, t) = local c x in
-  {c with locals = replace "local" c.locals x (`Local (`Set, t))}
+  let LocalT (_init, t) = local c x in
+  {c with locals = replace "local" c.locals x (LocalT (Set, t))}
 
 let init_locals (c : context) xs =
   List.fold_left init_local c xs
 
 let func_type (c : context) x =
   match type_ c x with
-  | #func_type as ft -> ft
+  | DefFuncT ft -> ft
 
 let refer category (s : Free.Set.t) x =
   if not (Free.Set.mem x.it s) then
@@ -93,48 +93,48 @@ let check_vec_type (c : context) (t : vec_type) at =
 
 let check_heap_type (c : context) (t : heap_type) at =
   match t with
-  | `Func -> ()
-  | `Extern -> ()
-  | `Def x -> ignore (type_ c (x @@ at))
-  | `Bot -> assert false
+  | FuncHT -> ()
+  | ExternHT -> ()
+  | DefHT x -> ignore (type_ c (x @@ at))
+  | BotHT -> assert false
 
 let check_ref_type (c : context) (t : ref_type) at =
   match t with
-  | `Ref (_nul, t') -> check_heap_type c t' at
+  | (_nul, ht) -> check_heap_type c ht at
 
 let check_val_type (c : context) (t : val_type) at =
   match t with
-  | #num_type as t' -> check_num_type c t' at
-  | #vec_type as t' -> check_vec_type c t' at
-  | #ref_type as t' -> check_ref_type c t' at
-  | `Bot -> assert false
+  | NumT t' -> check_num_type c t' at
+  | VecT t' -> check_vec_type c t' at
+  | RefT t' -> check_ref_type c t' at
+  | BotT -> assert false
 
 let check_result_type (c : context) (ts : result_type) at =
   List.iter (fun t -> check_val_type c t at) ts
 
 let check_func_type (c : context) (ft : func_type) at =
-  let `Func (ts1, ts2) = ft in
+  let FuncT (ts1, ts2) = ft in
   check_result_type c ts1 at;
   check_result_type c ts2 at
 
 let check_table_type (c : context) (tt : table_type) at =
-  let `Table (lim, t) = tt in
+  let TableT (lim, t) = tt in
   check_limits lim 0xffff_ffffl at "table size must be at most 2^32-1";
   check_ref_type c t at;
-  require (defaultable t) at "non-defaultable element type"
+  require (defaultable (RefT t)) at "non-defaultable element type"
 
 let check_memory_type (c : context) (mt : memory_type) at =
-  let `Memory lim = mt in
+  let MemoryT lim = mt in
   check_limits lim 0x1_0000l at
     "memory size must be at most 65536 pages (4GiB)"
 
 let check_global_type (c : context) (gt : global_type) at =
-  let `Global (_mut, t) = gt in
+  let GlobalT (_mut, t) = gt in
   check_val_type c t at
 
 let check_def_type (c : context) (dt : def_type) at =
   match dt with
-  | #func_type as ft -> check_func_type c ft at
+  | DefFuncT ft -> check_func_type c ft at
 
 
 
@@ -144,7 +144,7 @@ let check_def_type (c : context) (dt : def_type) at =
  * Note: The declarative typing rules are non-deterministic, that is, they
  * have the liberty to locally "guess" the right types implied by the context.
  * In the algorithmic formulation required here, stack types may hence pick
- * `BotType` as the principal choice for a locally unknown type.
+ * `BotT` as the principal choice for a locally unknown type.
  * Furthermore, an ellipses flag represents arbitrary sequences
  * of unknown types, in order to handle stack polymorphism algorithmically.
  *)
@@ -170,7 +170,7 @@ let pop c (ell1, ts1) (ell2, ts2) at =
   let n2 = List.length ts2 in
   let n = min n1 n2 in
   let n3 = if ell2 = Ellipses then (n1 - n) else 0 in
-  check_stack c (Lib.List.make n3 `Bot @ Lib.List.drop (n2 - n) ts2) ts1 at;
+  check_stack c (Lib.List.make n3 (BotT : val_type) @ Lib.List.drop (n2 - n) ts2) ts1 at;
   (ell2, if ell1 = Ellipses then [] else Lib.List.take (n2 - n) ts2)
 
 let push c (ell1, ts1) (ell2, ts2) =
@@ -178,13 +178,13 @@ let push c (ell1, ts1) (ell2, ts2) =
   (if ell1 = Ellipses || ell2 = Ellipses then Ellipses else NoEllipses),
   ts2 @ ts1
 
-let peek i (ell, ts) =
-  try List.nth (List.rev ts) i with Failure _ -> `Bot
+let peek i (ell, ts) : val_type =
+  try List.nth (List.rev ts) i with Failure _ -> BotT
 
-let peek_ref i (ell, ts) at =
+let peek_ref i (ell, ts) at : ref_type =
   match peek i (ell, ts) with
-  | #ref_type as rt -> rt
-  | `Bot -> `Ref (`NoNull, `Bot)
+  | RefT rt -> rt
+  | BotT -> (NoNull, BotHT)
   | t ->
     error at
       ("type mismatch: instruction requires reference type" ^
@@ -193,46 +193,46 @@ let peek_ref i (ell, ts) at =
 
 (* Type Synthesis *)
 
-let type_num = Value.type_of_num
-let type_vec = Value.type_of_vec
+let type_num = Value.type_of_op
+let type_vec = Value.type_of_vecop
 let type_vec_lane = function
-  | Value.V128 laneop -> (V128.type_of_lane laneop :> val_type)
+  | Value.V128 laneop -> V128.type_of_lane laneop
 
 let type_cvtop at = function
   | Value.I32 cvtop ->
     let open I32Op in
     (match cvtop with
     | ExtendSI32 | ExtendUI32 -> error at "invalid conversion"
-    | WrapI64 -> `I64
+    | WrapI64 -> I64T
     | TruncSF32 | TruncUF32 | TruncSatSF32 | TruncSatUF32
-    | ReinterpretFloat -> `F32
-    | TruncSF64 | TruncUF64 | TruncSatSF64 | TruncSatUF64 -> `F64
-    ), `I32
+    | ReinterpretFloat -> F32T
+    | TruncSF64 | TruncUF64 | TruncSatSF64 | TruncSatUF64 -> F64T
+    ), I32T
   | Value.I64 cvtop ->
     let open I64Op in
     (match cvtop with
-    | ExtendSI32 | ExtendUI32 -> `I32
+    | ExtendSI32 | ExtendUI32 -> I32T
     | WrapI64 -> error at "invalid conversion"
-    | TruncSF32 | TruncUF32 | TruncSatSF32 | TruncSatUF32 -> `F32
+    | TruncSF32 | TruncUF32 | TruncSatSF32 | TruncSatUF32 -> F32T
     | TruncSF64 | TruncUF64 | TruncSatSF64 | TruncSatUF64
-    | ReinterpretFloat -> `F64
-    ), `I64
+    | ReinterpretFloat -> F64T
+    ), I64T
   | Value.F32 cvtop ->
     let open F32Op in
     (match cvtop with
-    | ConvertSI32 | ConvertUI32 | ReinterpretInt -> `I32
-    | ConvertSI64 | ConvertUI64 -> `I64
+    | ConvertSI32 | ConvertUI32 | ReinterpretInt -> I32T
+    | ConvertSI64 | ConvertUI64 -> I64T
     | PromoteF32 -> error at "invalid conversion"
-    | DemoteF64 -> `F64
-    ), `F32
+    | DemoteF64 -> F64T
+    ), F32T
   | Value.F64 cvtop ->
     let open F64Op in
     (match cvtop with
-    | ConvertSI32 | ConvertUI32 -> `I32
-    | ConvertSI64 | ConvertUI64 | ReinterpretInt -> `I64
-    | PromoteF32 -> `F32
+    | ConvertSI32 | ConvertUI32 -> I32T
+    | ConvertSI64 | ConvertUI64 | ReinterpretInt -> I64T
+    | PromoteF32 -> F32T
     | DemoteF64 -> error at "invalid conversion"
-    ), `F64
+    ), F64T
 
 let num_lanes = function
   | Value.V128 laneop -> V128.num_lanes laneop
@@ -262,7 +262,7 @@ let check_pack sz t_sz at =
 let check_unop unop at =
   match unop with
   | Value.I32 (IntOp.ExtendS sz) | Value.I64 (IntOp.ExtendS sz) ->
-    check_pack sz (num_size (Value.type_of_num unop)) at
+    check_pack sz (num_size (Value.type_of_op unop)) at
   | _ -> ()
 
 let check_vec_binop binop at =
@@ -307,15 +307,15 @@ let check_memop (c : context) (memop : ('t, 's) memop) ty_size get_sz at =
 
 let check_block_type (c : context) (bt : block_type) at : instr_type =
   match bt with
-  | ValBlockType None -> `Instr ([], [], [])
-  | ValBlockType (Some t) -> check_val_type c t at; `Instr ([], [t], [])
+  | ValBlockType None -> InstrT ([], [], [])
+  | ValBlockType (Some t) -> check_val_type c t at; InstrT ([], [t], [])
   | VarBlockType x ->
-    let `Func (ts1, ts2) = func_type c (x @@ at) in `Instr (ts1, ts2, [])
+    let FuncT (ts1, ts2) = func_type c (x @@ at) in InstrT (ts1, ts2, [])
 
 let check_local (c : context) (loc : local) : local_type =
   check_val_type c loc.it.ltype loc.at;
-  let init = if defaultable loc.it.ltype then `Set else `Unset in
-  `Local (init, loc.it.ltype)
+  let init = if defaultable loc.it.ltype then Set else Unset in
+  LocalT (init, loc.it.ltype)
 
 let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_instr_type =
   match e.it with
@@ -333,50 +333,50 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
     require (is_num_type t || is_vec_type t) e.at
       ("type mismatch: instruction requires numeric or vector type" ^
        " but stack has " ^ string_of_val_type t);
-    [t; t; `I32] --> [t], []
+    [t; t; NumT I32T] --> [t], []
 
   | Select (Some ts) ->
     require (List.length ts = 1) e.at
       "invalid result arity other than 1 is not (yet) allowed";
     check_result_type c ts e.at;
-    (ts @ ts @ [`I32]) --> ts, []
+    (ts @ ts @ [NumT I32T]) --> ts, []
 
   | Block (bt, es) ->
-    let `Instr (ts1, ts2, xs) as it = check_block_type c bt e.at in
+    let InstrT (ts1, ts2, xs) as it = check_block_type c bt e.at in
     check_block {c with labels = ts2 :: c.labels} es it e.at;
     ts1 --> ts2, List.map (fun x -> x @@ e.at) xs
 
   | Loop (bt, es) ->
-    let `Instr (ts1, ts2, xs) as it = check_block_type c bt e.at in
+    let InstrT (ts1, ts2, xs) as it = check_block_type c bt e.at in
     check_block {c with labels = ts1 :: c.labels} es it e.at;
     ts1 --> ts2, List.map (fun x -> x @@ e.at) xs
 
   | If (bt, es1, es2) ->
-    let `Instr (ts1, ts2, xs) as it = check_block_type c bt e.at in
+    let InstrT (ts1, ts2, xs) as it = check_block_type c bt e.at in
     check_block {c with labels = ts2 :: c.labels} es1 it e.at;
     check_block {c with labels = ts2 :: c.labels} es2 it e.at;
-    (ts1 @ [`I32]) --> ts2, List.map (fun x -> x @@ e.at) xs
+    (ts1 @ [NumT I32T]) --> ts2, List.map (fun x -> x @@ e.at) xs
 
   | Br x ->
     label c x -->... [], []
 
   | BrIf x ->
-    (label c x @ [`I32]) --> label c x, []
+    (label c x @ [NumT I32T]) --> label c x, []
 
   | BrTable (xs, x) ->
     let n = List.length (label c x) in
     let ts = Lib.List.table n (fun i -> peek (n - i) s) in
     check_stack c ts (label c x) x.at;
     List.iter (fun x' -> check_stack c ts (label c x') x'.at) xs;
-    (ts @ [`I32]) -->... [], []
+    (ts @ [NumT I32T]) -->... [], []
 
   | BrOnNull x ->
-    let `Ref (_, ht) = peek_ref 0 s e.at in
-    (label c x @ [`Ref (`Null, ht)]) --> (label c x @ [`Ref (`NoNull, ht)]), []
+    let (_nul, ht) = peek_ref 0 s e.at in
+    (label c x @ [RefT (Null, ht)]) --> (label c x @ [RefT (NoNull, ht)]), []
 
   | BrOnNonNull x ->
-    let `Ref (_, ht) as t = peek_ref 0 s e.at in
-    let t' = `Ref (`NoNull, ht) in
+    let (_nul, ht) = peek_ref 0 s e.at in
+    let t' = RefT (NoNull, ht) in
     require (label c x <> []) e.at
       ("type mismatch: instruction requires type " ^ string_of_val_type t' ^
        " but label has " ^ string_of_result_type (label c x));
@@ -384,110 +384,110 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
     require (match_val_type c.types [] t' t1) e.at
       ("type mismatch: instruction requires type " ^ string_of_val_type t' ^
        " but label has " ^ string_of_result_type (label c x));
-    (ts0 @ [t]) --> ts0, []
+    (ts0 @ [RefT (_nul, ht)]) --> ts0, []
 
   | Return ->
     c.results -->... [], []
 
   | Call x ->
-    let `Func (ts1, ts2) = func c x in
+    let FuncT (ts1, ts2) = func c x in
     ts1 --> ts2, []
 
   | CallRef ->
     (match peek_ref 0 s e.at with
-    | `Ref (nul, `Def x) ->
-      let `Func (ts1, ts2) = func_type c (x @@ e.at) in
-      (ts1 @ [`Ref (nul, `Def x)]) --> ts2, []
-    | `Ref (_, `Bot) as t ->
-      [t] -->... [], []
-    | t ->
+    | (_, DefHT x) ->
+      let FuncT (ts1, ts2) = func_type c (x @@ e.at) in
+      (ts1 @ [RefT (Null, DefHT x)]) --> ts2, []
+    | (_, BotHT) ->
+      [RefT (Null, BotHT)] -->... [], []
+    | rt ->
       error e.at
         ("type mismatch: instruction requires function reference type" ^
-         " but stack has " ^ string_of_val_type t)
+         " but stack has " ^ string_of_val_type (RefT rt))
     )
 
   | CallIndirect (x, y) ->
-    let `Table (_lim, t) = table c x in
-    let `Func (ts1, ts2) = func_type c y in
-    require (match_ref_type c.types [] t (`Ref (`Null, `Func))) x.at
+    let TableT (_lim, t) = table c x in
+    let FuncT (ts1, ts2) = func_type c y in
+    require (match_ref_type c.types [] t (Null, FuncHT)) x.at
       ("type mismatch: instruction requires table of function type" ^
        " but table has element type " ^ string_of_ref_type t);
-    (ts1 @ [`I32]) --> ts2, []
+    (ts1 @ [NumT I32T]) --> ts2, []
 
   | ReturnCallRef ->
     (match peek_ref 0 s e.at with
-    | `Ref (nul, `Def x) ->
-      let `Func (ts1, ts2) = func_type c (x @@ e.at) in
+    | (_, DefHT x) ->
+      let FuncT (ts1, ts2) = func_type c (x @@ e.at) in
       require (match_result_type c.types [] ts2 c.results) e.at
         ("type mismatch: current function requires result type " ^
          string_of_result_type c.results ^
          " but callee returns " ^ string_of_result_type ts2);
-      (ts1 @ [`Ref (nul, `Def x)]) -->... [], []
-    | `Ref (_, `Bot) as t ->
-      [t] -->... [], []
-    | t ->
+      (ts1 @ [RefT (Null, DefHT x)]) -->... [], []
+    | (_, BotHT) ->
+      [RefT (Null, BotHT)] -->... [], []
+    | rt ->
       error e.at
         ("type mismatch: instruction requires function reference type" ^
-         " but stack has " ^ string_of_val_type t)
+         " but stack has " ^ string_of_ref_type rt)
     )
 
   | LocalGet x ->
-    let `Local (init, t) = local c x in
-    require (init = `Set) x.at "uninitialized local";
+    let LocalT (init, t) = local c x in
+    require (init = Set) x.at "uninitialized local";
     [] --> [t], []
 
   | LocalSet x ->
-    let `Local (_init, t) = local c x in
+    let LocalT (_init, t) = local c x in
     [t] --> [], [x]
 
   | LocalTee x ->
-    let `Local (_init, t) = local c x in
+    let LocalT (_init, t) = local c x in
     [t] --> [t], [x]
 
   | GlobalGet x ->
-    let `Global (_mut, t) = global c x in
+    let GlobalT (_mut, t) = global c x in
     [] --> [t], []
 
   | GlobalSet x ->
-    let `Global (mut, t) = global c x in
-    require (mut = `Var) x.at "immutable global";
+    let GlobalT (mut, t) = global c x in
+    require (mut = Var) x.at "immutable global";
     [t] --> [], []
 
   | TableGet x ->
-    let `Table (_lim, t) = table c x in
-    [`I32] --> [(t :> val_type)], []
+    let TableT (_lim, rt) = table c x in
+    [NumT I32T] --> [RefT rt], []
 
   | TableSet x ->
-    let `Table (_lim, t) = table c x in
-    [`I32; (t :> val_type)] --> [], []
+    let TableT (_lim, rt) = table c x in
+    [NumT I32T; RefT rt] --> [], []
 
   | TableSize x ->
     let _tt = table c x in
-    [] --> [`I32], []
+    [] --> [NumT I32T], []
 
   | TableGrow x ->
-    let `Table (_lim, t) = table c x in
-    [(t :> val_type); `I32] --> [`I32], []
+    let TableT (_lim, rt) = table c x in
+    [RefT rt; NumT I32T] --> [NumT I32T], []
 
   | TableFill x ->
-    let `Table (_lim, t) = table c x in
-    [`I32; (t :> val_type); `I32] --> [], []
+    let TableT (_lim, rt) = table c x in
+    [NumT I32T; RefT rt; NumT I32T] --> [], []
 
   | TableCopy (x, y) ->
-    let `Table (_lim1, t1) = table c x in
-    let `Table (_lim2, t2) = table c y in
+    let TableT (_lim1, t1) = table c x in
+    let TableT (_lim2, t2) = table c y in
     require (match_ref_type c.types [] t2 t1) x.at
       ("type mismatch: source element type " ^ string_of_ref_type t1 ^
        " does not match destination element type " ^ string_of_ref_type t2);
-    [`I32; `I32; `I32] --> [], []
+    [NumT I32T; NumT I32T; NumT I32T] --> [], []
 
   | TableInit (x, y) ->
-    let `Table (_lim1, t1) = table c x in
+    let TableT (_lim1, t1) = table c x in
     let t2 = elem c y in
     require (match_ref_type c.types [] t2 t1) x.at
       ("type mismatch: element segment's type " ^ string_of_ref_type t1 ^
        " does not match table's element type " ^ string_of_ref_type t2);
-    [`I32; `I32; `I32] --> [], []
+    [NumT I32T; NumT I32T; NumT I32T] --> [], []
 
   | ElemDrop x ->
     ignore (elem c x);
@@ -495,164 +495,164 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
 
   | Load memop ->
     check_memop c memop num_size (Lib.Option.map fst) e.at;
-    [`I32] --> [(memop.ty :> val_type)], []
+    [NumT I32T] --> [NumT memop.ty], []
 
   | Store memop ->
     check_memop c memop num_size (fun sz -> sz) e.at;
-    [`I32; (memop.ty :> val_type)] --> [], []
+    [NumT I32T; NumT memop.ty] --> [], []
 
   | VecLoad memop ->
     check_memop c memop vec_size (Lib.Option.map fst) e.at;
-    [`I32] --> [(memop.ty :> val_type)], []
+    [NumT I32T] --> [VecT memop.ty], []
 
   | VecStore memop ->
     check_memop c memop vec_size (fun _ -> None) e.at;
-    [`I32; (memop.ty :> val_type)] --> [], []
+    [NumT I32T; VecT memop.ty] --> [], []
 
   | VecLoadLane (memop, i) ->
     check_memop c memop vec_size (fun sz -> Some sz) e.at;
     require (i < vec_size memop.ty / Pack.packed_size memop.pack) e.at
       "invalid lane index";
-    [`I32; (memop.ty :> val_type)] -->  [(memop.ty :> val_type)], []
+    [NumT I32T; VecT memop.ty] -->  [VecT memop.ty], []
 
   | VecStoreLane (memop, i) ->
     check_memop c memop vec_size (fun sz -> Some sz) e.at;
     require (i < vec_size memop.ty / Pack.packed_size memop.pack) e.at
       "invalid lane index";
-    [`I32; (memop.ty :> val_type)] -->  [], []
+    [NumT I32T; VecT memop.ty] -->  [], []
 
   | MemorySize ->
     let _mt = memory c (0l @@ e.at) in
-    [] --> [`I32], []
+    [] --> [NumT I32T], []
 
   | MemoryGrow ->
     let _mt = memory c (0l @@ e.at) in
-    [`I32] --> [`I32], []
+    [NumT I32T] --> [NumT I32T], []
 
   | MemoryFill ->
     let _mt = memory c (0l @@ e.at) in
-    [`I32; `I32; `I32] --> [], []
+    [NumT I32T; NumT I32T; NumT I32T] --> [], []
 
   | MemoryCopy ->
     let _mt = memory c (0l @@ e.at) in
-    [`I32; `I32; `I32] --> [], []
+    [NumT I32T; NumT I32T; NumT I32T] --> [], []
 
   | MemoryInit x ->
     let _mt = memory c (0l @@ e.at) in
     let () = data c x in
-    [`I32; `I32; `I32] --> [], []
+    [NumT I32T; NumT I32T; NumT I32T] --> [], []
 
   | DataDrop x ->
     let () = data c x in
     [] --> [], []
 
-  | RefNull t ->
-    check_heap_type c t e.at;
-    [] --> [`Ref (`Null, t)], []
+  | RefNull ht ->
+    check_heap_type c ht e.at;
+    [] --> [RefT (Null, ht)], []
 
   | RefIsNull ->
-    let `Ref (_, t) = peek_ref 0 s e.at in
-    [`Ref (`Null, t)] --> [`I32], []
+    let (_, ht) = peek_ref 0 s e.at in
+    [RefT (Null, ht)] --> [NumT I32T], []
 
   | RefAsNonNull ->
-    let `Ref (_, t) = peek_ref 0 s e.at in
-    [`Ref (`Null, t)] --> [`Ref (`NoNull, t)], []
+    let (_, ht) = peek_ref 0 s e.at in
+    [RefT (Null, ht)] --> [RefT (NoNull, ht)], []
 
   | RefFunc x ->
     let ft = func c x in
-    let y = Lib.Option.force (Lib.List32.index_of (ft :> def_type) c.types) in
+    let y = Lib.Option.force (Lib.List32.index_of (DefFuncT ft) c.types) in
     refer_func c x;
-    [] --> [`Ref (`NoNull, `Def y)], []
+    [] --> [RefT (NoNull, DefHT y)], []
 
   | Const v ->
-    let t = type_num v.it in
+    let t = NumT (type_num v.it) in
     [] --> [t], []
 
   | Test testop ->
-    let t = type_num testop in
-    [t] --> [`I32], []
+    let t = NumT (type_num testop) in
+    [t] --> [NumT I32T], []
 
   | Compare relop ->
-    let t = type_num relop in
-    [t; t] --> [`I32], []
+    let t = NumT (type_num relop) in
+    [t; t] --> [NumT I32T], []
 
   | Unary unop ->
     check_unop unop e.at;
-    let t = type_num unop in
+    let t = NumT (type_num unop) in
     [t] --> [t], []
 
   | Binary binop ->
-    let t = type_num binop in
+    let t = NumT (type_num binop) in
     [t; t] --> [t], []
 
   | Convert cvtop ->
     let t1, t2 = type_cvtop e.at cvtop in
-    [t1] --> [t2], []
+    [NumT t1] --> [NumT t2], []
 
   | VecConst v ->
-    let t = type_vec v.it in
+    let t = VecT (type_vec v.it) in
     [] --> [t], []
 
   | VecTest testop ->
-    let t = type_vec testop in
-    [t] --> [`I32], []
+    let t = VecT (type_vec testop) in
+    [t] --> [NumT I32T], []
 
   | VecUnary unop ->
-    let t = type_vec unop in
+    let t = VecT (type_vec unop) in
     [t] --> [t], []
 
   | VecBinary binop ->
     check_vec_binop binop e.at;
-    let t = type_vec binop in
+    let t = VecT (type_vec binop) in
     [t; t] --> [t], []
 
   | VecCompare relop ->
-    let t = type_vec relop in
+    let t = VecT (type_vec relop) in
     [t; t] --> [t], []
 
   | VecConvert cvtop ->
-    let t = type_vec cvtop in
+    let t = VecT (type_vec cvtop) in
     [t] --> [t], []
 
   | VecShift shiftop ->
-    let t = type_vec shiftop in
-    [t; `I32] --> [t], []
+    let t = VecT (type_vec shiftop) in
+    [t; NumT I32T] --> [t], []
 
   | VecBitmask bitmaskop ->
-    let t = type_vec bitmaskop in
-    [t] --> [`I32], []
+    let t = VecT (type_vec bitmaskop) in
+    [t] --> [NumT I32T], []
 
   | VecTestBits vtestop ->
-    let t = type_vec vtestop in
-    [t] --> [`I32], []
+    let t = VecT (type_vec vtestop) in
+    [t] --> [NumT I32T], []
 
   | VecUnaryBits vunop ->
-    let t = type_vec vunop in
+    let t = VecT (type_vec vunop) in
     [t] --> [t], []
 
   | VecBinaryBits vbinop ->
-    let t = type_vec vbinop in
+    let t = VecT (type_vec vbinop) in
     [t; t] --> [t], []
 
   | VecTernaryBits vternop ->
-    let t = type_vec vternop in
+    let t = VecT (type_vec vternop) in
     [t; t; t] --> [t], []
 
   | VecSplat splatop ->
-    let t1 = type_vec_lane splatop in
-    let t2 = type_vec splatop in
+    let t1 = NumT (type_vec_lane splatop) in
+    let t2 = VecT (type_vec splatop) in
     [t1] --> [t2], []
 
   | VecExtract extractop ->
-    let t1 = type_vec extractop in
-    let t2 = type_vec_lane extractop in
+    let t1 = VecT (type_vec extractop) in
+    let t2 = NumT (type_vec_lane extractop) in
     require (lane_extractop extractop < num_lanes extractop) e.at
       "invalid lane index";
     [t1] --> [t2], []
 
   | VecReplace replaceop ->
-    let t1 = type_vec replaceop in
-    let t2 = type_vec_lane replaceop in
+    let t1 = VecT (type_vec replaceop) in
+    let t2 = NumT (type_vec_lane replaceop) in
     require (lane_replaceop replaceop < num_lanes replaceop) e.at
       "invalid lane index";
     [t1; t2] --> [t1], []
@@ -670,7 +670,7 @@ and check_seq (c : context) (s : infer_result_type) (es : instr list)
     push c outs (pop c ins s' e.at), xs @ xs'
 
 and check_block (c : context) (es : instr list) (it : instr_type) at =
-  let `Instr (ts1, ts2, _xs) = it in
+  let InstrT (ts1, ts2, _xs) = it in
   let s, xs' = check_seq c (stack ts1) es in
   let s' = pop c (stack ts2) s at in
   require (snd s' = []) at
@@ -694,15 +694,15 @@ and check_block (c : context) (es : instr list) (it : instr_type) at =
 
 let check_func (c : context) (f : func) =
   let {ftype; locals; body} = f.it in
-  let `Func (ts1, ts2) = func_type c ftype in
+  let FuncT (ts1, ts2) = func_type c ftype in
   let lts = List.map (check_local c) locals in
   let c' =
     { c with
-      locals = List.map (fun t -> `Local (`Set, t)) ts1 @ lts;
+      locals = List.map (fun t -> LocalT (Set, t)) ts1 @ lts;
       results = ts2;
       labels = [ts2]
     }
-  in check_block c' body (`Instr ([], ts2, [])) f.at
+  in check_block c' body (InstrT ([], ts2, [])) f.at
 
 
 let is_const (c : context) (e : instr) =
@@ -711,13 +711,13 @@ let is_const (c : context) (e : instr) =
   | RefFunc _
   | Const _
   | VecConst _ -> true
-  | GlobalGet x -> let `Global (mut, _t) = global c x in mut = `Const
+  | GlobalGet x -> let GlobalT (mut, _t) = global c x in mut = Cons
   | _ -> false
 
 let check_const (c : context) (const : const) (t : val_type) =
   require (List.for_all (is_const c) const.it) const.at
     "constant expression required";
-  check_block c const.it (`Instr ([], [t], [])) const.at
+  check_block c const.it (InstrT ([], [t], [])) const.at
 
 
 (* Tables, Memories, & Globals *)
@@ -734,17 +734,17 @@ let check_elem_mode (c : context) (t : ref_type) (mode : segment_mode) =
   match mode.it with
   | Passive -> ()
   | Active {index; offset} ->
-    let `Table (_lim, et) = table c index in
+    let TableT (_lim, et) = table c index in
     require (match_ref_type c.types [] t et) mode.at
       ("type mismatch: element segment's type " ^ string_of_ref_type t ^
        " does not match table's element type " ^ string_of_ref_type et);
-    check_const c offset `I32
+    check_const c offset (NumT I32T)
   | Declarative -> ()
 
 let check_elem (c : context) (seg : elem_segment) =
   let {etype; einit; emode} = seg.it in
   check_ref_type c etype seg.at;
-  List.iter (fun const -> check_const c const (etype :> val_type)) einit;
+  List.iter (fun const -> check_const c const (RefT etype)) einit;
   check_elem_mode c etype emode
 
 let check_data_mode (c : context) (mode : segment_mode) =
@@ -752,7 +752,7 @@ let check_data_mode (c : context) (mode : segment_mode) =
   | Passive -> ()
   | Active {index; offset} ->
     ignore (memory c index);
-    check_const c offset `I32
+    check_const c offset (NumT I32T)
   | Declarative -> assert false
 
 let check_data (c : context) (seg : data_segment) =
@@ -762,7 +762,7 @@ let check_data (c : context) (seg : data_segment) =
 let check_global (c : context) (glob : global) =
   let {gtype; ginit} = glob.it in
   check_global_type c gtype glob.at;
-  let `Global (_mut, t) = gtype in
+  let GlobalT (_mut, t) = gtype in
   check_const c ginit t
 
 
@@ -770,7 +770,7 @@ let check_global (c : context) (glob : global) =
 
 let check_start (c : context) (start : start) =
   let {sfunc} = start.it in
-  require (func c sfunc = `Func ([], [])) start.at
+  require (func c sfunc = FuncT ([], [])) start.at
     "start function must not have parameters or results"
 
 let check_type (c : context) (ty : type_) : context =

From 0f30adbc3d6379803b69e23937bc02a6f67540a0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Daniel=20Hillerstr=C3=B6m?= <daniel.hillerstrom@ed.ac.uk>
Date: Thu, 28 Jul 2022 16:30:07 +0100
Subject: [PATCH 148/285] Minor syntactic consistency fix (#68)

Change pseudo equality operator from `==` to `=`.
---
 document/core/appendix/algorithm.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/appendix/algorithm.rst b/document/core/appendix/algorithm.rst
index 8ddbd6317..1fd7eecce 100644
--- a/document/core/appendix/algorithm.rst
+++ b/document/core/appendix/algorithm.rst
@@ -67,7 +67,7 @@ Equivalence and subtyping checks can be defined on these types.
    func matches(t1 : val_type, t2 : val_type) : bool =
      return
        (is_num t1 && is_num t2 && t1 = t2) ||
-       (is_vec t1 && is_vec t2 && t1 == t2) ||
+       (is_vec t1 && is_vec t2 && t1 = t2) ||
        (is_ref t1 && is_ref t2 && matches_ref(t1, t2)) ||
        t1 = Bot
 

From f831cff61e52dbc892aff2fe9b8164605d63ccc9 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 28 Jul 2022 17:46:16 +0200
Subject: [PATCH 149/285] Bump version

---
 document/core/conf.py    | 2 +-
 interpreter/main/main.ml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/conf.py b/document/core/conf.py
index 172fb7ba5..947fce497 100644
--- a/document/core/conf.py
+++ b/document/core/conf.py
@@ -79,7 +79,7 @@
 # built documents.
 #
 # The short X.Y version.
-version = u'2.0'
+version = u'2.1'
 # The full version, including alpha/beta/rc tags.
 release = version + ('' if proposal == '' else ' + ') + proposal + draft
 
diff --git a/interpreter/main/main.ml b/interpreter/main/main.ml
index 898bdef1d..507e1801a 100644
--- a/interpreter/main/main.ml
+++ b/interpreter/main/main.ml
@@ -1,5 +1,5 @@
 let name = "wasm"
-let version = "2.0"
+let version = "2.1"
 
 let configure () =
   Import.register (Utf8.decode "spectest") Spectest.lookup;

From 27fc520a254060320ec9e709343093623ca97a54 Mon Sep 17 00:00:00 2001
From: cosine <CosineP@users.noreply.github.com>
Date: Fri, 29 Jul 2022 15:08:44 -0400
Subject: [PATCH 150/285] [spec] Fix table.copy validation typo (#1511)

---
 document/core/valid/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index a6d6b007a..2676905ff 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -875,7 +875,7 @@ Table Instructions
    \frac{
      C.\CTABLES[x] = \limits_1~t
      \qquad
-     C.\CTABLES[x] = \limits_2~t
+     C.\CTABLES[y] = \limits_2~t
    }{
      C \vdashinstr \TABLECOPY~x~y : [\I32~\I32~\I32] \to []
    }

From 1945563c50eed0c2ddf918b7ae8666f1b1685723 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Sat, 30 Jul 2022 19:10:49 +0200
Subject: [PATCH 151/285] More fixes

---
 document/core/appendix/embedding.rst  |  3 ++
 document/core/appendix/properties.rst | 20 ++++-----
 document/core/exec/modules.rst        | 62 ++++++++++++++-------------
 document/core/exec/types.rst          | 23 ++++++++--
 document/core/syntax/types.rst        |  3 +-
 document/core/util/macros.def         |  2 +
 6 files changed, 69 insertions(+), 44 deletions(-)

diff --git a/document/core/appendix/embedding.rst b/document/core/appendix/embedding.rst
index db83ae26b..a02ac76ca 100644
--- a/document/core/appendix/embedding.rst
+++ b/document/core/appendix/embedding.rst
@@ -64,6 +64,9 @@ In addition to pre- and post-conditions explicitly stated with each operation, t
 .. index:: allocation, store
 .. _embed-store:
 
+.. todo:: Update alloc functions to semantic types.
+
+
 Store
 ~~~~~
 
diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index a38d2e4b4..0a779a2a2 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -542,9 +542,7 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
 
 .. math::
    \frac{
-     (S \vdashvaltype t_1 \ok)^\ast
-     \qquad
-     (S \vdashvaltype t_2 \ok)^\ast
+     S \vdashinstrtype [t_1^\ast] \to [t_2^\ast] \ok
    }{
      S; C \vdashadmininstr \TRAP : [t_1^\ast] \to [t_2^\ast]
    }
@@ -555,12 +553,12 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
 :math:`\REFEXTERNADDR~\externaddr`
 ..................................
 
-* The instruction is valid with type :math:`[] \to [\EXTERNREF]`.
+* The instruction is valid with type :math:`[] \to [(\REF~\NULL~\EXTERN)]`.
 
 .. math::
    \frac{
    }{
-     S; C \vdashadmininstr \REFEXTERNADDR~\externaddr : [] \to [\EXTERNREF]
+     S; C \vdashadmininstr \REFEXTERNADDR~\externaddr : [] \to [(\REF~\NULL~\EXTERN)]
    }
 
 
@@ -571,13 +569,13 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
 
 * The :ref:`external function value <syntax-externval>` :math:`\EVFUNC~\funcaddr` must be :ref:`valid <valid-externval-func>` with :ref:`external function type <syntax-externtype>` :math:`\ETFUNC \functype`.
 
-* Then the instruction is valid with type :math:`[] \to [\FUNCREF]`.
+* Then the instruction is valid with type :math:`[] \to [(\REF~\NULL~\FUNC)]`.
 
 .. math::
    \frac{
      S \vdashexternval \EVFUNC~\funcaddr : \ETFUNC~\functype
    }{
-     S; C \vdashadmininstr \REFFUNCADDR~\funcaddr : [] \to [\FUNCREF]
+     S; C \vdashadmininstr \REFFUNCADDR~\funcaddr : [] \to [(\REF~\NULL~\FUNC)]
    }
 
 
@@ -603,20 +601,20 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
 :math:`\LABEL_n\{\instr_0^\ast\}~\instr^\ast~\END`
 ..................................................
 
-* The instruction sequence :math:`\instr_0^\ast` must be :ref:`valid <valid-instr-seq>` with some type :math:`[t_1^n] \to [t_2^*]`.
+* The instruction sequence :math:`\instr_0^\ast` must be :ref:`valid <valid-instr-seq>` with some type :math:`[t_1^n] \to_{x^\ast} [t_2^*]`.
 
 * Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the :ref:`result type <syntax-resulttype>` :math:`[t_1^n]` prepended to the |CLABELS| vector.
 
 * Under context :math:`C'`,
-  the instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[] \to [t_2^*]`.
+  the instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[] \to_{{x'}^\ast} [t_2^*]`.
 
 * Then the compound instruction is valid with type :math:`[] \to [t_2^*]`.
 
 .. math::
    \frac{
-     S; C \vdashinstrseq \instr_0^\ast : [t_1^n] \to [t_2^*]
+     S; C \vdashinstrseq \instr_0^\ast : [t_1^n] \to_{x^\ast} [t_2^*]
      \qquad
-     S; C,\CLABELS\,[t_1^n] \vdashinstrseq \instr^\ast : [] \to [t_2^*]
+     S; C,\CLABELS\,[t_1^n] \vdashinstrseq \instr^\ast : [] \to_{{x'}^\ast} [t_2^*]
    }{
      S; C \vdashadmininstr \LABEL_n\{\instr_0^\ast\}~\instr^\ast~\END : [] \to [t_2^*]
    }
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index b7fdc2805..a7dc82dda 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -170,7 +170,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 
 3. Assert: due to :ref:`validation <valid-module>`, any :ref:`type index <syntax-typeidx>` occurring in :math:`\functype` is smaller than the length of :math:`\moduleinst.\MITYPES`.
 
-4. Let :math:`\typeinst` be the :ref:`type instance <syntax-typeinst>` obtained from :math:`\functype` by substituting each :ref:`type index <syntax-typeidx>` :math:`x` occurring in it with the :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.\MITYPES[x]`.
+4. Let :math:`\typeinst` be the :ref:`type instance <syntax-typeinst>` obtained by :ref:`instantiating <sem>` :math:`\functype` inside :math:`\moduleinst`.
 
 5. Append :math:`\typeinst` to the |STYPES| of :math:`S`.
 
@@ -179,15 +179,15 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 .. math::
    ~\\[-1ex]
    \begin{array}{rlll}
-   \alloctype(S, \moduleinst, \functype) &=& S', \typeaddr \\[1ex]
+   \alloctype(S, \functype, \moduleinst) &=& S', \typeaddr \\[1ex]
    \mbox{where:} \hfill \\
    \typeaddr &=& |S.\STYPES| \\
-   \typeinst &=& \functype[\subst \moduleinst.\MITYPES] \\
+   \typeinst &=& \sem_\moduleinst(\functype) \\
    S' &=& S \compose \{\STYPES~\typeinst\} \\
    \end{array}
 
 
-.. index:: function, function instance, function address, module instance, function type
+.. index:: function, function instance, function address, module instance, function type, type instance
 .. _alloc-func:
 
 :ref:`Functions <syntax-funcinst>`
@@ -199,15 +199,13 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 
 3. Let :math:`\typeaddr` be the :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.\MITYPES[\func.\FTYPE]`.
 
-4. Let :math:`\functype` be the :ref:`function type <syntax-functype>` :math:`S.\STYPES[\typeaddr]`.
+4. Let :math:`\functype` be the :ref:`semantic <syntax-typeid>` :ref:`function type <syntax-functype>` :math:`S.\STYPES[\typeaddr]`.
 
-5. Let :math:`\functype'` be the :ref:`function type <syntax-functype>` obtained from :math:`\functype` by substituting each :ref:`type index <syntax-typeidx>` :math:`x` occurring in it with the :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.\MITYPES[x]`.
+5. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`\{ \FITYPE~\functype', \FIMODULE~\moduleinst, \FICODE~\func \}`.
 
-6. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`\{ \FITYPE~\functype', \FIMODULE~\moduleinst, \FICODE~\func \}`.
+6. Append :math:`\funcinst` to the |SFUNCS| of :math:`S`.
 
-7. Append :math:`\funcinst` to the |SFUNCS| of :math:`S`.
-
-8. Return :math:`a`.
+7. Return :math:`a`.
 
 .. math::
    ~\\[-1ex]
@@ -216,7 +214,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
    \mbox{where:} \hfill \\
    \funcaddr &=& |S.\SFUNCS| \\
    \functype &=& S.\STYPES[\moduleinst.\MITYPES[\func.\FTYPE]] \\
-   \funcinst &=& \{ \FITYPE~\functype[\subst \moduleinst.\MITYPES], \FIMODULE~\moduleinst, \FICODE~\func \} \\
+   \funcinst &=& \{ \FITYPE~\functype, \FIMODULE~\moduleinst, \FICODE~\func \} \\
    S' &=& S \compose \{\SFUNCS~\funcinst\} \\
    \end{array}
 
@@ -258,7 +256,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 :ref:`Tables <syntax-tableinst>`
 ................................
 
-1. Let :math:`\tabletype` be the :ref:`semantic <syntax-typeid>` :ref:`table type <syntax-tabletype>` to allocate and :math:`\reff` the initialization value.
+1. Let :math:`\tabletype` be the :ref:`semantic <syntax-typeid>` :ref:`table type <syntax-tabletype>` of the table to allocate and :math:`\reff` the initialization value.
 
 2. Let :math:`(\{\LMIN~n, \LMAX~m^?\}~\reftype)` be the structure of :ref:`table type <syntax-tabletype>` :math:`\tabletype`.
 
@@ -289,7 +287,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 :ref:`Memories <syntax-meminst>`
 ................................
 
-1. Let :math:`\memtype` be the :ref:`semantic <syntax-typeid>` :ref:`memory type <syntax-memtype>` to allocate.
+1. Let :math:`\memtype` be the :ref:`semantic <syntax-typeid>` :ref:`memory type <syntax-memtype>` of the memory to allocate.
 
 2. Let :math:`\{\LMIN~n, \LMAX~m^?\}` be the structure of :ref:`memory type <syntax-memtype>` :math:`\memtype`.
 
@@ -303,7 +301,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 
 .. math::
    \begin{array}{rlll}
-   \allocmem(S, \memtype, \moduleinst) &=& S', \memaddr \\[1ex]
+   \allocmem(S, \memtype) &=& S', \memaddr \\[1ex]
    \mbox{where:} \hfill \\
    \memtype &=& \{\LMIN~n, \LMAX~m^?\} \\
    \memaddr &=& |S.\SMEMS| \\
@@ -318,7 +316,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 :ref:`Globals <syntax-globalinst>`
 ..................................
 
-1. Let :math:`\globaltype` be the :ref:`semantic <syntax-typeid>` :ref:`global type <syntax-globaltype>` to allocate and :math:`\val` the :ref:`value <syntax-val>` to initialize the global with.
+1. Let :math:`\globaltype` be the :ref:`semantic <syntax-typeid>` :ref:`global type <syntax-globaltype>` of the global to allocate and :math:`\val` its initialization :ref:`value <syntax-val>`.
 
 2. Let :math:`a` be the first free :ref:`global address <syntax-globaladdr>` in :math:`S`.
 
@@ -344,7 +342,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 :ref:`Element segments <syntax-eleminst>`
 .........................................
 
-1. Let :math:`\reftype` be the elements':ref:`semantic <syntax-typeid>` type and :math:`\reff^\ast` the vector of :ref:`references <syntax-ref>` to allocate.
+1. Let :math:`\reftype` be the elements' :ref:`semantic <syntax-typeid>` type and :math:`\reff^\ast` the vector of :ref:`references <syntax-ref>` to allocate.
 
 2. Let :math:`a` be the first free :ref:`element address <syntax-elemaddr>` in :math:`S`.
 
@@ -486,22 +484,28 @@ and list of :ref:`reference <syntax-ref>` vectors for the module's :ref:`element
 
 4. For each :ref:`table <syntax-table>` :math:`\table_i` in :math:`\module.\MTABLES`, do:
 
-   a. Let :math:`\limits_i~t_i` be the :ref:`table type <syntax-tabletype>` :math:`\table_i.\TTYPE`.
+   a. Let :math:`\limits_i~t_i` be the :ref:`semantic <syntax-typeid>` :ref:`table type <syntax-tabletype>` obtained from :math:`\table_i.\TTYPE` in :math:`\moduleinst` defined below.
 
    b. Let :math:`\tableaddr_i` be the :ref:`table address <syntax-tableaddr>` resulting from :ref:`allocating <alloc-table>` :math:`\table_i.\TTYPE`
    with initialization value :math:`\REFNULL~t_i`.
 
 5. For each :ref:`memory <syntax-mem>` :math:`\mem_i` in :math:`\module.\MMEMS`, do:
 
-   a. Let :math:`\memaddr_i` be the :ref:`memory address <syntax-memaddr>` resulting from :ref:`allocating <alloc-mem>` :math:`\mem_i.\MTYPE`.
+   a. Let :math:`\memtype_i` be the :ref:`semantic <syntax-typeid>` :ref:`memory type <syntax-memtype>` obtained from :math:`\mem_i.\MTYPE` in :math:`\moduleinst` defined below.
+
+   b. Let :math:`\memaddr_i` be the :ref:`memory address <syntax-memaddr>` resulting from :ref:`allocating <alloc-mem>` :math:`\memtype_i`.
 
 6. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\MGLOBALS`, do:
 
-   a. Let :math:`\globaladdr_i` be the :ref:`global address <syntax-globaladdr>` resulting from :ref:`allocating <alloc-global>` :math:`\global_i.\GTYPE` with initializer value :math:`\val^\ast[i]`.
+   a. Let :math:`\globaltype_i` be the :ref:`semantic <syntax-typeid>` :ref:`global type <syntax-globaltype>` obtained from :math:`\global_i.\GTYPE` in :math:`\moduleinst` defined below.
+
+   b. Let :math:`\globaladdr_i` be the :ref:`global address <syntax-globaladdr>` resulting from :ref:`allocating <alloc-global>` :math:`\globaltype_i` with initializer value :math:`\val^\ast[i]`.
 
 7. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEMS`, do:
 
-   a. Let :math:`\elemaddr_i` be the :ref:`element address <syntax-elemaddr>` resulting from :ref:`allocating <alloc-elem>` a :ref:`element instance <syntax-eleminst>` of :ref:`reference type <syntax-reftype>` :math:`\elem_i.\ETYPE` with contents :math:`(\reff^\ast)^\ast[i]`.
+   a. Let :math:`\reftype_i` be the :ref:`semantic <syntax-typeid>` element :ref:`reference type <syntax-reftype>` obtained from :math:`\elem_i.\ETYPE` in :math:`\moduleinst` defined below.
+
+   b. Let :math:`\elemaddr_i` be the :ref:`element address <syntax-elemaddr>` resulting from :ref:`allocating <alloc-elem>` a :ref:`element instance <syntax-eleminst>` of :ref:`reference type <syntax-reftype>` :math:`\reftype_i` with contents :math:`(\reff^\ast)^\ast[i]`.
 
 8. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATAS`, do:
 
@@ -580,16 +584,16 @@ where:
    S_2, \funcaddr^\ast &=&
      \allocfunc^\ast(S_1, \module.\MFUNCS, \moduleinst) \\
    S_3, \tableaddr^\ast &=&
-     \alloctable^\ast(S_2, (\table.\TTYPE)^\ast, (\REFNULL~t)^\ast)
+     \alloctable^\ast(S_2, \sem_\moduleinst(\table.\TTYPE)^\ast, (\REFNULL~t)^\ast)
      \quad (\where (\table.\TTYPE)^\ast = (\limits~t)^\ast) \\
    S_4, \memaddr^\ast &=&
-     \allocmem^\ast(S_3, (\mem.\MTYPE)^\ast) \\
+     \allocmem^\ast(S_3, \sem_\moduleinst(\mem.\MTYPE)^\ast) \\
    S_5, \globaladdr^\ast &=&
-     \allocglobal^\ast(S_3, (\global.\GTYPE)^\ast, \val^\ast) \\
+     \allocglobal^\ast(S_3, \sem_\moduleinst(\global.\GTYPE)^\ast, \val^\ast) \\
    S_6, \elemaddr^\ast &=&
-     \allocelem^\ast(S_5, (\elem.\ETYPE)^\ast, (\reff^\ast)^\ast) \\
+     \allocelem^\ast(S_5, \sem_\moduleinst(\elem.\ETYPE)^\ast, (\reff^\ast)^\ast) \\
    S', \dataaddr^\ast &=&
-     \allocdata^\ast(S_6, (\data.\DINIT)^\ast) \\
+     \allocdata^\ast(S_6, \sem_\moduleinst(\data.\DINIT)^\ast) \\
    \exportinst^\ast &=&
      \{ \EINAME~(\export.\ENAME), \EIVALUE~\externval_{\F{ex}} \}^\ast \\[1ex]
    \evfuncs(\externval_{\F{ex}}^\ast) &=& (\moduleinst.\MIFUNCS[x])^\ast
@@ -658,7 +662,7 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
       i. Fail.
 
-   b. Let :math:`\externtype''_i` be the :ref:`semantic <syntax-typeid>` :ref:`external type <syntax-externtype>` obtained from :math:`\externtype'_i` by :ref:`substituting <notation-subst>` the :ref:`type indices <syntax-typeidx>` defined in :math:`\module` with the :ref:`type addresses <syntax-typeaddr>` they map to in :math:`\moduleinst.\MITYPES` defined below.
+   b. Let :math:`\externtype''_i` be the :ref:`semantic <syntax-typeid>` :ref:`external type <syntax-externtype>` obtained by :ref:`instantiating <sem>` :math:`\externtype'_i` in :math:`\moduleinst` defined below.
 
    c. If :math:`\externtype_i` does not :ref:`match <match-externtype>` :math:`\externtype''_i`, then:
 
@@ -755,7 +759,7 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
    &(\iff
      & \vdashmodule \module : \externtype_{\F{im}}^k \to \externtype_{\F{ex}}^\ast \\
      &\wedge& (S' \vdashexternval \externval : \externtype)^k \\
-     &\wedge& (S' \vdashexterntypematch \externtype \matchesexterntype \externtype_{\F{im}}[\subst \moduleinst.\MITABLES])^k \\[1ex]
+     &\wedge& (S' \vdashexterntypematch \externtype \matchesexterntype \sem_\moduleinst(\externtype_{\F{im}}))^k \\[1ex]
      &\wedge& \module.\MGLOBALS = \global^\ast \\
      &\wedge& \module.\MELEMS = \elem^n \\
      &\wedge& \module.\MDATAS = \data^m \\
@@ -786,9 +790,9 @@ where:
    \end{array}
 
 .. note::
-   Checking import types assumes that the :ref:`module instance <syntax-moduleinst>` has already been :ref:`allocated <alloc-module>` and the resulting :ref:`type addresses <syntax-typeaddr>` are available, in order to be substituted for the local :ref:`type indices <syntax-typeidx>` and both types are consistently :ref:`semantic <syntax-typeid>`.
+   Checking import types assumes that the :ref:`module instance <syntax-moduleinst>` has already been :ref:`allocated <alloc-module>` and the resulting :ref:`type addresses <syntax-typeaddr>` are available, in order to :ref:`instantiate <sem>` all relevant types.
    However, this forward reference merely is a way to simplify the specification.
-   In practice, it can be implemented by staging module allocation such that the module's own :math:`type instances <syntax-typeinst>` are pre-allocated in the store before checking imports, and discarded in case the imports fail to type-check.
+   In practice, implementations will likely allocate or canonicalize types beforehand, when *compiling* a module, in a stage before instantiation and before imports are checked.
 
    Similarly, module :ref:`allocation <alloc-module>` and the :ref:`evaluation <exec-expr>` of :ref:`global <syntax-global>` initializers and :ref:`element segments <syntax-elem>` are mutually recursive because the global initialization :ref:`values <syntax-val>` :math:`\val^\ast` and element segment contents :math:`(\reff^\ast)^\ast` are passed to the module allocator while depending on the module instance :math:`\moduleinst` and store :math:`S'` returned by allocation.
    Again, this recursion is just a specification device.
diff --git a/document/core/exec/types.rst b/document/core/exec/types.rst
index a23055c2b..c20a158c6 100644
--- a/document/core/exec/types.rst
+++ b/document/core/exec/types.rst
@@ -4,9 +4,13 @@
 Types
 -----
 
-Execution has to check and compare types and :ref:`type instances <syntax-typeinst>` in a few places, such as :ref:`executing <exec-call_indirect>` |CALLINDIRECT| or :ref:`instantiating <exec-instantiation>` :ref:`modules <syntax-module>`.
-However, types are represented as :ref:`semantic <syntax-semantic>` types during execution.
-Therefore, relevant type relations on syntactic types need to be redefined for execution.
+Execution has to check and compare :ref:`types <syntax-type>` and :ref:`type instances <syntax-typeinst>` in a few places, such as :ref:`executing <exec-call_indirect>` |CALLINDIRECT| or :ref:`instantiating <exec-instantiation>` :ref:`modules <syntax-module>`.
+During execution, types of all forms are represented as :ref:`semantic <syntax-typeid>` types, where all occurring :ref:`type identifiers <syntax-typeid>` are interpreted as :ref:`type addresses <syntax-typeaddr>`.
+Relevant type relations need to be redefined accordingly.
+
+.. note::
+   Runtime type checks generally involve types from multiple modules or types not defined by a module at all, such that module-local :ref:`type indices <syntax-typeidx>` are not meaningful.
+   Type addresses are global to a :ref:`store <syntax-store>` and can hence be interpreted independent of module boundaries.
 
 
 .. index:: type identifier, type address, store
@@ -38,6 +42,19 @@ During execution, :ref:`type identifiers <syntax-typeid>` are represented as :re
    Unlike :ref:`type indices <syntax-typeidx>` recorded in a context, the number of type addresses in a store is not bounded by :math:`2^{32}`.
 
 
+.. index:: type identifier, type index, type address, type instantiation, module instance
+
+.. _sem:
+
+Instantiation
+~~~~~~~~~~~~~
+
+Any form of :ref:`syntactic <syntax-typeid>` :ref:`type <syntax-type>` can be *instantiated* into a semantic type inside a :ref:`module instance <syntax-moduleinst>` by :ref:`substituting <notation-subst>` each :ref:`type index <syntax-typeidx>` :math:`x` occurring in it with the corresponding :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.\MITYPES[x]`.
+
+.. math::
+   \sem_\moduleinst(t) = t[\subst \moduleinst.\MITYPES]
+
+
 .. index:: type, matching, store, semantic types
 .. _exec-match:
 
diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index 19db14c85..a064c0c97 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -18,7 +18,7 @@ Types are checked during :ref:`validation <valid>`, :ref:`instantiation <exec-in
 Type Identifiers
 ~~~~~~~~~~~~~~~~
 
-Types such as :ref:`function types <syntax-functype>` are not embedded directly into other types, such as :ref:`reference types <syntax-reftype>`.
+Defined types like :ref:`function types <syntax-functype>` are not embedded directly into other types, such as :ref:`reference types <syntax-reftype>`.
 Instead, they are referred to indirectly.
 
 In a :ref:`module <syntax-module>` and during validation, this indirection is expressed through a :ref:`type index <syntax-typeidx>`, whose meaning is confined to one module.
@@ -34,6 +34,7 @@ The type grammar hence is conceptually parameterized by its interpretation of :r
 
 Types represented with type indices are referred to as *syntactic types*,
 whereas types represented with type addresses are referred to as *semantic types*.
+
 It is an invariant of the semantics that no syntactic type refers to a semantic type and vice versa, i.e., both universes are disjoint.
 Syntactic types are transformed into semantic types during module :ref:`instantiation <exec-instantiation>`.
 
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index 8cdec85aa..0b93afd4c 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -877,6 +877,8 @@
 
 .. Allocation
 
+.. |sem| mathdef:: \xref{exec/types}{sem}{\F{sem}}
+
 .. |alloctype| mathdef:: \xref{exec/modules}{alloc-type}{\F{alloctype}}
 .. |allocfunc| mathdef:: \xref{exec/modules}{alloc-func}{\F{allocfunc}}
 .. |allochostfunc| mathdef:: \xref{exec/modules}{alloc-hostfunc}{\F{allochostfunc}}

From 0a41ac775cc61d123afe9d312c987b70a896cacc Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Mon, 1 Aug 2022 11:15:49 +0200
Subject: [PATCH 152/285] Fix Latex

---
 document/core/appendix/properties.rst |  4 +++-
 document/core/exec/modules.rst        | 14 +++++++-------
 document/core/exec/types.rst          |  3 +--
 3 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index 0a779a2a2..05973f62a 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -542,7 +542,9 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
 
 .. math::
    \frac{
-     S \vdashinstrtype [t_1^\ast] \to [t_2^\ast] \ok
+     S \vdashresulttype [t_1^\ast] \ok
+     \qquad
+     S \vdashresulttype [t_2^\ast] \ok
    }{
      S; C \vdashadmininstr \TRAP : [t_1^\ast] \to [t_2^\ast]
    }
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index a7dc82dda..1fd727678 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -182,7 +182,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
    \alloctype(S, \functype, \moduleinst) &=& S', \typeaddr \\[1ex]
    \mbox{where:} \hfill \\
    \typeaddr &=& |S.\STYPES| \\
-   \typeinst &=& \sem_\moduleinst(\functype) \\
+   \typeinst &=& \sem_{\moduleinst}(\functype) \\
    S' &=& S \compose \{\STYPES~\typeinst\} \\
    \end{array}
 
@@ -584,16 +584,16 @@ where:
    S_2, \funcaddr^\ast &=&
      \allocfunc^\ast(S_1, \module.\MFUNCS, \moduleinst) \\
    S_3, \tableaddr^\ast &=&
-     \alloctable^\ast(S_2, \sem_\moduleinst(\table.\TTYPE)^\ast, (\REFNULL~t)^\ast)
+     \alloctable^\ast(S_2, \sem_{\moduleinst}(\table.\TTYPE)^\ast, (\REFNULL~t)^\ast)
      \quad (\where (\table.\TTYPE)^\ast = (\limits~t)^\ast) \\
    S_4, \memaddr^\ast &=&
-     \allocmem^\ast(S_3, \sem_\moduleinst(\mem.\MTYPE)^\ast) \\
+     \allocmem^\ast(S_3, \sem_{\moduleinst}(\mem.\MTYPE)^\ast) \\
    S_5, \globaladdr^\ast &=&
-     \allocglobal^\ast(S_3, \sem_\moduleinst(\global.\GTYPE)^\ast, \val^\ast) \\
+     \allocglobal^\ast(S_3, \sem_{\moduleinst}(\global.\GTYPE)^\ast, \val^\ast) \\
    S_6, \elemaddr^\ast &=&
-     \allocelem^\ast(S_5, \sem_\moduleinst(\elem.\ETYPE)^\ast, (\reff^\ast)^\ast) \\
+     \allocelem^\ast(S_5, \sem_{\moduleinst}(\elem.\ETYPE)^\ast, (\reff^\ast)^\ast) \\
    S', \dataaddr^\ast &=&
-     \allocdata^\ast(S_6, \sem_\moduleinst(\data.\DINIT)^\ast) \\
+     \allocdata^\ast(S_6, \sem_{\moduleinst}(\data.\DINIT)^\ast) \\
    \exportinst^\ast &=&
      \{ \EINAME~(\export.\ENAME), \EIVALUE~\externval_{\F{ex}} \}^\ast \\[1ex]
    \evfuncs(\externval_{\F{ex}}^\ast) &=& (\moduleinst.\MIFUNCS[x])^\ast
@@ -759,7 +759,7 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
    &(\iff
      & \vdashmodule \module : \externtype_{\F{im}}^k \to \externtype_{\F{ex}}^\ast \\
      &\wedge& (S' \vdashexternval \externval : \externtype)^k \\
-     &\wedge& (S' \vdashexterntypematch \externtype \matchesexterntype \sem_\moduleinst(\externtype_{\F{im}}))^k \\[1ex]
+     &\wedge& (S' \vdashexterntypematch \externtype \matchesexterntype \sem_{\moduleinst}(\externtype_{\F{im}}))^k \\[1ex]
      &\wedge& \module.\MGLOBALS = \global^\ast \\
      &\wedge& \module.\MELEMS = \elem^n \\
      &\wedge& \module.\MDATAS = \data^m \\
diff --git a/document/core/exec/types.rst b/document/core/exec/types.rst
index c20a158c6..b1f013241 100644
--- a/document/core/exec/types.rst
+++ b/document/core/exec/types.rst
@@ -17,7 +17,6 @@ Relevant type relations need to be redefined accordingly.
    pair: validation; type identifier
    single: abstract syntax; type identifier
 .. _valid-typeaddr:
-.. _valid-typeinst:
 
 Type Identifiers
 ~~~~~~~~~~~~~~~~
@@ -52,7 +51,7 @@ Instantiation
 Any form of :ref:`syntactic <syntax-typeid>` :ref:`type <syntax-type>` can be *instantiated* into a semantic type inside a :ref:`module instance <syntax-moduleinst>` by :ref:`substituting <notation-subst>` each :ref:`type index <syntax-typeidx>` :math:`x` occurring in it with the corresponding :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.\MITYPES[x]`.
 
 .. math::
-   \sem_\moduleinst(t) = t[\subst \moduleinst.\MITYPES]
+   \sem_{\moduleinst}(t) = t[\subst \moduleinst.\MITYPES]
 
 
 .. index:: type, matching, store, semantic types

From 8994306f0c34fa7d7ebc841f417b06224973b66f Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Mon, 1 Aug 2022 16:59:16 +0200
Subject: [PATCH 153/285] Adjust intro

---
 document/core/intro/overview.rst | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/document/core/intro/overview.rst b/document/core/intro/overview.rst
index 6973396c0..06c0ed83b 100644
--- a/document/core/intro/overview.rst
+++ b/document/core/intro/overview.rst
@@ -58,11 +58,10 @@ This language is structured around the following concepts.
 .. _table:
 
 **Tables**
-  A *table* is an array of opaque values of a particular *element type*.
+  A *table* is an array of opaque values of a particular *reference type*.
   It allows programs to select such values indirectly through a dynamic index operand.
-  Currently, the only available element type is an untyped function reference.
-  Thereby, a program can call functions indirectly through a dynamic index into a table.
-  For example, this allows emulating function pointers by way of table indices.
+  Thereby, for example, a program can call functions indirectly through a dynamic index into a table.
+  This allows emulating function pointers by way of table indices.
 
 .. _memory:
 

From 6194785ac4f882332cefefa8bb099d19a40dc974 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Tue, 2 Aug 2022 09:56:24 +0200
Subject: [PATCH 154/285] Spec local initialization (#67)

---
 document/core/appendix/algorithm.rst   | 106 ++++++++++++++++++-----
 document/core/appendix/changes.rst     |  11 +++
 document/core/appendix/index-rules.rst |  19 ++++-
 document/core/binary/modules.rst       |  10 +--
 document/core/exec/instructions.rst    |  19 +++--
 document/core/exec/runtime.rst         |  11 ++-
 document/core/syntax/modules.rst       |   4 +-
 document/core/syntax/types.rst         |  49 +++++++++++
 document/core/text/modules.rst         |   6 +-
 document/core/util/macros.def          |  14 ++-
 document/core/valid/conventions.rst    |  16 ++--
 document/core/valid/instructions.rst   | 113 ++++++++++++++-----------
 document/core/valid/modules.rst        |  57 ++++++++++++-
 document/core/valid/types.rst          |  85 +++++++++++++------
 14 files changed, 387 insertions(+), 133 deletions(-)

diff --git a/document/core/appendix/algorithm.rst b/document/core/appendix/algorithm.rst
index 1fd7eecce..10f6b2506 100644
--- a/document/core/appendix/algorithm.rst
+++ b/document/core/appendix/algorithm.rst
@@ -21,7 +21,10 @@ The algorithm is expressed in typed pseudo code whose semantics is intended to b
 Data Structures
 ~~~~~~~~~~~~~~~
 
-Types are representable as a set of enumerations.
+Types
+.....
+
+Value types are representable as a set of enumerations.
 
 .. code-block:: pseudo
 
@@ -65,37 +68,64 @@ Equivalence and subtyping checks can be defined on these types.
      return matches_heap(t1.heap, t2.heap) && matches_null(t1.null, t2.null)
 
    func matches(t1 : val_type, t2 : val_type) : bool =
-     return
-       (is_num t1 && is_num t2 && t1 = t2) ||
-       (is_vec t1 && is_vec t2 && t1 = t2) ||
-       (is_ref t1 && is_ref t2 && matches_ref(t1, t2)) ||
-       t1 = Bot
+     switch (t1, t2)
+       case (Ref(_), Ref(_))
+         return matches_ref(t1, t2)
+       case (Bot, _)
+         return true
+       case (_, _)
+         return t1 = t2
+
+Context
+.......
+
+Validation requires a :ref:`context <context>` for checking uses of :ref:`indices <syntax-index>`.
+For the purpose of presenting the algorithm, it is maintained in a set of global variables:
+
+.. code-block:: pseudo
+
+   var locals : array(val_type)
+   var locals_init : array(bool)
+   var globals : array(global_type)
+   var funcs : array(func_type)
+   var tables : array(table_type)
+   var mems : array(mem_type)
+
+This assumes suitable representations for the various :ref:`types <syntax-type>` besides :code:`val_type`, which are omitted here.
+
+For locals, there is an additional array recording the initialization status of each local.
+
+Stacks
+......
 
-The algorithm uses two separate stacks: the *value stack* and the *control stack*.
-The former tracks the :ref:`types <syntax-valtype>` of operand values on the :ref:`stack <stack>`,
-the latter surrounding :ref:`structured control instructions <syntax-instr-control>` and their associated :ref:`blocks <syntax-instr-control>`.
+The algorithm uses three separate stacks: the *value stack*, the *control stack*, and the *initialization stack*.
+The value stack tracks the :ref:`types <syntax-valtype>` of operand values on the :ref:`stack <stack>`.
+The control stack tracks surrounding :ref:`structured control instructions <syntax-instr-control>` and their associated :ref:`blocks <syntax-instr-control>`.
+The initialization stack records all :ref:`locals <syntax-local>` that have been initialized since the beginning of the function.
 
 .. code-block:: pseudo
 
    type val_stack = stack(val_type)
+   type init_stack = stack(u32)
 
    type ctrl_stack = stack(ctrl_frame)
    type ctrl_frame = {
      opcode : opcode
      start_types : list(val_type)
      end_types : list(val_type)
-     height : nat
+     val_height : nat
+     init_height : nat
      unreachable : bool
    }
 
-For each value, the value stack records its :ref:`value type <syntax-valtype>`. 
-For each entered block, the control stack records a *control frame* with the originating opcode, the types on the top of the operand stack at the start and end of the block (used to check its result as well as branches), the height of the operand stack at the start of the block (used to check that operands do not underflow the current block), and a flag recording whether the remainder of the block is unreachable (used to handle :ref:`stack-polymorphic <polymorphism>` typing after branches).
+For each entered block, the control stack records a *control frame* with the originating opcode, the types on the top of the operand stack at the start and end of the block (used to check its result as well as branches), the height of the operand stack at the start of the block (used to check that operands do not underflow the current block), the height of the initialization stack at the start of the block (used to reset initialization status at the end of the block), and a flag recording whether the remainder of the block is unreachable (used to handle :ref:`stack-polymorphic <polymorphism>` typing after branches).
 
-For the purpose of presenting the algorithm, the operand and control stacks are simply maintained as global variables:
+For the purpose of presenting the algorithm, these stacks are simply maintained as global variables:
 
 .. code-block:: pseudo
 
    var vals : val_stack
+   var inits : init_stack
    var ctrls : ctrl_stack
 
 However, these variables are not manipulated directly by the main checking function, but through a set of auxiliary functions:
@@ -123,7 +153,7 @@ However, these variables are not manipulated directly by the main checking funct
    func pop_ref() : ref_type =
      let actual = pop_val()
      error_if(not is_ref(actual))
-     if actual = Bot then return Ref(Bot, false)
+     if (actual = Bot) return Ref(Bot, false)
      return actual
 
    func push_vals(types : list(val_type)) = foreach (t in types) push_val(t)
@@ -150,12 +180,35 @@ Finally, there are accumulative functions for pushing or popping multiple operan
    so that, e.g., :code:`ctrls[0]` accesses the element pushed last.
 
 
+The initialization stack and the initialization status of locals is manipulated through the following functions:
+
+.. code-block:: pseudo
+
+   func get_local(idx : u32) =
+     error_if(not (locals_init[idx] || ctrls[0].unreachable))
+
+   func set_local(idx : u32) =
+     if (not locals_init[idx])
+       inits.push(idx)
+       locals_init[idx] := true
+
+   func reset_locals(height : nat) =
+     while (inits.size() > height)
+       locals_init[inits.pop()] := false
+
+Getting a local verifies that it is either known to be initialized, or that that the operation is unreachable in the current stack frame.
+When a local is set that was not set already,
+then its initialization status is updated and the change is recorded in the initialization stack.
+Thus, the initialization status of all locals can be reset to a previous state by denoting a specific height in the initialization stack.
+
+The size of the initialization stack is bounded by the number of (non-defaultable) locals in a function, so can be preallocated by an algorithm.
+
 The control stack is likewise manipulated through auxiliary functions:
 
 .. code-block:: pseudo
 
    func push_ctrl(opcode : opcode, in : list(val_type), out : list(val_type)) =
-     let frame = ctrl_frame(opcode, in, out, vals.size(), false)
+     let frame = ctrl_frame(opcode, in, out, vals.size(), inits.size(), false)
      ctrls.push(frame)
      push_vals(in)
 
@@ -163,12 +216,13 @@ The control stack is likewise manipulated through auxiliary functions:
      error_if(ctrls.is_empty())
      let frame = ctrls[0]
      pop_vals(frame.end_types)
-     error_if(vals.size() =/= frame.height)
+     error_if(vals.size() =/= frame.val_height)
+     reset_locals(frame.init_height)
      ctrls.pop()
      return frame
 
    func label_types(frame : ctrl_frame) : list(val_types) =
-     return (if frame.opcode == loop then frame.start_types else frame.end_types)
+     return (if (frame.opcode = loop) frame.start_types else frame.end_types)
 
    func unreachable() =
      vals.resize(ctrls[0].height)
@@ -180,6 +234,7 @@ It allocates a new frame record recording them along with the current height of
 Popping a frame first checks that the control stack is not empty.
 It then verifies that the operand stack contains the right types of values expected at the end of the exited block and pops them off the operand stack.
 Afterwards, it checks that the stack has shrunk back to its initial height.
+Finally, it undoes all changes to the initialization status of locals that happend inside the block.
 
 The type of the :ref:`label <syntax-label>` associated with a control frame is either that of the stack at the start or the end of the frame, determined by the opcode that it originates from.
 
@@ -192,6 +247,7 @@ In that case, all existing operand types are purged from the value stack, in ord
    However, a polymorphic stack cannot underflow, but instead generates :code:`Bot` types as needed.
 
 
+
 .. index:: opcode
 
 Validation of Opcode Sequences
@@ -200,10 +256,6 @@ Validation of Opcode Sequences
 The following function shows the validation of a number of representative instructions that manipulate the stack.
 Other instructions are checked in a similar manner.
 
-.. note::
-   Various instructions not shown here will additionally require the presence of a validation :ref:`context <context>` for checking uses of :ref:`indices <syntax-index>`.
-   That is an easy addition and therefore omitted from this presentation.
-
 .. code-block:: pseudo
 
    func validate(opcode) =
@@ -222,7 +274,7 @@ Other instructions are checked in a similar manner.
          let t2 = pop_val()
          error_if(not (is_num(t1) && is_num(t2) || is_vec(t1) && is_vec(t2)))
          error_if(t1 =/= t2 && t1 =/= Bot && t2 =/= Bot)
-         push_val(if (t1 == Bot) t2 else t1)
+         push_val(if (t1 = Bot) t2 else t1)
 
        case (select t)
          pop_val(I32)
@@ -238,6 +290,14 @@ Other instructions are checked in a similar manner.
          let rt = pop_ref()
          push_val(Ref(rt.heap, false))
 
+       case (local.get x)
+         get_local(x)
+         push_val(locals[x])
+
+       case (local.set x)
+         pop_val(locals[x])
+         set_local(x)
+
        case (unreachable)
          unreachable()
 
@@ -296,7 +356,7 @@ Other instructions are checked in a similar manner.
          let rt = pop_ref()
          if (rt.heap =/= Bot)
            error_if(not is_def(rt.heap))
-           let ft = lookup_func_type(rt.heap.idx)  // TODO
+           let ft = funcs[rt.heap.idx]
            pop_vals(ft.params)
            push_vals(ft.results)
 
diff --git a/document/core/appendix/changes.rst b/document/core/appendix/changes.rst
index 339cb25f9..710d574bc 100644
--- a/document/core/appendix/changes.rst
+++ b/document/core/appendix/changes.rst
@@ -138,6 +138,17 @@ Added vector type and instructions that manipulate multiple numeric values in pa
 * New injection/projection :ref:`vector instructions <syntax-instr-vec>`: :math:`\K{i}\!N\!\K{x}\!M\!\K{.splat}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.splat}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.bitmask}`
 
 
+Release 2.1
+~~~~~~~~~~~
+
+.. index:: reference
+
+Typeful References
+..................
+
+.. todo:: describe
+
+
 .. [#proposal-signext]
    https://github.com/WebAssembly/spec/tree/main/proposals/sign-extension-ops/
 
diff --git a/document/core/appendix/index-rules.rst b/document/core/appendix/index-rules.rst
index 755142184..3a21e3c94 100644
--- a/document/core/appendix/index-rules.rst
+++ b/document/core/appendix/index-rules.rst
@@ -14,8 +14,14 @@ Typing of Static Constructs
 Construct                                        Judgement
 ===============================================  ===============================================================================
 :ref:`Limits <valid-limits>`                     :math:`C \vdashlimits \limits : k`
+:ref:`Numeric type <valid-numtype>`              :math:`C \vdashnumtype \numtype \ok`
+:ref:`Vector type <valid-vectype>`               :math:`C \vdashvectype \vectype \ok`
+:ref:`Heap type <valid-heaptype>`                :math:`C \vdashheaptype \heaptype \ok`
+:ref:`Reference type <valid-reftype>`            :math:`C \vdashreftype \reftype \ok`
+:ref:`Value type <valid-valtype>`                :math:`C \vdashvaltype \valtype \ok`
 :ref:`Function type <valid-functype>`            :math:`C \vdashfunctype \functype \ok`
-:ref:`Block type <valid-blocktype>`              :math:`C \vdashblocktype \blocktype \ok`
+:ref:`Block type <valid-blocktype>`              :math:`C \vdashblocktype \blocktype : \instrtype`
+:ref:`Instruction type <valid-instrtype>`        :math:`C \vdashinstrtype \instrtype \ok`
 :ref:`Table type <valid-tabletype>`              :math:`C \vdashtabletype \tabletype \ok`
 :ref:`Memory type <valid-memtype>`               :math:`C \vdashmemtype \memtype \ok`
 :ref:`Global type <valid-globaltype>`            :math:`C \vdashglobaltype \globaltype \ok`
@@ -24,6 +30,7 @@ Construct                                        Judgement
 :ref:`Instruction sequence <valid-instr-seq>`    :math:`S;C \vdashinstrseq \instr^\ast : \functype`
 :ref:`Expression <valid-expr>`                   :math:`C \vdashexpr \expr : \resulttype`
 :ref:`Function <valid-func>`                     :math:`C \vdashfunc \func : \functype`
+:ref:`Local <valid-local>`                       :math:`C \vdashlocal \local : \localtype`
 :ref:`Table <valid-table>`                       :math:`C \vdashtable \table : \tabletype`
 :ref:`Memory <valid-mem>`                        :math:`C \vdashmem \mem : \memtype`
 :ref:`Global <valid-global>`                     :math:`C \vdashglobal \global : \globaltype`
@@ -66,6 +73,16 @@ Construct                                        Judgement
 ===============================================  ===============================================================================
 
 
+Defaultability
+~~~~~~~~~~~~~~
+
+=================================================  ===============================================================================
+Construct                                          Judgement
+=================================================  ===============================================================================
+:ref:`Defaultable value type <valid-defaultable>`  :math:`C \vdashvaltypedefaultable \valtype \defaultable`
+=================================================  ===============================================================================
+
+
 Constantness
 ~~~~~~~~~~~~
 
diff --git a/document/core/binary/modules.rst b/document/core/binary/modules.rst
index e9c72b61a..607014411 100644
--- a/document/core/binary/modules.rst
+++ b/document/core/binary/modules.rst
@@ -405,15 +405,15 @@ denoting *count* locals of the same value type.
      \X{size}{:}\Bu32~~\X{code}{:}\Bfunc
        &\Rightarrow& \X{code} & (\iff \X{size} = ||\Bfunc||) \\
    \production{function} & \Bfunc &::=&
-     (t^\ast)^\ast{:}\Bvec(\Blocals)~~e{:}\Bexpr
-       &\Rightarrow& \concat((t^\ast)^\ast), e
-         & (\iff |\concat((t^\ast)^\ast)| < 2^{32}) \\
+     (\local^\ast)^\ast{:}\Bvec(\Blocals)~~e{:}\Bexpr
+       &\Rightarrow& \concat((\local^\ast)^\ast), e
+         & (\iff |\concat((\local^\ast)^\ast)| < 2^{32}) \\
    \production{locals} & \Blocals &::=&
-     n{:}\Bu32~~t{:}\Bvaltype &\Rightarrow& t^n \\
+     n{:}\Bu32~~t{:}\Bvaltype &\Rightarrow& \{ \LTYPE~t \}^n \\
    \end{array}
 
 Here, :math:`\X{code}` ranges over pairs :math:`(\valtype^\ast, \expr)`.
-The meta function :math:`\concat((t^\ast)^\ast)` concatenates all sequences :math:`t_i^\ast` in :math:`(t^\ast)^\ast`.
+The meta function :math:`\concat((\local^\ast)^\ast)` concatenates all sequences :math:`\local_i^\ast` in :math:`(\local^\ast)^\ast`.
 Any code for which the length of the resulting sequence is out of bounds of the maximum size of a :ref:`vector <syntax-vec>` is malformed.
 
 .. note::
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 57ff1a5f1..0c94ae6cf 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -1043,7 +1043,7 @@ Variable Instructions
 
 1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
 
-2. Assert: due to :ref:`validation <valid-local.get>`, :math:`F.\ALOCALS[x]` exists.
+2. Assert: due to :ref:`validation <valid-local.get>`, :math:`F.\ALOCALS[x]` exists and is non-empty.
 
 3. Let :math:`\val` be the value :math:`F.\ALOCALS[x]`.
 
@@ -3007,7 +3007,7 @@ Invocation of :ref:`function address <syntax-funcaddr>` :math:`a`
 
 3. Let :math:`[t_1^n] \to [t_2^m]` be the :ref:`function type <syntax-functype>` :math:`f.\FITYPE`.
 
-4. Let :math:`t^\ast` be the list of :ref:`value types <syntax-valtype>` :math:`f.\FICODE.\FLOCALS`.
+4. Let :math:`\local^\ast` be the list of :ref:`locals <syntax-local>` :math:`f.\FICODE.\FLOCALS`.
 
 5. Let :math:`\instr^\ast~\END` be the :ref:`expression <syntax-expr>` :math:`f.\FICODE.\FBODY`.
 
@@ -3015,15 +3015,13 @@ Invocation of :ref:`function address <syntax-funcaddr>` :math:`a`
 
 7. Pop the values :math:`\val^n` from the stack.
 
-8. Let :math:`\val_0^\ast` be the list of zero values of types :math:`t^\ast`.
+8. Let :math:`F` be the :ref:`frame <syntax-frame>` :math:`\{ \AMODULE~f.\FIMODULE, \ALOCALS~\val^n~(\default_t)^\ast \}`.
 
-9. Let :math:`F` be the :ref:`frame <syntax-frame>` :math:`\{ \AMODULE~f.\FIMODULE, \ALOCALS~\val^n~(\default_t)^\ast \}`.
+9. Push the activation of :math:`F` with arity :math:`m` to the stack.
 
-10. Push the activation of :math:`F` with arity :math:`m` to the stack.
+10. Let :math:`L` be the :ref:`label <syntax-label>` whose arity is :math:`m` and whose continuation is the end of the function.
 
-11. Let :math:`L` be the :ref:`label <syntax-label>` whose arity is :math:`m` and whose continuation is the end of the function.
-
-12. :ref:`Enter <exec-instr-seq-enter>` the instruction sequence :math:`\instr^\ast` with label :math:`L`.
+11. :ref:`Enter <exec-instr-seq-enter>` the instruction sequence :math:`\instr^\ast` with label :math:`L`.
 
 .. math::
    ~\\[-1ex]
@@ -3035,11 +3033,14 @@ Invocation of :ref:`function address <syntax-funcaddr>` :math:`a`
      \begin{array}[t]{@{}r@{~}l@{}}
      (\iff & S.\SFUNCS[a] = f \\
      \wedge & f.\FITYPE = [t_1^n] \to [t_2^m] \\
-     \wedge & f.\FICODE = \{ \FTYPE~x, \FLOCALS~t^k, \FBODY~\instr^\ast~\END \} \\
+     \wedge & f.\FICODE = \{ \FTYPE~x, \FLOCALS~\{\LTYPE~t\}^k, \FBODY~\instr^\ast~\END \} \\
      \wedge & F = \{ \AMODULE~f.\FIMODULE, ~\ALOCALS~\val^n~(\default_t)^k \})
      \end{array} \\
    \end{array}
 
+.. note::
+   For non-defaultable types, the respective local is left uninitialized by these rules.
+
 
 .. _exec-invoke-exit:
 
diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index 50cb93e05..869d197eb 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -51,14 +51,16 @@ or *external references* pointing to an uninterpreted form of :ref:`extern addre
 
 .. _default-val:
 
-Each :ref:`value type <syntax-valtype>` has an associated *default value*;
-it is the respective value :math:`0` for :ref:`number types <syntax-numtype>`, :math:`0` for :ref:`vector types <syntax-vectype>`, and null for :ref:`reference types <syntax-reftype>`.
+:ref:`Value types <syntax-valtype>` can have an associated *default value*;
+it is the respective value :math:`0` for :ref:`number types <syntax-numtype>`, :math:`0` for :ref:`vector types <syntax-vectype>`, and null for nullable :ref:`reference types <syntax-reftype>`.
+For other references, no default value is defined, :math:`\default_t` hence is an optional value :math:`\val^?`.
 
 .. math::
    \begin{array}{lcl@{\qquad}l}
    \default_t &=& t{.}\CONST~0 & (\iff t = \numtype) \\
    \default_t &=& t{.}\CONST~0 & (\iff t = \vectype) \\
    \default_t &=& \REFNULL~t & (\iff t = (\REF~\NULL~\heaptype)) \\
+   \default_t &=& \epsilon & (\iff t = (\REF~\heaptype)) \\
    \end{array}
 
 
@@ -493,10 +495,11 @@ and a reference to the function's own :ref:`module instance <syntax-moduleinst>`
    \production{(activation)} & \X{activation} &::=&
      \FRAME_n\{\frame\} \\
    \production{(frame)} & \frame &::=&
-     \{ \ALOCALS~\val^\ast, \AMODULE~\moduleinst \} \\
+     \{ \ALOCALS~(\val^?)^\ast, \AMODULE~\moduleinst \} \\
    \end{array}
 
-The values of the locals are mutated by respective :ref:`variable instructions <syntax-instr-variable>`.
+Locals may be uninitialized, in which case they are empty.
+Locals are mutated by respective :ref:`variable instructions <syntax-instr-variable>`.
 
 
 .. _exec-expand:
diff --git a/document/core/syntax/modules.rst b/document/core/syntax/modules.rst
index f51a504f0..29a598aa8 100644
--- a/document/core/syntax/modules.rst
+++ b/document/core/syntax/modules.rst
@@ -142,7 +142,9 @@ The |MFUNCS| component of a module defines a vector of *functions* with the foll
 .. math::
    \begin{array}{llll}
    \production{function} & \func &::=&
-     \{ \FTYPE~\typeidx, \FLOCALS~\vec(\valtype), \FBODY~\expr \} \\
+     \{ \FTYPE~\typeidx, \FLOCALS~\vec(\local), \FBODY~\expr \} \\
+   \production{local} & \local &::=&
+     \{ \LTYPE~\valtype \} \\
    \end{array}
 
 The |FTYPE| of a function declares its signature by reference to a :ref:`type <syntax-type>` defined in the module.
diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index bf264d39c..818d7d948 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -167,6 +167,55 @@ which is a sequence of values, written with brackets.
    \end{array}
 
 
+.. index:: ! instruction type, value type, result type, instruction, local, local index
+   pair: abstract syntax; instruction type
+   pair: instruction; type
+.. _syntax-instrtype:
+
+Instruction Types
+~~~~~~~~~~~~~~~~~
+
+*Instruction types* classify the behaviour of :ref:`instructions <syntax-instr>` or instruction sequences, by describing how they manipulate the :ref:`operand stack <stack>` and the initialization status of :ref:`locals <syntax-local>`:
+
+.. math::
+   \begin{array}{llll}
+   \production{instruction type} & \instrtype &::=&
+     \resulttype \to_{\localidx^\ast} \resulttype \\
+   \end{array}
+
+An instruction type :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]` describes the required input stack with argument values of types :math:`t_1^\ast` that an instruction pops off
+and the provided output stack with result values of types :math:`t_2^\ast` that it pushes back.
+Moreover, it enumerates the :ref:`indices <syntax-localidx>` :math:`x^\ast` of locals that have been set by the instruction or sequence.
+
+.. note::
+   Instruction types are only used for :ref:`validation <valid>`,
+   they do not occur in programs.
+
+
+.. index:: ! local type, value type, local, local index
+   pair: abstract syntax; local type
+   pair: local; type
+.. _syntax-init:
+.. _syntax-localtype:
+
+Local Types
+~~~~~~~~~~~
+
+*Local types* classify :ref:`locals <syntax-local>`, by describing their :ref:`value type <syntax-valtype>` as well as their *initialization status*:
+
+.. math::
+   \begin{array}{llll}
+   \production{(initialization status)} & \init &::=&
+     \SET ~|~ \UNSET \\
+   \production{(local type)} & \localtype &::=&
+     \init~\valtype \\
+   \end{array}
+
+.. note::
+   Local types are only used for :ref:`validation <valid>`,
+   they do not occur in programs.
+
+
 .. index:: ! function type, value type, vector, function, parameter, result, result type
    pair: abstract syntax; function type
    pair: function; type
diff --git a/document/core/text/modules.rst b/document/core/text/modules.rst
index 61e419246..84aaf1138 100644
--- a/document/core/text/modules.rst
+++ b/document/core/text/modules.rst
@@ -198,12 +198,12 @@ Function definitions can bind a symbolic :ref:`function identifier <text-id>`, a
    \begin{array}{llclll}
    \production{function} & \Tfunc_I &::=&
      \text{(}~\text{func}~~\Tid^?~~x,I'{:}\Ttypeuse_I~~
-     (t{:}\Tlocal_I)^\ast~~(\X{in}{:}\Tinstr_{I''})^\ast~\text{)} \\ &&& \qquad
-       \Rightarrow\quad \{ \FTYPE~x, \FLOCALS~t^\ast, \FBODY~\X{in}^\ast~\END \} \\ &&& \qquad\qquad\qquad
+     (\X{loc}{:}\Tlocal_I)^\ast~~(\X{in}{:}\Tinstr_{I''})^\ast~\text{)} \\ &&& \qquad
+       \Rightarrow\quad \{ \FTYPE~x, \FLOCALS~\X{loc}^\ast, \FBODY~\X{in}^\ast~\END \} \\ &&& \qquad\qquad\qquad
        (\iff I'' = I' \compose \{\ILOCALS~\F{id}(\Tlocal)^\ast\} \idcwellformed) \\[1ex]
    \production{local} & \Tlocal_I &::=&
      \text{(}~\text{local}~~\Tid^?~~t{:}\Tvaltype_I~\text{)}
-       \quad\Rightarrow\quad t \\
+       \quad\Rightarrow\quad \{ \LTYPE~t \} \\
    \end{array}
 
 The definition of the local :ref:`identifier context <text-context>` :math:`I''` uses the following auxiliary function to extract optional identifiers from locals:
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index c19f2020c..f73c2d5b4 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -172,7 +172,7 @@
 .. Types, terminals
 
 .. |to| mathdef:: \xref{syntax/types}{syntax-functype}{\rightarrow}
- 
+
 .. |BOT| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{bot}}
 
 .. |I8| mathdef:: \xref{exec/runtime}{syntax-storagetype}{\K{i8}}
@@ -200,6 +200,9 @@
 .. |MVAR| mathdef:: \xref{syntax/types}{syntax-mut}{\K{var}}
 .. |MCONST| mathdef:: \xref{syntax/types}{syntax-mut}{\K{const}}
 
+.. |SET| mathdef:: \xref{syntax/types}{syntax-init}{\mathrel{\mbox{set}}}
+.. |UNSET| mathdef:: \xref{syntax/types}{syntax-init}{\mathrel{\mbox{unset}}}
+
 .. |LMIN| mathdef:: \xref{syntax/types}{syntax-limits}{\K{min}}
 .. |LMAX| mathdef:: \xref{syntax/types}{syntax-limits}{\K{max}}
 
@@ -225,7 +228,10 @@
 
 .. |limits| mathdef:: \xref{syntax/types}{syntax-limits}{\X{limits}}
 .. |mut| mathdef:: \xref{syntax/types}{syntax-mut}{\X{mut}}
+.. |init| mathdef:: \xref{syntax/types}{syntax-init}{\X{init}}
 
+.. |instrtype| mathdef:: \xref{syntax/types}{syntax-instrtype}{\X{instrtype}}
+.. |localtype| mathdef:: \xref{syntax/types}{syntax-localtype}{\X{localtype}}
 .. |externtype| mathdef:: \xref{syntax/types}{syntax-externtype}{\X{externtype}}
 
 
@@ -280,6 +286,8 @@
 .. |FLOCALS| mathdef:: \xref{syntax/modules}{syntax-func}{\K{locals}}
 .. |FBODY| mathdef:: \xref{syntax/modules}{syntax-func}{\K{body}}
 
+.. |LTYPE| mathdef:: \xref{syntax/modules}{syntax-local}{\K{type}}
+
 .. |TTYPE| mathdef:: \xref{syntax/modules}{syntax-table}{\K{type}}
 
 .. |MTYPE| mathdef:: \xref{syntax/modules}{syntax-mem}{\K{type}}
@@ -326,6 +334,7 @@
 .. |module| mathdef:: \xref{syntax/modules}{syntax-module}{\X{module}}
 .. |type| mathdef:: \xref{syntax/types}{syntax-functype}{\X{type}}
 .. |func| mathdef:: \xref{syntax/modules}{syntax-func}{\X{func}}
+.. |local| mathdef:: \xref{syntax/modules}{syntax-local}{\X{local}}
 .. |table| mathdef:: \xref{syntax/modules}{syntax-table}{\X{table}}
 .. |mem| mathdef:: \xref{syntax/modules}{syntax-mem}{\X{mem}}
 .. |global| mathdef:: \xref{syntax/modules}{syntax-global}{\X{global}}
@@ -925,6 +934,8 @@
 .. |vdashglobaltype| mathdef:: \xref{valid/types}{valid-globaltype}{\vdash}
 .. |vdashexterntype| mathdef:: \xref{valid/types}{valid-externtype}{\vdash}
 
+.. |vdashinstrtype| mathdef:: \xref{valid/instructions}{valid-instrtype}{\vdash}
+
 .. |vdashvaltypedefaultable| mathdef:: \xref{valid/types}{valid-defaultable}{\vdash}
 .. |vdashtabletypedefaultable| mathdef:: \xref{valid/types}{valid-defaultable}{\vdash}
 
@@ -949,6 +960,7 @@
 
 .. |vdashtypes| mathdef:: \xref{valid/modules}{valid-types}{\vdash}
 .. |vdashfunc| mathdef:: \xref{valid/modules}{valid-func}{\vdash}
+.. |vdashlocal| mathdef:: \xref{valid/modules}{valid-local}{\vdash}
 .. |vdashtable| mathdef:: \xref{valid/modules}{valid-table}{\vdash}
 .. |vdashmem| mathdef:: \xref{valid/modules}{valid-mem}{\vdash}
 .. |vdashglobal| mathdef:: \xref{valid/modules}{valid-global}{\vdash}
diff --git a/document/core/valid/conventions.rst b/document/core/valid/conventions.rst
index ae219e44a..528016fd2 100644
--- a/document/core/valid/conventions.rst
+++ b/document/core/valid/conventions.rst
@@ -24,7 +24,7 @@ That is, they only formulate the constraints, they do not define an algorithm.
 The skeleton of a sound and complete algorithm for type-checking instruction sequences according to this specification is provided in the :ref:`appendix <algo-valid>`.
 
 
-.. index:: ! context, function type, table type, memory type, global type, value type, result type, index space, module, function
+.. index:: ! context, local type, function type, table type, memory type, global type, value type, result type, index space, module, function, local type
 .. _context:
 
 Contexts
@@ -40,7 +40,7 @@ which collects relevant information about the surrounding :ref:`module <syntax-m
 * *Globals*: the list of globals declared in the current module, represented by their global type.
 * *Element Segments*: the list of element segments declared in the current module, represented by their element type.
 * *Data Segments*: the list of data segments declared in the current module, each represented by an |ok| entry.
-* *Locals*: the list of locals declared in the current function (including parameters), represented by their value type.
+* *Locals*: the list of locals declared in the current function (including parameters), represented by their local type.
 * *Labels*: the stack of labels accessible from the current position, represented by their result type.
 * *Return*: the return type of the current function, represented as an optional result type that is absent when no return is allowed, as in free-standing expressions.
 * *References*: the list of :ref:`function indices <syntax-funcidx>` that occur in the module outside functions and can hence be used to form references inside them.
@@ -63,11 +63,11 @@ More concretely, contexts are defined as :ref:`records <notation-record>` :math:
         & \CGLOBALS & \globaltype^\ast, \\
         & \CELEMS & \reftype^\ast, \\
         & \CDATAS & {\ok}^\ast, \\
-        & \CLOCALS & \valtype^\ast, \\
+        & \CLOCALS & \localtype^\ast, \\
         & \CLABELS & \resulttype^\ast, \\
         & \CRETURN & \resulttype^?, \\
         & \CREFS & \funcidx^\ast ~\} \\
-     \end{array}
+     \end{array} \\
    \end{array}
 
 .. _notation-extend:
@@ -158,15 +158,15 @@ and there is one respective rule for each relevant construct :math:`A` of the ab
 
    .. math::
       \frac{
-        C.\CLOCALS[x] = t
+        C.\CGLOBALS[x] = \mut~t
       }{
-        C \vdash \LOCALGET~x : [] \to [t]
+        C \vdash \GLOBALGET~x : [] \to [t]
       }
 
-   Here, the premise enforces that the immediate :ref:`local index <syntax-localidx>` :math:`x` exists in the context.
+   Here, the premise enforces that the immediate :ref:`global index <syntax-globalidx>` :math:`x` exists in the context.
    The instruction produces a value of its respective type :math:`t`
    (and does not consume any values).
-   If :math:`C.\CLOCALS[x]` does not exist then the premise does not hold,
+   If :math:`C.\CGLOBALS[x]` does not exist then the premise does not hold,
    and the instruction is ill-typed.
 
    Finally, a :ref:`structured <syntax-instr-control>` instruction requires
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index e6d1ea13b..c9bad0e4e 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -1,20 +1,22 @@
-.. index:: instruction, function type, context, value, operand stack, ! polymorphism, ! bottom type
+.. index:: instruction, ! instruction type, context, value, operand stack, ! polymorphism
 .. _valid-instr:
 
 Instructions
 ------------
 
-:ref:`Instructions <syntax-instr>` are classified by :ref:`function types <syntax-functype>` :math:`[t_1^\ast] \to [t_2^\ast]`
-that describe how they manipulate the :ref:`operand stack <stack>`.
-The types describe the required input stack with argument values of types :math:`t_1^\ast` that an instruction pops off
+:ref:`Instructions <syntax-instr>` are classified by :ref:`instruction types <syntax-instrtype>` that describe how they manipulate the :ref:`operand stack <stack>` and initialize :ref:`locals <syntax-local>`:
+A type :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]` describes the required input stack with argument values of types :math:`t_1^\ast` that an instruction pops off
 and the provided output stack with result values of types :math:`t_2^\ast` that it pushes back.
+Moreover, it enumerates the :ref:`indices <syntax-localidx>` :math:`x^\ast` of locals that have been set by the instruction.
+In most cases, this is empty.
 
 .. note::
    For example, the instruction :math:`\I32.\ADD` has type :math:`[\I32~\I32] \to [\I32]`,
    consuming two |I32| values and producing one.
+   The instruction :math:`LOCALSET~x` has type :math:`[t] \to_x []`, provided :math:`t` is the type declared for the local :math:`x`.
 
 Typing extends to :ref:`instruction sequences <valid-instr-seq>` :math:`\instr^\ast`.
-Such a sequence has a :ref:`function type <syntax-functype>` :math:`[t_1^\ast] \to [t_2^\ast]` if the accumulative effect of executing the instructions is consuming values of types :math:`t_1^\ast` off the operand stack and pushing new values of types :math:`t_2^\ast`.
+Such a sequence has an instruction type :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]` if the accumulative effect of executing the instructions is consuming values of types :math:`t_1^\ast` off the operand stack, pushing new values of types :math:`t_2^\ast`, and setting all locals :math:`x^\ast`.
 
 .. _polymorphism:
 
@@ -27,9 +29,8 @@ Two degrees of polymorphism can be distinguished:
   the :ref:`value type <syntax-valtype>` :math:`t` of one or several individual operands is unconstrained.
   That is the case for all :ref:`parametric instructions <valid-instr-parametric>` like |DROP| and |SELECT|.
 
-
 * *stack-polymorphic*:
-  the entire (or most of the) :ref:`function type <syntax-functype>` :math:`[t_1^\ast] \to [t_2^\ast]` of the instruction is unconstrained.
+  the entire (or most of the) :ref:`instruction type <syntax-instrtype>` :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]` of the instruction is unconstrained.
   That is the case for all :ref:`control instructions <valid-instr-control>` that perform an *unconditional control transfer*, such as |UNREACHABLE|, |BR|, |BRTABLE|, and |RETURN|.
 
 In both cases, the unconstrained types or type sequences can be chosen arbitrarily, as long as they meet the constraints imposed for the surrounding parts of the program.
@@ -47,13 +48,14 @@ In both cases, the unconstrained types or type sequences can be chosen arbitrari
 
    are valid, with :math:`t` in the typing of |SELECT| being instantiated to |I32| or |F64|, respectively.
 
-   The |UNREACHABLE| instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]` for any possible sequences of value types :math:`t_1^\ast` and :math:`t_2^\ast`.
+   The |UNREACHABLE| instruction is stack-polymorphic,
+   and hence valid with type :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]` for any possible sequences of value types :math:`t_1^\ast` and :math:`t_2^\ast` and sequence of locals :math:`x^\ast`.
    Consequently,
 
    .. math::
       \UNREACHABLE~~\I32.\ADD
 
-   is valid by assuming type :math:`[] \to [\I32~\I32]` for the |UNREACHABLE| instruction.
+   is valid by assuming type :math:`[] \to [\I32]` for the |UNREACHABLE| instruction.
    In contrast,
 
    .. math::
@@ -650,13 +652,15 @@ Variable Instructions
 
 * The local :math:`C.\CLOCALS[x]` must be defined in the context.
 
-* Let :math:`t` be the :ref:`value type <syntax-valtype>` :math:`C.\CLOCALS[x]`.
+* Let :math:`\init~t` be the :ref:`local type <syntax-localtype>` :math:`C.\CLOCALS[x]`.
+
+* The :ref:`initialization status <syntax-init>` :math:`\init` must be :math:`\SET`.
 
 * Then the instruction is valid with type :math:`[] \to [t]`.
 
 .. math::
    \frac{
-     C.\CLOCALS[x] = t
+     C.\CLOCALS[x] = \SET~t
    }{
      C \vdashinstr \LOCALGET~x : [] \to [t]
    }
@@ -669,15 +673,15 @@ Variable Instructions
 
 * The local :math:`C.\CLOCALS[x]` must be defined in the context.
 
-* Let :math:`t` be the :ref:`value type <syntax-valtype>` :math:`C.\CLOCALS[x]`.
+* Let :math:`\init~t` be the :ref:`local type <syntax-localtype>` :math:`C.\CLOCALS[x]`.
 
-* Then the instruction is valid with type :math:`[t] \to []`.
+* Then the instruction is valid with type :math:`[t] \to_x []`.
 
 .. math::
    \frac{
-     C.\CLOCALS[x] = t
+     C.\CLOCALS[x] = \init~t
    }{
-     C \vdashinstr \LOCALSET~x : [t] \to []
+     C \vdashinstr \LOCALSET~x : [t] \to_x []
    }
 
 
@@ -688,15 +692,15 @@ Variable Instructions
 
 * The local :math:`C.\CLOCALS[x]` must be defined in the context.
 
-* Let :math:`t` be the :ref:`value type <syntax-valtype>` :math:`C.\CLOCALS[x]`.
+* Let :math:`\init~t` be the :ref:`local type <syntax-localtype>` :math:`C.\CLOCALS[x]`.
 
-* Then the instruction is valid with type :math:`[t] \to [t]`.
+* Then the instruction is valid with type :math:`[t] \to_x [t]`.
 
 .. math::
    \frac{
-     C.\CLOCALS[x] = t
+     C.\CLOCALS[x] = \init~t
    }{
-     C \vdashinstr \LOCALTEE~x : [t] \to [t]
+     C \vdashinstr \LOCALTEE~x : [t] \to_x [t]
    }
 
 
@@ -1253,13 +1257,13 @@ Control Instructions
 :math:`\UNREACHABLE`
 ....................
 
-* The instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`, for any sequences of :ref:`valid <valid-valtype>` :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
+* The instruction is valid with any :ref:`valid <valid-instrtype>` type :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]`.
 
 .. math::
    \frac{
-     C \vdashfunctype [t_1^\ast] \to [t_2^\ast] \ok
+     C \vdashinstrtype [t_1^\ast] \to_{x^\ast} [t_2^\ast] \ok
    }{
-     C \vdashinstr \UNREACHABLE : [t_1^\ast] \to [t_2^\ast]
+     C \vdashinstr \UNREACHABLE : [t_1^\ast] \to_{x^\ast} [t_2^\ast]
    }
 
 .. note::
@@ -1276,7 +1280,7 @@ Control Instructions
 * Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the :ref:`result type <syntax-resulttype>` :math:`[t_2^\ast]` prepended to the |CLABELS| vector.
 
 * Under context :math:`C'`,
-  the instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[t_1^\ast] \to [t_2^\ast]`.
+  the instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]`, for any sequence of :ref:`local indices <syntax-localidx>` :math:`x^\ast`.
 
 * Then the compound instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`.
 
@@ -1284,7 +1288,7 @@ Control Instructions
    \frac{
      C \vdashblocktype \blocktype : [t_1^\ast] \to [t_2^\ast]
      \qquad
-     C,\CLABELS\,[t_2^\ast] \vdashinstrseq \instr^\ast : [t_1^\ast] \to [t_2^\ast]
+     C,\CLABELS\,[t_2^\ast] \vdashinstrseq \instr^\ast : [t_1^\ast] \to_{x^\ast} [t_2^\ast]
    }{
      C \vdashinstr \BLOCK~\blocktype~\instr^\ast~\END : [t_1^\ast] \to [t_2^\ast]
    }
@@ -1298,12 +1302,12 @@ Control Instructions
 :math:`\LOOP~\blocktype~\instr^\ast~\END`
 .........................................
 
-* The :ref:`block type <syntax-blocktype>` must be :ref:`valid <valid-blocktype>` as some :ref:`function type <syntax-functype>` :math:`[t_1^\ast] \to [t_2^\ast]`.
+* The :ref:`block type <syntax-blocktype>` must be :ref:`valid <valid-blocktype>` as some :ref:`instruction type <syntax-functype>` :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]`.
 
 * Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the :ref:`result type <syntax-resulttype>` :math:`[t_1^\ast]` prepended to the |CLABELS| vector.
 
 * Under context :math:`C'`,
-  the instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[t_1^\ast] \to [t_2^\ast]`.
+  the instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]`, for any sequence of :ref:`local indices <syntax-localidx>` :math:`x^\ast`.
 
 * Then the compound instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`.
 
@@ -1311,7 +1315,7 @@ Control Instructions
    \frac{
      C \vdashblocktype \blocktype : [t_1^\ast] \to [t_2^\ast]
      \qquad
-     C,\CLABELS\,[t_1^\ast] \vdashinstrseq \instr^\ast : [t_1^\ast] \to [t_2^\ast]
+     C,\CLABELS\,[t_1^\ast] \vdashinstrseq \instr^\ast : [t_1^\ast] \to_{x^\ast} [t_2^\ast]
    }{
      C \vdashinstr \LOOP~\blocktype~\instr^\ast~\END : [t_1^\ast] \to [t_2^\ast]
    }
@@ -1330,10 +1334,10 @@ Control Instructions
 * Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the :ref:`result type <syntax-resulttype>` :math:`[t_2^\ast]` prepended to the |CLABELS| vector.
 
 * Under context :math:`C'`,
-  the instruction sequence :math:`\instr_1^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[t_1^\ast] \to [t_2^\ast]`.
+  the instruction sequence :math:`\instr_1^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[t_1^\ast] \to_{x_1^\ast} [t_2^\ast]`, for any sequence of :ref:`local indices <syntax-localidx>` :math:`x_1^\ast`.
 
 * Under context :math:`C'`,
-  the instruction sequence :math:`\instr_2^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[t_1^\ast] \to [t_2^\ast]`.
+  the instruction sequence :math:`\instr_2^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[t_1^\ast] \to_{x_2^\ast} [t_2^\ast]`, for any sequence of :ref:`local indices <syntax-localidx>` :math:`x_2^\ast`.
 
 * Then the compound instruction is valid with type :math:`[t_1^\ast~\I32] \to [t_2^\ast]`.
 
@@ -1341,9 +1345,9 @@ Control Instructions
    \frac{
      C \vdashblocktype \blocktype : [t_1^\ast] \to [t_2^\ast]
      \qquad
-     C,\CLABELS\,[t_2^\ast] \vdashinstrseq \instr_1^\ast : [t_1^\ast] \to [t_2^\ast]
+     C,\CLABELS\,[t_2^\ast] \vdashinstrseq \instr_1^\ast : [t_1^\ast] \to_{x_1^\ast} [t_2^\ast]
      \qquad
-     C,\CLABELS\,[t_2^\ast] \vdashinstrseq \instr_2^\ast : [t_1^\ast] \to [t_2^\ast]
+     C,\CLABELS\,[t_2^\ast] \vdashinstrseq \instr_2^\ast : [t_1^\ast] \to_{x_2^\ast} [t_2^\ast]
    }{
      C \vdashinstr \IF~\blocktype~\instr_1^\ast~\ELSE~\instr_2^\ast~\END : [t_1^\ast~\I32] \to [t_2^\ast]
    }
@@ -1361,15 +1365,15 @@ Control Instructions
 
 * Let :math:`[t^\ast]` be the :ref:`result type <syntax-resulttype>` :math:`C.\CLABELS[l]`.
 
-* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`, for any sequences of :ref:`valid <valid-valtype>` :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
+* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast] \to_{x^\ast} [t_2^\ast]`, for any :ref:`valid <valid-instrtype>` type :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]`.
 
 .. math::
    \frac{
      C.\CLABELS[l] = [t^\ast]
      \qquad
-     C \vdashfunctype [t_1^\ast] \to [t_2^\ast] \ok
+     C \vdashinstrtype [t_1^\ast] \to_{x^\ast} [t_2^\ast] \ok
    }{
-     C \vdashinstr \BR~l : [t_1^\ast~t^\ast] \to [t_2^\ast]
+     C \vdashinstr \BR~l : [t_1^\ast~t^\ast] \to_{x^\ast} [t_2^\ast]
    }
 
 .. note::
@@ -1418,7 +1422,7 @@ Control Instructions
   * For all :math:`l_i` in :math:`l^\ast`,
     the result type :math:`[t^\ast]` :ref:`matches <match-resulttype>` :math:`C.\CLABELS[l_i]`.
 
-* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast~\I32] \to [t_2^\ast]`, for any sequences of :ref:`valid <valid-valtype>` :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
+* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast~\I32] \to_{x^\ast} [t_2^\ast]`, for any :ref:`valid <valid-instrtype>` type :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]`.
 
 .. math::
    \frac{
@@ -1426,9 +1430,9 @@ Control Instructions
      \qquad
      C \vdashresulttypematch [t^\ast] \matchesresulttype C.\CLABELS[l_N]
      \qquad
-     C \vdashfunctype [t_1^\ast] \to [t_2^\ast] \ok
+     C \vdashinstrtype [t_1^\ast] \to_{x^\ast} [t_2^\ast] \ok
    }{
-     C \vdashinstr \BRTABLE~l^\ast~l_N : [t_1^\ast~t^\ast~\I32] \to [t_2^\ast]
+     C \vdashinstr \BRTABLE~l^\ast~l_N : [t_1^\ast~t^\ast~\I32] \to_{x^\ast} [t_2^\ast]
    }
 
 .. note::
@@ -1496,15 +1500,15 @@ Control Instructions
 
 * Let :math:`[t^\ast]` be the :ref:`result type <syntax-resulttype>` of :math:`C.\CRETURN`.
 
-* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`, for any sequences of :ref:`valid <valid-valtype>` :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
+* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast] \to_{x^\ast} [t_2^\ast]`, for any :ref:`valid <valid-instrtype>` type :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]`.
 
 .. math::
    \frac{
      C.\CRETURN = [t^\ast]
      \qquad
-     C \vdashfunctype [t_1^\ast] \to [t_2^\ast] \ok
+     C \vdashinstrtype [t_1^\ast] \to_{x^\ast} [t_2^\ast] \ok
    }{
-     C \vdashinstr \RETURN : [t_1^\ast~t^\ast] \to [t_2^\ast]
+     C \vdashinstr \RETURN : [t_1^\ast~t^\ast] \to_{x^\ast} [t_2^\ast]
    }
 
 .. note::
@@ -1578,7 +1582,7 @@ Control Instructions
    }
 
 
-.. index:: instruction, instruction sequence
+.. index:: instruction, instruction sequence, local type
 .. _valid-instr-seq:
 
 Instruction Sequences
@@ -1603,10 +1607,15 @@ Empty Instruction Sequence: :math:`\epsilon`
 Non-empty Instruction Sequence: :math:`\instr^\ast~\instr_N`
 ............................................................
 
-* The instruction sequence :math:`\instr^\ast` must be valid with type :math:`[t_1^\ast] \to [t_2^\ast]`,
+* The instruction sequence :math:`\instr^\ast` must be valid with type :math:`[t_1^\ast] \to_{x_1^\ast} [t_2^\ast]`,
   for some sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
-* The instruction :math:`\instr_N` must be valid with type :math:`[t^\ast] \to [t_3^\ast]`,
+* Let :math:`C'` be the same :ref:`context <context>` as :math:`C`,
+  but with:
+
+  * |CLOCALS| the same as in C, except that for every :ref:`local index <syntax-localidx>` :math:`x` in :math:`x_1^\ast`, the :ref:`local type <syntax-localtype>` :math:`\CLOCALS[x]` has been updated to :ref:`initialization status <syntax-init>` `\SET`.
+
+* Under context :math:`C'`, the instruction :math:`\instr_N` must be valid with type :math:`[t^\ast] \to_{x_2^\ast} [t_3^\ast]`,
   for some sequences of :ref:`value types <syntax-valtype>` :math:`t^\ast` and :math:`t_3^\ast`.
 
 * There must be a sequence of :ref:`value types <syntax-valtype>` :math:`t_0^\ast`,
@@ -1614,17 +1623,23 @@ Non-empty Instruction Sequence: :math:`\instr^\ast~\instr_N`
 
 * For each :ref:`value type <syntax-valtype>` :math:`t'_i` in :math:`{t'}^\ast` and corresponding type :math:`t_i` in :math:`t^\ast`, the type :math:`t'_i` must :ref:`match <match-valtype>` :math:`t_i`.
 
-* Then the combined instruction sequence is valid with type :math:`[t_1^\ast] \to [t_0^\ast~t_3^\ast]`.
+* Then the combined instruction sequence is valid with type :math:`[t_1^\ast] \to_{x_1^\ast x_2^\ast} [t_0^\ast~t_3^\ast]`.
 
 .. math::
    \frac{
-     C \vdashinstrseq \instr^\ast : [t_1^\ast] \to [t_0^\ast~{t'}^\ast]
+     \begin{array}{@{}c@{}}
+     C \vdashinstrseq \instr^\ast : [t_1^\ast] \to_{x_1^\ast} [t_0^\ast~{t'}^\ast]
      \qquad
      (C \vdashvaltypematch t' \matchesvaltype t)^\ast
      \qquad
-     C \vdashinstr \instr_N : [t^\ast] \to [t_3^\ast]
+     C' \vdashinstr \instr_N : [t^\ast] \to_{x_2^\ast} [t_3^\ast]
+     \\
+     (\init~t = C.\CLOCALS[x_1])^\ast
+     \qquad
+     C' = C~(\with C.\CLOCALS[x_1] = \SET~t)^\ast
+     \end{array}
    }{
-     C \vdashinstrseq \instr^\ast~\instr_N : [t_1^\ast] \to [t_0^\ast~t_3^\ast]
+     C \vdashinstrseq \instr^\ast~\instr_N : [t_1^\ast] \to_{x_1^\ast x_2^\ast} [t_0^\ast~t_3^\ast]
    }
 
 
@@ -1643,7 +1658,7 @@ Expressions :math:`\expr` are classified by :ref:`result types <syntax-resulttyp
 :math:`\instr^\ast~\END`
 ........................
 
-* The instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with some :ref:`type <syntax-functype>` :math:`[] \to [{t'}^\ast]`.
+* The instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with some :ref:`type <syntax-instrtype>` :math:`[] \to_{x^\ast} [{t'}^\ast]`.
 
 * For each :ref:`value type <syntax-valtype>` :math:`t'_i` in :math:`{t'}^\ast` and corresponding :ref:`valid <valid-valtype>` :ref:`value type <syntax-valtype>` type :math:`t_i` in :math:`t^\ast`, :math:`t'_i` :ref:`matches <match-valtype>` :math:`t_i`.
 
@@ -1651,7 +1666,7 @@ Expressions :math:`\expr` are classified by :ref:`result types <syntax-resulttyp
 
 .. math::
    \frac{
-     C \vdashinstrseq \instr^\ast : [] \to [{t'}^\ast]
+     C \vdashinstrseq \instr^\ast : [] \to_{x^\ast} [{t'}^\ast]
      \qquad
      C \vdashresulttype [t^\ast] \ok
      \qquad
diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index efb9c4c1b..20c6a5b9c 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -5,7 +5,7 @@ Modules
 Furthermore, most definitions are themselves classified with a suitable type.
 
 
-.. index:: function, local, function index, local index, type index, function type, value type, expression, import
+.. index:: function, local, function index, local index, type index, function type, value type, local type, expression, import
    pair: abstract syntax; function
    single: abstract syntax; function
 .. _valid-local:
@@ -24,10 +24,16 @@ Functions :math:`\func` are classified by :ref:`function types <syntax-functype>
 
 * Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[x]`.
 
+* For each local declared by a :ref:`value type <syntax-valtype>` :math:`t` in :math:`t^\ast`:
+
+  * The local for type :math:`t` must be :ref:`valid <valid-localtype>` with :ref:`local type <syntax-localtype>` :math:`\localtype_i`.
+
+* Let :math:`\localtype^\ast` be the concatenation of all :math:`\localtype_i`.
+
 * Let :math:`C'` be the same :ref:`context <context>` as :math:`C`,
   but with:
 
-  * |CLOCALS| set to the sequence of :ref:`value types <syntax-valtype>` :math:`t_1^\ast~t^\ast`, concatenating parameters and locals,
+  * |CLOCALS| set to the sequence of :ref:`value types <syntax-valtype>` :math:`(\SET~t_1)^\ast~\localtype^\ast`, concatenating parameters and locals,
 
   * |CLABELS| set to the singular sequence containing only :ref:`result type <syntax-resulttype>` :math:`[t_2^\ast]`.
 
@@ -42,12 +48,57 @@ Functions :math:`\func` are classified by :ref:`function types <syntax-functype>
    \frac{
      C.\CTYPES[x] = [t_1^\ast] \to [t_2^\ast]
      \qquad
-     C,\CLOCALS\,t_1^\ast~t^\ast,\CLABELS~[t_2^\ast],\CRETURN~[t_2^\ast] \vdashexpr \expr : [t_2^\ast]
+     (C \vdashlocal t : \init~t)^\ast
+     \qquad
+     C,\CLOCALS\,(\SET~t_1)^\ast~(\init~t)^\ast,\CLABELS~[t_2^\ast],\CRETURN~[t_2^\ast] \vdashexpr \expr : [t_2^\ast]
    }{
      C \vdashfunc \{ \FTYPE~x, \FLOCALS~t^\ast, \FBODY~\expr \} : [t_1^\ast] \to [t_2^\ast]
    }
 
 
+.. index:: local, local type, value type
+   pair: validation; local
+   single: abstract syntax; local
+.. _valid-localtype:
+
+Locals
+~~~~~~
+
+:ref:`Locals <syntax-local>` are classified with :ref:`local types <syntax-localtype>`.
+
+:math:`\{ \LTYPE~\valtype \}`
+.............................
+
+* The :ref:`value type <syntax-valtype>` :math:`\valtype` must be :ref:`valid <valid-valtype>`.
+
+* If :math:`\valtype` is :ref:`defaultable <valid-defaultable>`, then:
+
+  * The local is valid with :ref:`local type <syntax-localtype>` :math:`\SET~\valtype`.
+
+* Else:
+
+  * The local is valid with :ref:`local type <syntax-localtype>` :math:`\UNSET~\valtype`.
+
+.. math::
+   \frac{
+     C \vdashvaltype t \ok
+     \qquad
+     C \vdashvaltypedefaultable t \defaultable
+   }{
+     C \vdashlocal \{ \LTYPE~t \} : \SET~t \ok
+   }
+
+.. math::
+   \frac{
+     C \vdashvaltype t \ok
+   }{
+     C \vdashlocal \{ LTYPE~t \} : \UNSET~t \ok
+   }
+
+.. note::
+   For cases where both rules are applicable, the former yields the more permissable type.
+
+
 .. index:: table, table type, defaultable
    pair: validation; table
    single: abstract syntax; table
diff --git a/document/core/valid/types.rst b/document/core/valid/types.rst
index e4f7a7995..ad9c42913 100644
--- a/document/core/valid/types.rst
+++ b/document/core/valid/types.rst
@@ -146,7 +146,7 @@ Valid :ref:`value types <syntax-valtype>` are either valid :ref:`number type <va
    }
 
 
-.. index:: block type
+.. index:: block type, instruction type
    pair: validation; block type
    single: abstract syntax; block type
 .. _valid-blocktype:
@@ -154,20 +154,22 @@ Valid :ref:`value types <syntax-valtype>` are either valid :ref:`number type <va
 Block Types
 ~~~~~~~~~~~
 
-:ref:`Block types <syntax-blocktype>` may be expressed in one of two forms, both of which are converted to plain :ref:`function types <syntax-functype>` by the following rules.
+:ref:`Block types <syntax-blocktype>` may be expressed in one of two forms, both of which are converted to :ref:`instruction types <syntax-instrtype>` by the following rules.
 
 :math:`\typeidx`
 ................
 
 * The type :math:`C.\CTYPES[\typeidx]` must be defined in the context.
 
-* Then the block type is valid as :ref:`function type <syntax-functype>` :math:`C.\CTYPES[\typeidx]`.
+* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[\typeidx]`.
+
+* Then the block type is valid as :ref:`instruction type <syntax-instrtype>` :math:`[t_1^\ast] \to [t_2^\ast]`.
 
 .. math::
    \frac{
-     C.\CTYPES[\typeidx] = \functype
+     C.\CTYPES[\typeidx] = [t_1^\ast] \to [t_2^\ast]
    }{
-     C \vdashblocktype \typeidx : \functype
+     C \vdashblocktype \typeidx : [t_1^\ast] \to [t_2^\ast]
    }
 
 
@@ -176,7 +178,7 @@ Block Types
 
 * The value type :math:`\valtype` must either be absent, or :ref:`valid <valid-valtype>`.
 
-* Then the block type is valid as :ref:`function type <syntax-functype>` :math:`[] \to [\valtype^?]`.
+* Then the block type is valid as :ref:`instruction type <syntax-instrtype>` :math:`[] \to [\valtype^?]`.
 
 .. math::
    \frac{
@@ -209,38 +211,34 @@ Result Types
    }
 
 
-.. index:: limits
-   pair: validation; limits
-   single: abstract syntax; limits
-.. _valid-limits:
-
-Limits
-~~~~~~
-
-:ref:`Limits <syntax-limits>` must have meaningful bounds that are within a given range.
+.. index:: instruction type
+   pair: validation; instruction type
+   single: abstract syntax; instruction type
+.. _valid-instrtype:
 
-:math:`\{ \LMIN~n, \LMAX~m^? \}`
-................................
+Instruction Types
+~~~~~~~~~~~~~~~~~
 
-* The value of :math:`n` must not be larger than :math:`k`.
+:math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]`
+..........................................
 
-* If the maximum :math:`m^?` is not empty, then:
+* The :ref:`result type <syntax-resulttype>` :math:`[t_1^\ast]` must be :ref:`valid <valid-resulttype>`.
 
-  * Its value must not be larger than :math:`k`.
+* The :ref:`result type <syntax-resulttype>` :math:`[t_2^\ast]` must be :ref:`valid <valid-resulttype>`.
 
-  * Its value must not be smaller than :math:`n`.
+* Each :ref:`local index <syntax-localidx>` :math:`x_i` in :math:`x^\ast` must be defined in the context.
 
-* Then the limit is valid within range :math:`k`.
+* Then the instruction type is valid.
 
 .. math::
    \frac{
-     n \leq k
+     C \vdashvaltype [t_1^\ast] \ok
      \qquad
-     (m \leq k)^?
+     C \vdashvaltype [t_2^\ast] \ok
      \qquad
-     (n \leq m)^?
+     (C.\CLOCALS[x] = \localtype)^\ast
    }{
-     C \vdashlimits \{ \LMIN~n, \LMAX~m^? \} : k
+     C \vdashfunctype [t_1^\ast] \to_{x^\ast} [t_2^\ast] \ok
    }
 
 
@@ -271,6 +269,41 @@ Function Types
    }
 
 
+.. index:: limits
+   pair: validation; limits
+   single: abstract syntax; limits
+.. _valid-limits:
+
+Limits
+~~~~~~
+
+:ref:`Limits <syntax-limits>` must have meaningful bounds that are within a given range.
+
+:math:`\{ \LMIN~n, \LMAX~m^? \}`
+................................
+
+* The value of :math:`n` must not be larger than :math:`k`.
+
+* If the maximum :math:`m^?` is not empty, then:
+
+  * Its value must not be larger than :math:`k`.
+
+  * Its value must not be smaller than :math:`n`.
+
+* Then the limit is valid within range :math:`k`.
+
+.. math::
+   \frac{
+     n \leq k
+     \qquad
+     (m \leq k)^?
+     \qquad
+     (n \leq m)^?
+   }{
+     C \vdashlimits \{ \LMIN~n, \LMAX~m^? \} : k
+   }
+
+
 .. index:: table type, reference type, limits
    pair: validation; table type
    single: abstract syntax; table type

From b1c93944729cb55f16bb2edc7875ae6cb0416820 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Tue, 2 Aug 2022 10:54:48 +0200
Subject: [PATCH 155/285] Add table initialiser (#65)

---
 document/core/binary/modules.rst          | 10 ++-
 document/core/exec/modules.rst            | 68 +++++++++++--------
 document/core/syntax/modules.rst          |  9 +--
 document/core/util/macros.def             |  2 +-
 document/core/valid/modules.rst           | 26 +++++---
 document/core/valid/types.rst             | 16 -----
 interpreter/binary/decode.ml              | 16 ++++-
 interpreter/binary/encode.ml              |  7 +-
 interpreter/exec/eval.ml                  | 11 +++-
 interpreter/syntax/ast.ml                 |  1 +
 interpreter/syntax/free.ml                |  2 +-
 interpreter/text/arrange.ml               |  6 +-
 interpreter/text/parser.mly               | 20 ++++--
 interpreter/valid/valid.ml                |  9 +--
 proposals/function-references/Overview.md | 20 ++++--
 test/core/table.wast                      | 80 ++++++++++++++++++-----
 16 files changed, 206 insertions(+), 97 deletions(-)

diff --git a/document/core/binary/modules.rst b/document/core/binary/modules.rst
index 607014411..6c4a88890 100644
--- a/document/core/binary/modules.rst
+++ b/document/core/binary/modules.rst
@@ -210,9 +210,17 @@ It decodes into a vector of :ref:`tables <syntax-table>` that represent the |MTA
    \production{table section} & \Btablesec &::=&
      \X{tab}^\ast{:}\Bsection_4(\Bvec(\Btable)) &\Rightarrow& \X{tab}^\ast \\
    \production{table} & \Btable &::=&
-     \X{tt}{:}\Btabletype &\Rightarrow& \{ \TTYPE~\X{tt} \} \\
+     \X{tt}{:}\Btabletype
+       &\Rightarrow& \{ \TTYPE~\X{tt}, \TINIT~(\REFNULL~\X{ht}) \}
+         \qquad \iff \X{tt} = \limits~(\REF~\NULL^?~\X{ht}) \\
+     \hex{40}~~\X{tt}{:}\Btabletype~~e{:}\Bexpr
+       &\Rightarrow& \{ \TTYPE~\X{tt}, \TINIT~e \} \\
    \end{array}
 
+.. note::
+   The encoding of a table type cannot start with byte :math:`\hex{40}`,
+   hence decoding is unambiguous.
+
 
 .. index:: ! memory section, memory, memory type
    pair: binary format; memory
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index 3a54942ff..16202d59c 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -439,7 +439,7 @@ The allocation function for :ref:`modules <syntax-module>` requires a suitable l
 a list of initialization :ref:`values <syntax-val>` for the module's :ref:`globals <syntax-global>`,
 and list of :ref:`reference <syntax-ref>` vectors for the module's :ref:`element segments <syntax-elem>`.
 
-1. Let :math:`\module` be the :ref:`module <syntax-module>` to allocate and :math:`\externval_{\F{im}}^\ast` the vector of :ref:`external values <syntax-externval>` providing the module's imports, :math:`\val^\ast` the initialization :ref:`values <syntax-val>` of the module's :ref:`globals <syntax-global>`, and :math:`(\reff^\ast)^\ast` the :ref:`reference <syntax-ref>` vectors of the module's :ref:`element segments <syntax-elem>`.
+1. Let :math:`\module` be the :ref:`module <syntax-module>` to allocate and :math:`\externval_{\F{im}}^\ast` the vector of :ref:`external values <syntax-externval>` providing the module's imports, :math:`\val_{\F{g}}^\ast` the initialization :ref:`values <syntax-val>` of the module's :ref:`globals <syntax-global>`, :math:`\reff_{\F{t}}^\ast` the initializer :ref:`reference <syntax-ref>` of the module's :ref:`tables <syntax-table>`, and :math:`(\reff_{\F{e}}^\ast)^\ast` the :ref:`reference <syntax-ref>` vectors of the module's :ref:`element segments <syntax-elem>`.
 
 2. For each :ref:`function <syntax-func>` :math:`\func_i` in :math:`\module.\MFUNCS`, do:
 
@@ -447,10 +447,8 @@ and list of :ref:`reference <syntax-ref>` vectors for the module's :ref:`element
 
 3. For each :ref:`table <syntax-table>` :math:`\table_i` in :math:`\module.\MTABLES`, do:
 
-   a. Let :math:`\limits_i~t_i` be the :ref:`table type <syntax-tabletype>` :math:`\table_i.\TTYPE`.
-
-   b. Let :math:`\tableaddr_i` be the :ref:`table address <syntax-tableaddr>` resulting from :ref:`allocating <alloc-table>` :math:`\table_i.\TTYPE`
-   with initialization value :math:`\REFNULL~t_i`.
+   a. Let :math:`\tableaddr_i` be the :ref:`table address <syntax-tableaddr>` resulting from :ref:`allocating <alloc-table>` :math:`\table_i.\TTYPE`
+   with initialization value :math:`\ref_{\F{t}}^\ast[i]`.
 
 4. For each :ref:`memory <syntax-mem>` :math:`\mem_i` in :math:`\module.\MMEMS`, do:
 
@@ -458,11 +456,11 @@ and list of :ref:`reference <syntax-ref>` vectors for the module's :ref:`element
 
 5. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\MGLOBALS`, do:
 
-   a. Let :math:`\globaladdr_i` be the :ref:`global address <syntax-globaladdr>` resulting from :ref:`allocating <alloc-global>` :math:`\global_i.\GTYPE` with initializer value :math:`\val^\ast[i]`.
+   a. Let :math:`\globaladdr_i` be the :ref:`global address <syntax-globaladdr>` resulting from :ref:`allocating <alloc-global>` :math:`\global_i.\GTYPE` with initializer value :math:`\val_{\F{g}}^\ast[i]`.
 
 6. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEMS`, do:
 
-   a. Let :math:`\elemaddr_i` be the :ref:`element address <syntax-elemaddr>` resulting from :ref:`allocating <alloc-elem>` an :ref:`element instance <syntax-eleminst>` of :ref:`reference type <syntax-reftype>` :math:`\elem_i.\ETYPE` with contents :math:`(\reff^\ast)^\ast[i]`.
+   a. Let :math:`\elemaddr_i` be the :ref:`element address <syntax-elemaddr>` resulting from :ref:`allocating <alloc-elem>` an :ref:`element instance <syntax-eleminst>` of :ref:`reference type <syntax-reftype>` :math:`\elem_i.\ETYPE` with contents :math:`(\reff_{\F{e}}^\ast)^\ast[i]`.
 
 7. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATAS`, do:
 
@@ -510,7 +508,7 @@ and list of :ref:`reference <syntax-ref>` vectors for the module's :ref:`element
 .. math::
    ~\\
    \begin{array}{rlll}
-   \allocmodule(S, \module, \externval_{\F{im}}^\ast, \val^\ast, (\reff^\ast)^\ast) &=& S', \moduleinst
+   \allocmodule(S, \module, \externval_{\F{im}}^\ast, \val_{\F{g}}^\ast, \reff_{\F{t}}^\ast, (\reff_{\F{e}}^\ast)^\ast) &=& S', \moduleinst
    \end{array}
 
 where:
@@ -537,14 +535,14 @@ where:
    S_1, \funcaddr^\ast &=&
      \allocfunc^\ast(S, \module.\MFUNCS, \moduleinst) \\
    S_2, \tableaddr^\ast &=&
-     \alloctable^\ast(S_1, (\table.\TTYPE)^\ast, (\REFNULL~t)^\ast)
+     \alloctable^\ast(S_1, (\table.\TTYPE)^\ast, \ref_{\F{t}}^\ast)
      \quad (\where (\table.\TTYPE)^\ast = (\limits~t)^\ast) \\
    S_3, \memaddr^\ast &=&
      \allocmem^\ast(S_2, (\mem.\MTYPE)^\ast) \\
    S_4, \globaladdr^\ast &=&
-     \allocglobal^\ast(S_3, (\global.\GTYPE)^\ast, \val^\ast) \\
+     \allocglobal^\ast(S_3, (\global.\GTYPE)^\ast, \val_{\F{g}}^\ast) \\
    S_5, \elemaddr^\ast &=&
-     \allocelem^\ast(S_4, (\elem.\ETYPE)^\ast, (\reff^\ast)^\ast) \\
+     \allocelem^\ast(S_4, (\elem.\ETYPE)^\ast, (\reff_{\F{e}}^\ast)^\ast) \\
    S', \dataaddr^\ast &=&
      \allocdata^\ast(S_5, (\data.\DINIT)^\ast) \\
    \exportinst^\ast &=&
@@ -627,17 +625,31 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
 7. Push the frame :math:`F_{\F{init}}` to the stack.
 
-8. Let :math:`\val^\ast` be the vector of :ref:`global <syntax-global>` initialization :ref:`values <syntax-val>` determined by :math:`\module` and :math:`\externval^n`. These may be calculated as follows.
+8. Let :math:`\val_{\F{g}}^\ast` be the vector of :ref:`global <syntax-global>` initialization :ref:`values <syntax-val>` determined by :math:`\module` and :math:`\externval^n`. These may be calculated as follows.
 
    a. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\MGLOBALS`, do:
 
-      i. Let :math:`\val_i` be the result of :ref:`evaluating <exec-expr>` the initializer expression :math:`\global_i.\GINIT`.
+      i. Let :math:`\val_{\F{g}i}` be the result of :ref:`evaluating <exec-expr>` the initializer expression :math:`\global_i.\GINIT`.
+
+   b. Assert: due to :ref:`validation <valid-module>`, the frame :math:`F_{\F{init}}` is now on the top of the stack.
+
+   c. Let :math:`\val_{\F{g}}^\ast` be the concatenation of :math:`\val_{\F{g}i}` in index order.
+
+9. Let :math:`\reff_{\F{t}}^\ast` be the vector of :ref:`table <syntax-table>` initialization :ref:`references <syntax-ref>` determined by :math:`\module` and :math:`\externval^n`. These may be calculated as follows.
+
+   a. For each :ref:`table <syntax-table>` :math:`\table_i` in :math:`\module.\MTABLES`, do:
+
+      i. Let :math:`\val_{\F{t}i}` be the result of :ref:`evaluating <exec-expr>` the initializer expression :math:`\table_i.\TINIT`.
+
+      ii. Assert: due to :ref:`validation <valid-table>`, :math:`\val_{\F{t}i}` is a :ref:`reference <syntax-ref>`.
+
+      iii. Let :math:`\reff_{\F{t}i}` be the reference :math:`\val_{\F{t}i}`.
 
    b. Assert: due to :ref:`validation <valid-module>`, the frame :math:`F_{\F{init}}` is now on the top of the stack.
 
-   c. Let :math:`\val^\ast` be the concatenation of :math:`\val_i` in index order.
+   c. Let :math:`\reff_{\F{t}}^\ast` be the concatenation of :math:`\reff_{ti}` in index order.
 
-9. Let :math:`(\reff^\ast)^\ast` be the list of :ref:`reference <syntax-ref>` vectors determined by the :ref:`element segments <syntax-elem>` in :math:`\module`. These may be calculated as follows.
+10. Let :math:`(\reff_{\F{e}}^\ast)^\ast` be the list of :ref:`reference <syntax-ref>` vectors determined by the :ref:`element segments <syntax-elem>` in :math:`\module`. These may be calculated as follows.
 
     a. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEMS`, and for each element :ref:`expression <syntax-expr>` :math:`\expr_{ij}` in :math:`\elem_i.\EINIT`, do:
 
@@ -645,17 +657,17 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
     b. Let :math:`\reff^\ast_i` be the concatenation of function elements :math:`\reff_{ij}` in order of index :math:`j`.
 
-    c. Let :math:`(\reff^\ast)^\ast` be the concatenation of function element vectors :math:`\reff^\ast_i` in order of index :math:`i`.
+    c. Let :math:`(\reff_{\F{e}}^\ast)^\ast` be the concatenation of function element vectors :math:`\reff^\ast_i` in order of index :math:`i`.
 
-10. Pop the frame :math:`F_{\F{init}}` from the stack.
+11. Pop the frame :math:`F_{\F{init}}` from the stack.
 
-11. Let :math:`\moduleinst` be a new module instance :ref:`allocated <alloc-module>` from :math:`\module` in store :math:`S` with imports :math:`\externval^n`, global initializer values :math:`\val^\ast`, and element segment contents :math:`(\reff^\ast)^\ast`, and let :math:`S'` be the extended store produced by module allocation.
+12. Let :math:`\moduleinst` be a new module instance :ref:`allocated <alloc-module>` from :math:`\module` in store :math:`S` with imports :math:`\externval^n`, global initializer values :math:`\val_{\F{g}}^\ast`, table initializer values :math:`\reff_{\F{t}}^\ast`, and element segment contents :math:`(\reff_{\F{e}}^\ast)^\ast`, and let :math:`S'` be the extended store produced by module allocation.
 
-12. Let :math:`F` be the auxiliary :ref:`frame <syntax-frame>` :math:`\{ \AMODULE~\moduleinst, \ALOCALS~\epsilon \}`.
+13. Let :math:`F` be the auxiliary :ref:`frame <syntax-frame>` :math:`\{ \AMODULE~\moduleinst, \ALOCALS~\epsilon \}`.
 
-13. Push the frame :math:`F` to the stack.
+14. Push the frame :math:`F` to the stack.
 
-14. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEMS` whose :ref:`mode <syntax-elemmode>` is of the form :math:`\EACTIVE~\{ \ETABLE~\tableidx_i, \EOFFSET~\X{einstr}^\ast_i~\END \}`, do:
+15. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEMS` whose :ref:`mode <syntax-elemmode>` is of the form :math:`\EACTIVE~\{ \ETABLE~\tableidx_i, \EOFFSET~\X{einstr}^\ast_i~\END \}`, do:
 
     a. Let :math:`n` be the length of the vector :math:`\elem_i.\EINIT`.
 
@@ -669,7 +681,7 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
     f. :ref:`Execute <exec-elem.drop>` the instruction :math:`\ELEMDROP~i`.
 
-15. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATAS` whose :ref:`mode <syntax-datamode>` is of the form :math:`\DACTIVE~\{ \DMEM~\memidx_i, \DOFFSET~\X{dinstr}^\ast_i~\END \}`, do:
+16. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATAS` whose :ref:`mode <syntax-datamode>` is of the form :math:`\DACTIVE~\{ \DMEM~\memidx_i, \DOFFSET~\X{dinstr}^\ast_i~\END \}`, do:
 
     a. Assert: :math:`\memidx_i` is :math:`0`.
 
@@ -685,15 +697,15 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
     g. :ref:`Execute <exec-data.drop>` the instruction :math:`\DATADROP~i`.
 
-16. If the :ref:`start function <syntax-start>` :math:`\module.\MSTART` is not empty, then:
+17. If the :ref:`start function <syntax-start>` :math:`\module.\MSTART` is not empty, then:
 
     a. Let :math:`\start` be the :ref:`start function <syntax-start>` :math:`\module.\MSTART`.
 
     b. :ref:`Execute <exec-call>` the instruction :math:`\CALL~\start.\SFUNC`.
 
-17. Assert: due to :ref:`validation <valid-module>`, the frame :math:`F` is now on the top of the stack.
+18. Assert: due to :ref:`validation <valid-module>`, the frame :math:`F` is now on the top of the stack.
 
-18. Pop the frame :math:`F` from the stack.
+19. Pop the frame :math:`F` from the stack.
 
 
 .. math::
@@ -714,11 +726,13 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
      &\wedge& \module.\MDATAS = \data^m \\
      &\wedge& \module.\MSTART = \start^? \\
      &\wedge& (\expr_{\F{g}} = \global.\GINIT)^\ast \\
+     &\wedge& (\expr_{\F{t}} = \table.\GINIT)^\ast \\
      &\wedge& (\expr_{\F{e}}^\ast = \elem.\EINIT)^n \\[1ex]
      &\wedge& S', \moduleinst = \allocmodule(S, \module, \externval^k, \val^\ast, (\reff^\ast)^n) \\
      &\wedge& F = \{ \AMODULE~\moduleinst, \ALOCALS~\epsilon \} \\[1ex]
-     &\wedge& (S'; F; \expr_{\F{g}} \stepto^\ast S'; F; \val~\END)^\ast \\
-     &\wedge& ((S'; F; \expr_{\F{e}} \stepto^\ast S'; F; \reff~\END)^\ast)^n \\
+     &\wedge& (S'; F; \expr_{\F{g}} \stepto^\ast S'; F; \val_{\F{g}}~\END)^\ast \\
+     &\wedge& (S'; F; \expr_{\F{t}} \stepto^\ast S'; F; \reff_{\F{t}}~\END)^\ast \\
+     &\wedge& ((S'; F; \expr_{\F{e}} \stepto^\ast S'; F; \reff_{\F{e}}~\END)^\ast)^n \\
      &\wedge& (\tableaddr = \moduleinst.\MITABLES[\elem.\ETABLE])^\ast \\
      &\wedge& (\memaddr = \moduleinst.\MIMEMS[\data.\DMEM])^\ast \\
      &\wedge& (\funcaddr = \moduleinst.\MIFUNCS[\start.\SFUNC])^?)
diff --git a/document/core/syntax/modules.rst b/document/core/syntax/modules.rst
index 29a598aa8..d9a27bd3f 100644
--- a/document/core/syntax/modules.rst
+++ b/document/core/syntax/modules.rst
@@ -172,13 +172,14 @@ The |MTABLES| component of a module defines a vector of *tables* described by th
 .. math::
    \begin{array}{llll}
    \production{table} & \table &::=&
-     \{ \TTYPE~\tabletype \} \\
+     \{ \TTYPE~\tabletype, \TINIT~\expr \} \\
    \end{array}
 
-A table is a vector of opaque values of a particular :ref:`reference type <syntax-reftype>`.
-The |LMIN| size in the :ref:`limits <syntax-limits>` of the table type specifies the initial size of that table, while its |LMAX|, if present, restricts the size to which it can grow later.
+A table is an array of opaque values of a particular :ref:`reference type <syntax-reftype>`.
+Moreover, each table slot is initialized with the |TINIT| value given by a :ref:`constant <valid-constant>` initializer :ref:`expression <syntax-expr>`.
+Tables can further be initialized through :ref:`element segments <syntax-elem>`.
 
-Tables can be initialized through :ref:`element segments <syntax-elem>`.
+The |LMIN| size in the :ref:`limits <syntax-limits>` of the table type specifies the initial size of that table, while its |LMAX|, if present, restricts the size to which it can grow later.
 
 Tables are referenced through :ref:`table indices <syntax-tableidx>`,
 starting with the smallest index not referencing a table :ref:`import <syntax-import>`.
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index f73c2d5b4..9ff0d1629 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -289,6 +289,7 @@
 .. |LTYPE| mathdef:: \xref{syntax/modules}{syntax-local}{\K{type}}
 
 .. |TTYPE| mathdef:: \xref{syntax/modules}{syntax-table}{\K{type}}
+.. |TINIT| mathdef:: \xref{syntax/modules}{syntax-table}{\K{init}}
 
 .. |MTYPE| mathdef:: \xref{syntax/modules}{syntax-mem}{\K{type}}
 
@@ -937,7 +938,6 @@
 .. |vdashinstrtype| mathdef:: \xref{valid/instructions}{valid-instrtype}{\vdash}
 
 .. |vdashvaltypedefaultable| mathdef:: \xref{valid/types}{valid-defaultable}{\vdash}
-.. |vdashtabletypedefaultable| mathdef:: \xref{valid/types}{valid-defaultable}{\vdash}
 
 .. |vdashnumtypematch| mathdef:: \xref{valid/matching}{match-numtype}{\vdash}
 .. |vdashvectypematch| mathdef:: \xref{valid/matching}{match-vectype}{\vdash}
diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index 20c6a5b9c..ca19ca510 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -99,7 +99,7 @@ Locals
    For cases where both rules are applicable, the former yields the more permissable type.
 
 
-.. index:: table, table type, defaultable
+.. index:: table, table type, reference type, expression, constant, defaultable
    pair: validation; table
    single: abstract syntax; table
 .. _valid-table:
@@ -109,20 +109,30 @@ Tables
 
 Tables :math:`\table` are classified by :ref:`table types <syntax-tabletype>`.
 
-:math:`\{ \TTYPE~\tabletype \}`
-...............................
+:math:`\{ \TTYPE~\tabletype, \TINIT~\expr \}`
+.............................................
 
 * The :ref:`table type <syntax-tabletype>` :math:`\tabletype` must be :ref:`valid <valid-tabletype>`.
 
+* Let :math:`t` be the element :ref:`reference type <syntax-reftype>` of :math:`\tabletype`.
+
+* The expression :math:`\expr` must be :ref:`valid <valid-expr>` with :ref:`result type <syntax-resulttype>` :math:`[t]`.
+
+* The expression :math:`\expr` must be :ref:`constant <valid-constant>`.
+
 * Then the table definition is valid with type :math:`\tabletype`.
 
 .. math::
    \frac{
      C \vdashtabletype \tabletype \ok
      \qquad
-     C \vdashtabletypedefaultable \tabletype \defaultable
+     \tabletype = \limits~t
+     \qquad
+     C \vdashexpr \expr : [t]
+     \qquad
+     C \vdashexprconst \expr \const
    }{
-     C \vdashtable \{ \TTYPE~\tabletype \} : \tabletype
+     C \vdashtable \{ \TTYPE~\tabletype, \TINIT~\expr \} : \tabletype
    }
 
 
@@ -151,7 +161,7 @@ Memories :math:`\mem` are classified by :ref:`memory types <syntax-memtype>`.
    }
 
 
-.. index:: global, global type, expression
+.. index:: global, global type, expression, constant
    pair: validation; global
    single: abstract syntax; global
 .. _valid-global:
@@ -185,7 +195,7 @@ Globals :math:`\global` are classified by :ref:`global types <syntax-globaltype>
    }
 
 
-.. index:: element, table, table index, expression, function index
+.. index:: element, table, table index, expression, constant, function index
    pair: validation; element
    single: abstract syntax; element
    single: table; element
@@ -286,7 +296,7 @@ Element segments :math:`\elem` are classified by the :ref:`reference type <synta
 
 
 
-.. index:: data, memory, memory index, expression, byte
+.. index:: data, memory, memory index, expression, constant, byte
    pair: validation; data
    single: abstract syntax; data
    single: memory; data
diff --git a/document/core/valid/types.rst b/document/core/valid/types.rst
index ad9c42913..659706b9f 100644
--- a/document/core/valid/types.rst
+++ b/document/core/valid/types.rst
@@ -479,19 +479,3 @@ Value Types
    }{
      C \vdashvaltypedefaultable (\REF~\NULL~\heaptype) \defaultable
    }
-
-
-Table Types
-...........
-
-* A defaultable :ref:`table type <syntax-tabletype>` must be:
-
-  - of the form :math:`\limits~t`, where `t` is a :ref:`defaultable <valid-defaultable>` :ref:`reference type <syntax-numtype>`.
-
-
-.. math::
-   \frac{
-     C \vdashvaltypedefaultable \reftype \defaultable
-   }{
-     C \vdashtabletypedefaultable \limits~\reftype \defaultable
-   }
diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 28bbbfb08..29d318e26 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -908,8 +908,20 @@ let func_section s =
 (* Table section *)
 
 let table s =
-  let ttype = table_type s in
-  {ttype}
+  either [
+    (fun s ->
+      expect 0x40 s "";
+      zero s;
+      let ttype = table_type s in
+      let tinit = const s in
+      {ttype; tinit}
+    );
+    (fun s ->
+      let at = region s (pos s) (pos s) in
+      let TableT (_, (_, ht)) as ttype = table_type s in
+      {ttype; tinit = [RefNull ht @@ at] @@ at}
+    );
+  ] s
 
 let table_section s =
   section `TableSection (vec (at table)) [] s
diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index e5e439df4..60ed152b1 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -798,8 +798,11 @@ struct
   (* Table section *)
 
   let table tab =
-    let {ttype} = tab.it in
-    table_type ttype
+    let {ttype; tinit} = tab.it in
+    match ttype, tinit.it with
+    | TableT (_, (_, ht1)), [{it = RefNull ht2; _}] when ht1 = ht2 ->
+      table_type ttype
+    | _ -> op 0x40; op 0x00; table_type ttype; const tinit
 
   let table_section tabs =
     section 4 (vec table) tabs (tabs <> [])
diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index 310a1ac80..407b81ff4 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -758,9 +758,14 @@ let create_func (inst : module_inst) (f : func) : func_inst =
   Func.alloc (type_ inst f.it.ftype) (Lib.Promise.make ()) f
 
 let create_table (inst : module_inst) (tab : table) : table_inst =
-  let {ttype} = tab.it in
-  let TableT (_lim, (_nul, t)) as tt = Types.Sem.sem_table_type inst.types ttype in
-  Table.alloc tt (NullRef t)
+  let {ttype; tinit} = tab.it in
+  let tt = Types.Sem.sem_table_type inst.types ttype in
+  let r =
+    match eval_const inst tinit with
+    | Ref r -> r
+    | _ -> Crash.error tinit.at "non-reference table initializer"
+  in
+  Table.alloc tt r
 
 let create_memory (inst : module_inst) (mem : memory) : memory_inst =
   let {mtype} = mem.it in
diff --git a/interpreter/syntax/ast.ml b/interpreter/syntax/ast.ml
index b8356acf1..bbe17c6f1 100644
--- a/interpreter/syntax/ast.ml
+++ b/interpreter/syntax/ast.ml
@@ -240,6 +240,7 @@ type table = table' Source.phrase
 and table' =
 {
   ttype : table_type;
+  tinit : const;
 }
 
 type memory = memory' Source.phrase
diff --git a/interpreter/syntax/free.ml b/interpreter/syntax/free.ml
index 8793e28b2..764e08b25 100644
--- a/interpreter/syntax/free.ml
+++ b/interpreter/syntax/free.ml
@@ -138,7 +138,7 @@ let const (c : const) = block c.it
 let global (g : global) = global_type g.it.gtype ++ const g.it.ginit
 let func (f : func) =
   {(types (idx f.it.ftype) ++ block f.it.body) with locals = Set.empty}
-let table (t : table) = table_type t.it.ttype
+let table (t : table) = table_type t.it.ttype ++ const t.it.tinit
 let memory (m : memory) = memory_type m.it.mtype
 
 let segment_mode f (m : segment_mode) =
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index 3fae93b98..b86fa6ea4 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -538,9 +538,9 @@ let func f =
 (* Tables & memories *)
 
 let table off i tab =
-  let {ttype = TableT (lim, t)} = tab.it in
+  let {ttype = TableT (lim, t); tinit} = tab.it in
   Node ("table $" ^ nat (off + i) ^ " " ^ limits nat32 lim,
-    [atom ref_type t]
+    atom ref_type t :: list instr tinit.it
   )
 
 let memory off i mem =
@@ -598,7 +598,7 @@ let import_desc fx tx mx gx d =
   | FuncImport x ->
     incr fx; Node ("func $" ^ nat (!fx - 1), [Node ("type", [atom var x])])
   | TableImport t ->
-    incr tx; table 0 (!tx - 1) ({ttype = t} @@ d.at)
+    incr tx; table 0 (!tx - 1) ({ttype = t; tinit = [] @@ d.at} @@ d.at)
   | MemoryImport t ->
     incr mx; memory 0 (!mx - 1) ({mtype = t} @@ d.at)
   | GlobalImport t ->
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index 469e61048..b41ecdf56 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -736,6 +736,9 @@ expr_list :
 const_expr :
   | instr_list { let at = at () in fun c -> $1 c @@ at }
 
+const_expr1 :
+  | instr instr_list { let at = at () in fun c -> ($1 c @ $2 c) @@ at }
+
 
 /* Functions */
 
@@ -895,8 +898,11 @@ table :
       fun () -> $4 c x at }
 
 table_fields :
-  | table_type
-    { fun c x at -> [{ttype = $1 c} @@ at], [], [], [] }
+  | table_type const_expr1
+    { fun c x at -> [{ttype = $1 c; tinit = $2 c} @@ at], [], [], [] }
+  | table_type  /* Sugar */
+    { fun c x at -> let TableT (_, (_, ht)) as ttype = $1 c in
+      [{ttype; tinit = [RefNull ht @@ at] @@ at} @@ at], [], [], [] }
   | inline_import table_type  /* Sugar */
     { fun c x at ->
       [], [],
@@ -911,8 +917,9 @@ table_fields :
       let einit = $4 c func in
       let size = Lib.List32.length einit in
       let emode = Active {index = x; offset} @@ at in
-      let etype = $1 c in
-      [{ttype = TableT ({min = size; max = Some size}, etype)} @@ at],
+      let (_, ht) as etype = $1 c in
+      let tinit = [RefNull ht @@ at] @@ at in
+      [{ttype = TableT ({min = size; max = Some size}, etype); tinit} @@ at],
       [{etype; einit; emode} @@ at],
       [], [] }
   | ref_type LPAR ELEM elem_expr elem_expr_list RPAR  /* Sugar */
@@ -921,8 +928,9 @@ table_fields :
       let einit = (fun c -> $4 c :: $5 c) c in
       let size = Lib.List32.length einit in
       let emode = Active {index = x; offset} @@ at in
-      let etype = $1 c in
-      [{ttype = TableT ({min = size; max = Some size}, etype)} @@ at],
+      let (_, ht) as etype = $1 c in
+      let tinit = [RefNull ht @@ at] @@ at in
+      [{ttype = TableT ({min = size; max = Some size}, etype); tinit} @@ at],
       [{etype; einit; emode} @@ at],
       [], [] }
 
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index b5db1a5fb..9159037ff 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -120,8 +120,7 @@ let check_func_type (c : context) (ft : func_type) at =
 let check_table_type (c : context) (tt : table_type) at =
   let TableT (lim, t) = tt in
   check_limits lim 0xffff_ffffl at "table size must be at most 2^32-1";
-  check_ref_type c t at;
-  require (defaultable (RefT t)) at "non-defaultable element type"
+  check_ref_type c t at
 
 let check_memory_type (c : context) (mt : memory_type) at =
   let MemoryT lim = mt in
@@ -723,8 +722,10 @@ let check_const (c : context) (const : const) (t : val_type) =
 (* Tables, Memories, & Globals *)
 
 let check_table (c : context) (tab : table) =
-  let {ttype} = tab.it in
-  check_table_type c ttype tab.at
+  let {ttype; tinit} = tab.it in
+  check_table_type c ttype tab.at;
+  let TableT (_lim, rt) = ttype in
+  check_const c tinit (RefT rt)
 
 let check_memory (c : context) (mem : memory) =
   let {mtype} = mem.it in
diff --git a/proposals/function-references/Overview.md b/proposals/function-references/Overview.md
index 4a5fcafb8..e3b93e9b9 100644
--- a/proposals/function-references/Overview.md
+++ b/proposals/function-references/Overview.md
@@ -165,7 +165,7 @@ The following rules, now defined in terms of heap types, replace and extend the
 
 * Function-level locals must have a type that is defaultable.
 
-* TODO: Table definitions with a type that is not defaultable must have an initialiser value. (Imports are not affected.)
+* Table definitions with a type that is not defaultable must have an initialiser value. (Imports are not affected.)
 
 
 #### Local Types
@@ -283,9 +283,13 @@ A subsumption rule allows to go to a supertype for any instruction:
 
 ### Tables
 
-* TODO: Table definitions have an initialiser value: `(table <tabletype> <constexpr>)`
+Table definitions have an initialiser value:
+
+* `(table <tabletype> <constexpr>)` is an extended form of table definition
   - `(table <limits> <reftype> <constexpr>) ok` iff `<limits> <reftype> ok` and `<constexpr> : <reftype>`
-  - `(table <tabletype>)` is shorthand for `(table <tabletype> (ref.null))`
+
+* `(table <tabletype>)` is shorthand for `(table <tabletype> (ref.null <heaptype>))`, where `<heaptype>` is the element heap type contained in `<tabletype>`
+  - note: the typing rule above implies that this only validates if the table's reference type is nullable
 
 
 ## Binary Format
@@ -323,7 +327,15 @@ The opcode for heap types is encoded as an `s33`.
 
 ### Tables
 
-TODO.
+Entries to the table section are extended as follows:
+
+| Table Definition | Note |
+|------------------|------|
+| tabletype        | null-initialized table (as before) |
+| 0x40 0x00 tabletype constexpr | explicitly initialized table |
+
+The encoding of a table type starts with the encoding of a reference type, which cannot be 0x40 (since this is a pseudo type code otherwise only used in block types). Consequently, both forms can be distinguished by the first byte.
+The second byte is reserved for possible future extensions.
 
 
 ## JS API
diff --git a/test/core/table.wast b/test/core/table.wast
index 532c13d09..16e35a801 100644
--- a/test/core/table.wast
+++ b/test/core/table.wast
@@ -15,6 +15,10 @@
 (module (table 0 funcref) (table 0 funcref))
 (module (table (import "spectest" "table") 0 funcref) (table 0 funcref))
 
+(module (table 0 funcref (ref.null func)))
+(module (table 1 funcref (ref.null func)))
+(module (table 1 (ref null func) (ref.null func)))
+
 (assert_invalid (module (elem (i32.const 0))) "unknown table")
 (assert_invalid (module (elem (i32.const 0) $f) (func $f)) "unknown table")
 
@@ -41,30 +45,76 @@
   "i32 constant out of range"
 )
 
+(assert_invalid
+  (module (table 1 (ref null func) (i32.const 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (table 1 (ref func) (ref.null extern)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (type $t (func)) (table 1 (ref $t) (ref.null func)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (table 1 (ref func) (ref.null func)))
+  "type mismatch"
+)
 (assert_invalid
   (module (table 0 (ref func)))
-  "non-defaultable element type"
+  "type mismatch"
 )
 (assert_invalid
   (module (table 0 (ref extern)))
-  "non-defaultable element type"
+  "type mismatch"
 )
 (assert_invalid
   (module (type $t (func)) (table 0 (ref $t)))
-  "non-defaultable element type"
+  "type mismatch"
 )
 
+
+;; Table initializer
+
+(module
+  (type $dummy (func))
+  (func $dummy)
+
+  (table $t1 10 funcref)
+  (table $t2 10 funcref (ref.func $dummy))
+  (table $t3 10 (ref $dummy) (ref.func $dummy))
+
+  (func (export "get1") (result funcref) (table.get $t1 (i32.const 1)))
+  (func (export "get2") (result funcref) (table.get $t2 (i32.const 4)))
+  (func (export "get3") (result funcref) (table.get $t3 (i32.const 7)))
+)
+
+(assert_return (invoke "get1") (ref.null))
+(assert_return (invoke "get2") (ref.func))
+(assert_return (invoke "get3") (ref.func))
+
+
 ;; Duplicate table identifiers
 
-(assert_malformed (module quote
-  "(table $foo 1 funcref)"
-  "(table $foo 1 funcref)")
-  "duplicate table")
-(assert_malformed (module quote
-  "(import \"\" \"\" (table $foo 1 funcref))"
-  "(table $foo 1 funcref)")
-  "duplicate table")
-(assert_malformed (module quote
-  "(import \"\" \"\" (table $foo 1 funcref))"
-  "(import \"\" \"\" (table $foo 1 funcref))")
-  "duplicate table")
+(assert_malformed
+  (module quote
+    "(table $foo 1 funcref)"
+    "(table $foo 1 funcref)"
+  )
+  "duplicate table"
+)
+(assert_malformed
+  (module quote
+    "(import \"\" \"\" (table $foo 1 funcref))"
+    "(table $foo 1 funcref)"
+  )
+  "duplicate table"
+)
+(assert_malformed
+  (module quote
+    "(import \"\" \"\" (table $foo 1 funcref))"
+    "(import \"\" \"\" (table $foo 1 funcref))"
+  )
+  "duplicate table"
+)

From 07a4a26bef55d76fb88533e38580d52a24ba59a2 Mon Sep 17 00:00:00 2001
From: Alberto Fiori <9143617+fifofefe@users.noreply.github.com>
Date: Wed, 8 Jun 2022 15:40:16 +0200
Subject: [PATCH 156/285] [spec] Remove outdated note (#1491)

---
 document/core/exec/runtime.rst | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index 869d197eb..1fdddfa10 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -87,10 +87,6 @@ It is either a sequence of :ref:`values <syntax-val>` or a :ref:`trap <syntax-tr
      \TRAP
    \end{array}
 
-.. note::
-   In the current version of WebAssembly, a result can consist of at most one value.
-
-
 .. index:: ! store, function instance, table instance, memory instance, global instance, module, allocation
    pair: abstract syntax; store
 .. _syntax-store:

From a9d46aad9a8201f2521fe3065ccda327b1a3a27f Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Thu, 9 Jun 2022 12:25:43 +0200
Subject: [PATCH 157/285] [interpreter] Factor data and element segments into
 abstract types (#1492)

---
 interpreter/exec/eval.ml        | 23 ++++++++++++-----------
 interpreter/exec/ixx.ml         |  4 ++--
 interpreter/runtime/data.ml     |  7 +++++++
 interpreter/runtime/data.mli    |  7 +++++++
 interpreter/runtime/elem.ml     |  7 +++++++
 interpreter/runtime/elem.mli    |  9 +++++++++
 interpreter/runtime/instance.ml |  8 ++++----
 7 files changed, 48 insertions(+), 17 deletions(-)
 create mode 100644 interpreter/runtime/data.ml
 create mode 100644 interpreter/runtime/data.mli
 create mode 100644 interpreter/runtime/elem.ml
 create mode 100644 interpreter/runtime/elem.mli

diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index 407b81ff4..89b313400 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -142,7 +142,7 @@ let mem_oob frame x i n =
 
 let data_oob frame x i n =
   I64.gt_u (I64.add (I64_convert.extend_i32_u i) (I64_convert.extend_i32_u n))
-    (I64.of_int_u (String.length !(data frame.inst x)))
+    (Data.size (data frame.inst x))
 
 let table_oob frame x i n =
   I64.gt_u (I64.add (I64_convert.extend_i32_u i) (I64_convert.extend_i32_u n))
@@ -150,7 +150,7 @@ let table_oob frame x i n =
 
 let elem_oob frame x i n =
   I64.gt_u (I64.add (I64_convert.extend_i32_u i) (I64_convert.extend_i32_u n))
-    (I64.of_int_u (List.length !(elem frame.inst x)))
+    (I64_convert.extend_i32_u (Elem.size (elem frame.inst x)))
 
 let rec step (c : config) : config =
   let vs, es = c.code in
@@ -349,10 +349,10 @@ let rec step (c : config) : config =
         else if n = 0l then
           vs', []
         else
-          let seg = !(elem c.frame.inst y) in
+          let seg = elem c.frame.inst y in
           vs', List.map (Lib.Fun.flip (@@) e.at) [
             Plain (Const (I32 d @@ e.at));
-            Refer (List.nth seg (Int32.to_int s));
+            Refer (Elem.load seg s);
             Plain (TableSet x);
             Plain (Const (I32 (I32.add d 1l) @@ e.at));
             Plain (Const (I32 (I32.add s 1l) @@ e.at));
@@ -362,7 +362,7 @@ let rec step (c : config) : config =
 
       | ElemDrop x, vs ->
         let seg = elem c.frame.inst x in
-        seg := [];
+        Elem.drop seg;
         vs, []
 
       | Load {offset; ty; pack; _}, Num (I32 i) :: vs' ->
@@ -513,11 +513,12 @@ let rec step (c : config) : config =
         else if n = 0l then
           vs', []
         else
-          let seg = !(data c.frame.inst x) in
-          let b = Int32.of_int (Char.code seg.[Int32.to_int s]) in
+          let seg = data c.frame.inst x in
+          let a = I64_convert.extend_i32_u s in
+          let b = Data.load seg a in
           vs', List.map (Lib.Fun.flip (@@) e.at) [
             Plain (Const (I32 d @@ e.at));
-            Plain (Const (I32 b @@ e.at));
+            Plain (Const (I32 (I32.of_int_u (Char.code b)) @@ e.at));
             Plain (Store
               {ty = Types.I32T; align = 0; offset = 0l; pack = Some Pack8});
             Plain (Const (I32 (I32.add d 1l) @@ e.at));
@@ -528,7 +529,7 @@ let rec step (c : config) : config =
 
       | DataDrop x, vs ->
         let seg = data c.frame.inst x in
-        seg := "";
+        Data.drop seg;
         vs, []
 
       | RefNull t, vs' ->
@@ -788,11 +789,11 @@ let create_export (inst : module_inst) (ex : export) : export_inst =
 
 let create_elem (inst : module_inst) (seg : elem_segment) : elem_inst =
   let {etype; einit; _} = seg.it in
-  ref (List.map (fun c -> as_ref (eval_const inst c)) einit)
+  Elem.alloc (List.map (fun c -> as_ref (eval_const inst c)) einit)
 
 let create_data (inst : module_inst) (seg : data_segment) : data_inst =
   let {dinit; _} = seg.it in
-  ref dinit
+  Data.alloc dinit
 
 
 let add_import (m : module_) (ext : extern) (im : import) (inst : module_inst)
diff --git a/interpreter/exec/ixx.ml b/interpreter/exec/ixx.ml
index 18f8b7d06..0a13d22b6 100644
--- a/interpreter/exec/ixx.ml
+++ b/interpreter/exec/ixx.ml
@@ -30,8 +30,8 @@ sig
 
   val of_int : int -> t
   val to_int : t -> int
-  val of_int64: int64 -> t
-  val to_int64: t -> int64
+  val of_int64 : int64 -> t
+  val to_int64 : t -> int64
   val to_string : t -> string
   val to_hex_string : t -> string
 
diff --git a/interpreter/runtime/data.ml b/interpreter/runtime/data.ml
new file mode 100644
index 000000000..e73cd2f31
--- /dev/null
+++ b/interpreter/runtime/data.ml
@@ -0,0 +1,7 @@
+type data = string ref
+type t = data
+
+let alloc bs = ref bs
+let size seg = I64.of_int_u (String.length !seg)
+let load seg i = (!seg).[Int64.to_int i]
+let drop seg = seg := ""
diff --git a/interpreter/runtime/data.mli b/interpreter/runtime/data.mli
new file mode 100644
index 000000000..498c45149
--- /dev/null
+++ b/interpreter/runtime/data.mli
@@ -0,0 +1,7 @@
+type data
+type t = data
+
+val alloc : string -> data
+val size : data -> Memory.address
+val load : data -> Memory.address -> char
+val drop : data -> unit
diff --git a/interpreter/runtime/elem.ml b/interpreter/runtime/elem.ml
new file mode 100644
index 000000000..fe8997482
--- /dev/null
+++ b/interpreter/runtime/elem.ml
@@ -0,0 +1,7 @@
+type elem = Values.ref_ list ref
+type t = elem
+
+let alloc rs = ref rs
+let size seg = Lib.List32.length !seg
+let load seg i = Lib.List32.nth !seg i
+let drop seg = seg := []
diff --git a/interpreter/runtime/elem.mli b/interpreter/runtime/elem.mli
new file mode 100644
index 000000000..5eb0c0e56
--- /dev/null
+++ b/interpreter/runtime/elem.mli
@@ -0,0 +1,9 @@
+open Values
+
+type elem
+type t = elem
+
+val alloc : ref_ list -> elem
+val size : elem -> Table.size
+val load : elem -> Table.index -> ref_
+val drop : elem -> unit
diff --git a/interpreter/runtime/instance.ml b/interpreter/runtime/instance.ml
index a7fa55e8e..69c0b5815 100644
--- a/interpreter/runtime/instance.ml
+++ b/interpreter/runtime/instance.ml
@@ -7,9 +7,9 @@ type module_inst =
   tables : table_inst list;
   memories : memory_inst list;
   globals : global_inst list;
-  exports : export_inst list;
   elems : elem_inst list;
   datas : data_inst list;
+  exports : export_inst list;
 }
 
 and type_inst = var
@@ -17,9 +17,9 @@ and func_inst = module_inst Lib.Promise.t Func.t
 and table_inst = Table.t
 and memory_inst = Memory.t
 and global_inst = Global.t
+and elem_inst = Elem.t
+and data_inst = Data.t
 and export_inst = Ast.name * extern
-and elem_inst = Value.ref_ list ref
-and data_inst = string ref
 
 and extern =
   | ExternFunc of func_inst
@@ -56,7 +56,7 @@ let () =
 
 let empty_module_inst =
   { types = []; funcs = []; tables = []; memories = []; globals = [];
-    exports = []; elems = []; datas = [] }
+    elems = []; datas = []; exports = [] }
 
 let extern_type_of c = function
   | ExternFunc func -> ExternFuncT (Func.type_of func)

From 88c4b347f26ee6f6499a1b9ac325dbba9b4769fb Mon Sep 17 00:00:00 2001
From: Keith Winstein <keithw@cs.stanford.edu>
Date: Mon, 13 Jun 2022 03:04:08 -0700
Subject: [PATCH 158/285] [spec] Update note on module initialization trapping
 (#1493)

---
 document/core/exec/modules.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index 16202d59c..d81ca7b6a 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -594,7 +594,7 @@ Given a :ref:`store <syntax-store>` :math:`S`, a :ref:`module <syntax-module>` :
 
 Instantiation checks that the module is :ref:`valid <valid>` and the provided imports :ref:`match <match-externtype>` the declared types,
 and may *fail* with an error otherwise.
-Instantiation can also result in a :ref:`trap <trap>` from executing the start function.
+Instantiation can also result in a :ref:`trap <trap>` from initializing a table or memory from an active segment or from executing the start function.
 It is up to the :ref:`embedder <embedder>` to define how such conditions are reported.
 
 1. If :math:`\module` is not :ref:`valid <valid-module>`, then:

From c502b7a735c2be6a1d1ac85951a2db45e1a10e06 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Mon, 27 Jun 2022 12:32:27 +0200
Subject: [PATCH 159/285] [spec] Add note about control stack invariant to
 algorithm (#1498)

---
 document/core/appendix/algorithm.rst | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/document/core/appendix/algorithm.rst b/document/core/appendix/algorithm.rst
index 10f6b2506..172b9773a 100644
--- a/document/core/appendix/algorithm.rst
+++ b/document/core/appendix/algorithm.rst
@@ -240,6 +240,8 @@ The type of the :ref:`label <syntax-label>` associated with a control frame is e
 
 Finally, the current frame can be marked as unreachable.
 In that case, all existing operand types are purged from the value stack, in order to allow for the :ref:`stack-polymorphism <polymorphism>` logic in :code:`pop_val` to take effect.
+Because every function has an implicit outermost label that corresponds to an implicit block frame,
+it is an invariant of the validation algorithm that there always is at least one frame on the control stack when validating an instruction, and hence, `ctrls[0]` is always defined.
 
 .. note::
    Even with the unreachable flag set, consecutive operands are still pushed to and popped from the operand stack.

From 11d1a53b30a6030094d9ebce36f533ea9f421a92 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Tue, 28 Jun 2022 22:50:26 +0200
Subject: [PATCH 160/285] [spec] Tweak tokenisation for text format (#1499)

---
 document/core/text/lexical.rst |   8 +-
 interpreter/text/lexer.mll     |  10 +-
 test/core/tokens.wast          | 274 +++++++++++++++++++++++++++++++++
 3 files changed, 284 insertions(+), 8 deletions(-)
 create mode 100644 test/core/tokens.wast

diff --git a/document/core/text/lexical.rst b/document/core/text/lexical.rst
index a3b4529d3..0c40a58d1 100644
--- a/document/core/text/lexical.rst
+++ b/document/core/text/lexical.rst
@@ -50,7 +50,7 @@ The character stream in the source text is divided, from left to right, into a s
      (\text{a} ~|~ \dots ~|~ \text{z})~\Tidchar^\ast
      \qquad (\mbox{if occurring as a literal terminal in the grammar}) \\
    \production{reserved} & \Treserved &::=&
-     \Tidchar^+ \\
+     (\Tidchar ~|~ \Tstring)^+ \\
    \end{array}
 
 Tokens are formed from the input character stream according to the *longest match* rule.
@@ -63,9 +63,9 @@ The set of *keyword* tokens is defined implicitly, by all occurrences of a :ref:
 Any token that does not fall into any of the other categories is considered *reserved*, and cannot occur in source text.
 
 .. note::
-   The effect of defining the set of reserved tokens is that all tokens must be separated by either parentheses or :ref:`white space <text-space>`.
-   For example, :math:`\text{0\$x}` is a single reserved token.
-   Consequently, it is not recognized as two separate tokens :math:`\text{0}` and :math:`\text{\$x}`, but instead disallowed.
+   The effect of defining the set of reserved tokens is that all tokens must be separated by either parentheses, :ref:`white space <text-space>`, or :ref:`comments <text-comment>`.
+   For example, :math:`\text{0\$x}` is a single reserved token, as is :math:`\text{"a""b"}`.
+   Consequently, they are not recognized as two separate tokens :math:`\text{0}` and :math:`\text{\$x}`, or :math:`"a"` and :math:`"b"`, respectively, but instead disallowed.
    This property of tokenization is not affected by the fact that the definition of reserved tokens overlaps with other token classes.
 
 
diff --git a/interpreter/text/lexer.mll b/interpreter/text/lexer.mll
index ccbce712e..064c3069b 100644
--- a/interpreter/text/lexer.mll
+++ b/interpreter/text/lexer.mll
@@ -63,8 +63,9 @@ let symbol =
   ['+''-''*''/''\\''^''~''=''<''>''!''?''@''#''$''%''&''|'':''`''.''\'']
 
 let space = [' ''\t''\n''\r']
+let control = ['\x00'-'\x1f'] # space
 let ascii = ['\x00'-'\x7f']
-let ascii_no_nl = ['\x00'-'\x09''\x0b'-'\x7f']
+let ascii_no_nl = ascii # '\x0a'
 let utf8cont = ['\x80'-'\xbf']
 let utf8enc =
     ['\xc2'-'\xdf'] utf8cont
@@ -104,7 +105,7 @@ let name = idchar+
 let id = '$' name
 
 let keyword = ['a'-'z'] (letter | digit | '_' | '.' | ':')+
-let reserved = name | ',' | ';' | '[' | ']' | '{' | '}'
+let reserved = (idchar | string)+ | ',' | ';' | '[' | ']' | '{' | '}'
 
 let ixx = "i" ("32" | "64")
 let fxx = "f" ("32" | "64")
@@ -713,13 +714,14 @@ rule token = parse
   | eof { EOF }
 
   | reserved { unknown lexbuf }
-  | utf8 { error lexbuf "malformed operator" }
+  | control { error lexbuf "misplaced control character" }
+  | utf8enc { error lexbuf "misplaced unicode character" }
   | _ { error lexbuf "malformed UTF-8 encoding" }
 
 and comment start = parse
   | ";)" { () }
   | "(;" { comment (Lexing.lexeme_start_p lexbuf) lexbuf; comment start lexbuf }
   | '\n' { Lexing.new_line lexbuf; comment start lexbuf }
+  | utf8_no_nl { comment start lexbuf }
   | eof { error_nest start lexbuf "unclosed comment" }
-  | utf8 { comment start lexbuf }
   | _ { error lexbuf "malformed UTF-8 encoding" }
diff --git a/test/core/tokens.wast b/test/core/tokens.wast
new file mode 100644
index 000000000..4e785154e
--- /dev/null
+++ b/test/core/tokens.wast
@@ -0,0 +1,274 @@
+;; Tokens can be delimited by parentheses
+
+(module
+  (func(nop))
+)
+(module
+  (func (nop)nop)
+)
+(module
+  (func nop(nop))
+)
+(module
+  (func(nop)(nop))
+)
+(module
+  (func $f(nop))
+)
+(module
+  (func br 0(nop))
+)
+(module
+  (table 1 funcref)
+  (func)
+  (elem (i32.const 0)0)
+)
+(module
+  (table 1 funcref)
+  (func $f)
+  (elem (i32.const 0)$f)
+)
+(module
+  (memory 1)
+  (data (i32.const 0)"a")
+)
+(module
+  (import "spectest" "print"(func))
+)
+
+
+;; Tokens can be delimited by comments
+
+(module
+  (func;;bla
+  )
+)
+(module
+  (func (nop);;bla
+  )
+)
+(module
+  (func nop;;bla
+  )
+)
+(module
+  (func $f;;bla
+  )
+)
+(module
+  (func br 0;;bla
+  )
+)
+(module
+  (data "a";;bla
+  )
+)
+
+
+;; Space required between symbols and non-parenthesis tokens
+
+(module
+  (func (block $l (i32.const 0) (br_table 0 $l)))
+)
+(assert_malformed
+  (module quote
+    "(func (block $l (i32.const 0) (br_table 0$l)))"
+  )
+  "unknown operator"
+)
+
+(module
+  (func (block $l (i32.const 0) (br_table $l 0)))
+)
+(assert_malformed
+  (module quote
+    "(func (block $l (i32.const 0) (br_table $l0)))"
+  )
+  "unknown label"
+)
+
+(module
+  (func (block $l (i32.const 0) (br_table $l $l)))
+)
+(assert_malformed
+  (module quote
+    "(func (block $l (i32.const 0) (br_table $l$l)))"
+  )
+  "unknown label"
+)
+
+(module
+  (func (block $l0 (i32.const 0) (br_table $l0)))
+)
+(module
+  (func (block $l$l (i32.const 0) (br_table $l$l)))
+)
+
+
+;; Space required between strings and non-parenthesis tokens
+
+(module
+  (data "a")
+)
+(assert_malformed
+  (module quote
+    "(data\"a\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data $l "a")
+)
+(assert_malformed
+  (module quote
+    "(data $l\"a\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data $l " a")
+)
+(assert_malformed
+  (module quote
+    "(data $l\" a\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data $l "a ")
+)
+(assert_malformed
+  (module quote
+    "(data $l\"a \")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data $l "a " "b")
+)
+(assert_malformed
+  (module quote
+    "(data $l\"a \"\"b\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data $l "")
+)
+(assert_malformed
+  (module quote
+    "(data $l\"\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data $l " ")
+)
+(assert_malformed
+  (module quote
+    "(data $l\" \")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data $l " ")
+)
+(assert_malformed
+  (module quote
+    "(data $l\" \")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data "a" "b")
+)
+(assert_malformed
+  (module quote
+    "(data \"a\"\"b\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data "a" " b")
+)
+(assert_malformed
+  (module quote
+    "(data \"a\"\" b\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data "a " "b")
+)
+(assert_malformed
+  (module quote
+    "(data \"a \"\"b\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data "" "")
+)
+(assert_malformed
+  (module quote
+    "(data \"\"\"\")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data "" " ")
+)
+(assert_malformed
+  (module quote
+    "(data \"\"\" \")"
+  )
+  "unknown operator"
+)
+
+(module
+  (data " " "")
+)
+(assert_malformed
+  (module quote
+    "(data \" \"\"\")"
+  )
+  "unknown operator"
+)
+
+
+(assert_malformed
+  (module quote
+    "(func \"a\"x)"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(func \"a\"0)"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(func 0\"a\")"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(func \"a\"$x)"
+  )
+  "unknown operator"
+)

From 110762616c46e2dcf217c565ee993e7bb82c8bd5 Mon Sep 17 00:00:00 2001
From: cosine <CosineP@users.noreply.github.com>
Date: Mon, 11 Jul 2022 13:39:20 -0400
Subject: [PATCH 161/285] [test] Use still-illegal opcode (func-refs) (#1501)

---
 test/core/binary.wast | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/core/binary.wast b/test/core/binary.wast
index 29c6273b3..84f4b1538 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -1241,7 +1241,7 @@
   )                            ;; end
   "data count section required")
 
-;; passive element segment containing opcode other than ref.func or ref.null
+;; passive element segment containing illegal opcode
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
@@ -1258,7 +1258,7 @@
     "\09\07\01"                ;; Element section with one segment
     "\05\70"                   ;; Passive, funcref
     "\01"                      ;; 1 element
-    "\d5\00\0b"                ;; bad opcode, index 0, end
+    "\f3\00\0b"                ;; bad opcode, index 0, end
 
     "\0a\04\01"                ;; Code section
 

From e262c4ce7873a19f8113abe50e2d7046bf58305f Mon Sep 17 00:00:00 2001
From: ariez-xyz <41232910+ariez-xyz@users.noreply.github.com>
Date: Sat, 23 Jul 2022 23:18:33 +0200
Subject: [PATCH 162/285] [spec] Fix typo (#1508)

---
 document/core/syntax/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index 186f8a241..986cba335 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -195,7 +195,7 @@ Occasionally, it is convenient to group operators together according to the foll
 Vector Instructions
 ~~~~~~~~~~~~~~~~~~~
 
-Vector instructions (also known as *SIMD* instructions, single data multiple value) provide basic operations over :ref:`values <syntax-value>` of :ref:`vector type <syntax-vectype>`.
+Vector instructions (also known as *SIMD* instructions, single instruction multiple data) provide basic operations over :ref:`values <syntax-value>` of :ref:`vector type <syntax-vectype>`.
 
 .. math::
    \begin{array}{llcl}

From cf9e5113f0dadda800388e9ade7cce344d2805ed Mon Sep 17 00:00:00 2001
From: cosine <CosineP@users.noreply.github.com>
Date: Fri, 29 Jul 2022 15:08:44 -0400
Subject: [PATCH 163/285] [spec] Fix table.copy validation typo (#1511)

---
 document/core/valid/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index c9bad0e4e..bea76a600 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -866,7 +866,7 @@ Table Instructions
    \frac{
      C.\CTABLES[x] = \limits_1~t_1
      \qquad
-     C.\CTABLES[x] = \limits_2~t_2
+     C.\CTABLES[y] = \limits_2~t_2
      \qquad
      C \vdashreftypematch t_2 \matchesvaltype t_1
    }{

From 794388bd6ad334f0394a491a5f4f74dc26756c9a Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Tue, 2 Aug 2022 11:44:44 +0200
Subject: [PATCH 164/285] Merge fallout

---
 document/core/conf.py        | 2 +-
 interpreter/runtime/elem.ml  | 2 +-
 interpreter/runtime/elem.mli | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/document/core/conf.py b/document/core/conf.py
index 947fce497..172fb7ba5 100644
--- a/document/core/conf.py
+++ b/document/core/conf.py
@@ -79,7 +79,7 @@
 # built documents.
 #
 # The short X.Y version.
-version = u'2.1'
+version = u'2.0'
 # The full version, including alpha/beta/rc tags.
 release = version + ('' if proposal == '' else ' + ') + proposal + draft
 
diff --git a/interpreter/runtime/elem.ml b/interpreter/runtime/elem.ml
index fe8997482..91e5b1957 100644
--- a/interpreter/runtime/elem.ml
+++ b/interpreter/runtime/elem.ml
@@ -1,4 +1,4 @@
-type elem = Values.ref_ list ref
+type elem = Value.ref_ list ref
 type t = elem
 
 let alloc rs = ref rs
diff --git a/interpreter/runtime/elem.mli b/interpreter/runtime/elem.mli
index 5eb0c0e56..ca1513053 100644
--- a/interpreter/runtime/elem.mli
+++ b/interpreter/runtime/elem.mli
@@ -1,4 +1,4 @@
-open Values
+open Value
 
 type elem
 type t = elem

From 6d1c8c70c1b2ae1bb5f47d21eb462e7aa67a42e1 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Tue, 2 Aug 2022 12:18:40 +0200
Subject: [PATCH 165/285] Latex fixes

---
 document/core/exec/modules.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index d81ca7b6a..ae252d930 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -448,7 +448,7 @@ and list of :ref:`reference <syntax-ref>` vectors for the module's :ref:`element
 3. For each :ref:`table <syntax-table>` :math:`\table_i` in :math:`\module.\MTABLES`, do:
 
    a. Let :math:`\tableaddr_i` be the :ref:`table address <syntax-tableaddr>` resulting from :ref:`allocating <alloc-table>` :math:`\table_i.\TTYPE`
-   with initialization value :math:`\ref_{\F{t}}^\ast[i]`.
+   with initialization value :math:`\reff_{\F{t}}^\ast[i]`.
 
 4. For each :ref:`memory <syntax-mem>` :math:`\mem_i` in :math:`\module.\MMEMS`, do:
 
@@ -535,7 +535,7 @@ where:
    S_1, \funcaddr^\ast &=&
      \allocfunc^\ast(S, \module.\MFUNCS, \moduleinst) \\
    S_2, \tableaddr^\ast &=&
-     \alloctable^\ast(S_1, (\table.\TTYPE)^\ast, \ref_{\F{t}}^\ast)
+     \alloctable^\ast(S_1, (\table.\TTYPE)^\ast, \reff_{\F{t}}^\ast)
      \quad (\where (\table.\TTYPE)^\ast = (\limits~t)^\ast) \\
    S_3, \memaddr^\ast &=&
      \allocmem^\ast(S_2, (\mem.\MTYPE)^\ast) \\

From 4f7b5c0890819158fc8834763cb2609e83b4bf01 Mon Sep 17 00:00:00 2001
From: Surma <surma@surma.dev>
Date: Tue, 2 Aug 2022 13:13:36 +0100
Subject: [PATCH 166/285] [spec] Minor copy edit (#1512)

---
 document/core/intro/overview.rst     | 2 +-
 document/core/syntax/modules.rst     | 2 +-
 document/core/valid/instructions.rst | 2 +-
 document/core/valid/types.rst        | 3 +--
 4 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/document/core/intro/overview.rst b/document/core/intro/overview.rst
index 5a4760baf..84c375e21 100644
--- a/document/core/intro/overview.rst
+++ b/document/core/intro/overview.rst
@@ -70,7 +70,7 @@ This language is structured around the following concepts.
 **Tables**
   A *table* is an array of opaque values of a particular *element type*.
   It allows programs to select such values indirectly through a dynamic index operand.
-  Currently, the only available element type is an untyped function reference.
+  Currently, the only available element type is an untyped function reference or a reference to an external host value.
   Thereby, a program can call functions indirectly through a dynamic index into a table.
   For example, this allows emulating function pointers by way of table indices.
 
diff --git a/document/core/syntax/modules.rst b/document/core/syntax/modules.rst
index cfd8935aa..c03c98502 100644
--- a/document/core/syntax/modules.rst
+++ b/document/core/syntax/modules.rst
@@ -328,7 +328,7 @@ The |MSTART| component of a module declares the :ref:`function index <syntax-fun
 
 .. note::
    The start function is intended for initializing the state of a module.
-   The module and its exports are not accessible before this initialization has completed.
+   The module and its exports are not accessible externally before this initialization has completed.
 
 
 .. index:: ! export, name, index, function index, table index, memory index, global index, function, table, memory, global, instantiation
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 2676905ff..436800260 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -620,7 +620,7 @@ Parametric Instructions
 
   * The length of :math:`t^\ast` must be :math:`1`.
 
-  * Then the instruction is valid with type :math:`[t^\ast~t^\ast~\I32] \to [t^\ast]`.
+  * The instruction is valid with type :math:`[t^\ast~t^\ast~\I32] \to [t^\ast]`.
 
 * Else:
 
diff --git a/document/core/valid/types.rst b/document/core/valid/types.rst
index 214014564..0e78e5976 100644
--- a/document/core/valid/types.rst
+++ b/document/core/valid/types.rst
@@ -240,7 +240,7 @@ Import Subtyping
 
 When :ref:`instantiating <exec-module>` a module,
 :ref:`external values <syntax-externval>` must be provided whose :ref:`types <valid-externval>` are *matched* against the respective :ref:`external types <syntax-externtype>` classifying each import.
-In some cases, this allows for a simple form of subtyping, as defined here.
+In some cases, this allows for a simple form of subtyping (written ":math:`\matchesexterntype`" formally), as defined here.
 
 
 .. index:: limits
@@ -279,7 +279,6 @@ Limits
      \vdashlimitsmatch \{ \LMIN~n_1, \LMAX~m_1 \} \matcheslimits \{ \LMIN~n_2, \LMAX~m_2 \}
    }
 
-
 .. _match-externtype:
 
 .. index:: function type

From 0a1f6f77002992572c2f718c1864af119b4c91c8 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 3 Aug 2022 10:55:59 +0200
Subject: [PATCH 167/285] Spec changelog

---
 document/core/appendix/changes.rst | 27 +++++++++++++++++++++++----
 document/core/util/macros.def      |  8 ++++----
 document/core/valid/matching.rst   |  2 ++
 3 files changed, 29 insertions(+), 8 deletions(-)

diff --git a/document/core/appendix/changes.rst b/document/core/appendix/changes.rst
index 710d574bc..012386e6d 100644
--- a/document/core/appendix/changes.rst
+++ b/document/core/appendix/changes.rst
@@ -53,7 +53,7 @@ Added |FUNCREF| and |EXTERNREF| as new value types and respective instructions [
 
 * New :ref:`reference instructions <syntax-instr-ref>`: |REFNULL|, |REFFUNC|, |REFISNULL|
 
-* Enrich :ref:`parametric instruction <syntax-instr-parametric>`: |SELECT| with optional type immediate
+* Extended :ref:`parametric instruction <syntax-instr-parametric>`: |SELECT| with optional type immediate
 
 * New :ref:`declarative <syntax-elemmode>` form of :ref:`element segment <syntax-elem>`
 
@@ -138,15 +138,31 @@ Added vector type and instructions that manipulate multiple numeric values in pa
 * New injection/projection :ref:`vector instructions <syntax-instr-vec>`: :math:`\K{i}\!N\!\K{x}\!M\!\K{.splat}`, :math:`\K{f}\!N\!\K{x}\!M\!\K{.splat}`, :math:`\K{i}\!N\!\K{x}\!M\!\K{.bitmask}`
 
 
-Release 2.1
+Release 2.?
 ~~~~~~~~~~~
 
-.. index:: reference
+.. index:: reference, reference type, heap type, value type, local, local type, instruction, instruction type, table, function, function type, matching, subtyping
 
 Typeful References
 ..................
 
-.. todo:: describe
+Added more precise types for references [#proposal-typedref]_.
+
+* New generalised form of :ref:`reference types <syntax-reftype>`: :math:`(\REF~\NULL^?~\heaptype)`
+
+* New class of :ref:`heap types <syntax-heaptype>`: |FUNC|, |EXTERN|, :math:`\typeidx`
+
+* Basic :ref:`subtyping <match>` on :ref:`reference <match-reftype>` and :ref:`value <match-valtype>` types
+
+* New :ref:`reference instructions <syntax-instr-ref>`: |REFASNONNULL|, |BRONNULL|, |BRONNONNULL|
+
+* New :ref:`control instruction <syntax-instr-control>`: |CALLREF|
+
+* Refined typing of :ref:`reference instruction <syntax-instr-ref>` |REFFUNC| with more precise result type
+
+* Refined typing of :ref:`local instructions <valid-instr-variable>` and :ref:`instruction sequences <valid-instr-seq>` to track the :ref:`initialization status <syntax-init>` of :ref:`locals <syntax-local>` with non-:ref:`defaultable <valid-defaultable>` type
+
+* Extended :ref:`table definitions <syntax-table>` with optional initializer expression
 
 
 .. [#proposal-signext]
@@ -166,3 +182,6 @@ Typeful References
 
 .. [#proposal-vectype]
    https://github.com/WebAssembly/spec/tree/main/proposals/simd/
+
+.. [#proposal-typedref]
+   https://github.com/WebAssembly/spec/tree/main/proposals/function-references/
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index 9ff0d1629..462d8d8c8 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -407,10 +407,10 @@
 .. |MEMORYINIT| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{memory.init}}
 .. |DATADROP| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{data.drop}}
 
-.. |REFNULL| mathdef:: \xref{syntax/instructions}{syntax-instr-ref}{\K{ref{.}null}}
-.. |REFFUNC| mathdef:: \xref{syntax/instructions}{syntax-instr-ref}{\K{ref{.}func}}
-.. |REFISNULL| mathdef:: \xref{syntax/instructions}{syntax-instr-ref}{\K{ref{.}is\_null}}
-.. |REFASNONNULL| mathdef:: \xref{syntax/instructions}{syntax-instr-ref}{\K{ref{.}as\_non\_null}}
+.. |REFNULL| mathdef:: \xref{syntax/instructions}{syntax-instr-ref}{\K{ref.null}}
+.. |REFFUNC| mathdef:: \xref{syntax/instructions}{syntax-instr-ref}{\K{ref.func}}
+.. |REFISNULL| mathdef:: \xref{syntax/instructions}{syntax-instr-ref}{\K{ref.is\_null}}
+.. |REFASNONNULL| mathdef:: \xref{syntax/instructions}{syntax-instr-ref}{\K{ref.as\_non\_null}}
 
 .. |CONST| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{const}}
 .. |EQZ| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{eqz}}
diff --git a/document/core/valid/matching.rst b/document/core/valid/matching.rst
index 75cd4aedc..d0bc9ed90 100644
--- a/document/core/valid/matching.rst
+++ b/document/core/valid/matching.rst
@@ -1,5 +1,7 @@
 .. index:: ! matching, subtyping
 
+.. _match:
+
 Matching
 --------
 

From 815954184d9574ce10191f9d3cb46fe8a322a7f6 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Wed, 3 Aug 2022 11:04:54 +0200
Subject: [PATCH 168/285] [spec] Trivial editorial fix

---
 document/core/valid/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 436800260..2676905ff 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -620,7 +620,7 @@ Parametric Instructions
 
   * The length of :math:`t^\ast` must be :math:`1`.
 
-  * The instruction is valid with type :math:`[t^\ast~t^\ast~\I32] \to [t^\ast]`.
+  * Then the instruction is valid with type :math:`[t^\ast~t^\ast~\I32] \to [t^\ast]`.
 
 * Else:
 

From 6e4102e12bcc25df19f91c89e4eb344954410b82 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 3 Aug 2022 11:59:08 +0200
Subject: [PATCH 169/285] Update embedding

---
 document/core/appendix/embedding.rst  | 51 ++++++++++++++++++---------
 document/core/appendix/properties.rst |  8 ++---
 document/core/exec/modules.rst        | 41 ++++++++++-----------
 document/core/exec/runtime.rst        |  2 +-
 document/core/exec/types.rst          | 34 +++++++++++++-----
 document/core/syntax/types.rst        |  3 +-
 document/core/valid/matching.rst      |  2 --
 document/core/valid/types.rst         |  4 ++-
 8 files changed, 89 insertions(+), 56 deletions(-)

diff --git a/document/core/appendix/embedding.rst b/document/core/appendix/embedding.rst
index a02ac76ca..0fff5d507 100644
--- a/document/core/appendix/embedding.rst
+++ b/document/core/appendix/embedding.rst
@@ -64,9 +64,6 @@ In addition to pre- and post-conditions explicitly stated with each operation, t
 .. index:: allocation, store
 .. _embed-store:
 
-.. todo:: Update alloc functions to semantic types.
-
-
 Store
 ~~~~~
 
@@ -83,7 +80,6 @@ Store
    \end{array}
 
 
-
 .. index:: module
 .. _embed-module:
 
@@ -171,7 +167,7 @@ Modules
 :math:`\F{module\_imports}(\module) : (\name, \name, \externtype)^\ast`
 .......................................................................
 
-1. Pre-condition: :math:`\module` is :ref:`valid <valid-module>` with external import types :math:`\externtype^\ast` and external export types :math:`{\externtype'}^\ast`.
+1. Pre-condition: :math:`\module` is :ref:`valid <valid-module>` with the :ref:`semantic <syntax-type-sem>` external import types :math:`\externtype^\ast` and external export types :math:`{\externtype'}^\ast`.
 
 2. Let :math:`\import^\ast` be the :ref:`imports <syntax-import>` :math:`\module.\MIMPORTS`.
 
@@ -183,7 +179,7 @@ Modules
 
 5. Return the concatenation of all :math:`\X{result}_i`, in index order.
 
-6. Post-condition: each :math:`\externtype_i` is :ref:`valid <valid-externtype>`.
+6. Post-condition: each :ref:`semantic <syntax-type-sem>` :math:`\externtype_i` is :ref:`valid <valid-externtype>`.
 
 .. math::
    ~ \\
@@ -199,7 +195,7 @@ Modules
 :math:`\F{module\_exports}(\module) : (\name, \externtype)^\ast`
 ................................................................
 
-1. Pre-condition: :math:`\module` is :ref:`valid <valid-module>` with external import types :math:`\externtype^\ast` and external export types :math:`{\externtype'}^\ast`.
+1. Pre-condition: :math:`\module` is :ref:`valid <valid-module>` with the :ref:`semantic <syntax-type-sem>` external import types :math:`\externtype^\ast` and external export types :math:`{\externtype'}^\ast`.
 
 2. Let :math:`\export^\ast` be the :ref:`exports <syntax-export>` :math:`\module.\MEXPORTS`.
 
@@ -211,7 +207,7 @@ Modules
 
 5. Return the concatenation of all :math:`\X{result}_i`, in index order.
 
-6. Post-condition: each :math:`\externtype'_i` is :ref:`valid <valid-externtype>`.
+6. Post-condition: each :ref:`semantic <syntax-type-sem>` :math:`\externtype'_i` is :ref:`valid <valid-externtype>`.
 
 .. math::
    ~ \\
@@ -250,6 +246,29 @@ Module Instances
    \end{array}
 
 
+.. index:: type, type instance, function type
+.. _embed-type:
+
+Types
+~~~~~
+
+.. _embed-type-alloc:
+
+:math:`\F{type\_alloc}(\store, \functype) : (\store, \typeaddr)`
+...........................................................................
+
+1. Pre-condition: the :ref:`semantic <syntax-type-sem>` :math:`\functype` is :ref:`valid <valid-functype>`.
+
+2. Let :math:`\typeaddr` be the result of :ref:`allocating a type <alloc-type>` in :math:`\store` for :ref:`function type <syntax-functype>` :math:`\functype`.
+
+3. Return the new store paired with :math:`\typeaddr`.
+
+.. math::
+   \begin{array}{lclll}
+   \F{type\_alloc}(S, \X{ft}) &=& (S', \X{a}) && (\iff \alloctype(S, \X{ft}) = S', \X{a}) \\
+   \end{array}
+
+
 .. index:: function, host function, function address, function instance, function type, store
 .. _embed-func:
 
@@ -261,7 +280,7 @@ Functions
 :math:`\F{func\_alloc}(\store, \functype, \hostfunc) : (\store, \funcaddr)`
 ...........................................................................
 
-1. Pre-condition: :math:`\functype` is :math:`valid <valid-functype>`.
+1. Pre-condition: the :ref:`semantic <syntax-type-sem>` :math:`\functype` is :ref:`valid <valid-functype>`.
 
 2. Let :math:`\funcaddr` be the result of :ref:`allocating a host function <alloc-func>` in :math:`\store` with :ref:`function type <syntax-functype>` :math:`\functype` and host function code :math:`\hostfunc`.
 
@@ -285,7 +304,7 @@ Functions
 
 1. Return :math:`S.\SFUNCS[a].\FITYPE`.
 
-2. Post-condition: the returned :ref:`function type <syntax-functype>` is :ref:`valid <valid-functype>`.
+2. Post-condition: the returned :ref:`semantic <syntax-type-sem>` :ref:`function type <syntax-functype>` is :ref:`valid <valid-functype>`.
 
 .. math::
    \begin{array}{lclll}
@@ -329,7 +348,7 @@ Tables
 :math:`\F{table\_alloc}(\store, \tabletype) : (\store, \tableaddr, \reff)`
 ..........................................................................
 
-1. Pre-condition: :math:`\tabletype` is :math:`valid <valid-tabletype>`.
+1. Pre-condition: the :ref:`semantic <syntax-type-sem>` :math:`\tabletype` is :ref:`valid <valid-tabletype>`.
 
 2. Let :math:`\tableaddr` be the result of :ref:`allocating a table <alloc-table>` in :math:`\store` with :ref:`table type <syntax-tabletype>` :math:`\tabletype` and initialization value :math:`\reff`.
 
@@ -348,7 +367,7 @@ Tables
 
 1. Return :math:`S.\STABLES[a].\TITYPE`.
 
-2. Post-condition: the returned :ref:`table type <syntax-tabletype>` is :math:`valid <valid-tabletype>`.
+2. Post-condition: the returned :ref:`semantic <syntax-type-sem>` :ref:`table type <syntax-tabletype>` is :ref:`valid <valid-tabletype>`.
 
 .. math::
    \begin{array}{lclll}
@@ -441,7 +460,7 @@ Memories
 :math:`\F{mem\_alloc}(\store, \memtype) : (\store, \memaddr)`
 ................................................................
 
-1. Pre-condition: :math:`\memtype` is :math:`valid <valid-memtype>`.
+1. Pre-condition: the :ref:`semantic <syntax-type-sem>` :math:`\memtype` is :ref:`valid <valid-memtype>`.
 
 2. Let :math:`\memaddr` be the result of :ref:`allocating a memory <alloc-mem>` in :math:`\store` with :ref:`memory type <syntax-memtype>` :math:`\memtype`.
 
@@ -460,7 +479,7 @@ Memories
 
 1. Return :math:`S.\SMEMS[a].\MITYPE`.
 
-2. Post-condition: the returned :ref:`memory type <syntax-memtype>` is :math:`valid <valid-memtype>`.
+2. Post-condition: the returned :ref:`semantic <syntax-type-sem>` :ref:`memory type <syntax-memtype>` is :ref:`valid <valid-memtype>`.
 
 .. math::
    \begin{array}{lclll}
@@ -554,7 +573,7 @@ Globals
 :math:`\F{global\_alloc}(\store, \globaltype, \val) : (\store, \globaladdr)`
 ............................................................................
 
-1. Pre-condition: :math:`\globaltype` is :math:`valid <valid-globaltype>`.
+1. Pre-condition: the :ref:`semantic <syntax-type-sem>` :math:`\globaltype` is :ref:`valid <valid-globaltype>`.
 
 2. Let :math:`\globaladdr` be the result of :ref:`allocating a global <alloc-global>` in :math:`\store` with :ref:`global type <syntax-globaltype>` :math:`\globaltype` and initialization value :math:`\val`.
 
@@ -573,7 +592,7 @@ Globals
 
 1. Return :math:`S.\SGLOBALS[a].\GITYPE`.
 
-2. Post-condition: the returned :ref:`global type <syntax-globaltype>` is :math:`valid <valid-globaltype>`.
+2. Post-condition: the returned :ref:`semantic <syntax-type-sem>` :ref:`global type <syntax-globaltype>` is :ref:`valid <valid-globaltype>`.
 
 .. math::
    \begin{array}{lclll}
diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index 05973f62a..0b2a3d28b 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -56,7 +56,7 @@ Results
 :ref:`Results <syntax-result>` :math:`\TRAP`
 ............................................
 
-* The result is valid with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`, for any :ref:`valid <valid-resulttype>` :ref:`semantic <syntax-typeid>` :ref:`result types <syntax-resulttype>`.
+* The result is valid with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`, for any :ref:`valid <valid-resulttype>` :ref:`semantic <syntax-type-sem>` :ref:`result types <syntax-resulttype>`.
 
 .. math::
    \frac{
@@ -538,13 +538,11 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
 :math:`\TRAP`
 .............
 
-* The instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`, for any sequences of :ref:`valid <valid-valtype>` :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
+* The instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`, for any sequences of :ref:`valid <valid-instrtype>` :ref:`instruction type <syntax-instrtype>` of the form :math:`[t_1^\ast] \to [t_2^\ast]`.
 
 .. math::
    \frac{
-     S \vdashresulttype [t_1^\ast] \ok
-     \qquad
-     S \vdashresulttype [t_2^\ast] \ok
+     S \vdashinstrtype [t_1^\ast] \to [t_2^\ast] \ok
    }{
      S; C \vdashadmininstr \TRAP : [t_1^\ast] \to [t_2^\ast]
    }
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index 1fd727678..36c8863a3 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -164,25 +164,20 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 :ref:`Types <syntax-typeinst>`
 ..............................
 
-1. Let :math:`\functype` be the type to allocate and :math:`\moduleinst` its :ref:`module instance <syntax-moduleinst>`.
+1. Let :math:`\functype` be the :ref:`semantic type <syntax-type-sem>`.
 
 2. Let :math:`a` be the first free :ref:`type address <syntax-typeaddr>` in :math:`S`.
 
-3. Assert: due to :ref:`validation <valid-module>`, any :ref:`type index <syntax-typeidx>` occurring in :math:`\functype` is smaller than the length of :math:`\moduleinst.\MITYPES`.
+3. Append :math:`\typeinst` to the |STYPES| of :math:`S`.
 
-4. Let :math:`\typeinst` be the :ref:`type instance <syntax-typeinst>` obtained by :ref:`instantiating <sem>` :math:`\functype` inside :math:`\moduleinst`.
-
-5. Append :math:`\typeinst` to the |STYPES| of :math:`S`.
-
-6. Return :math:`a`.
+4. Return :math:`a`.
 
 .. math::
    ~\\[-1ex]
    \begin{array}{rlll}
-   \alloctype(S, \functype, \moduleinst) &=& S', \typeaddr \\[1ex]
+   \alloctype(S, \functype) &=& S', \typeaddr \\[1ex]
    \mbox{where:} \hfill \\
    \typeaddr &=& |S.\STYPES| \\
-   \typeinst &=& \sem_{\moduleinst}(\functype) \\
    S' &=& S \compose \{\STYPES~\typeinst\} \\
    \end{array}
 
@@ -199,7 +194,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 
 3. Let :math:`\typeaddr` be the :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.\MITYPES[\func.\FTYPE]`.
 
-4. Let :math:`\functype` be the :ref:`semantic <syntax-typeid>` :ref:`function type <syntax-functype>` :math:`S.\STYPES[\typeaddr]`.
+4. Let :math:`\functype` be the :ref:`semantic <syntax-type-sem>` :ref:`function type <syntax-functype>` :math:`S.\STYPES[\typeaddr]`.
 
 5. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`\{ \FITYPE~\functype', \FIMODULE~\moduleinst, \FICODE~\func \}`.
 
@@ -225,7 +220,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 :ref:`Host Functions <syntax-hostfunc>`
 .......................................
 
-1. Let :math:`\hostfunc` be the :ref:`host function <syntax-hostfunc>` to allocate and :math:`\functype` its :ref:`semantic <syntax-typeid>` :ref:`function type <syntax-functype>`.
+1. Let :math:`\hostfunc` be the :ref:`host function <syntax-hostfunc>` to allocate and :math:`\functype` its :ref:`semantic <syntax-type-sem>` :ref:`function type <syntax-functype>`.
 
 2. Let :math:`a` be the first free :ref:`function address <syntax-funcaddr>` in :math:`S`.
 
@@ -256,7 +251,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 :ref:`Tables <syntax-tableinst>`
 ................................
 
-1. Let :math:`\tabletype` be the :ref:`semantic <syntax-typeid>` :ref:`table type <syntax-tabletype>` of the table to allocate and :math:`\reff` the initialization value.
+1. Let :math:`\tabletype` be the :ref:`semantic <syntax-type-sem>` :ref:`table type <syntax-tabletype>` of the table to allocate and :math:`\reff` the initialization value.
 
 2. Let :math:`(\{\LMIN~n, \LMAX~m^?\}~\reftype)` be the structure of :ref:`table type <syntax-tabletype>` :math:`\tabletype`.
 
@@ -287,7 +282,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 :ref:`Memories <syntax-meminst>`
 ................................
 
-1. Let :math:`\memtype` be the :ref:`semantic <syntax-typeid>` :ref:`memory type <syntax-memtype>` of the memory to allocate.
+1. Let :math:`\memtype` be the :ref:`semantic <syntax-type-sem>` :ref:`memory type <syntax-memtype>` of the memory to allocate.
 
 2. Let :math:`\{\LMIN~n, \LMAX~m^?\}` be the structure of :ref:`memory type <syntax-memtype>` :math:`\memtype`.
 
@@ -316,7 +311,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 :ref:`Globals <syntax-globalinst>`
 ..................................
 
-1. Let :math:`\globaltype` be the :ref:`semantic <syntax-typeid>` :ref:`global type <syntax-globaltype>` of the global to allocate and :math:`\val` its initialization :ref:`value <syntax-val>`.
+1. Let :math:`\globaltype` be the :ref:`semantic <syntax-type-sem>` :ref:`global type <syntax-globaltype>` of the global to allocate and :math:`\val` its initialization :ref:`value <syntax-val>`.
 
 2. Let :math:`a` be the first free :ref:`global address <syntax-globaladdr>` in :math:`S`.
 
@@ -342,7 +337,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 :ref:`Element segments <syntax-eleminst>`
 .........................................
 
-1. Let :math:`\reftype` be the elements' :ref:`semantic <syntax-typeid>` type and :math:`\reff^\ast` the vector of :ref:`references <syntax-ref>` to allocate.
+1. Let :math:`\reftype` be the elements' :ref:`semantic <syntax-type-sem>` type and :math:`\reff^\ast` the vector of :ref:`references <syntax-ref>` to allocate.
 
 2. Let :math:`a` be the first free :ref:`element address <syntax-elemaddr>` in :math:`S`.
 
@@ -476,7 +471,9 @@ and list of :ref:`reference <syntax-ref>` vectors for the module's :ref:`element
 
 2. For each :ref:`function type <syntax-functype>` :math:`\functype_i` in :math:`\module.\MTYPES`, do:
 
-   a. Let :math:`\typeaddr_i` be the :ref:`type address <syntax-typeaddr>` resulting from :ref:`allocating <alloc-type>` :math:`\functype_i` for the :ref:`\module instance <syntax-moduleinst>` :math:`\moduleinst` defined below.
+   a. Let :math:`\functype'_i` be the :ref:`semantic <syntax-type-sem>` :ref:`function type <syntax-functype>` obtained from :math:`\functype_i` in :math:`\moduleinst` defined below.
+
+   b. Let :math:`\typeaddr_i` be the :ref:`type address <syntax-typeaddr>` resulting from :ref:`allocating <alloc-type>` :math:`\functype'_i`.
 
 3. For each :ref:`function <syntax-func>` :math:`\func_i` in :math:`\module.\MFUNCS`, do:
 
@@ -484,26 +481,26 @@ and list of :ref:`reference <syntax-ref>` vectors for the module's :ref:`element
 
 4. For each :ref:`table <syntax-table>` :math:`\table_i` in :math:`\module.\MTABLES`, do:
 
-   a. Let :math:`\limits_i~t_i` be the :ref:`semantic <syntax-typeid>` :ref:`table type <syntax-tabletype>` obtained from :math:`\table_i.\TTYPE` in :math:`\moduleinst` defined below.
+   a. Let :math:`\limits_i~t_i` be the :ref:`semantic <syntax-type-sem>` :ref:`table type <syntax-tabletype>` obtained from :math:`\table_i.\TTYPE` in :math:`\moduleinst` defined below.
 
    b. Let :math:`\tableaddr_i` be the :ref:`table address <syntax-tableaddr>` resulting from :ref:`allocating <alloc-table>` :math:`\table_i.\TTYPE`
    with initialization value :math:`\REFNULL~t_i`.
 
 5. For each :ref:`memory <syntax-mem>` :math:`\mem_i` in :math:`\module.\MMEMS`, do:
 
-   a. Let :math:`\memtype_i` be the :ref:`semantic <syntax-typeid>` :ref:`memory type <syntax-memtype>` obtained from :math:`\mem_i.\MTYPE` in :math:`\moduleinst` defined below.
+   a. Let :math:`\memtype_i` be the :ref:`semantic <syntax-type-sem>` :ref:`memory type <syntax-memtype>` obtained from :math:`\mem_i.\MTYPE` in :math:`\moduleinst` defined below.
 
    b. Let :math:`\memaddr_i` be the :ref:`memory address <syntax-memaddr>` resulting from :ref:`allocating <alloc-mem>` :math:`\memtype_i`.
 
 6. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\MGLOBALS`, do:
 
-   a. Let :math:`\globaltype_i` be the :ref:`semantic <syntax-typeid>` :ref:`global type <syntax-globaltype>` obtained from :math:`\global_i.\GTYPE` in :math:`\moduleinst` defined below.
+   a. Let :math:`\globaltype_i` be the :ref:`semantic <syntax-type-sem>` :ref:`global type <syntax-globaltype>` obtained from :math:`\global_i.\GTYPE` in :math:`\moduleinst` defined below.
 
    b. Let :math:`\globaladdr_i` be the :ref:`global address <syntax-globaladdr>` resulting from :ref:`allocating <alloc-global>` :math:`\globaltype_i` with initializer value :math:`\val^\ast[i]`.
 
 7. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEMS`, do:
 
-   a. Let :math:`\reftype_i` be the :ref:`semantic <syntax-typeid>` element :ref:`reference type <syntax-reftype>` obtained from :math:`\elem_i.\ETYPE` in :math:`\moduleinst` defined below.
+   a. Let :math:`\reftype_i` be the :ref:`semantic <syntax-type-sem>` element :ref:`reference type <syntax-reftype>` obtained from :math:`\elem_i.\ETYPE` in :math:`\moduleinst` defined below.
 
    b. Let :math:`\elemaddr_i` be the :ref:`element address <syntax-elemaddr>` resulting from :ref:`allocating <alloc-elem>` a :ref:`element instance <syntax-eleminst>` of :ref:`reference type <syntax-reftype>` :math:`\reftype_i` with contents :math:`(\reff^\ast)^\ast[i]`.
 
@@ -580,7 +577,7 @@ where:
      \MIEXPORTS~\exportinst^\ast ~\}
      \end{array} \\[1ex]
    S_1, \typeaddr^\ast &=&
-     \alloctype^\ast(S, \module.\MTYPES, \moduleinst) \\
+     \alloctype^\ast(S, \sem_{\moduleinst}(\module.\MTYPES)) \\
    S_2, \funcaddr^\ast &=&
      \allocfunc^\ast(S_1, \module.\MFUNCS, \moduleinst) \\
    S_3, \tableaddr^\ast &=&
@@ -662,7 +659,7 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
       i. Fail.
 
-   b. Let :math:`\externtype''_i` be the :ref:`semantic <syntax-typeid>` :ref:`external type <syntax-externtype>` obtained by :ref:`instantiating <sem>` :math:`\externtype'_i` in :math:`\moduleinst` defined below.
+   b. Let :math:`\externtype''_i` be the :ref:`semantic <syntax-type-sem>` :ref:`external type <syntax-externtype>` obtained by :ref:`instantiating <sem>` :math:`\externtype'_i` in :math:`\moduleinst` defined below.
 
    c. If :math:`\externtype_i` does not :ref:`match <match-externtype>` :math:`\externtype''_i`, then:
 
diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index 24f275649..a301f1876 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -239,7 +239,7 @@ Type Instances
 ~~~~~~~~~~~~~~
 
 A *type instance* is the runtime representation of a :ref:`function type <syntax-functype>`.
-It is a :ref:`semantic type <syntax-typeid>` equivalent to the respective syntactic type that appeared in the module.
+It is a :ref:`semantic type <syntax-type-sem>` equivalent to the respective :ref:`syntactic type <syntax-type-syn>` that appeared in the module.
 
 .. math::
    \begin{array}{llll}
diff --git a/document/core/exec/types.rst b/document/core/exec/types.rst
index b1f013241..b1773fb5c 100644
--- a/document/core/exec/types.rst
+++ b/document/core/exec/types.rst
@@ -5,7 +5,7 @@ Types
 -----
 
 Execution has to check and compare :ref:`types <syntax-type>` and :ref:`type instances <syntax-typeinst>` in a few places, such as :ref:`executing <exec-call_indirect>` |CALLINDIRECT| or :ref:`instantiating <exec-instantiation>` :ref:`modules <syntax-module>`.
-During execution, types of all forms are represented as :ref:`semantic <syntax-typeid>` types, where all occurring :ref:`type identifiers <syntax-typeid>` are interpreted as :ref:`type addresses <syntax-typeaddr>`.
+During execution, types of all forms are represented as :ref:`semantic <syntax-type-sem>` types, where all occurring :ref:`type identifiers <syntax-typeid>` are interpreted as :ref:`type addresses <syntax-typeaddr>`.
 Relevant type relations need to be redefined accordingly.
 
 .. note::
@@ -41,26 +41,27 @@ During execution, :ref:`type identifiers <syntax-typeid>` are represented as :re
    Unlike :ref:`type indices <syntax-typeidx>` recorded in a context, the number of type addresses in a store is not bounded by :math:`2^{32}`.
 
 
-.. index:: type identifier, type index, type address, type instantiation, module instance
+.. index:: type identifier, type index, type address, type instantiation, module instance, semantic type
 
 .. _sem:
 
 Instantiation
 ~~~~~~~~~~~~~
 
-Any form of :ref:`syntactic <syntax-typeid>` :ref:`type <syntax-type>` can be *instantiated* into a semantic type inside a :ref:`module instance <syntax-moduleinst>` by :ref:`substituting <notation-subst>` each :ref:`type index <syntax-typeidx>` :math:`x` occurring in it with the corresponding :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.\MITYPES[x]`.
+Any form of :ref:`syntactic <syntax-type-syn>` :ref:`type <syntax-type>` can be *instantiated* into a :ref:`semantic <syntax-type-sem>` type inside a :ref:`module instance <syntax-moduleinst>` by :ref:`substituting <notation-subst>` each :ref:`type index <syntax-typeidx>` :math:`x` occurring in it with the corresponding :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.\MITYPES[x]`.
 
 .. math::
    \sem_{\moduleinst}(t) = t[\subst \moduleinst.\MITYPES]
 
 
-.. index:: type, matching, store, semantic types
+.. index:: type, matching, store, semantic types, validity
 .. _exec-match:
+.. _exec-valid-type:
 
-Matching
-~~~~~~~~
+Matching and Validity
+~~~~~~~~~~~~~~~~~~~~~
 
-For each *static* :ref:`matching relation <match>` on syntactic types, operating relative to a :ref:`context <context>`, an analogous *dynamic* matching relation is defined, operating relative to a :ref:`store <syntax-store>`.
+For each *static* :ref:`matching relation <match>` on syntactic types, operating relative to a :ref:`context <context>`, an analogous *dynamic* validity or matching relation is defined, operating relative to a :ref:`store <syntax-store>`.
 
 Formally, for each judgement
 
@@ -73,4 +74,21 @@ on syntactic types :math:`T_1` and :math:`T_2`, an analogous judgement
 on corresponding semantic types :math:`T'_1` and :math:`T'_2` is introduced. It is defined analogously, by replacing all occurrences of a :ref:`context <context>` :math:`C` in the associated rules with a :ref:`store <syntax-store>` :math:`S`.
 
 .. note::
-   Where the static matching rules invoke :ref:`static lookup <valid-typeidx>` for :ref:`type indices <syntax-typeidx>` in the context, the dynamic matching rules thereby invoke :ref:`dynamic lookup <valid-typeaddr>` for :ref:`type addresses <syntax-typeaddr>` in the store.
+   Where the static rules invoke :ref:`static lookup <valid-typeidx>` for :ref:`type indices <syntax-typeidx>` in the context, the dynamic rules thereby invoke :ref:`dynamic lookup <valid-typeaddr>` for :ref:`type addresses <syntax-typeaddr>` in the store.
+
+Likewise, for each *static* :ref:`validity rule <valid-type>` on syntactic types, operating relative to a :ref:`context <context>`, an analogous *dynamic* validity rule is defined, operating relative to a :ref:`store <syntax-store>`.
+
+Formally, for each judgement
+
+.. math:: C \vdash T \ok
+
+on syntactic type :math:`T`, an analogous judgement
+
+.. math:: S \vdash T' \ok
+
+on corresponding semantic types :math:`T'` is introduced. It is defined analogously, by replacing all occurrences of a :ref:`context <context>` :math:`C` in the associated rules with a :ref:`store <syntax-store>` :math:`S`.
+
+.. note::
+   Dynamic validity rules are not needed for the semantics,
+   but to prove :ref:`soundness <soundness-statement>`
+   and for specifying parts of the :ref:`embedder <embed>` interface.
diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index a064c0c97..c10f2ff1b 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -13,7 +13,8 @@ Types are checked during :ref:`validation <valid>`, :ref:`instantiation <exec-in
 .. index:: ! type identifier, type index, type address
    pair: abstract syntax; type identifier
 .. _syntax-typeid:
-.. _syntax-semantic:
+.. _syntax-type-syn:
+.. _syntax-type-sem:
 
 Type Identifiers
 ~~~~~~~~~~~~~~~~
diff --git a/document/core/valid/matching.rst b/document/core/valid/matching.rst
index a04fa8680..78ad51494 100644
--- a/document/core/valid/matching.rst
+++ b/document/core/valid/matching.rst
@@ -6,8 +6,6 @@ Matching
 
 On most types, a simple notion of subtyping is defined that is applicable in validation rules or during :ref:`module instantiation <exec-instantiation>` when checking the types of imports.
 
-.. todo:: externtype matching is used on semantic types; need to define how to reinterpret C for semantic types
-
 
 .. index:: heap type
 .. _match-heaptype:
diff --git a/document/core/valid/types.rst b/document/core/valid/types.rst
index 7e12c9598..d75b4452d 100644
--- a/document/core/valid/types.rst
+++ b/document/core/valid/types.rst
@@ -1,3 +1,5 @@
+.. _valid-type:
+
 Types
 -----
 
@@ -33,7 +35,7 @@ During validation, :ref:`type identifiers <syntax-typeid>` are represented as :r
    }
 
 .. note::
-   :ref:`Semantic types <syntax-typeid>` do not arise during validation.
+   :ref:`Semantic types <syntax-type-sem>` do not arise during validation.
    They only need to be :ref:`looked up <valid-typeaddr>` during :ref:`execution <exec-type>`.
 
 

From 1491e6841dbc31d4bae6c52a9e1fea9a902e5618 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 3 Aug 2022 12:05:17 +0200
Subject: [PATCH 170/285] Oops

---
 document/core/appendix/properties.rst | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index 0b2a3d28b..5d10d0b3f 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -538,14 +538,16 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
 :math:`\TRAP`
 .............
 
-* The instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`, for any sequences of :ref:`valid <valid-instrtype>` :ref:`instruction type <syntax-instrtype>` of the form :math:`[t_1^\ast] \to [t_2^\ast]`.
+* The instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`, for any sequences of :ref:`valid <valid-valtype>` :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
-.. math::
-   \frac{
-     S \vdashinstrtype [t_1^\ast] \to [t_2^\ast] \ok
-   }{
-     S; C \vdashadmininstr \TRAP : [t_1^\ast] \to [t_2^\ast]
-   }
+ .. math::
+    \frac{
+     S \vdashresulttype [t_1^\ast] \ok
+     \qquad
+     S \vdashresulttype [t_2^\ast] \ok
+    }{
+      S; C \vdashadmininstr \TRAP : [t_1^\ast] \to [t_2^\ast]
+    }
 
 
 .. index:: extern address

From 20fa3e44dc16387a474ac36c06ac495b4a4a1d24 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 3 Aug 2022 12:09:52 +0200
Subject: [PATCH 171/285] Argh

---
 document/core/appendix/properties.rst | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index 5d10d0b3f..dd3ab78ad 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -540,14 +540,14 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
 
 * The instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`, for any sequences of :ref:`valid <valid-valtype>` :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
- .. math::
-    \frac{
+.. math::
+   \frac{
      S \vdashresulttype [t_1^\ast] \ok
      \qquad
      S \vdashresulttype [t_2^\ast] \ok
-    }{
-      S; C \vdashadmininstr \TRAP : [t_1^\ast] \to [t_2^\ast]
-    }
+   }{
+     S; C \vdashadmininstr \TRAP : [t_1^\ast] \to [t_2^\ast]
+   }
 
 
 .. index:: extern address

From 4140b2d436f672bf5ef6b2f0caacae39dda1e44d Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 3 Aug 2022 12:50:51 +0200
Subject: [PATCH 172/285] Rename Sem to Dyn

---
 interpreter/exec/eval.ml        |  34 ++++----
 interpreter/exec/eval_num.ml    |   2 +-
 interpreter/host/env.ml         |   6 +-
 interpreter/host/spectest.ml    |   4 +-
 interpreter/runtime/func.ml     |   2 +-
 interpreter/runtime/func.mli    |   2 +-
 interpreter/runtime/global.ml   |   6 +-
 interpreter/runtime/global.mli  |   2 +-
 interpreter/runtime/instance.ml |   2 +-
 interpreter/runtime/memory.ml   |   2 +-
 interpreter/runtime/memory.mli  |   2 +-
 interpreter/runtime/table.ml    |   4 +-
 interpreter/runtime/table.mli   |   2 +-
 interpreter/runtime/value.ml    |   2 +-
 interpreter/script/import.ml    |   4 +-
 interpreter/script/import.mli   |   2 +-
 interpreter/script/js.ml        |  12 +--
 interpreter/script/run.ml       |  12 +--
 interpreter/script/script.ml    |   2 +-
 interpreter/syntax/types.ml     | 140 ++++++++++++++++----------------
 interpreter/text/arrange.ml     |   8 +-
 interpreter/text/parser.mly     |   2 +-
 interpreter/valid/match.ml      |  26 +++---
 23 files changed, 140 insertions(+), 140 deletions(-)

diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index 89b313400..342f8bcd9 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -1,7 +1,7 @@
 open Ast
 open Pack
 open Source
-open Types.Sem
+open Types.Dyn
 open Value
 open Instance
 
@@ -112,7 +112,7 @@ let func_ref (inst : module_inst) x i at =
 let block_type (inst : module_inst) bt at =
   match bt with
   | ValBlockType None -> InstrT ([], [], [])
-  | ValBlockType (Some t) -> InstrT ([], [sem_val_type inst.types t], [])
+  | ValBlockType (Some t) -> InstrT ([], [dyn_val_type inst.types t], [])
   | VarBlockType x ->
     let FuncT (ts1, ts2) = func_type inst (x @@ at) in InstrT (ts1, ts2, [])
 
@@ -230,7 +230,7 @@ let rec step (c : config) : config =
       | CallIndirect (x, y), Num (I32 i) :: vs ->
         let f = func_ref c.frame.inst x i e.at in
         if
-          Match.Sem.eq_func_type () [] (func_type c.frame.inst y) (Func.type_of f)
+          Match.Dyn.eq_func_type () [] (func_type c.frame.inst y) (Func.type_of f)
         then
           vs, [Invoke f @@ e.at]
         else
@@ -368,7 +368,7 @@ let rec step (c : config) : config =
       | Load {offset; ty; pack; _}, Num (I32 i) :: vs' ->
         let mem = memory c.frame.inst (0l @@ e.at) in
         let a = I64_convert.extend_i32_u i in
-        let t = sem_num_type [] ty in
+        let t = dyn_num_type [] ty in
         (try
           let n =
             match pack with
@@ -391,7 +391,7 @@ let rec step (c : config) : config =
       | VecLoad {offset; ty; pack; _}, Num (I32 i) :: vs' ->
         let mem = memory c.frame.inst (0l @@ e.at) in
         let a = I64_convert.extend_i32_u i in
-        let t = sem_vec_type [] ty in
+        let t = dyn_vec_type [] ty in
         (try
           let v =
             match pack with
@@ -533,7 +533,7 @@ let rec step (c : config) : config =
         vs, []
 
       | RefNull t, vs' ->
-        Ref (NullRef (sem_heap_type c.frame.inst.types t)) :: vs', []
+        Ref (NullRef (dyn_heap_type c.frame.inst.types t)) :: vs', []
 
       | RefIsNull, Ref r :: vs' ->
         (match r with
@@ -701,7 +701,7 @@ let rec step (c : config) : config =
       | Func.AstFunc (_, inst', func) ->
         let {locals; body; _} = func.it in
         let m = Lib.Promise.value inst' in
-        let ts = List.map (fun loc -> Types.Sem.sem_val_type m.types loc.it.ltype) locals in
+        let ts = List.map (fun loc -> Types.Dyn.dyn_val_type m.types loc.it.ltype) locals in
         let locs' = List.(rev (map Option.some args) @ map default_value ts) in
         let frame' = {inst = m; locals = List.map ref locs'} in
         let instr' = [Label (n2, [], ([], List.map plain body)) @@ func.at] in
@@ -737,7 +737,7 @@ let invoke (func : func_inst) (vs : value list) : value list =
   let FuncT (ts1, _ts2) = Func.type_of func in
   if List.length vs <> List.length ts1 then
     Crash.error at "wrong number of arguments";
-  if not (List.for_all2 (fun v -> Match.Sem.match_val_type () [] (type_of_value v)) vs ts1) then
+  if not (List.for_all2 (fun v -> Match.Dyn.match_val_type () [] (type_of_value v)) vs ts1) then
     Crash.error at "wrong types of arguments";
   let c = config empty_module_inst (List.rev vs) [Invoke func @@ at] in
   try List.rev (eval c) with Stack_overflow ->
@@ -753,14 +753,14 @@ let eval_const (inst : module_inst) (const : const) : value =
 (* Modules *)
 
 let create_type (_ : type_) : type_inst =
-  Types.Sem.alloc_uninit ()
+  Types.Dyn.alloc_uninit ()
 
 let create_func (inst : module_inst) (f : func) : func_inst =
   Func.alloc (type_ inst f.it.ftype) (Lib.Promise.make ()) f
 
 let create_table (inst : module_inst) (tab : table) : table_inst =
   let {ttype; tinit} = tab.it in
-  let tt = Types.Sem.sem_table_type inst.types ttype in
+  let tt = Types.Dyn.dyn_table_type inst.types ttype in
   let r =
     match eval_const inst tinit with
     | Ref r -> r
@@ -770,12 +770,12 @@ let create_table (inst : module_inst) (tab : table) : table_inst =
 
 let create_memory (inst : module_inst) (mem : memory) : memory_inst =
   let {mtype} = mem.it in
-  Memory.alloc (Types.Sem.sem_memory_type inst.types mtype)
+  Memory.alloc (Types.Dyn.dyn_memory_type inst.types mtype)
 
 let create_global (inst : module_inst) (glob : global) : global_inst =
   let {gtype; ginit} = glob.it in
   let v = eval_const inst ginit in
-  Global.alloc (Types.Sem.sem_global_type inst.types gtype) v
+  Global.alloc (Types.Dyn.dyn_global_type inst.types gtype) v
 
 let create_export (inst : module_inst) (ex : export) : export_inst =
   let {name; edesc} = ex.it in
@@ -799,14 +799,14 @@ let create_data (inst : module_inst) (seg : data_segment) : data_inst =
 let add_import (m : module_) (ext : extern) (im : import) (inst : module_inst)
   : module_inst =
   let it = Types.extern_type_of_import_type (import_type_of m im) in
-  let et = Types.Sem.sem_extern_type inst.types it in
+  let et = Types.Dyn.dyn_extern_type inst.types it in
   let et' = extern_type_of inst.types ext in
-  if not (Match.Sem.match_extern_type () [] et' et) then
+  if not (Match.Dyn.match_extern_type () [] et' et) then
     Link.error im.at ("incompatible import type for " ^
       "\"" ^ Utf8.encode im.it.module_name ^ "\" " ^
       "\"" ^ Utf8.encode im.it.item_name ^ "\": " ^
-      "expected " ^ Types.Sem.string_of_extern_type et ^
-      ", got " ^ Types.Sem.string_of_extern_type et');
+      "expected " ^ Types.Dyn.string_of_extern_type et ^
+      ", got " ^ Types.Dyn.string_of_extern_type et');
   match ext with
   | ExternFunc func -> {inst with funcs = func :: inst.funcs}
   | ExternTable tab -> {inst with tables = tab :: inst.tables}
@@ -815,7 +815,7 @@ let add_import (m : module_) (ext : extern) (im : import) (inst : module_inst)
 
 
 let init_type (inst : module_inst) (type_ : type_) (x : type_inst) =
-  Types.Sem.init x (Types.Sem.sem_def_type inst.types type_.it)
+  Types.Dyn.init x (Types.Dyn.dyn_def_type inst.types type_.it)
 
 let init_func (inst : module_inst) (func : func_inst) =
   match func with
diff --git a/interpreter/exec/eval_num.ml b/interpreter/exec/eval_num.ml
index dba3b3814..a42c302f6 100644
--- a/interpreter/exec/eval_num.ml
+++ b/interpreter/exec/eval_num.ml
@@ -1,5 +1,5 @@
+open Types.Dyn
 open Value
-open Types.Sem
 
 
 (* Int operators *)
diff --git a/interpreter/host/env.ml b/interpreter/host/env.ml
index 85a436b3b..f82d9a663 100644
--- a/interpreter/host/env.ml
+++ b/interpreter/host/env.ml
@@ -4,7 +4,7 @@
  * we have agreement on what libc should look like.
  *)
 
-open Types.Sem
+open Types.Dyn
 open Value
 open Instance
 
@@ -42,7 +42,7 @@ let exit vs =
 let lookup name et =
   match Utf8.encode name, et with
   | "abort", ExternFuncT ft ->
-    ExternFunc (Func.alloc_host (Types.Sem.alloc (DefFuncT ft)) abort)
+    ExternFunc (Func.alloc_host (Types.Dyn.alloc (DefFuncT ft)) abort)
   | "exit", ExternFuncT ft ->
-    ExternFunc (Func.alloc_host (Types.Sem.alloc (DefFuncT ft)) exit)
+    ExternFunc (Func.alloc_host (Types.Dyn.alloc (DefFuncT ft)) exit)
   | _ -> raise Not_found
diff --git a/interpreter/host/spectest.ml b/interpreter/host/spectest.ml
index 53249a6f2..ffab91ce3 100644
--- a/interpreter/host/spectest.ml
+++ b/interpreter/host/spectest.ml
@@ -2,7 +2,7 @@
  * Simple collection of functions useful for writing test cases.
  *)
 
-open Types.Sem
+open Types.Dyn
 open Value
 open Instance
 
@@ -23,7 +23,7 @@ let table =
   Table.alloc (TableT ({min = 10l; max = Some 20l}, (Null, FuncHT)))
     (NullRef FuncHT)
 let memory = Memory.alloc (MemoryT {min = 1l; max = Some 2l})
-let func f ft = Func.alloc_host (Types.Sem.alloc (DefFuncT ft)) (f ft)
+let func f ft = Func.alloc_host (Types.Dyn.alloc (DefFuncT ft)) (f ft)
 
 let print_value v =
   Printf.printf "%s : %s\n"
diff --git a/interpreter/runtime/func.ml b/interpreter/runtime/func.ml
index 93bed037f..7d1123733 100644
--- a/interpreter/runtime/func.ml
+++ b/interpreter/runtime/func.ml
@@ -1,4 +1,4 @@
-open Types.Sem
+open Types.Dyn
 open Value
 
 type 'inst t = 'inst func
diff --git a/interpreter/runtime/func.mli b/interpreter/runtime/func.mli
index 8fe126c86..814e2c280 100644
--- a/interpreter/runtime/func.mli
+++ b/interpreter/runtime/func.mli
@@ -1,4 +1,4 @@
-open Types.Sem
+open Types.Dyn
 open Value
 
 type 'inst t = 'inst func
diff --git a/interpreter/runtime/global.ml b/interpreter/runtime/global.ml
index 3da86fd84..bf527ad6b 100644
--- a/interpreter/runtime/global.ml
+++ b/interpreter/runtime/global.ml
@@ -1,4 +1,4 @@
-open Types.Sem
+open Types.Dyn
 open Value
 
 type global = {ty : global_type; mutable content : value}
@@ -8,7 +8,7 @@ exception Type
 exception NotMutable
 
 let alloc (GlobalT (_mut, t) as ty) v =
-  if not (Match.Sem.match_val_type () [] (type_of_value v) t) then raise Type;
+  if not (Match.Dyn.match_val_type () [] (type_of_value v) t) then raise Type;
   {ty; content = v}
 
 let type_of glob =
@@ -20,5 +20,5 @@ let load glob =
 let store glob v =
   let GlobalT (mut, t) = glob.ty in
   if mut <> Var then raise NotMutable;
-  if not (Match.Sem.match_val_type () [] (type_of_value v) t) then raise Type;
+  if not (Match.Dyn.match_val_type () [] (type_of_value v) t) then raise Type;
   glob.content <- v
diff --git a/interpreter/runtime/global.mli b/interpreter/runtime/global.mli
index 47c905e4d..b38aa8f31 100644
--- a/interpreter/runtime/global.mli
+++ b/interpreter/runtime/global.mli
@@ -1,4 +1,4 @@
-open Types.Sem
+open Types.Dyn
 open Value
 
 type global
diff --git a/interpreter/runtime/instance.ml b/interpreter/runtime/instance.ml
index 69c0b5815..29d42f533 100644
--- a/interpreter/runtime/instance.ml
+++ b/interpreter/runtime/instance.ml
@@ -1,4 +1,4 @@
-open Types.Sem
+open Types.Dyn
 
 type module_inst =
 {
diff --git a/interpreter/runtime/memory.ml b/interpreter/runtime/memory.ml
index 226a8f51e..9b6a42a35 100644
--- a/interpreter/runtime/memory.ml
+++ b/interpreter/runtime/memory.ml
@@ -1,4 +1,4 @@
-open Types.Sem
+open Types.Dyn
 open Pack
 open Value
 open Bigarray
diff --git a/interpreter/runtime/memory.mli b/interpreter/runtime/memory.mli
index a6d103775..960c754e4 100644
--- a/interpreter/runtime/memory.mli
+++ b/interpreter/runtime/memory.mli
@@ -1,4 +1,4 @@
-open Types.Sem
+open Types.Dyn
 open Value
 
 type memory
diff --git a/interpreter/runtime/table.ml b/interpreter/runtime/table.ml
index def7bbb13..d698ba169 100644
--- a/interpreter/runtime/table.ml
+++ b/interpreter/runtime/table.ml
@@ -1,4 +1,4 @@
-open Types.Sem
+open Types.Dyn
 open Value
 
 type size = int32
@@ -51,7 +51,7 @@ let load tab i =
 
 let store tab i r =
   let TableT (lim, t) = tab.ty in
-  if not (Match.Sem.match_ref_type () [] (type_of_ref r) t) then raise Type;
+  if not (Match.Dyn.match_ref_type () [] (type_of_ref r) t) then raise Type;
   try Lib.Array32.set tab.content i r with Invalid_argument _ -> raise Bounds
 
 let blit tab offset rs =
diff --git a/interpreter/runtime/table.mli b/interpreter/runtime/table.mli
index e2d59abba..7da1ac3f0 100644
--- a/interpreter/runtime/table.mli
+++ b/interpreter/runtime/table.mli
@@ -1,4 +1,4 @@
-open Types.Sem
+open Types.Dyn
 open Value
 
 type table
diff --git a/interpreter/runtime/value.ml b/interpreter/runtime/value.ml
index 6dcaf209d..f9679fff3 100644
--- a/interpreter/runtime/value.ml
+++ b/interpreter/runtime/value.ml
@@ -1,4 +1,4 @@
-open Types.Sem
+open Types.Dyn
 
 
 (* Values and operators *)
diff --git a/interpreter/script/import.ml b/interpreter/script/import.ml
index 67405b81f..95b48b8d2 100644
--- a/interpreter/script/import.ml
+++ b/interpreter/script/import.ml
@@ -1,6 +1,6 @@
 open Source
 open Ast
-open Types.Sem
+open Types.Dyn
 
 module Unknown = Error.Make ()
 exception Unknown = Unknown.Error  (* indicates unknown import name *)
@@ -17,5 +17,5 @@ let lookup (ImportT (et, module_name, item_name)) at : Instance.extern =
         "\".\"" ^ Types.string_of_name item_name ^ "\"")
 
 let link m =
-  let ModuleT (_, its, _) = Types.Sem.sem_module_type (module_type_of m) in
+  let ModuleT (_, its, _) = Types.Dyn.dyn_module_type (module_type_of m) in
   List.map2 lookup its (List.map Source.at m.it.imports)
diff --git a/interpreter/script/import.mli b/interpreter/script/import.mli
index b9587f1b2..23f3b3239 100644
--- a/interpreter/script/import.mli
+++ b/interpreter/script/import.mli
@@ -4,5 +4,5 @@ val link : Ast.module_ -> Instance.extern list (* raises Unknown *)
 
 val register :
   Ast.name ->
-  (Ast.name -> Types.Sem.extern_type -> Instance.extern (* raises Not_found *)) ->
+  (Ast.name -> Types.Dyn.extern_type -> Instance.extern (* raises Not_found *)) ->
   unit
diff --git a/interpreter/script/js.ml b/interpreter/script/js.ml
index b6155483c..c07932557 100644
--- a/interpreter/script/js.ml
+++ b/interpreter/script/js.ml
@@ -265,12 +265,12 @@ let abs_mask_of = function
   | I64T | F64T -> I64 Int64.max_int
 
 let null_heap_type_of = function
-  | Types.Sem.FuncHT -> FuncHT
-  | Types.Sem.ExternHT -> ExternHT
-  | Types.Sem.BotHT -> assert false
-  | Types.Sem.DefHT x ->
-    match Types.Sem.def_of x with
-    | Types.Sem.DefFuncT _ -> FuncHT
+  | Types.Dyn.FuncHT -> FuncHT
+  | Types.Dyn.ExternHT -> ExternHT
+  | Types.Dyn.BotHT -> assert false
+  | Types.Dyn.DefHT x ->
+    match Types.Dyn.def_of x with
+    | Types.Dyn.DefFuncT _ -> FuncHT
 
 let value v =
   match v.it with
diff --git a/interpreter/script/run.ml b/interpreter/script/run.ml
index 31883822e..f03381719 100644
--- a/interpreter/script/run.ml
+++ b/interpreter/script/run.ml
@@ -220,20 +220,20 @@ let print_module x_opt m =
 let print_values vs =
   let ts = List.map Value.type_of_value vs in
   Printf.printf "%s : %s\n%!"
-    (Value.string_of_values vs) (Types.Sem.string_of_result_type ts)
+    (Value.string_of_values vs) (Types.Dyn.string_of_result_type ts)
 
 let string_of_nan = function
   | CanonicalNan -> "nan:canonical"
   | ArithmeticNan -> "nan:arithmetic"
 
 let type_of_result r =
-  let open Types.Sem in
+  let open Types.Dyn in
   match r with
   | NumResult (NumPat n) -> NumT (Value.type_of_num n.it)
   | NumResult (NanPat n) -> NumT (Value.type_of_num n.it)
   | VecResult (VecPat v) -> VecT (Value.type_of_vec v)
   | RefResult (RefPat r) -> RefT (Value.type_of_ref r.it)
-  | RefResult (RefTypePat t) -> RefT (NoNull, sem_heap_type [] t)
+  | RefResult (RefTypePat t) -> RefT (NoNull, dyn_heap_type [] t)
   | RefResult (NullPat) -> RefT (Null, ExternHT)
 
 let string_of_num_pat (p : num_pat) =
@@ -268,7 +268,7 @@ let string_of_results = function
 let print_results rs =
   let ts = List.map type_of_result rs in
   Printf.printf "%s : %s\n%!"
-    (string_of_results rs) (Types.Sem.string_of_result_type ts)
+    (string_of_results rs) (Types.Dyn.string_of_result_type ts)
 
 
 (* Configuration *)
@@ -325,11 +325,11 @@ let run_action act : Value.t list =
     let inst = lookup_instance x_opt act.at in
     (match Instance.export inst name with
     | Some (Instance.ExternFunc f) ->
-      let Types.Sem.FuncT (ts1, _ts2) = Func.type_of f in
+      let Types.Dyn.FuncT (ts1, _ts2) = Func.type_of f in
       if List.length vs <> List.length ts1 then
         Script.error act.at "wrong number of arguments";
       List.iter2 (fun v t ->
-        if not (Match.Sem.match_val_type () [] (Value.type_of_value v.it) t) then
+        if not (Match.Dyn.match_val_type () [] (Value.type_of_value v.it) t) then
           Script.error v.at "wrong type of argument"
       ) vs ts1;
       Eval.invoke f (List.map (fun v -> v.it) vs)
diff --git a/interpreter/script/script.ml b/interpreter/script/script.ml
index 0d110505a..067028ddb 100644
--- a/interpreter/script/script.ml
+++ b/interpreter/script/script.ml
@@ -70,7 +70,7 @@ exception Syntax of Source.region * string
 let () =
   let type_of_ref' = !Value.type_of_ref' in
   Value.type_of_ref' := function
-    | ExternRef _ -> Types.Sem.ExternHT
+    | ExternRef _ -> Types.Dyn.ExternHT
     | r -> type_of_ref' r
 
 let () =
diff --git a/interpreter/syntax/types.ml b/interpreter/syntax/types.ml
index 05f7833f5..25b74c1f7 100644
--- a/interpreter/syntax/types.ml
+++ b/interpreter/syntax/types.ml
@@ -201,23 +201,23 @@ struct
 end
 
 
-(* Syntactic Types *)
+(* Static Types *)
 
-module SynVar =
+module StatVar =
 struct
   type var = int32
   let eq_var = (=)
   let string_of_var = I32.to_string_u
 end
 
-module Syn = Make (SynVar)
+module Stat = Make (StatVar)
 
-include Syn
+include Stat
 
 
-(* Semantic Types *)
+(* Dynamic Types *)
 
-module SemVar =
+module DynVar =
 struct
   (* Use extensible type, since recursive modules won't work *)
   type var = ..
@@ -228,11 +228,11 @@ struct
   let string_of_var x = !string_of_var' x
 end
 
-module Sem =
+module Dyn =
 struct
-  include Make (SemVar)
+  include Make (DynVar)
 
-  type SemVar.var += Addr of def_type Lib.Promise.t
+  type DynVar.var += Addr of def_type Lib.Promise.t
 
   let unwrap = function
     | Addr p -> p
@@ -243,7 +243,7 @@ struct
   let alloc dt = let x = alloc_uninit () in init x dt; x
   let def_of x = Lib.Promise.value (unwrap x)
 
-  let () = SemVar.string_of_var' :=
+  let () = DynVar.string_of_var' :=
     let inner = ref false in
     fun x ->
       if !inner then "..." else
@@ -256,86 +256,86 @@ struct
 
   (* Conversion *)
 
-  let sem_null c : Syn.null -> null = function
-    | Syn.Null -> Null
-    | Syn.NoNull -> NoNull
+  let dyn_null c : Stat.null -> null = function
+    | Stat.Null -> Null
+    | Stat.NoNull -> NoNull
 
-  let sem_mut c : Syn.mut -> mut = function
-    | Syn.Cons -> Cons
-    | Syn.Var -> Var
+  let dyn_mut c : Stat.mut -> mut = function
+    | Stat.Cons -> Cons
+    | Stat.Var -> Var
 
-  let sem_init c : Syn.init -> init = function
-    | Syn.Set -> Set
-    | Syn.Unset -> Unset
+  let dyn_init c : Stat.init -> init = function
+    | Stat.Set -> Set
+    | Stat.Unset -> Unset
 
-  let sem_limits c : 'a Syn.limits -> 'a limits = function
-    | Syn.{min; max} -> {min; max}
+  let dyn_limits c : 'a Stat.limits -> 'a limits = function
+    | Stat.{min; max} -> {min; max}
 
-  let sem_var_type c (x : Syn.var) : var = Lib.List32.nth c x
+  let dyn_var_type c (x : Stat.var) : var = Lib.List32.nth c x
 
-  let sem_num_type c : Syn.num_type -> num_type = function
-    | Syn.I32T -> I32T
-    | Syn.I64T -> I64T
-    | Syn.F32T -> F32T
-    | Syn.F64T -> F64T
+  let dyn_num_type c : Stat.num_type -> num_type = function
+    | Stat.I32T -> I32T
+    | Stat.I64T -> I64T
+    | Stat.F32T -> F32T
+    | Stat.F64T -> F64T
 
-  let sem_vec_type c : Syn.vec_type -> vec_type = function
-    | Syn.V128T -> V128T
+  let dyn_vec_type c : Stat.vec_type -> vec_type = function
+    | Stat.V128T -> V128T
 
-  let sem_heap_type c : Syn.heap_type -> heap_type = function
-    | Syn.FuncHT -> FuncHT
-    | Syn.ExternHT -> ExternHT
-    | Syn.DefHT x -> DefHT (sem_var_type c x)
-    | Syn.BotHT -> BotHT
+  let dyn_heap_type c : Stat.heap_type -> heap_type = function
+    | Stat.FuncHT -> FuncHT
+    | Stat.ExternHT -> ExternHT
+    | Stat.DefHT x -> DefHT (dyn_var_type c x)
+    | Stat.BotHT -> BotHT
 
-  let sem_ref_type c : Syn.ref_type -> ref_type = function
-    | (nul, t) -> (sem_null c nul, sem_heap_type c t)
+  let dyn_ref_type c : Stat.ref_type -> ref_type = function
+    | (nul, t) -> (dyn_null c nul, dyn_heap_type c t)
 
-  let sem_val_type c : Syn.val_type -> val_type = function
-    | Syn.NumT t -> NumT (sem_num_type c t)
-    | Syn.VecT t -> VecT (sem_vec_type c t)
-    | Syn.RefT t -> RefT (sem_ref_type c t)
-    | Syn.BotT -> BotT
+  let dyn_val_type c : Stat.val_type -> val_type = function
+    | Stat.NumT t -> NumT (dyn_num_type c t)
+    | Stat.VecT t -> VecT (dyn_vec_type c t)
+    | Stat.RefT t -> RefT (dyn_ref_type c t)
+    | Stat.BotT -> BotT
 
-  let sem_result_type c : Syn.result_type -> result_type = function
-    | ts -> List.map (sem_val_type c) ts
+  let dyn_result_type c : Stat.result_type -> result_type = function
+    | ts -> List.map (dyn_val_type c) ts
 
-  let sem_func_type c : Syn.func_type -> func_type = function
-    | Syn.FuncT (ts1, ts2) -> FuncT (sem_result_type c ts1, sem_result_type c ts2)
+  let dyn_func_type c : Stat.func_type -> func_type = function
+    | Stat.FuncT (ts1, ts2) -> FuncT (dyn_result_type c ts1, dyn_result_type c ts2)
 
-  let sem_def_type c : Syn.def_type -> def_type = function
-    | Syn.DefFuncT ft -> DefFuncT (sem_func_type c ft)
+  let dyn_def_type c : Stat.def_type -> def_type = function
+    | Stat.DefFuncT ft -> DefFuncT (dyn_func_type c ft)
 
-  let sem_local_type c : Syn.local_type -> local_type = function
-    | Syn.LocalT (init, t) -> LocalT (sem_init c init, sem_val_type c t)
+  let dyn_local_type c : Stat.local_type -> local_type = function
+    | Stat.LocalT (init, t) -> LocalT (dyn_init c init, dyn_val_type c t)
 
-  let sem_memory_type c : Syn.memory_type -> memory_type = function
-    | Syn.MemoryT lim -> MemoryT (sem_limits c lim)
+  let dyn_memory_type c : Stat.memory_type -> memory_type = function
+    | Stat.MemoryT lim -> MemoryT (dyn_limits c lim)
 
-  let sem_table_type c : Syn.table_type -> table_type = function
-    | Syn.TableT (lim, t) -> TableT (sem_limits c lim, sem_ref_type c t)
+  let dyn_table_type c : Stat.table_type -> table_type = function
+    | Stat.TableT (lim, t) -> TableT (dyn_limits c lim, dyn_ref_type c t)
 
-  let sem_global_type c : Syn.global_type -> global_type = function
-    | Syn.GlobalT (mut, t) -> GlobalT (sem_mut c mut, sem_val_type c t)
+  let dyn_global_type c : Stat.global_type -> global_type = function
+    | Stat.GlobalT (mut, t) -> GlobalT (dyn_mut c mut, dyn_val_type c t)
 
-  let sem_extern_type c : Syn.extern_type -> extern_type = function
-    | Syn.ExternFuncT ft -> ExternFuncT (sem_func_type c ft)
-    | Syn.ExternTableT tt -> ExternTableT (sem_table_type c tt)
-    | Syn.ExternMemoryT mt -> ExternMemoryT (sem_memory_type c mt)
-    | Syn.ExternGlobalT gt -> ExternGlobalT (sem_global_type c gt)
+  let dyn_extern_type c : Stat.extern_type -> extern_type = function
+    | Stat.ExternFuncT ft -> ExternFuncT (dyn_func_type c ft)
+    | Stat.ExternTableT tt -> ExternTableT (dyn_table_type c tt)
+    | Stat.ExternMemoryT mt -> ExternMemoryT (dyn_memory_type c mt)
+    | Stat.ExternGlobalT gt -> ExternGlobalT (dyn_global_type c gt)
 
-  let sem_export_type c : Syn.export_type -> export_type = function
-    | Syn.ExportT (et, name) -> ExportT (sem_extern_type c et, name)
+  let dyn_export_type c : Stat.export_type -> export_type = function
+    | Stat.ExportT (et, name) -> ExportT (dyn_extern_type c et, name)
 
-  let sem_import_type c : Syn.import_type -> import_type = function
-    | Syn.ImportT (et, module_name, name) ->
-      ImportT (sem_extern_type c et, module_name, name)
+  let dyn_import_type c : Stat.import_type -> import_type = function
+    | Stat.ImportT (et, module_name, name) ->
+      ImportT (dyn_extern_type c et, module_name, name)
 
-  let sem_module_type : Syn.module_type -> module_type = function
-    | Syn.ModuleT (dts, its, ets) ->
+  let dyn_module_type : Stat.module_type -> module_type = function
+    | Stat.ModuleT (dts, its, ets) ->
       let c = List.map (fun _ -> alloc_uninit ()) dts in
-      List.iter2 (fun x dt -> init x (sem_def_type c dt)) c dts;
-      let its = List.map (sem_import_type c) its in
-      let ets = List.map (sem_export_type c) ets in
+      List.iter2 (fun x dt -> init x (dyn_def_type c dt)) c dts;
+      let its = List.map (dyn_import_type c) its in
+      let ets = List.map (dyn_export_type c) ets in
       ModuleT ([], its, ets)
 end
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index b86fa6ea4..027dcde7d 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -355,7 +355,7 @@ struct
 end
 
 let oper (iop, fop) op =
-  Sem.string_of_num_type (type_of_num op) ^ "." ^
+  Dyn.string_of_num_type (type_of_num op) ^ "." ^
   (match op with
   | I32 o -> iop "32" o
   | I64 o -> iop "64" o
@@ -427,8 +427,8 @@ let vec_laneop instr (op, i) =
 let var x = nat32 x.it
 let num v = string_of_num v.it
 let vec v = string_of_vec v.it
-let constop v = Sem.string_of_num_type (type_of_num v) ^ ".const"
-let vec_constop v = Sem.string_of_vec_type (type_of_vec v) ^ ".const i32x4"
+let constop v = Dyn.string_of_num_type (type_of_num v) ^ ".const"
+let vec_constop v = Dyn.string_of_vec_type (type_of_vec v) ^ ".const i32x4"
 
 let block_type = function
   | VarBlockType x -> [Node ("type " ^ nat32 x, [])]
@@ -669,7 +669,7 @@ let num mode = if mode = `Binary then hex_string_of_num else string_of_num
 let vec mode = if mode = `Binary then hex_string_of_vec else string_of_vec
 
 let ref_ = function
-  | NullRef t -> Node ("ref.null " ^ Types.Sem.string_of_heap_type t, [])
+  | NullRef t -> Node ("ref.null " ^ Types.Dyn.string_of_heap_type t, [])
   | Script.ExternRef n -> Node ("ref.extern " ^ nat32 n, [])
   | _ -> assert false
 
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index b41ecdf56..1bf13ff20 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -1197,7 +1197,7 @@ literal_vec :
 
 literal_ref :
   | LPAR REF_NULL heap_type RPAR
-    { Value.NullRef (Types.Sem.sem_heap_type [] ($3 (empty_context ()))) }
+    { Value.NullRef (Types.Dyn.dyn_heap_type [] ($3 (empty_context ()))) }
   | LPAR REF_EXTERN NAT RPAR { Script.ExternRef (nat32 $3 (ati 3)) }
 
 literal :
diff --git a/interpreter/valid/match.ml b/interpreter/valid/match.ml
index 5849967f1..84631b158 100644
--- a/interpreter/valid/match.ml
+++ b/interpreter/valid/match.ml
@@ -16,7 +16,7 @@ module Make
   ) =
 struct
 
-  open Types.Make(Var)
+  open Types.Make (Var)
   open Context
 
 
@@ -177,29 +177,29 @@ struct
 end
 
 
-(* Syntactic Matching *)
+(* Static Matching *)
 
-module SynContext =
+module StatContext =
 struct
-  type var = Types.Syn.var
-  type def_type = Types.Syn.def_type
+  type var = Types.Stat.var
+  type def_type = Types.Stat.def_type
   type context = def_type list
   let lookup c x = Lib.List32.nth c x
 end
 
-module Syn = Make (Types.SynVar) (SynContext)
+module Stat = Make (Types.StatVar) (StatContext)
 
-include Syn
+include Stat
 
 
-(* Semantic Matching *)
+(* Dynamic Matching *)
 
-module SemContext =
+module DynContext =
 struct
-  type var = Types.Sem.var
-  type def_type = Types.Sem.def_type
+  type var = Types.Dyn.var
+  type def_type = Types.Dyn.def_type
   type context = unit
-  let lookup _c x = Types.Sem.def_of x
+  let lookup _c x = Types.Dyn.def_of x
 end
 
-module Sem = Make (Types.SemVar) (SemContext)
+module Dyn = Make (Types.DynVar) (DynContext)

From b9c26861c8ee5468803b463b99e2769d3ab21bfc Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 3 Aug 2022 12:59:20 +0200
Subject: [PATCH 173/285] Readd match.mli

---
 interpreter/valid/match.mli | 78 +++++++++++++++++++++++++++++++++++++
 1 file changed, 78 insertions(+)
 create mode 100644 interpreter/valid/match.mli

diff --git a/interpreter/valid/match.mli b/interpreter/valid/match.mli
new file mode 100644
index 000000000..516e87aa2
--- /dev/null
+++ b/interpreter/valid/match.mli
@@ -0,0 +1,78 @@
+(* Generic Matching *)
+
+module type Context =
+sig
+  type var
+  type def_type
+  type context
+  val lookup : context -> var -> def_type
+end
+
+module Make
+  (Var : Types.Var)
+  (Context : Context
+    with type var = Var.var
+    with type def_type = Types.Make(Var).def_type
+  ) :
+sig
+  open Types.Make (Var)
+  open Context
+
+  type assump = (var * var) list
+
+  (* Equivalence *)
+
+  val eq_num_type : context -> assump -> num_type -> num_type -> bool
+  val eq_ref_type : context -> assump -> ref_type -> ref_type -> bool
+  val eq_val_type : context -> assump -> val_type -> val_type -> bool
+
+  val eq_result_type : context -> assump -> result_type -> result_type -> bool
+
+  val eq_func_type : context -> assump -> func_type -> func_type -> bool
+  val eq_table_type : context -> assump -> table_type -> table_type -> bool
+  val eq_memory_type : context -> assump -> memory_type -> memory_type -> bool
+  val eq_global_type : context -> assump -> global_type -> global_type -> bool
+
+  val eq_extern_type : context -> assump -> extern_type -> extern_type -> bool
+
+  val eq_def_type : context -> assump -> def_type -> def_type -> bool
+
+  (* Subtyping *)
+
+  val match_num_type : context -> assump -> num_type -> num_type -> bool
+  val match_ref_type : context -> assump -> ref_type -> ref_type -> bool
+  val match_val_type : context -> assump -> val_type -> val_type -> bool
+
+  val match_result_type : context -> assump -> result_type -> result_type -> bool
+
+  val match_func_type : context -> assump -> func_type -> func_type -> bool
+  val match_table_type : context -> assump -> table_type -> table_type -> bool
+  val match_memory_type : context -> assump -> memory_type -> memory_type -> bool
+  val match_global_type : context -> assump -> global_type -> global_type -> bool
+
+  val match_extern_type : context -> assump -> extern_type -> extern_type -> bool
+
+  val match_def_type : context -> assump -> def_type -> def_type -> bool
+end
+
+
+(* Static Matching *)
+
+module StatContext : Context
+  with type var = Types.Stat.var
+  with type def_type = Types.Stat.def_type
+  with type context = Types.Stat.def_type list
+
+module Stat : module type of Make (Types.StatVar) (StatContext)
+
+include module type of Stat
+
+
+(* Dynamic Matching *)
+
+module DynContext : Context
+  with type var = Types.Dyn.var
+  with type def_type = Types.Dyn.def_type
+  with type context = unit
+
+module Dyn : module type of Make (Types.DynVar) (DynContext)

From 40dca7389c9431780c49d2300f6fef4c3d814cf2 Mon Sep 17 00:00:00 2001
From: Asumu Takikawa <asumu@igalia.com>
Date: Thu, 4 Aug 2022 01:32:43 -0700
Subject: [PATCH 174/285] [interpreter] Build wast.js with Js_of_ocaml (#1507)

---
 .github/workflows/main.yml           | 11 ++++
 interpreter/Makefile                 | 24 +++----
 interpreter/README.md                | 23 ++++++-
 interpreter/dune                     |  5 +-
 interpreter/meta/jslib/bsconfig.json |  6 --
 interpreter/meta/jslib/build.sh      | 97 ----------------------------
 interpreter/meta/jslib/wasm.ml       |  9 ---
 interpreter/meta/jslib/wast.ml       | 26 ++++++++
 8 files changed, 72 insertions(+), 129 deletions(-)
 delete mode 100644 interpreter/meta/jslib/bsconfig.json
 delete mode 100755 interpreter/meta/jslib/build.sh
 delete mode 100644 interpreter/meta/jslib/wasm.ml
 create mode 100644 interpreter/meta/jslib/wast.ml

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 4a5527ca2..9a7a111a1 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -21,6 +21,17 @@ jobs:
       - run: opam install --yes ocamlbuild.0.14.0
       - run: cd interpreter && opam exec make all
 
+  ref-interpreter-js-library:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup OCaml
+        uses: ocaml/setup-ocaml@v2
+        with:
+          ocaml-compiler: 4.12.x
+      - run: opam install --yes ocamlbuild.0.14.0 ocamlfind.1.9.5 js_of_ocaml.4.0.0 js_of_ocaml-ppx.4.0.0
+      - run: cd interpreter && opam exec make wast.js
+
   build-js-api-spec:
     runs-on: ubuntu-latest
     steps:
diff --git a/interpreter/Makefile b/interpreter/Makefile
index 1783a9c4d..7820e6428 100644
--- a/interpreter/Makefile
+++ b/interpreter/Makefile
@@ -2,7 +2,7 @@
 # package manager to build. However, Opam package management is available
 # optionally through the check/install/uninstall targets.
 #
-# The $(JSLIB) target requires node.js and BuckleScript.
+# The $(JSLIB).js target requires Js_of_ocaml (using ocamlfind).
 #
 # See README.me for instructions.
 
@@ -14,7 +14,7 @@ UNOPT = 	$(NAME).debug
 OPT =   	$(NAME)
 LIB =		$(NAME)
 ZIP =		$(NAME).zip
-JSLIB =		wast.js
+JSLIB =		wast
 WINMAKE =	winmake.bat
 
 DIRS =		util syntax binary text valid runtime exec script host main tests
@@ -22,6 +22,7 @@ LIBS =		bigarray
 FLAGS = 	-lexflags -ml -cflags '-w +a-4-27-42-44-45-70 -warn-error +a-3'
 OCBA =		ocamlbuild $(FLAGS) $(DIRS:%=-I %)
 OCB =		$(OCBA) $(LIBS:%=-libs %)
+JSO =		js_of_ocaml -q --opt 3
 JS =		# set to JS shell command to run JS tests
 
 
@@ -35,7 +36,7 @@ opt:		$(OPT)
 unopt:		$(UNOPT)
 libopt:		_build/$(LIB).cmx _build/$(LIB).cmxa
 libunopt:	_build/$(LIB).cmo _build/$(LIB).cma
-jslib:		$(JSLIB)
+jslib:		$(JSLIB).js
 all:		unopt opt libunopt libopt test
 land:		$(WINMAKE) all
 zip: 		$(ZIP)
@@ -108,14 +109,15 @@ _build/$(LIB).cmxa: $(FILES) $(LIB).mllib _tags Makefile
 
 # Building JavaScript library
 
-.PHONY:		$(JSLIB)
-$(JSLIB):	$(UNOPT)
-		mkdir -p _build/jslib/src
-		cp meta/jslib/* _build/jslib
-		cp $(DIRS:%=_build/%/*.ml*) meta/jslib/*.ml _build/jslib/src
-		rm _build/jslib/src/*.ml[^i]
-		(cd _build/jslib; ./build.sh ../../$@)
+JSLIB_DIR =		meta/jslib
+JSLIB_FLAGS =	-I $(JSLIB_DIR) -use-ocamlfind -pkg js_of_ocaml -pkg js_of_ocaml-ppx
 
+.INTERMEDIATE:	$(JSLIB).byte
+$(JSLIB).byte:	$(JSLIB_DIR)/$(JSLIB).ml
+		$(OCBA) $(JSLIB_FLAGS) $@
+
+$(JSLIB).js: $(JSLIB).byte
+		$(JSO) $<
 
 # Building Windows build file
 
@@ -181,7 +183,7 @@ $(ZIP):		$(WINMAKE)
 		git archive --format=zip --prefix=$(NAME)/ -o $@ HEAD
 
 clean:
-		rm -rf _build/jslib $(LIB).mlpack _tags
+		rm -rf _build/jslib $(LIB).mlpack _tags $(JSLIB).js
 		$(OCB) -clean
 
 
diff --git a/interpreter/README.md b/interpreter/README.md
index 6f55c1f3f..11258ae62 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -65,7 +65,10 @@ The Makefile also provides a target to compile (parts of) the interpreter into a
 ```
 make wast.js
 ```
-Building this target requires node.js and BuckleScript.
+Building this target requires `js_of_ocaml`, which can be installed with OPAM:
+```
+opam install js_of_ocaml js_of_ocaml-ppx
+```
 
 
 ## Synopsis
@@ -139,7 +142,7 @@ WebAssemblyText.encode(source)
 ```
 which turns a module in S-expression syntax into a WebAssembly binary, and
 ```
-WebAssemblyText.decode(binary, width = 80)
+WebAssemblyText.decode(binary, width)
 ```
 which pretty-prints a binary back into a canonicalised S-expression string.
 
@@ -151,7 +154,7 @@ let binary = WebAssemblyText.encode(source)
 (new WebAssembly.Instance(new WebAssembly.Module(binary))).exports.f(3, 4)
 // => 7
 
-WebAssemblyText.decode(binary)
+WebAssemblyText.decode(binary, 80)
 // =>
 // (module
 //   (type $0 (func (param i32 i32) (result i32)))
@@ -160,6 +163,20 @@ WebAssemblyText.decode(binary)
 // )
 ```
 
+Depending on how you load the library, the object may be accessed in different ways. For example, using `require` in node.js:
+
+```
+let wast = require("./wast.js");
+let binary = wast.WebAssemblyText.encode("(module)");
+```
+
+Or using `load` from a JavaScript shell:
+
+```
+load("./wast.js");
+let binary = WebAssemblyText.encode("(module)");
+```
+
 
 ## S-Expression Syntax
 
diff --git a/interpreter/dune b/interpreter/dune
index 6f6dfff3e..48274aad9 100644
--- a/interpreter/dune
+++ b/interpreter/dune
@@ -4,10 +4,9 @@
  (name wasm)
  ; The 'main' module shall not be part of the library, as it would start the
  ; Wasm REPL every time in all the dependencies.
- ; We also need to exclude the 'wasm' module as it overlaps with the library
- ; name.
+ ; We exclude the 'wast' module as it is only used for the JS build.
  ; 'smallint' is a separate test module.
- (modules :standard \ main wasm smallint))
+ (modules :standard \ main smallint wast))
 
 (executable
  (name main)
diff --git a/interpreter/meta/jslib/bsconfig.json b/interpreter/meta/jslib/bsconfig.json
deleted file mode 100644
index d313bf93d..000000000
--- a/interpreter/meta/jslib/bsconfig.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "name": "wasm",
-  "sources": [
-    {"dir": "src"},
-  ]
-}
diff --git a/interpreter/meta/jslib/build.sh b/interpreter/meta/jslib/build.sh
deleted file mode 100755
index 14471217b..000000000
--- a/interpreter/meta/jslib/build.sh
+++ /dev/null
@@ -1,97 +0,0 @@
-link () {
-echo "// DO NOT EDIT. Generated from WebAssembly spec interpreter"
-echo "
-let WebAssemblyText = (function() {
-  let _registry = {__proto__: null};
-  function normalize(file) {
-    return file.split('/').reverse()[0].split('.')[0];
-  }
-  function require(file) {
-    let name = normalize(file);
-    if (!(name in _registry)) {
-      throw new Error('missing module: ' + name)
-    } else if (typeof _registry[name] === 'function') {
-"
-if (($LOG == 1))
-then
-  echo 1>&2 Logging on
-  echo "
-    console.log(name);
-"
-fi
-echo "
-      let f = _registry[name];
-      _registry[name] = function() { throw new Error('cyclic module: ' + name) };
-      _registry[name] = f();
-    }
-    return _registry[name];
-  }
-"
-
-for file in $*
-do
-  echo 1>&2 Including $file
-  name=`basename $file | sed s/[.]js//g`
-  echo "
-  _registry['$name'] = function() {
-    let exports = {};
-//////// start of $name.js ////////"
-  cat $file
-  echo "//////// end of $name.js ////////
-    return exports;
-  };
-"
-done
-
-echo "
-  function binary(bytes) {
-    let buffer = new ArrayBuffer(bytes.length);
-    let view = new Uint8Array(buffer);
-    for (let i = 0; i < bytes.length; ++i) {
-      view[i] = bytes.charCodeAt(i);
-    }
-    return buffer;
-  }
-  function bytes(buffer) {
-    let string = '';
-    let view = new Uint8Array(buffer);
-    for (let i = 0; i < view.length; ++i) {
-      string += String.fromCodePoint(view[i]);
-    }
-    return string;
-  }
-  let Wasm = require('wasm');
-  return {
-    encode(s) { return binary(Wasm.encode(s)) },
-    decode(b, w = 80) { return Wasm.decode(bytes(b), w) }
-  };
-})();
-
-"
-}
-
-echo 1>&2 ==== Preparing ====
-npm link bs-platform
-
-echo 1>&2 ==== Compiling ====
-bsb || exit 1
-
-echo 1>&2 ==== Linking full version ====
-LOG=1
-FILES='node_modules/bs-platform/lib/js/*.js lib/js/src/*.js'
-link $FILES >temp.js || exit 1
-
-echo 1>&2 ==== Running for dependencies ====
-node temp.js | tee temp.log || exit 1
-
-echo 1>&2 ==== Linking stripped version ====
-used=''
-for file in `ls $FILES`
-do
-  if grep -q `basename $file | sed s/.js//g` temp.log
-  then
-    used="$used $file"
-  fi
-done
-LOG=0
-link $used >$1 || exit 1
diff --git a/interpreter/meta/jslib/wasm.ml b/interpreter/meta/jslib/wasm.ml
deleted file mode 100644
index 915fdafb0..000000000
--- a/interpreter/meta/jslib/wasm.ml
+++ /dev/null
@@ -1,9 +0,0 @@
-let encode s =
-  let def = Parse.string_to_module s in
-  match def.Source.it with
-  | Script.Textual m -> Encode.encode m
-  | Script.Encoded (_, bs) -> bs
-
-let decode s width =
-  let m = Decode.decode "(decode)" s in
-  Sexpr.to_string width (Arrange.module_ m)
diff --git a/interpreter/meta/jslib/wast.ml b/interpreter/meta/jslib/wast.ml
new file mode 100644
index 000000000..9af04f918
--- /dev/null
+++ b/interpreter/meta/jslib/wast.ml
@@ -0,0 +1,26 @@
+(* Implements a wrapper library that allows the use of the reference
+ * interpreter's encode/decode functionality in JavaScript.
+ *)
+open Js_of_ocaml
+
+let _ =
+  Js.export "WebAssemblyText"
+    (object%js (_self)
+
+      method encode (s : Js.js_string Js.t) : (Typed_array.arrayBuffer Js.t) =
+        let def = Parse.string_to_module (Js.to_string s) in
+        let bs =
+          match def.Source.it with
+          | Script.Textual m -> (Encode.encode m)
+          | Script.Encoded (_, bs) -> bs
+          | Script.Quoted (_, _) -> failwith "Unsupported" in
+        let buf = new%js Typed_array.arrayBuffer (String.length bs) in
+        let u8arr = new%js Typed_array.uint8Array_fromBuffer buf in
+        String.iteri (fun i c -> Typed_array.set u8arr i (int_of_char c)) bs; buf
+
+      method decode (buf : Typed_array.arrayBuffer Js.t) width : (Js.js_string Js.t) =
+        let s = Typed_array.String.of_uint8Array (new%js Typed_array.uint8Array_fromBuffer buf) in
+        let m = Decode.decode "(decode)" s in
+        Js.string (Sexpr.to_string width (Arrange.module_ m))
+
+    end)

From 9de780529d75ca2a3a1171744628f333f4c58729 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Thu, 4 Aug 2022 11:27:16 +0200
Subject: [PATCH 175/285] [interpreter] Add flag for controlling call budget

---
 interpreter/exec/eval.ml  | 3 ++-
 interpreter/main/flags.ml | 1 +
 interpreter/main/main.ml  | 6 ++++--
 test/build.py             | 2 +-
 4 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index 3a112ce49..18ff7150d 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -73,7 +73,8 @@ type config =
 }
 
 let frame inst locals = {inst; locals}
-let config inst vs es = {frame = frame inst []; code = vs, es; budget = 300}
+let config inst vs es =
+  {frame = frame inst []; code = vs, es; budget = !Flags.budget}
 
 let plain e = Plain e.it @@ e.at
 
diff --git a/interpreter/main/flags.ml b/interpreter/main/flags.ml
index e3fcc2abf..b92378aa2 100644
--- a/interpreter/main/flags.ml
+++ b/interpreter/main/flags.ml
@@ -5,3 +5,4 @@ let print_sig = ref false
 let dry = ref false
 let width = ref 80
 let harness = ref true
+let budget = ref 256
diff --git a/interpreter/main/main.ml b/interpreter/main/main.ml
index 898bdef1d..beeb98049 100644
--- a/interpreter/main/main.ml
+++ b/interpreter/main/main.ml
@@ -24,11 +24,13 @@ let argspec = Arg.align
     " read script from file";
   "-o", Arg.String (fun file -> add_arg ("(output " ^ quote file ^ ")")),
     " write module to file";
+  "-b", Arg.Int (fun n -> Flags.budget := n),
+    " configure call depth budget (default is " ^ string_of_int !Flags.budget ^ ")";
   "-w", Arg.Int (fun n -> Flags.width := n),
-    " configure output width (default is 80)";
+    " configure output width (default is " ^ string_of_int !Flags.width ^ ")";
   "-s", Arg.Set Flags.print_sig, " show module signatures";
   "-u", Arg.Set Flags.unchecked, " unchecked, do not perform validation";
-  "-h", Arg.Clear Flags.harness, " exclude harness for JS conversion";
+  "-j", Arg.Clear Flags.harness, " exclude harness for JS conversion";
   "-d", Arg.Set Flags.dry, " dry, do not run program";
   "-t", Arg.Set Flags.trace, " trace execution";
   "-v", Arg.Unit banner, " show version"
diff --git a/test/build.py b/test/build.py
index bfb39727d..69c1b19a2 100755
--- a/test/build.py
+++ b/test/build.py
@@ -60,7 +60,7 @@ def ensure_wasm_executable(path_to_wasm):
 def convert_one_wast_file(inputs):
     wast_file, js_file = inputs
     print('Compiling {} to JS...'.format(wast_file))
-    return run(WASM_EXEC, wast_file, '-h', '-o', js_file)
+    return run(WASM_EXEC, wast_file, '-j', '-o', js_file)
 
 def convert_wast_to_js(out_js_dir):
     """Compile all the wast files to JS and store the results in the JS dir."""

From 3eea65616b4eef8ff90d5095f73910d712522ff9 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 4 Aug 2022 15:01:15 +0200
Subject: [PATCH 176/285] Spec zero byte

---
 document/core/binary/modules.rst | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/document/core/binary/modules.rst b/document/core/binary/modules.rst
index 6c4a88890..c1a513fd9 100644
--- a/document/core/binary/modules.rst
+++ b/document/core/binary/modules.rst
@@ -213,13 +213,14 @@ It decodes into a vector of :ref:`tables <syntax-table>` that represent the |MTA
      \X{tt}{:}\Btabletype
        &\Rightarrow& \{ \TTYPE~\X{tt}, \TINIT~(\REFNULL~\X{ht}) \}
          \qquad \iff \X{tt} = \limits~(\REF~\NULL^?~\X{ht}) \\
-     \hex{40}~~\X{tt}{:}\Btabletype~~e{:}\Bexpr
+     \hex{40}~~\hex{00}~~\X{tt}{:}\Btabletype~~e{:}\Bexpr
        &\Rightarrow& \{ \TTYPE~\X{tt}, \TINIT~e \} \\
    \end{array}
 
 .. note::
    The encoding of a table type cannot start with byte :math:`\hex{40}`,
    hence decoding is unambiguous.
+   The zero byte following it is reserved for futre extensions.
 
 
 .. index:: ! memory section, memory, memory type

From 36770f4b0381999baa5587f4a08dfe8980706c4a Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 4 Aug 2022 18:01:44 +0200
Subject: [PATCH 177/285] Fix table/elem expansion (#71)

---
 document/core/text/modules.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/text/modules.rst b/document/core/text/modules.rst
index 84aaf1138..d6930ffdd 100644
--- a/document/core/text/modules.rst
+++ b/document/core/text/modules.rst
@@ -292,7 +292,7 @@ An :ref:`element segment <text-elem>` can be given inline with a table definitio
    \production{module field} &
      \text{(}~\text{table}~~\Tid^?~~\Treftype~~\text{(}~\text{elem}~~\expr^n{:}\Tvec(\Telemexpr)~\text{)}~\text{)} \quad\equiv \\ & \qquad
        \text{(}~\text{table}~~\Tid'~~n~~n~~\Treftype~\text{)} \\ & \qquad
-       \text{(}~\text{elem}~~\text{(}~\text{table}~~\Tid'~\text{)}~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Tvec(\Telemexpr)~\text{)}
+       \text{(}~\text{elem}~~\text{(}~\text{table}~~\Tid'~\text{)}~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Treftype~~\Tvec(\Telemexpr)~\text{)}
        \\ & \qquad\qquad
        (\iff \Tid^? \neq \epsilon \wedge \Tid' = \Tid^? \vee \Tid^? = \epsilon \wedge \Tid' \idfresh) \\
    \end{array}
@@ -302,7 +302,7 @@ An :ref:`element segment <text-elem>` can be given inline with a table definitio
    \production{module field} &
      \text{(}~\text{table}~~\Tid^?~~\Treftype~~\text{(}~\text{elem}~~x^n{:}\Tvec(\Tfuncidx)~\text{)}~\text{)} \quad\equiv \\ & \qquad
        \text{(}~\text{table}~~\Tid'~~n~~n~~\Treftype~\text{)} \\ & \qquad
-       \text{(}~\text{elem}~~\text{(}~\text{table}~~\Tid'~\text{)}~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Tvec(\Tfuncidx)~\text{)}
+       \text{(}~\text{elem}~~\text{(}~\text{table}~~\Tid'~\text{)}~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\text{func}~~\Tvec(\Tfuncidx)~\text{)}
        \\ & \qquad\qquad
        (\iff \Tid^? \neq \epsilon \wedge \Tid' = \Tid^? \vee \Tid^? = \epsilon \wedge \Tid' \idfresh) \\
    \end{array}

From 62c3b5a1303c9dd5c0419707b57d8342a1d22940 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Mon, 8 Aug 2022 14:52:22 +0200
Subject: [PATCH 178/285] Fix merge artefact

---
 document/core/valid/matching.rst | 2 --
 1 file changed, 2 deletions(-)

diff --git a/document/core/valid/matching.rst b/document/core/valid/matching.rst
index 4b17d54b3..e3d976555 100644
--- a/document/core/valid/matching.rst
+++ b/document/core/valid/matching.rst
@@ -1,8 +1,6 @@
 .. index:: ! matching, subtyping
 .. _match:
 
-.. _match:
-
 Matching
 --------
 

From 888cce93a4ad29d84d7b408d4f08ba788a75bf59 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 10 Aug 2022 11:33:47 +0200
Subject: [PATCH 179/285] Restrict init from stack-polymorphism (#75)

---
 document/core/appendix/algorithm.rst |  4 ++--
 document/core/valid/instructions.rst | 28 ++++++++++++++--------------
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/document/core/appendix/algorithm.rst b/document/core/appendix/algorithm.rst
index 172b9773a..ee55fbdb1 100644
--- a/document/core/appendix/algorithm.rst
+++ b/document/core/appendix/algorithm.rst
@@ -185,7 +185,7 @@ The initialization stack and the initialization status of locals is manipulated
 .. code-block:: pseudo
 
    func get_local(idx : u32) =
-     error_if(not (locals_init[idx] || ctrls[0].unreachable))
+     error_if(not locals_init[idx])
 
    func set_local(idx : u32) =
      if (not locals_init[idx])
@@ -196,7 +196,7 @@ The initialization stack and the initialization status of locals is manipulated
      while (inits.size() > height)
        locals_init[inits.pop()] := false
 
-Getting a local verifies that it is either known to be initialized, or that that the operation is unreachable in the current stack frame.
+Getting a local verifies that it is known to be initialized.
 When a local is set that was not set already,
 then its initialization status is updated and the change is recorded in the initialization stack.
 Thus, the initialization status of all locals can be reset to a previous state by denoting a specific height in the initialization stack.
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index accf07037..9b1ebf214 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -30,7 +30,7 @@ Two degrees of polymorphism can be distinguished:
   That is the case for all :ref:`parametric instructions <valid-instr-parametric>` like |DROP| and |SELECT|.
 
 * *stack-polymorphic*:
-  the entire (or most of the) :ref:`instruction type <syntax-instrtype>` :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]` of the instruction is unconstrained.
+  the entire (or most of the) :ref:`instruction type <syntax-instrtype>` :math:`[t_1^\ast] \to [t_2^\ast]` of the instruction is unconstrained.
   That is the case for all :ref:`control instructions <valid-instr-control>` that perform an *unconditional control transfer*, such as |UNREACHABLE|, |BR|, |BRTABLE|, and |RETURN|.
 
 In both cases, the unconstrained types or type sequences can be chosen arbitrarily, as long as they meet the constraints imposed for the surrounding parts of the program.
@@ -49,7 +49,7 @@ In both cases, the unconstrained types or type sequences can be chosen arbitrari
    are valid, with :math:`t` in the typing of |SELECT| being instantiated to |I32| or |F64|, respectively.
 
    The |UNREACHABLE| instruction is stack-polymorphic,
-   and hence valid with type :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]` for any possible sequences of value types :math:`t_1^\ast` and :math:`t_2^\ast` and sequence of locals :math:`x^\ast`.
+   and hence valid with type :math:`[t_1^\ast] \to [t_2^\ast]` for any possible sequences of value types :math:`t_1^\ast` and :math:`t_2^\ast`.
    Consequently,
 
    .. math::
@@ -1257,13 +1257,13 @@ Control Instructions
 :math:`\UNREACHABLE`
 ....................
 
-* The instruction is valid with any :ref:`valid <valid-instrtype>` type :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]`.
+* The instruction is valid with any :ref:`valid <valid-instrtype>` type of the form :math:`[t_1^\ast] \to [t_2^\ast]`.
 
 .. math::
    \frac{
-     C \vdashinstrtype [t_1^\ast] \to_{x^\ast} [t_2^\ast] \ok
+     C \vdashinstrtype [t_1^\ast] \to [t_2^\ast] \ok
    }{
-     C \vdashinstr \UNREACHABLE : [t_1^\ast] \to_{x^\ast} [t_2^\ast]
+     C \vdashinstr \UNREACHABLE : [t_1^\ast] \to [t_2^\ast]
    }
 
 .. note::
@@ -1365,15 +1365,15 @@ Control Instructions
 
 * Let :math:`[t^\ast]` be the :ref:`result type <syntax-resulttype>` :math:`C.\CLABELS[l]`.
 
-* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast] \to_{x^\ast} [t_2^\ast]`, for any :ref:`valid <valid-instrtype>` type :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]`.
+* Then the instruction is valid with any :ref:`valid <valid-instrtype>` type of the form :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`.
 
 .. math::
    \frac{
      C.\CLABELS[l] = [t^\ast]
      \qquad
-     C \vdashinstrtype [t_1^\ast] \to_{x^\ast} [t_2^\ast] \ok
+     C \vdashinstrtype [t_1^\ast~t^\ast] \to [t_2^\ast] \ok
    }{
-     C \vdashinstr \BR~l : [t_1^\ast~t^\ast] \to_{x^\ast} [t_2^\ast]
+     C \vdashinstr \BR~l : [t_1^\ast~t^\ast] \to [t_2^\ast]
    }
 
 .. note::
@@ -1422,7 +1422,7 @@ Control Instructions
   * For all :math:`l_i` in :math:`l^\ast`,
     the result type :math:`[t^\ast]` :ref:`matches <match-resulttype>` :math:`C.\CLABELS[l_i]`.
 
-* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast~\I32] \to_{x^\ast} [t_2^\ast]`, for any :ref:`valid <valid-instrtype>` type :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]`.
+* Then the instruction is valid with any :ref:`valid <valid-instrtype>` type of the form :math:`[t_1^\ast~t^\ast~\I32] \to [t_2^\ast]`.
 
 .. math::
    \frac{
@@ -1430,9 +1430,9 @@ Control Instructions
      \qquad
      C \vdashresulttypematch [t^\ast] \matchesresulttype C.\CLABELS[l_N]
      \qquad
-     C \vdashinstrtype [t_1^\ast] \to_{x^\ast} [t_2^\ast] \ok
+     C \vdashinstrtype [t_1^\ast~t^\ast~\I32] \to [t_2^\ast] \ok
    }{
-     C \vdashinstr \BRTABLE~l^\ast~l_N : [t_1^\ast~t^\ast~\I32] \to_{x^\ast} [t_2^\ast]
+     C \vdashinstr \BRTABLE~l^\ast~l_N : [t_1^\ast~t^\ast~\I32] \to [t_2^\ast]
    }
 
 .. note::
@@ -1500,15 +1500,15 @@ Control Instructions
 
 * Let :math:`[t^\ast]` be the :ref:`result type <syntax-resulttype>` of :math:`C.\CRETURN`.
 
-* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast] \to_{x^\ast} [t_2^\ast]`, for any :ref:`valid <valid-instrtype>` type :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]`.
+* Then the instruction is valid with any :ref:`valid <valid-instrtype>` type of the form :math:`[t_1^\ast] \to [t_2^\ast]`.
 
 .. math::
    \frac{
      C.\CRETURN = [t^\ast]
      \qquad
-     C \vdashinstrtype [t_1^\ast] \to_{x^\ast} [t_2^\ast] \ok
+     C \vdashinstrtype [t_1^\ast~t^\ast] \to [t_2^\ast] \ok
    }{
-     C \vdashinstr \RETURN : [t_1^\ast~t^\ast] \to_{x^\ast} [t_2^\ast]
+     C \vdashinstr \RETURN : [t_1^\ast~t^\ast] \to [t_2^\ast]
    }
 
 .. note::

From e9dccd92450d46c5f8b912435531e6fa793705a6 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Wed, 10 Aug 2022 11:34:12 +0200
Subject: [PATCH 180/285] [spec] Simplify exec rule for if (#1517)

---
 document/core/exec/instructions.rst | 34 ++++++++++-------------------
 1 file changed, 12 insertions(+), 22 deletions(-)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 194c39851..c7586d074 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -2587,37 +2587,27 @@ Control Instructions
 :math:`\IF~\blocktype~\instr_1^\ast~\ELSE~\instr_2^\ast~\END`
 .............................................................
 
-1. Assert: due to :ref:`validation <valid-blocktype>`, :math:`\expand_F(\blocktype)` is defined.
-
-2. Let :math:`[t_1^m] \to [t_2^n]` be the :ref:`function type <syntax-functype>` :math:`\expand_F(\blocktype)`.
-
-3. Let :math:`L` be the label whose arity is :math:`n` and whose continuation is the end of the |IF| instruction.
-
-4. Assert: due to :ref:`validation <valid-if>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
-
-5. Pop the value :math:`\I32.\CONST~c` from the stack.
-
-6. Assert: due to :ref:`validation <valid-if>`, there are at least :math:`m` values on the top of the stack.
+1. Assert: due to :ref:`validation <valid-if>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
 
-7. Pop the values :math:`\val^m` from the stack.
+2. Pop the value :math:`\I32.\CONST~c` from the stack.
 
-8. If :math:`c` is non-zero, then:
+3. If :math:`c` is non-zero, then:
 
-   a. :ref:`Enter <exec-instr-seq-enter>` the block :math:`\val^m~\instr_1^\ast` with label :math:`L`.
+   a. Execute the block instruction :math:`\BLOCK~\X{bt}~\instr_1^\ast~\END`.
 
-9. Else:
+4. Else:
 
-   a. :ref:`Enter <exec-instr-seq-enter>` the block :math:`\val^m~\instr_2^\ast` with label :math:`L`.
+   a. Execute the block instruction :math:`\BLOCK~\X{bt}~\instr_2^\ast~\END`.
 
 .. math::
    ~\\[-1ex]
    \begin{array}{lcl}
-   F; \val^m~(\I32.\CONST~c)~\IF~\X{bt}~\instr_1^\ast~\ELSE~\instr_2^\ast~\END &\stepto&
-     F; \LABEL_n\{\epsilon\}~\val^m~\instr_1^\ast~\END
-     \\&&\quad (\iff c \neq 0 \wedge \expand_F(\X{bt}) = [t_1^m] \to [t_2^n]) \\
-   F; \val^m~(\I32.\CONST~c)~\IF~\X{bt}~\instr_1^\ast~\ELSE~\instr_2^\ast~\END &\stepto&
-     F; \LABEL_n\{\epsilon\}~\val^m~\instr_2^\ast~\END
-     \\&&\quad (\iff c = 0 \wedge \expand_F(\X{bt}) = [t_1^m] \to [t_2^n]) \\
+   F; (\I32.\CONST~c)~\IF~\X{bt}~\instr_1^\ast~\ELSE~\instr_2^\ast~\END &\stepto&
+     F; \BLOCK~\X{bt}~\instr_1^\ast~\END
+     \\&&\quad (\iff c \neq 0) \\
+   F; (\I32.\CONST~c)~\IF~\X{bt}~\instr_1^\ast~\ELSE~\instr_2^\ast~\END &\stepto&
+     F; \BLOCK~\X{bt}~\instr_2^\ast~\END
+     \\&&\quad (\iff c = 0) \\
    \end{array}
 
 

From 14e97f56648d3d0f4bca76cad5cfc0fdfd482bbf Mon Sep 17 00:00:00 2001
From: Ian Henderson <ian@ianhenderson.org>
Date: Wed, 10 Aug 2022 23:17:33 -0700
Subject: [PATCH 181/285] [spec] Formatting tweak (#1519)

---
 document/core/binary/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/binary/instructions.rst b/document/core/binary/instructions.rst
index abd4ee5c0..e13a03236 100644
--- a/document/core/binary/instructions.rst
+++ b/document/core/binary/instructions.rst
@@ -614,7 +614,7 @@ All other vector instructions are plain opcodes without any immediates.
      \hex{FD}~~216{:}\Bu32 &\Rightarrow& \I64X2.\VLT\K{\_s} \\ &&|&
      \hex{FD}~~217{:}\Bu32 &\Rightarrow& \I64X2.\VGT\K{\_s} \\ &&|&
      \hex{FD}~~218{:}\Bu32 &\Rightarrow& \I64X2.\VLE\K{\_s} \\ &&|&
-     \hex{FD}~~219{:}\Bu32 &\Rightarrow& \I64X2.\VGE\K{\_s} \\ &&|&
+     \hex{FD}~~219{:}\Bu32 &\Rightarrow& \I64X2.\VGE\K{\_s} \\
    \end{array}
 
 .. _binary-vfrelop:

From ceecbe413af65c0a46be591ebacad62e307e7134 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Thu, 11 Aug 2022 15:33:25 +0200
Subject: [PATCH 182/285] [spec] Fix typing rule in appendix (#1516)

---
 document/core/appendix/index-rules.rst |  2 +-
 document/core/appendix/properties.rst  | 28 ++++++++++++++++----------
 2 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/document/core/appendix/index-rules.rst b/document/core/appendix/index-rules.rst
index 0da084123..8fa955d19 100644
--- a/document/core/appendix/index-rules.rst
+++ b/document/core/appendix/index-rules.rst
@@ -55,7 +55,7 @@ Construct                                        Judgement
 :ref:`Table instance <valid-tableinst>`          :math:`S \vdashtableinst \tableinst : \tabletype`
 :ref:`Memory instance <valid-meminst>`           :math:`S \vdashmeminst \meminst : \memtype`
 :ref:`Global instance <valid-globalinst>`        :math:`S \vdashglobalinst \globalinst : \globaltype`
-:ref:`Element instance <valid-eleminst>`         :math:`S \vdasheleminst \eleminst \ok`
+:ref:`Element instance <valid-eleminst>`         :math:`S \vdasheleminst \eleminst : t`
 :ref:`Data instance <valid-datainst>`            :math:`S \vdashdatainst \datainst \ok`
 :ref:`Export instance <valid-exportinst>`        :math:`S \vdashexportinst \exportinst \ok`
 :ref:`Module instance <valid-moduleinst>`        :math:`S \vdashmoduleinst \moduleinst : C`
diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index 72251114e..364b5f04a 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -87,7 +87,7 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 
 * Each :ref:`global instance <syntax-globalinst>` :math:`\globalinst_i` in :math:`S.\SGLOBALS` must be :ref:`valid <valid-globalinst>` with some  :ref:`global type <syntax-globaltype>` :math:`\globaltype_i`.
 
-* Each :ref:`element instance <syntax-eleminst>` :math:`\eleminst_i` in :math:`S.\SELEMS` must be :ref:`valid <valid-eleminst>`.
+* Each :ref:`element instance <syntax-eleminst>` :math:`\eleminst_i` in :math:`S.\SELEMS` must be :ref:`valid <valid-eleminst>` with some :ref:`reference type <syntax-reftype>` :math:`\reftype_i`.
 
 * Each :ref:`data instance <syntax-datainst>` :math:`\datainst_i` in :math:`S.\SDATAS` must be :ref:`valid <valid-datainst>`.
 
@@ -105,7 +105,7 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
      \qquad
      (S \vdashglobalinst \globalinst : \globaltype)^\ast
      \\
-     (S \vdasheleminst \eleminst \ok)^\ast
+     (S \vdasheleminst \eleminst : \reftype)^\ast
      \qquad
      (S \vdashdatainst \datainst \ok)^\ast
      \\
@@ -285,13 +285,13 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 
   * The :ref:`reference <syntax-ref>` :math:`\reff_i` must be :ref:`valid <valid-ref>` with :ref:`reference type <syntax-reftype>` :math:`t`.
 
-* Then the table instance is valid.
+* Then the element instance is valid with :ref:`reference type <syntax-reftype>` :math:`t`.
 
 .. math::
    \frac{
      (S \vdash \reff : t)^\ast
    }{
-     S \vdasheleminst \{ \EITYPE~t, \EIELEM~\reff^\ast \} \ok
+     S \vdasheleminst \{ \EITYPE~t, \EIELEM~\reff^\ast \} : t
    }
 
 
@@ -344,7 +344,7 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 
 * For each :ref:`global address <syntax-globaladdr>` :math:`\globaladdr_i` in :math:`\moduleinst.\MIGLOBALS`, the :ref:`external value <syntax-externval>` :math:`\EVGLOBAL~\globaladdr_i` must be :ref:`valid <valid-externval-global>` with some :ref:`external type <syntax-externtype>` :math:`\ETGLOBAL~\globaltype_i`.
 
-* For each :ref:`element address <syntax-elemaddr>` :math:`\elemaddr_i` in :math:`\moduleinst.\MIELEMS`, the :ref:`element instance <syntax-eleminst>` :math:`S.\SELEMS[\elemaddr_i]` must be :ref:`valid <valid-eleminst>`.
+* For each :ref:`element address <syntax-elemaddr>` :math:`\elemaddr_i` in :math:`\moduleinst.\MIELEMS`, the :ref:`element instance <syntax-eleminst>` :math:`S.\SELEMS[\elemaddr_i]` must be :ref:`valid <valid-eleminst>` with some :ref:`reference type <syntax-reftype>` :math:`\reftype_i`.
 
 * For each :ref:`data address <syntax-dataaddr>` :math:`\dataaddr_i` in :math:`\moduleinst.\MIDATAS`, the :ref:`data instance <syntax-datainst>` :math:`S.\SDATAS[\dataaddr_i]` must be :ref:`valid <valid-datainst>`.
 
@@ -360,8 +360,12 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 
 * Let :math:`\globaltype^\ast` be the concatenation of all :math:`\globaltype_i` in order.
 
-* | Then the module instance is valid with :ref:`context <context>`
-  | :math:`\{\CTYPES~\functype^\ast, \CFUNCS~{\functype'}^\ast, \CTABLES~\tabletype^\ast, \CMEMS~\memtype^\ast, \CGLOBALS~\globaltype^\ast\}`.
+* Let :math:`\reftype^\ast` be the concatenation of all :math:`\reftype_i` in order.
+
+* Let :math:`n` be the length of :math:`\moduleinst.\MIDATAS`.
+
+* Then the module instance is valid with :ref:`context <context>`
+  :math:`\{\CTYPES~\functype^\ast,` :math:`\CFUNCS~{\functype'}^\ast,` :math:`\CTABLES~\tabletype^\ast,` :math:`\CMEMS~\memtype^\ast,` :math:`\CGLOBALS~\globaltype^\ast,` :math:`\CELEMS~\reftype^\ast,` :math:`\CDATAS~{\ok}^n\}`.
 
 .. math::
    ~\\[-1ex]
@@ -377,9 +381,9 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
      \qquad
      (S \vdashexternval \EVGLOBAL~\globaladdr : \ETGLOBAL~\globaltype)^\ast
      \\
-     (S \vdasheleminst S.\SELEMS[\elemaddr] \ok)^\ast
+     (S \vdasheleminst S.\SELEMS[\elemaddr] : \reftype)^\ast
      \qquad
-     (S \vdashdatainst S.\SDATAS[\dataaddr] \ok)^\ast
+     (S \vdashdatainst S.\SDATAS[\dataaddr] \ok)^n
      \\
      (S \vdashexportinst \exportinst \ok)^\ast
      \qquad
@@ -394,14 +398,16 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
        \MIMEMS & \memaddr^\ast, \\
        \MIGLOBALS & \globaladdr^\ast, \\
        \MIELEMS & \elemaddr^\ast, \\
-       \MIDATAS & \dataaddr^\ast, \\
+       \MIDATAS & \dataaddr^n, \\
        \MIEXPORTS & \exportinst^\ast ~\} : \{
          \begin{array}[t]{@{}l@{~}l@{}}
          \CTYPES & \functype^\ast, \\
          \CFUNCS & {\functype'}^\ast, \\
          \CTABLES & \tabletype^\ast, \\
          \CMEMS & \memtype^\ast, \\
-         \CGLOBALS & \globaltype^\ast ~\}
+         \CGLOBALS & \globaltype^\ast, \\
+         \CELEMS & \reftype^\ast, \\
+         \CDATAS & {\ok}^n ~\}
          \end{array}
        \end{array}
    }

From 399677387ea866294e292d4175411f8570797f53 Mon Sep 17 00:00:00 2001
From: Tom Stuart <hi@tomstu.art>
Date: Tue, 23 Aug 2022 09:55:53 +0100
Subject: [PATCH 183/285] =?UTF-8?q?[spec]=20Fix=20=E2=80=9Cinvertible?=
 =?UTF-8?q?=E2=80=9D=20typo=20(#1520)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 document/core/exec/numerics.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/exec/numerics.rst b/document/core/exec/numerics.rst
index c7050b17d..71dfef6a9 100644
--- a/document/core/exec/numerics.rst
+++ b/document/core/exec/numerics.rst
@@ -177,7 +177,7 @@ When a number is stored into :ref:`memory <syntax-mem>`, it is converted into a
    \littleendian(d^8~{d'}^\ast~) &=& \littleendian({d'}^\ast)~\ibits_8^{-1}(d^8) \\
    \end{array}
 
-Again these functions are invertable bijections.
+Again these functions are invertible bijections.
 
 
 .. index:: numeric vectors, shape

From 429b2e30a0e3decb2b77fa1bf9250f6f0b31ae17 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Thu, 25 Aug 2022 18:36:53 +0200
Subject: [PATCH 184/285] [spec] Correct use of opdtype and stacktype (#1524)

---
 document/core/valid/instructions.rst | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 2676905ff..6ed7b429c 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -48,7 +48,7 @@ This is extended to stack types in a point-wise manner.
    consuming two |I32| values and producing one.
 
 Typing extends to :ref:`instruction sequences <valid-instr-seq>` :math:`\instr^\ast`.
-Such a sequence has a :ref:`function type <syntax-functype>` :math:`[t_1^\ast] \to [t_2^\ast]` if the accumulative effect of executing the instructions is consuming values of types :math:`t_1^\ast` off the operand stack and pushing new values of types :math:`t_2^\ast`.
+Such a sequence has a :ref:`stack type <syntax-stacktype>` :math:`[t_1^\ast] \to [t_2^\ast]` if the accumulative effect of executing the instructions is consuming values of types :math:`t_1^\ast` off the operand stack and pushing new values of types :math:`t_2^\ast`.
 
 .. _polymorphism:
 
@@ -63,7 +63,7 @@ Two degrees of polymorphism can be distinguished:
 
 
 * *stack-polymorphic*:
-  the entire (or most of the) :ref:`function type <syntax-functype>` :math:`[t_1^\ast] \to [t_2^\ast]` of the instruction is unconstrained.
+  the entire (or most of the) :ref:`stack type <syntax-stacktype>` :math:`[t_1^\ast] \to [t_2^\ast]` of the instruction is unconstrained.
   That is the case for all :ref:`control instructions <valid-instr-control>` that perform an *unconditional control transfer*, such as |UNREACHABLE|, |BR|, |BRTABLE|, and |RETURN|.
 
 In both cases, the unconstrained types or type sequences can be chosen arbitrarily, as long as they meet the constraints imposed for the surrounding parts of the program.
@@ -81,7 +81,7 @@ In both cases, the unconstrained types or type sequences can be chosen arbitrari
 
    are valid, with :math:`t` in the typing of |SELECT| being instantiated to |I32| or |F64|, respectively.
 
-   The |UNREACHABLE| instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]` for any possible sequences of value types :math:`t_1^\ast` and :math:`t_2^\ast`.
+   The |UNREACHABLE| instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]` for any possible sequences of :ref:`operand types <syntax-opdtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
    Consequently,
 
    .. math::
@@ -258,7 +258,7 @@ Reference Instructions
 Vector Instructions
 ~~~~~~~~~~~~~~~~~~~
 
-Vector instructions can have a prefix to describe the :ref:`shape <syntax-vec-shape>` of the operand. Packed numeric types, |I8| and |I16|, are not :ref:`value type <syntax-valtype>`, we define an auxiliary function to map such packed types into value types:
+Vector instructions can have a prefix to describe the :ref:`shape <syntax-vec-shape>` of the operand. Packed numeric types, |I8| and |I16|, are not :ref:`value types <syntax-valtype>`. An auxiliary function maps such packed types to value types:
 
 .. math::
    \begin{array}{lll@{\qquad}l}
@@ -598,7 +598,7 @@ Parametric Instructions
 :math:`\DROP`
 .............
 
-* The instruction is valid with type :math:`[t] \to []`, for any :ref:`value type <syntax-valtype>` :math:`t`.
+* The instruction is valid with type :math:`[t] \to []`, for any :ref:`operand type <syntax-opdtype>` :math:`t`.
 
 .. math::
    \frac{
@@ -1262,7 +1262,7 @@ Control Instructions
 :math:`\UNREACHABLE`
 ....................
 
-* The instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
+* The instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`, for any sequences of :ref:`operand types <syntax-opdtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
 .. math::
    \frac{
@@ -1369,7 +1369,7 @@ Control Instructions
 
 * Let :math:`[t^\ast]` be the :ref:`result type <syntax-resulttype>` :math:`C.\CLABELS[l]`.
 
-* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
+* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`, for any sequences of :ref:`operand types <syntax-opdtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
 .. math::
    \frac{
@@ -1417,14 +1417,14 @@ Control Instructions
 * For all :math:`l_i` in :math:`l^\ast`,
   the label :math:`C.\CLABELS[l_i]` must be defined in the context.
 
-* There must be a :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`, such that:
+* There must be a sequence :math:`t^\ast` of :ref:`operand types <syntax-opdtype>`, such that:
 
   * For each :ref:`operand type <syntax-opdtype>` :math:`t_j` in :math:`t^\ast` and corresponding type :math:`t'_{Nj}` in :math:`C.\CLABELS[l_N]`, :math:`t_j` :ref:`matches <match-opdtype>` :math:`t'_{Nj}`.
 
   * For all :math:`l_i` in :math:`l^\ast`,
     and for each :ref:`operand type <syntax-opdtype>` :math:`t_j` in :math:`t^\ast` and corresponding type :math:`t'_{ij}` in :math:`C.\CLABELS[l_i]`, :math:`t_j` :ref:`matches <match-opdtype>` :math:`t'_{ij}`.
 
-* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast~\I32] \to [t_2^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
+* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast~\I32] \to [t_2^\ast]`, for any sequences of :ref:`operand types <syntax-opdtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
 .. math::
    \frac{
@@ -1450,7 +1450,7 @@ Control Instructions
 
 * Let :math:`[t^\ast]` be the :ref:`result type <syntax-resulttype>` of :math:`C.\CRETURN`.
 
-* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
+* Then the instruction is valid with type :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`, for any sequences of :ref:`operand types <syntax-opdtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
 .. math::
    \frac{
@@ -1537,12 +1537,12 @@ Non-empty Instruction Sequence: :math:`\instr^\ast~\instr_N`
 ............................................................
 
 * The instruction sequence :math:`\instr^\ast` must be valid with type :math:`[t_1^\ast] \to [t_2^\ast]`,
-  for some sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
+  for some sequences of :ref:`operand types <syntax-opdtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
 * The instruction :math:`\instr_N` must be valid with type :math:`[t^\ast] \to [t_3^\ast]`,
-  for some sequences of :ref:`value types <syntax-valtype>` :math:`t^\ast` and :math:`t_3^\ast`.
+  for some sequences of :ref:`operand types <syntax-opdtype>` :math:`t^\ast` and :math:`t_3^\ast`.
 
-* There must be a sequence of :ref:`value types <syntax-valtype>` :math:`t_0^\ast`,
+* There must be a sequence of :ref:`operand types <syntax-opdtype>` :math:`t_0^\ast`,
   such that :math:`t_2^\ast = t_0^\ast~{t'}^\ast` where the type sequence :math:`{t'}^\ast` is as long as :math:`t^\ast`.
 
 * For each :ref:`operand type <syntax-opdtype>` :math:`t'_i` in :math:`{t'}^\ast` and corresponding type :math:`t_i` in :math:`t^\ast`, :math:`t'_i` :ref:`matches <match-opdtype>` :math:`t_i`.

From 550e79de20091cb5ed7faade2962c06799915f2c Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Thu, 25 Aug 2022 20:53:40 +0200
Subject: [PATCH 185/285] [spec] Add note to instruction index (#1528)

---
 document/core/appendix/gen-index-instructions.py | 9 +++++++++
 document/core/appendix/index-instructions.rst    | 5 +++++
 2 files changed, 14 insertions(+)

diff --git a/document/core/appendix/gen-index-instructions.py b/document/core/appendix/gen-index-instructions.py
index 2b61b5508..65a971715 100755
--- a/document/core/appendix/gen-index-instructions.py
+++ b/document/core/appendix/gen-index-instructions.py
@@ -21,6 +21,14 @@
 ---------------------
 """
 
+FOOTER = """\
+
+.. note::
+   Multi-byte opcodes are given with the shortest possible encoding in the table.
+   However, what is following the first byte is actually a :ref:`u32 <binary-uint>` with variable-length encoding
+   and consequently has multiple possible representations.\
+"""
+
 COLUMNS = [
     'Instruction',
     'Binary Opcode',
@@ -591,3 +599,4 @@ def Row(columns):
           print(Row(instr), file=f)
 
         print(DIVIDER, file=f)
+        print(FOOTER, file=f)
diff --git a/document/core/appendix/index-instructions.rst b/document/core/appendix/index-instructions.rst
index 0636a4266..84055a9fa 100644
--- a/document/core/appendix/index-instructions.rst
+++ b/document/core/appendix/index-instructions.rst
@@ -516,3 +516,8 @@ Instruction                                        Binary Opcode
 :math:`\F64X2.\VCONVERT\K{\_low\_i32x4\_s}`        :math:`\hex{FD}~~\hex{FE}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_s>`    
 :math:`\F64X2.\VCONVERT\K{\_low\_i32x4\_u}`        :math:`\hex{FD}~~\hex{FF}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_u>`    
 =================================================  ====================================  =============================================  =============================================  ==================================================================
+
+.. note::
+   Multi-byte opcodes are given with the shortest possible encoding in the table.
+   However, what is following the first byte is actually a :ref:`u32 <binary-uint>` with variable-length encoding
+   and consequently has multiple possible representations.

From 2b194cef87ba7f71c187b063a2ff8fea878e900a Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 25 Aug 2022 23:37:21 +0200
Subject: [PATCH 186/285] Add type annotation to call_ref (#76)

---
 .../core/appendix/gen-index-instructions.py   |   2 +-
 document/core/appendix/index-instructions.rst |   2 +-
 document/core/binary/instructions.rst         |   6 +-
 document/core/exec/instructions.rst           |   6 +-
 document/core/syntax/instructions.rst         |   2 +-
 document/core/text/instructions.rst           |   2 +-
 document/core/valid/instructions.rst          |  10 +-
 interpreter/binary/decode.ml                  |   4 +-
 interpreter/binary/encode.ml                  |   4 +-
 interpreter/exec/eval.ml                      |  10 +-
 interpreter/syntax/ast.ml                     |   4 +-
 interpreter/syntax/free.ml                    |   3 +-
 interpreter/syntax/operators.ml               |   4 +-
 interpreter/text/arrange.ml                   |   4 +-
 interpreter/text/parser.mly                   |   4 +-
 interpreter/valid/valid.ml                    |  38 ++-----
 proposals/function-references/Overview.md     |  24 ++--
 test/core/br_on_non_null.wast                 |   8 +-
 test/core/br_on_null.wast                     |   8 +-
 test/core/call_ref.wast                       |  36 +++---
 test/core/ref_as_non_null.wast                |   4 +-
 test/core/return_call_ref.wast                | 104 ++++++++++--------
 22 files changed, 148 insertions(+), 141 deletions(-)

diff --git a/document/core/appendix/gen-index-instructions.py b/document/core/appendix/gen-index-instructions.py
index 2f2a91759..77c2c0197 100755
--- a/document/core/appendix/gen-index-instructions.py
+++ b/document/core/appendix/gen-index-instructions.py
@@ -81,7 +81,7 @@ def Instruction(name, opcode, type=None, validation=None, execution=None, operat
     Instruction(r'\CALLINDIRECT~x~y', r'\hex{11}', r'[t_1^\ast~\I32] \to [t_2^\ast]', r'valid-call_indirect', r'exec-call_indirect'),
     Instruction(None, r'\hex{12}'),
     Instruction(None, r'\hex{13}'),
-    Instruction(r'\CALLREF', r'\hex{14}', r'[t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]', r'valid-call_ref', r'exec-call_ref'),
+    Instruction(r'\CALLREF~x', r'\hex{14}', r'[t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]', r'valid-call_ref', r'exec-call_ref'),
     Instruction(None, r'\hex{15}'),
     Instruction(None, r'\hex{16}'),
     Instruction(None, r'\hex{17}'),
diff --git a/document/core/appendix/index-instructions.rst b/document/core/appendix/index-instructions.rst
index 67ffce6ba..38f32d94f 100644
--- a/document/core/appendix/index-instructions.rst
+++ b/document/core/appendix/index-instructions.rst
@@ -29,7 +29,7 @@ Instruction                                        Binary Opcode
 :math:`\CALLINDIRECT~x~y`                          :math:`\hex{11}`                      :math:`[t_1^\ast~\I32] \to [t_2^\ast]`                           :ref:`validation <valid-call_indirect>`        :ref:`execution <exec-call_indirect>`                             
 (reserved)                                         :math:`\hex{12}`                                                                                                                                                                                                        
 (reserved)                                         :math:`\hex{13}`                                                                                                                                                                                                        
-:math:`\CALLREF`                                   :math:`\hex{14}`                      :math:`[t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]`                 :ref:`validation <valid-call_ref>`             :ref:`execution <exec-call_ref>`                                  
+:math:`\CALLREF~x`                                 :math:`\hex{14}`                      :math:`[t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]`                 :ref:`validation <valid-call_ref>`             :ref:`execution <exec-call_ref>`                                  
 (reserved)                                         :math:`\hex{15}`                                                                                                                                                                                                        
 (reserved)                                         :math:`\hex{16}`                                                                                                                                                                                                        
 (reserved)                                         :math:`\hex{17}`                                                                                                                                                                                                        
diff --git a/document/core/binary/instructions.rst b/document/core/binary/instructions.rst
index 7f3f9019f..e2f913cb9 100644
--- a/document/core/binary/instructions.rst
+++ b/document/core/binary/instructions.rst
@@ -66,9 +66,9 @@ Control Instructions
      \hex{0F} &\Rightarrow& \RETURN \\ &&|&
      \hex{10}~~x{:}\Bfuncidx &\Rightarrow& \CALL~x \\ &&|&
      \hex{11}~~y{:}\Btypeidx~~x{:}\Btableidx &\Rightarrow& \CALLINDIRECT~x~y \\ &&|&
-     \hex{14} &\Rightarrow& \CALLREF \\ &&|&
-     \hex{D4}~~x{:}\Bfuncidx &\Rightarrow& \BRONNULL \\ &&|&
-     \hex{D6}~~x{:}\Bfuncidx &\Rightarrow& \BRONNONNULL \\
+     \hex{14}~~x{:}\Btypeidx &\Rightarrow& \CALLREF~x \\ &&|&
+     \hex{D4}~~l{:}\Blabelidx &\Rightarrow& \BRONNULL~l \\ &&|&
+     \hex{D6}~~l{:}\Blabelidx &\Rightarrow& \BRONNONNULL~l \\
    \end{array}
 
 .. note::
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index d708b436a..ee37c00b5 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -2837,8 +2837,8 @@ Control Instructions
 
 .. _exec-call_ref:
 
-:math:`\CALLREF`
-................
+:math:`\CALLREF~x`
+..................
 
 1. Assert: due to :ref:`validation <valid-call_ref>`, a :ref:`function reference <syntax-ref>` is on the top of the stack.
 
@@ -2848,7 +2848,7 @@ Control Instructions
 
 .. math::
    \begin{array}{lcl@{\qquad}l}
-   F; (\REFFUNCADDR~a)~\CALLREF &\stepto& F; (\INVOKE~a)
+   F; (\REFFUNCADDR~a)~\CALLREF~x &\stepto& F; (\INVOKE~a)
    \end{array}
 
 
diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index c394bae56..4cde34c33 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -648,7 +648,7 @@ Instructions in this group affect the flow of control.
      \BRONNONNULL~\labelidx \\&&|&
      \RETURN \\&&|&
      \CALL~\funcidx \\&&|&
-     \CALLREF \\&&|&
+     \CALLREF~\typeidx \\&&|&
      \CALLINDIRECT~\tableidx~\typeidx \\
    \end{array}
 
diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index a1a7e34b2..8b48c2c15 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -117,7 +117,7 @@ All other control instruction are represented verbatim.
      \text{br\_on\_non\_null}~~l{:}\Tlabelidx_I &\Rightarrow& \BRONNONNULL~l \\ &&|&
      \text{return} &\Rightarrow& \RETURN \\ &&|&
      \text{call}~~x{:}\Tfuncidx_I &\Rightarrow& \CALL~x \\ &&|&
-     \text{call\_ref} &\Rightarrow& \CALLREF \\ &&|&
+     \text{call\_ref}~~x{:}\Ttypeidx &\Rightarrow& \CALLREF~x \\ &&|&
      \text{call\_indirect}~~x{:}\Ttableidx~~y,I'{:}\Ttypeuse_I &\Rightarrow& \CALLINDIRECT~x~y
        & (\iff I' = \{\ILOCALS~(\epsilon)^\ast\}) \\
    \end{array}
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index d9dc84535..b5cb94b92 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -1538,10 +1538,12 @@ Control Instructions
 
 .. _valid-call_ref:
 
-:math:`\CALLREF`
-................
+:math:`\CALLREF~x`
+..................
+
+* The type :math:`C.\CTYPES[x]` must be defined in the context.
 
-* Let :math:`x` be some :ref:`type index <syntax-typeidx>` for which :math:`C.\CTYPES[x]` is a :ref:`function type <syntax-functype>` of the form :math:`[t_1^\ast] \to [t_2^\ast]`.
+* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[x]`.
 
 * Then the instruction is valid with type :math:`[t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]`.
 
@@ -1549,7 +1551,7 @@ Control Instructions
    \frac{
      C.\CTYPES[x] = [t_1^\ast] \to [t_2^\ast]
    }{
-     C \vdashinstr \CALLREF : [t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]
+     C \vdashinstr \CALLREF~x : [t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]
    }
 
 
diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 29d318e26..fdc128bf1 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -318,8 +318,8 @@ let rec instr s =
 
   | 0x12 | 0x13 as b -> illegal s pos b  (* return_call, return_call_indirect *)
 
-  | 0x14 -> call_ref
-  | 0x15 -> return_call_ref
+  | 0x14 -> call_ref (at var s)
+  | 0x15 -> return_call_ref (at var s)
 
   | 0x16 as b -> illegal s pos b
 
diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index 60ed152b1..139dbcd0b 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -197,9 +197,9 @@ struct
     | BrOnNonNull x -> op 0xd6; var x
     | Return -> op 0x0f
     | Call x -> op 0x10; var x
-    | CallRef -> op 0x14
+    | CallRef x -> op 0x14; var x
     | CallIndirect (x, y) -> op 0x11; var y; var x
-    | ReturnCallRef -> op 0x15
+    | ReturnCallRef x -> op 0x15; var x
 
     | Drop -> op 0x1a
     | Select None -> op 0x1b
diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index 5e9231abb..c67d467af 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -222,10 +222,10 @@ let rec step (c : config) : config =
       | Call x, vs ->
         vs, [Invoke (func c.frame.inst x) @@ e.at]
 
-      | CallRef, Ref (NullRef _) :: vs ->
+      | CallRef _x, Ref (NullRef _) :: vs ->
         vs, [Trapping "null function reference" @@ e.at]
 
-      | CallRef, Ref (FuncRef f) :: vs ->
+      | CallRef _x, Ref (FuncRef f) :: vs ->
         vs, [Invoke f @@ e.at]
 
       | CallIndirect (x, y), Num (I32 i) :: vs ->
@@ -237,11 +237,11 @@ let rec step (c : config) : config =
         else
           vs, [Trapping "indirect call type mismatch" @@ e.at]
 
-      | ReturnCallRef, Ref (NullRef _) :: vs ->
+      | ReturnCallRef _x, Ref (NullRef _) :: vs ->
         vs, [Trapping "null function reference" @@ e.at]
 
-      | ReturnCallRef, vs ->
-        (match (step {c with code = (vs, [Plain CallRef @@ e.at])}).code with
+      | ReturnCallRef x, vs ->
+        (match (step {c with code = (vs, [Plain (CallRef x) @@ e.at])}).code with
         | vs', [{it = Invoke a; at}] -> vs', [ReturningInvoke (vs', a) @@ at]
         | vs', [{it = Trapping s; at}] -> vs', [Trapping s @@ at]
         | _ -> assert false
diff --git a/interpreter/syntax/ast.ml b/interpreter/syntax/ast.ml
index bbe17c6f1..421cf1038 100644
--- a/interpreter/syntax/ast.ml
+++ b/interpreter/syntax/ast.ml
@@ -153,9 +153,9 @@ and instr' =
   | BrOnNonNull of idx                (* break on non-null *)
   | Return                            (* break from function body *)
   | Call of idx                       (* call function *)
-  | CallRef                           (* call function through reference *)
+  | CallRef of idx                    (* call function through reference *)
   | CallIndirect of idx * idx         (* call function through table *)
-  | ReturnCallRef                     (* tail call through reference *)
+  | ReturnCallRef of idx              (* tail call through reference *)
   | LocalGet of idx                   (* read local idxiable *)
   | LocalSet of idx                   (* write local idxiable *)
   | LocalTee of idx                   (* write local idxiable and keep value *)
diff --git a/interpreter/syntax/free.ml b/interpreter/syntax/free.ml
index 764e08b25..41ee61378 100644
--- a/interpreter/syntax/free.ml
+++ b/interpreter/syntax/free.ml
@@ -108,8 +108,9 @@ let rec instr (e : instr) =
   | If (bt, es1, es2) -> block_type bt ++ block es1 ++ block es2
   | Br x | BrIf x | BrOnNull x | BrOnNonNull x -> labels (idx x)
   | BrTable (xs, x) -> list (fun x -> labels (idx x)) (x::xs)
-  | Return | CallRef | ReturnCallRef -> empty
+  | Return -> empty
   | Call x -> funcs (idx x)
+  | CallRef x | ReturnCallRef x -> types (idx x)
   | CallIndirect (x, y) -> tables (idx x) ++ types (idx y)
   | LocalGet x | LocalSet x | LocalTee x -> locals (idx x)
   | GlobalGet x | GlobalSet x -> globals (idx x)
diff --git a/interpreter/syntax/operators.ml b/interpreter/syntax/operators.ml
index ecc86a9ba..5712b6a05 100644
--- a/interpreter/syntax/operators.ml
+++ b/interpreter/syntax/operators.ml
@@ -32,9 +32,9 @@ let br_on_non_null x = BrOnNonNull x
 
 let return = Return
 let call x = Call x
-let call_ref = CallRef
+let call_ref x = CallRef x
 let call_indirect x y = CallIndirect (x, y)
-let return_call_ref = ReturnCallRef
+let return_call_ref x = ReturnCallRef x
 
 let local_get x = LocalGet x
 let local_set x = LocalSet x
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index 027dcde7d..1dd877b82 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -456,10 +456,10 @@ let rec instr e =
     | BrOnNonNull x -> "br_on_non_null " ^ var x, []
     | Return -> "return", []
     | Call x -> "call " ^ var x, []
-    | CallRef -> "call_ref", []
+    | CallRef x -> "call_ref " ^ var x, []
     | CallIndirect (x, y) ->
       "call_indirect " ^ var x, [Node ("type " ^ var y, [])]
-    | ReturnCallRef -> "return_call_ref", []
+    | ReturnCallRef x -> "return_call_ref " ^ var x, []
     | LocalGet x -> "local.get " ^ var x, []
     | LocalSet x -> "local.set " ^ var x, []
     | LocalTee x -> "local.tee " ^ var x, []
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index 1bf13ff20..0e687622a 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -447,8 +447,8 @@ plain_instr :
   | BR_ON_NON_NULL var { fun c -> br_on_non_null ($2 c label) }
   | RETURN { fun c -> return }
   | CALL var { fun c -> call ($2 c func) }
-  | CALL_REF { fun c -> call_ref }
-  | RETURN_CALL_REF { fun c -> return_call_ref }
+  | CALL_REF var { fun c -> call_ref ($2 c type_) }
+  | RETURN_CALL_REF var { fun c -> return_call_ref ($2 c type_) }
   | LOCAL_GET var { fun c -> local_get ($2 c local) }
   | LOCAL_SET var { fun c -> local_set ($2 c local) }
   | LOCAL_TEE var { fun c -> local_tee ($2 c local) }
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index 9159037ff..eaa80959d 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -392,18 +392,9 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
     let FuncT (ts1, ts2) = func c x in
     ts1 --> ts2, []
 
-  | CallRef ->
-    (match peek_ref 0 s e.at with
-    | (_, DefHT x) ->
-      let FuncT (ts1, ts2) = func_type c (x @@ e.at) in
-      (ts1 @ [RefT (Null, DefHT x)]) --> ts2, []
-    | (_, BotHT) ->
-      [RefT (Null, BotHT)] -->... [], []
-    | rt ->
-      error e.at
-        ("type mismatch: instruction requires function reference type" ^
-         " but stack has " ^ string_of_val_type (RefT rt))
-    )
+  | CallRef x ->
+    let FuncT (ts1, ts2) = func_type c x in
+    (ts1 @ [RefT (Null, DefHT x.it)]) --> ts2, []
 
   | CallIndirect (x, y) ->
     let TableT (_lim, t) = table c x in
@@ -413,22 +404,13 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
        " but table has element type " ^ string_of_ref_type t);
     (ts1 @ [NumT I32T]) --> ts2, []
 
-  | ReturnCallRef ->
-    (match peek_ref 0 s e.at with
-    | (_, DefHT x) ->
-      let FuncT (ts1, ts2) = func_type c (x @@ e.at) in
-      require (match_result_type c.types [] ts2 c.results) e.at
-        ("type mismatch: current function requires result type " ^
-         string_of_result_type c.results ^
-         " but callee returns " ^ string_of_result_type ts2);
-      (ts1 @ [RefT (Null, DefHT x)]) -->... [], []
-    | (_, BotHT) ->
-      [RefT (Null, BotHT)] -->... [], []
-    | rt ->
-      error e.at
-        ("type mismatch: instruction requires function reference type" ^
-         " but stack has " ^ string_of_ref_type rt)
-    )
+  | ReturnCallRef x ->
+    let FuncT (ts1, ts2) = func_type c x in
+    require (match_result_type c.types [] ts2 c.results) e.at
+      ("type mismatch: current function requires result type " ^
+       string_of_result_type c.results ^
+       " but callee returns " ^ string_of_result_type ts2);
+    (ts1 @ [RefT (Null, DefHT x.it)]) -->... [], []
 
   | LocalGet x ->
     let LocalT (init, t) = local c x in
diff --git a/proposals/function-references/Overview.md b/proposals/function-references/Overview.md
index e3b93e9b9..08c537cde 100644
--- a/proposals/function-references/Overview.md
+++ b/proposals/function-references/Overview.md
@@ -48,7 +48,7 @@ The function `$hof` takes a function pointer as parameter, and is invoked by `$c
 (type $i32-i32 (func (param i32) (result i32)))
 
 (func $hof (param $f (ref $i32-i32)) (result i32)
-  (i32.add (i32.const 10) (call_ref (i32.const 42) (local.get $f)))
+  (i32.add (i32.const 10) (call_ref $i32-i32 (i32.const 42) (local.get $f)))
 )
 
 (func $inc (param $i i32) (result i32)
@@ -204,13 +204,13 @@ Note: Extending block types with index sets to allow initialization status to la
      - iff `$f : $t`
   - this is a *constant instruction*
 
-* `call_ref` calls a function through a reference
-  - `call_ref : [t1* (ref null $t)] -> [t2*]`
+* `call_ref <typeidx>` calls a function through a reference
+  - `call_ref $t : [t1* (ref null $t)] -> [t2*]`
      - iff `$t = [t1*] -> [t2*]`
   - traps on `null`
 
 * With the [tail call proposal](https://github.com/WebAssembly/tail-call/blob/master/proposals/tail-call/Overview.md), there will also be `return_call_ref`:
-  - `return_call_ref : [t1* (ref null $t)] -> [t2*]`
+  - `return_call_ref $t : [t1* (ref null $t)] -> [t2*]`
      - iff `$t = [t1*] -> [t2*]`
      - and `t2* <: C.result`
   - traps on `null`
@@ -218,7 +218,7 @@ Note: Extending block types with index sets to allow initialization status to la
 
 #### Optional References
 
-* `ref.null` is generalised to take a `<heaptype>` immediate
+* `ref.null <heaptype>` is generalised to take a `<heaptype>` immediate
   - `ref.null ht: [] -> [(ref null ht)]`
     - iff `ht ok`
 
@@ -227,13 +227,13 @@ Note: Extending block types with index sets to allow initialization status to la
     - iff `ht ok`
   - traps on `null`
 
-* `br_on_null $l` checks for null and branches if present
+* `br_on_null <labelidx>` checks for null and branches if present
   - `br_on_null $l : [t* (ref null ht)] -> [t* (ref ht)]`
     - iff `$l : [t*]`
     - and `ht ok`
   - branches to `$l` on `null`, otherwise returns operand as non-null
 
-* `br_on_non_null $l` checks for null and branches if not present
+* `br_on_non_null <labelidx>` checks for null and branches if not present
   - `br_on_non_null $l : [t* (ref null ht)] -> [t*]`
     - iff `$l : [t* (ref ht)]`
     - and `ht ok`
@@ -246,15 +246,15 @@ Note: Extending block types with index sets to allow initialization status to la
 
 Typing of local instructions is updated to account for the initialization status of locals.
 
-* `local.get $x`
+* `local.get <localidx>`
   - `local.get $x : [] -> [t]`
     - iff `$x : set t`
 
-* `local.set $x`
+* `local.set <localidx>`
   - `local.set $x : [t] -> [] $x`
     - iff `$x : set? t`
 
-* `local.tee $x`
+* `local.tee <localidx>`
   - `local.tee $x : [t] -> [t] $x`
     - iff `$x : set? t`
 
@@ -319,8 +319,8 @@ The opcode for heap types is encoded as an `s33`.
 
 | Opcode | Instruction              | Immediates |
 | ------ | ------------------------ | ---------- |
-| 0x14   | `call_ref`               |            |
-| 0x15   | `return_call_ref`        |            |
+| 0x14   | `call_ref $t`            | `$t : u32` |
+| 0x15   | `return_call_ref $t`     | `$t : u32` |
 | 0xd3   | `ref.as_non_null`        |            |
 | 0xd4   | `br_on_null $l`          | `$l : u32` |
 | 0xd6   | `br_on_non_null $l`      | `$l : u32` |
diff --git a/test/core/br_on_non_null.wast b/test/core/br_on_non_null.wast
index 145b4f832..6cf7eff50 100644
--- a/test/core/br_on_non_null.wast
+++ b/test/core/br_on_non_null.wast
@@ -2,7 +2,7 @@
   (type $t (func (result i32)))
 
   (func $nn (param $r (ref $t)) (result i32)
-    (call_ref
+    (call_ref $t
       (block $l (result (ref $t))
         (br_on_non_null $l (local.get $r))
         (return (i32.const -1))
@@ -10,7 +10,7 @@
     )
   )
   (func $n (param $r (ref null $t)) (result i32)
-    (call_ref
+    (call_ref $t
       (block $l (result (ref $t))
         (br_on_non_null $l (local.get $r))
         (return (i32.const -1))
@@ -27,7 +27,7 @@
 
   (func (export "unreachable") (result i32)
     (block $l
-      (return (call_ref (br_on_null $l (unreachable))))
+      (return (call_ref $t (br_on_null $l (unreachable))))
     )
     (i32.const -1)
   )
@@ -53,7 +53,7 @@
   (func $f (param i32) (result i32) (i32.mul (local.get 0) (local.get 0)))
 
   (func $a (param $n i32) (param $r (ref null $t)) (result i32)
-    (call_ref
+    (call_ref $t
       (block $l (result i32 (ref $t))
         (return (br_on_non_null $l (local.get $n) (local.get $r)))
       )
diff --git a/test/core/br_on_null.wast b/test/core/br_on_null.wast
index ec3471cce..c6505a3f7 100644
--- a/test/core/br_on_null.wast
+++ b/test/core/br_on_null.wast
@@ -3,13 +3,13 @@
 
   (func $nn (param $r (ref $t)) (result i32)
     (block $l
-      (return (call_ref (br_on_null $l (local.get $r))))
+      (return (call_ref $t (br_on_null $l (local.get $r))))
     )
     (i32.const -1)
   )
   (func $n (param $r (ref null $t)) (result i32)
     (block $l
-      (return (call_ref (br_on_null $l (local.get $r))))
+      (return (call_ref $t (br_on_null $l (local.get $r))))
     )
     (i32.const -1)
   )
@@ -23,7 +23,7 @@
 
   (func (export "unreachable") (result i32)
     (block $l
-      (return (call_ref (br_on_null $l (unreachable))))
+      (return (call_ref $t (br_on_null $l (unreachable))))
     )
     (i32.const -1)
   )
@@ -50,7 +50,7 @@
 
   (func $a (param $n i32) (param $r (ref null $t)) (result i32)
     (block $l (result i32)
-      (return (call_ref (br_on_null $l (local.get $n) (local.get $r))))
+      (return (call_ref $t (br_on_null $l (local.get $n) (local.get $r))))
     )
   )
 
diff --git a/test/core/call_ref.wast b/test/core/call_ref.wast
index 503c4e861..425339593 100644
--- a/test/core/call_ref.wast
+++ b/test/core/call_ref.wast
@@ -2,7 +2,7 @@
   (type $ii (func (param i32) (result i32)))
 
   (func $apply (param $f (ref $ii)) (param $x i32) (result i32)
-    (call_ref (local.get $x) (local.get $f))
+    (call_ref $ii (local.get $x) (local.get $f))
   )
 
   (func $f (type $ii) (i32.mul (local.get 0) (local.get 0)))
@@ -15,11 +15,11 @@
     (local $rg (ref null $ii))
     (local.set $rf (ref.func $f))
     (local.set $rg (ref.func $g))
-    (call_ref (call_ref (local.get $x) (local.get $rf)) (local.get $rg))
+    (call_ref $ii (call_ref $ii (local.get $x) (local.get $rf)) (local.get $rg))
   )
 
   (func (export "null") (result i32)
-    (call_ref (i32.const 1) (ref.null $ii))
+    (call_ref $ii (i32.const 1) (ref.null $ii))
   )
 
   ;; Recursion
@@ -36,7 +36,7 @@
       (else
         (i64.mul
           (local.get 0)
-          (call_ref (i64.sub (local.get 0) (i64.const 1)) (global.get $fac))
+          (call_ref $ll (i64.sub (local.get 0) (i64.const 1)) (global.get $fac))
         )
       )
     )
@@ -49,7 +49,7 @@
     (if (result i64) (i64.eqz (local.get 0))
       (then (local.get 1))
       (else
-        (call_ref
+        (call_ref $lll
           (i64.sub (local.get 0) (i64.const 1))
           (i64.mul (local.get 0) (local.get 1))
           (global.get $fac-acc)
@@ -66,8 +66,8 @@
       (then (i64.const 1))
       (else
         (i64.add
-          (call_ref (i64.sub (local.get 0) (i64.const 2)) (global.get $fib))
-          (call_ref (i64.sub (local.get 0) (i64.const 1)) (global.get $fib))
+          (call_ref $ll (i64.sub (local.get 0) (i64.const 2)) (global.get $fib))
+          (call_ref $ll (i64.sub (local.get 0) (i64.const 1)) (global.get $fib))
         )
       )
     )
@@ -80,13 +80,13 @@
   (func $even (export "even") (type $ll)
     (if (result i64) (i64.eqz (local.get 0))
       (then (i64.const 44))
-      (else (call_ref (i64.sub (local.get 0) (i64.const 1)) (global.get $odd)))
+      (else (call_ref $ll (i64.sub (local.get 0) (i64.const 1)) (global.get $odd)))
     )
   )
   (func $odd (export "odd") (type $ll)
     (if (result i64) (i64.eqz (local.get 0))
       (then (i64.const 99))
-      (else (call_ref (i64.sub (local.get 0) (i64.const 1)) (global.get $even)))
+      (else (call_ref $ll (i64.sub (local.get 0) (i64.const 1)) (global.get $even)))
     )
   )
 )
@@ -127,34 +127,37 @@
 ;; Unreachable typing.
 
 (module
+  (type $t (func))
   (func (export "unreachable") (result i32)
     (unreachable)
-    (call_ref)
+    (call_ref $t)
   )
 )
 (assert_trap (invoke "unreachable") "unreachable")
 
 (module
   (elem declare func $f)
+  (type $t (func (param i32) (result i32)))
   (func $f (param i32) (result i32) (local.get 0))
 
   (func (export "unreachable") (result i32)
     (unreachable)
     (ref.func $f)
-    (call_ref)
+    (call_ref $t)
   )
 )
 (assert_trap (invoke "unreachable") "unreachable")
 
 (module
   (elem declare func $f)
+  (type $t (func (param i32) (result i32)))
   (func $f (param i32) (result i32) (local.get 0))
 
   (func (export "unreachable") (result i32)
     (unreachable)
     (i32.const 0)
     (ref.func $f)
-    (call_ref)
+    (call_ref $t)
     (drop)
     (i32.const 0)
   )
@@ -164,13 +167,14 @@
 (assert_invalid
   (module
     (elem declare func $f)
+    (type $t (func (param i32) (result i32)))
     (func $f (param i32) (result i32) (local.get 0))
 
     (func (export "unreachable") (result i32)
       (unreachable)
       (i64.const 0)
       (ref.func $f)
-      (call_ref)
+      (call_ref $t)
     )
   )
   "type mismatch"
@@ -179,12 +183,13 @@
 (assert_invalid
   (module
     (elem declare func $f)
+    (type $t (func (param i32) (result i32)))
     (func $f (param i32) (result i32) (local.get 0))
 
     (func (export "unreachable") (result i32)
       (unreachable)
       (ref.func $f)
-      (call_ref)
+      (call_ref $t)
       (drop)
       (i64.const 0)
     )
@@ -194,8 +199,9 @@
 
 (assert_invalid
   (module
+    (type $t (func))
     (func $f (param $r externref)
-      (call_ref (local.get $r))
+      (call_ref $t (local.get $r))
     )
   )
   "type mismatch"
diff --git a/test/core/ref_as_non_null.wast b/test/core/ref_as_non_null.wast
index ba5c45470..6b3380fc5 100644
--- a/test/core/ref_as_non_null.wast
+++ b/test/core/ref_as_non_null.wast
@@ -2,10 +2,10 @@
   (type $t (func (result i32)))
 
   (func $nn (param $r (ref $t)) (result i32)
-    (call_ref (ref.as_non_null (local.get $r)))
+    (call_ref $t (ref.as_non_null (local.get $r)))
   )
   (func $n (param $r (ref null $t)) (result i32)
-    (call_ref (ref.as_non_null (local.get $r)))
+    (call_ref $t (ref.as_non_null (local.get $r)))
   )
 
   (elem func $f)
diff --git a/test/core/return_call_ref.wast b/test/core/return_call_ref.wast
index 8e7aac821..353811f03 100644
--- a/test/core/return_call_ref.wast
+++ b/test/core/return_call_ref.wast
@@ -59,48 +59,48 @@
   ;; Typing
 
   (func (export "type-i32") (result i32)
-    (return_call_ref (global.get $const-i32))
+    (return_call_ref $-i32 (global.get $const-i32))
   )
   (func (export "type-i64") (result i64)
-    (return_call_ref (global.get $const-i64))
+    (return_call_ref $-i64 (global.get $const-i64))
   )
   (func (export "type-f32") (result f32)
-    (return_call_ref (global.get $const-f32))
+    (return_call_ref $-f32 (global.get $const-f32))
   )
   (func (export "type-f64") (result f64)
-    (return_call_ref (global.get $const-f64))
+    (return_call_ref $-f64 (global.get $const-f64))
   )
 
   (func (export "type-first-i32") (result i32)
-    (return_call_ref (i32.const 32) (global.get $id-i32))
+    (return_call_ref $i32-i32 (i32.const 32) (global.get $id-i32))
   )
   (func (export "type-first-i64") (result i64)
-    (return_call_ref (i64.const 64) (global.get $id-i64))
+    (return_call_ref $i64-i64 (i64.const 64) (global.get $id-i64))
   )
   (func (export "type-first-f32") (result f32)
-    (return_call_ref (f32.const 1.32) (global.get $id-f32))
+    (return_call_ref $f32-f32 (f32.const 1.32) (global.get $id-f32))
   )
   (func (export "type-first-f64") (result f64)
-    (return_call_ref (f64.const 1.64) (global.get $id-f64))
+    (return_call_ref $f64-f64 (f64.const 1.64) (global.get $id-f64))
   )
 
   (func (export "type-second-i32") (result i32)
-    (return_call_ref (f32.const 32.1) (i32.const 32) (global.get $f32-i32))
+    (return_call_ref $f32-i32 (f32.const 32.1) (i32.const 32) (global.get $f32-i32))
   )
   (func (export "type-second-i64") (result i64)
-    (return_call_ref (i32.const 32) (i64.const 64) (global.get $i32-i64))
+    (return_call_ref $i32-i64 (i32.const 32) (i64.const 64) (global.get $i32-i64))
   )
   (func (export "type-second-f32") (result f32)
-    (return_call_ref (f64.const 64) (f32.const 32) (global.get $f64-f32))
+    (return_call_ref $f64-f32 (f64.const 64) (f32.const 32) (global.get $f64-f32))
   )
   (func (export "type-second-f64") (result f64)
-    (return_call_ref (i64.const 64) (f64.const 64.1) (global.get $i64-f64))
+    (return_call_ref $i64-f64 (i64.const 64) (f64.const 64.1) (global.get $i64-f64))
   )
 
   ;; Null
 
   (func (export "null")
-    (return_call_ref (ref.null $proc))
+    (return_call_ref $proc (ref.null $proc))
   )
 
   ;; Recursion
@@ -112,7 +112,7 @@
     (if (result i64) (i64.eqz (local.get 0))
       (then (local.get 1))
       (else
-        (return_call_ref
+        (return_call_ref $i64i64-i64
           (i64.sub (local.get 0) (i64.const 1))
           (i64.mul (local.get 0) (local.get 1))
           (global.get $fac-acc)
@@ -128,7 +128,7 @@
     (if (result i64) (i64.eqz (local.get 0))
       (then (local.get 0))
       (else
-        (return_call_ref
+        (return_call_ref $i64-i64
           (i64.sub (local.get 0) (i64.const 1))
           (global.get $count)
         )
@@ -144,7 +144,7 @@
     (if (result i64) (i64.eqz (local.get 0))
       (then (i64.const 44))
       (else
-        (return_call_ref
+        (return_call_ref $i64-i64
           (i64.sub (local.get 0) (i64.const 1))
           (global.get $odd)
         )
@@ -156,7 +156,7 @@
     (if (result i64) (i64.eqz (local.get 0))
       (then (i64.const 99))
       (else
-        (return_call_ref
+        (return_call_ref $i64-i64
           (i64.sub (local.get 0) (i64.const 1))
           (global.get $even)
         )
@@ -212,24 +212,29 @@
 
 (module
   (type $t (func))
+  (type $t1 (func (result (ref $t))))
+  (type $t2 (func (result (ref null $t))))
+  (type $t3 (func (result (ref func))))
+  (type $t4 (func (result (ref null func))))
   (elem declare func $f11 $f22 $f33 $f44)
-  (func $f11 (result (ref $t)) (return_call_ref (ref.func $f11)))
-  (func $f21 (result (ref null $t)) (return_call_ref (ref.func $f11)))
-  (func $f22 (result (ref null $t)) (return_call_ref (ref.func $f22)))
-  (func $f31 (result (ref func)) (return_call_ref (ref.func $f11)))
-  (func $f33 (result (ref func)) (return_call_ref (ref.func $f33)))
-  (func $f41 (result (ref null func)) (return_call_ref (ref.func $f11)))
-  (func $f42 (result (ref null func)) (return_call_ref (ref.func $f22)))
-  (func $f43 (result (ref null func)) (return_call_ref (ref.func $f33)))
-  (func $f44 (result (ref null func)) (return_call_ref (ref.func $f44)))
+  (func $f11 (result (ref $t)) (return_call_ref $t1 (ref.func $f11)))
+  (func $f21 (result (ref null $t)) (return_call_ref $t1 (ref.func $f11)))
+  (func $f22 (result (ref null $t)) (return_call_ref $t2 (ref.func $f22)))
+  (func $f31 (result (ref func)) (return_call_ref $t1 (ref.func $f11)))
+  (func $f33 (result (ref func)) (return_call_ref $t3 (ref.func $f33)))
+  (func $f41 (result (ref null func)) (return_call_ref $t1 (ref.func $f11)))
+  (func $f42 (result (ref null func)) (return_call_ref $t2 (ref.func $f22)))
+  (func $f43 (result (ref null func)) (return_call_ref $t3 (ref.func $f33)))
+  (func $f44 (result (ref null func)) (return_call_ref $t4 (ref.func $f44)))
 )
 
 (assert_invalid
   (module
     (type $t (func))
+    (type $t2 (func (result (ref null $t))))
     (elem declare func $f22)
-    (func $f12 (result (ref $t)) (return_call_ref (ref.func $f22)))
-    (func $f22 (result (ref null $t)) (return_call_ref (ref.func $f22)))
+    (func $f12 (result (ref $t)) (return_call_ref $t2 (ref.func $f22)))
+    (func $f22 (result (ref null $t)) (return_call_ref $t2 (ref.func $f22)))
   )
   "type mismatch"
 )
@@ -237,9 +242,10 @@
 (assert_invalid
   (module
     (type $t (func))
+    (type $t3 (func (result (ref func))))
     (elem declare func $f33)
-    (func $f13 (result (ref $t)) (return_call_ref (ref.func $f33)))
-    (func $f33 (result (ref func)) (return_call_ref (ref.func $f33)))
+    (func $f13 (result (ref $t)) (return_call_ref $t3 (ref.func $f33)))
+    (func $f33 (result (ref func)) (return_call_ref $t3 (ref.func $f33)))
   )
   "type mismatch"
 )
@@ -247,9 +253,10 @@
 (assert_invalid
   (module
     (type $t (func))
+    (type $t4 (func (result (ref null func))))
     (elem declare func $f44)
-    (func $f14 (result (ref $t)) (return_call_ref (ref.func $f44)))
-    (func $f44 (result (ref null func)) (return_call_ref (ref.func $f44)))
+    (func $f14 (result (ref $t)) (return_call_ref $t4 (ref.func $f44)))
+    (func $f44 (result (ref null func)) (return_call_ref $t4 (ref.func $f44)))
   )
   "type mismatch"
 )
@@ -257,9 +264,10 @@
 (assert_invalid
   (module
     (type $t (func))
+    (type $t3 (func (result (ref func))))
     (elem declare func $f33)
-    (func $f23 (result (ref null $t)) (return_call_ref (ref.func $f33)))
-    (func $f33 (result (ref func)) (return_call_ref (ref.func $f33)))
+    (func $f23 (result (ref null $t)) (return_call_ref $t3 (ref.func $f33)))
+    (func $f33 (result (ref func)) (return_call_ref $t3 (ref.func $f33)))
   )
   "type mismatch"
 )
@@ -267,18 +275,20 @@
 (assert_invalid
   (module
     (type $t (func))
+    (type $t4 (func (result (ref null func))))
     (elem declare func $f44)
-    (func $f24 (result (ref null $t)) (return_call_ref (ref.func $f44)))
-    (func $f44 (result (ref null func)) (return_call_ref (ref.func $f44)))
+    (func $f24 (result (ref null $t)) (return_call_ref $t4 (ref.func $f44)))
+    (func $f44 (result (ref null func)) (return_call_ref $t4 (ref.func $f44)))
   )
   "type mismatch"
 )
 
 (assert_invalid
   (module
+    (type $t4 (func (result (ref null func))))
     (elem declare func $f44)
-    (func $f34 (result (ref func)) (return_call_ref (ref.func $f44)))
-    (func $f44 (result (ref null func)) (return_call_ref (ref.func $f44)))
+    (func $f34 (result (ref func)) (return_call_ref $t4 (ref.func $f44)))
+    (func $f44 (result (ref null func)) (return_call_ref $t4 (ref.func $f44)))
   )
   "type mismatch"
 )
@@ -287,34 +297,37 @@
 ;; Unreachable typing.
 
 (module
+  (type $t (func (result i32)))
   (func (export "unreachable") (result i32)
     (unreachable)
-    (return_call_ref)
+    (return_call_ref $t)
   )
 )
 (assert_trap (invoke "unreachable") "unreachable")
 
 (module
   (elem declare func $f)
+  (type $t (func (param i32) (result i32)))
   (func $f (param i32) (result i32) (local.get 0))
 
   (func (export "unreachable") (result i32)
     (unreachable)
     (ref.func $f)
-    (return_call_ref)
+    (return_call_ref $t)
   )
 )
 (assert_trap (invoke "unreachable") "unreachable")
 
 (module
   (elem declare func $f)
+  (type $t (func (param i32) (result i32)))
   (func $f (param i32) (result i32) (local.get 0))
 
   (func (export "unreachable") (result i32)
     (unreachable)
     (i32.const 0)
     (ref.func $f)
-    (return_call_ref)
+    (return_call_ref $t)
     (i32.const 0)
   )
 )
@@ -323,13 +336,14 @@
 (assert_invalid
   (module
     (elem declare func $f)
+    (type $t (func (param i32) (result i32)))
     (func $f (param i32) (result i32) (local.get 0))
 
     (func (export "unreachable") (result i32)
       (unreachable)
       (i64.const 0)
       (ref.func $f)
-      (return_call_ref)
+      (return_call_ref $t)
     )
   )
   "type mismatch"
@@ -338,12 +352,13 @@
 (assert_invalid
   (module
     (elem declare func $f)
+    (type $t (func (param i32) (result i32)))
     (func $f (param i32) (result i32) (local.get 0))
 
     (func (export "unreachable") (result i32)
       (unreachable)
       (ref.func $f)
-      (return_call_ref)
+      (return_call_ref $t)
       (i64.const 0)
     )
   )
@@ -352,8 +367,9 @@
 
 (assert_invalid
   (module
+    (type $t (func))
     (func $f (param $r externref)
-      (return_call_ref (local.get $r))
+      (return_call_ref $t (local.get $r))
     )
   )
   "type mismatch"

From f35463a6331f5fef9c76d78160b323a7802b1b3d Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Fri, 26 Aug 2022 14:59:31 +0200
Subject: [PATCH 187/285] [spec] Tweak wording to avoid first person

---
 document/core/syntax/modules.rst     | 2 +-
 document/core/valid/conventions.rst  | 2 +-
 document/core/valid/instructions.rst | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/document/core/syntax/modules.rst b/document/core/syntax/modules.rst
index c03c98502..84e0bb6a7 100644
--- a/document/core/syntax/modules.rst
+++ b/document/core/syntax/modules.rst
@@ -106,7 +106,7 @@ Conventions
 
 * The meta variables :math:`x, y` range over indices in any of the other index spaces.
 
-* The notation :math:`\F{idx}(A)` denotes the set of indices from index space :math:`\X{idx}` occurring free in :math:`A`. We sometimes reinterpret this set as the :ref:`vector <syntax-vec>` of its elements.
+* The notation :math:`\F{idx}(A)` denotes the set of indices from index space :math:`\X{idx}` occurring free in :math:`A`. Sometimes this set is reinterpreted as the :ref:`vector <syntax-vec>` of its elements.
 
 .. note::
    For example, if :math:`\instr^\ast` is :math:`(\DATADROP~x) (\MEMORYINIT~y)`, then :math:`\freedataidx(\instr^\ast) = \{x, y\}`, or equivalently, the vector :math:`x~y`.
diff --git a/document/core/valid/conventions.rst b/document/core/valid/conventions.rst
index ae219e44a..fbd4f6e20 100644
--- a/document/core/valid/conventions.rst
+++ b/document/core/valid/conventions.rst
@@ -79,7 +79,7 @@ In addition to field access written :math:`C.\K{field}` the following notation i
 * :math:`C,\K{field}\,A^\ast` denotes the same context as :math:`C` but with the elements :math:`A^\ast` prepended to its :math:`\K{field}` component sequence.
 
 .. note::
-   We use :ref:`indexing notation <notation-index>` like :math:`C.\CLABELS[i]` to look up indices in their respective :ref:`index space <syntax-index>` in the context.
+   :ref:`Indexing notation <notation-index>` like :math:`C.\CLABELS[i]` is used to look up indices in their respective :ref:`index space <syntax-index>` in the context.
    Context extension notation :math:`C,\K{field}\,A` is primarily used to locally extend *relative* index spaces, such as :ref:`label indices <syntax-labelidx>`.
    Accordingly, the notation is defined to append at the *front* of the respective sequence, introducing a new relative index :math:`0` and shifting the existing ones.
 
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 6ed7b429c..9a98b78ef 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -258,7 +258,7 @@ Reference Instructions
 Vector Instructions
 ~~~~~~~~~~~~~~~~~~~
 
-Vector instructions can have a prefix to describe the :ref:`shape <syntax-vec-shape>` of the operand. Packed numeric types, |I8| and |I16|, are not :ref:`value types <syntax-valtype>`. An auxiliary function maps such packed types to value types:
+Vector instructions can have a prefix to describe the :ref:`shape <syntax-vec-shape>` of the operand. Packed numeric types, |I8| and |I16|, are not :ref:`value types <syntax-valtype>`. An auxiliary function maps such packed type shapes to value types:
 
 .. math::
    \begin{array}{lll@{\qquad}l}
@@ -268,7 +268,7 @@ Vector instructions can have a prefix to describe the :ref:`shape <syntax-vec-sh
    \end{array}
 
 
-We also define an auxiliary function to get number of packed numeric types in a |V128|, *dimension*:
+The following auxiliary function denotes the number of lanes in a vector shape, i.e., its *dimension*:
 
 .. _aux-dim:
 

From 6269af7aab3e91803457bf08db3b75006359bfa7 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Fri, 26 Aug 2022 17:14:56 +0200
Subject: [PATCH 188/285] Eps

---
 interpreter/binary/encode.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index 139dbcd0b..0a81fca01 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -167,7 +167,7 @@ struct
   let block_type = function
     | ValBlockType None -> s33 (-0x40l)
     | ValBlockType (Some t) -> val_type t
-    | VarBlockType x -> s33 x
+    | VarBlockType x -> var_type x
 
   let local (n, loc) = len n; val_type loc.it.ltype
 

From f6aed3329be8e217d0651f91c3a123a138d8935e Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Fri, 26 Aug 2022 17:27:19 +0200
Subject: [PATCH 189/285] Eps2

---
 interpreter/text/parser.mly | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index 0e687622a..e0660a13b 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -366,7 +366,7 @@ limits :
   | NAT NAT { {min = nat32 $1 (ati 1); max = Some (nat32 $2 (ati 2))} }
 
 type_use :
-  | LPAR TYPE var RPAR { $3 }
+  | LPAR TYPE var RPAR { fun c -> $3 c type_ }
 
 
 /* Immediates */
@@ -543,8 +543,8 @@ call_instr_type :
     { let at1 = ati 1 in
       fun c ->
       match $2 c with
-      | FuncT ([], []) -> $1 c type_
-      | ft -> inline_func_type_explicit c ($1 c type_) ft at1 }
+      | FuncT ([], []) -> $1 c
+      | ft -> inline_func_type_explicit c ($1 c) ft at1 }
   | call_instr_params
     { let at = at () in fun c -> inline_func_type c ($1 c) at }
 
@@ -574,8 +574,8 @@ call_instr_type_instr :
     { let at1 = ati 1 in
       fun c ->
       match $2 c with
-      | FuncT ([], []), es -> $1 c type_, es
-      | ft, es -> inline_func_type_explicit c ($1 c type_) ft at1, es }
+      | FuncT ([], []), es -> $1 c, es
+      | ft, es -> inline_func_type_explicit c ($1 c) ft at1, es }
   | call_instr_params_instr
     { let at = at () in
       fun c -> let ft, es = $1 c in inline_func_type c ft at, es }
@@ -609,7 +609,7 @@ block :
   | type_use block_param_body
     { let at1 = ati 1 in
       fun c -> let ft, es = $2 c in
-      let x = inline_func_type_explicit c ($1 c type_) ft at1 in
+      let x = inline_func_type_explicit c ($1 c) ft at1 in
       VarBlockType x.it, es }
   | block_param_body  /* Sugar */
     { let at = at () in
@@ -666,8 +666,8 @@ call_expr_type :
     { let at1 = ati 1 in
       fun c ->
       match $2 c with
-      | FuncT ([], []), es -> $1 c type_, es
-      | ft, es -> inline_func_type_explicit c ($1 c type_) ft at1, es }
+      | FuncT ([], []), es -> $1 c, es
+      | ft, es -> inline_func_type_explicit c ($1 c) ft at1, es }
   | call_expr_params
     { let at1 = ati 1 in
       fun c -> let ft, es = $1 c in inline_func_type c ft at1, es }
@@ -690,7 +690,7 @@ if_block :
   | type_use if_block_param_body
     { let at = at () in
       fun c c' -> let ft, es = $2 c c' in
-      let x = inline_func_type_explicit c ($1 c type_) ft at in
+      let x = inline_func_type_explicit c ($1 c) ft at in
       VarBlockType x.it, es }
   | if_block_param_body  /* Sugar */
     { let at = at () in
@@ -751,7 +751,7 @@ func_fields :
   | type_use func_fields_body
     { fun c x at ->
       let c' = enter_func c at in
-      let y = inline_func_type_explicit c' ($1 c' type_) (fst $2 c') at in
+      let y = inline_func_type_explicit c' ($1 c') (fst $2 c') at in
       [{(snd $2 c') with ftype = y} @@ at], [], [] }
   | func_fields_body  /* Sugar */
     { fun c x at ->
@@ -760,7 +760,7 @@ func_fields :
       [{(snd $1 c') with ftype = y} @@ at], [], [] }
   | inline_import type_use func_fields_import  /* Sugar */
     { fun c x at ->
-      let y = inline_func_type_explicit c ($2 c type_) ($3 c) at in
+      let y = inline_func_type_explicit c ($2 c) ($3 c) at in
       [],
       [{ module_name = fst $1; item_name = snd $1;
          idesc = FuncImport y @@ at } @@ at ], [] }
@@ -999,7 +999,7 @@ global_fields :
 import_desc :
   | LPAR FUNC bind_var_opt type_use RPAR
     { fun c -> ignore ($3 c anon_func bind_func);
-      fun () -> FuncImport ($4 c type_) }
+      fun () -> FuncImport ($4 c) }
   | LPAR FUNC bind_var_opt func_type RPAR  /* Sugar */
     { let at4 = ati 4 in
       fun c -> ignore ($3 c anon_func bind_func);

From 5b18ee806dc8fd125d7aecbc25ab52203537c9bb Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Fri, 26 Aug 2022 17:52:24 +0200
Subject: [PATCH 190/285] Eps3

---
 interpreter/binary/decode.ml | 2 +-
 interpreter/binary/encode.ml | 2 +-
 interpreter/exec/eval.ml     | 2 +-
 interpreter/syntax/ast.ml    | 2 +-
 interpreter/syntax/free.ml   | 2 +-
 interpreter/text/arrange.ml  | 2 +-
 interpreter/text/parser.mly  | 8 ++++----
 interpreter/valid/valid.ml   | 2 +-
 8 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index fdc128bf1..7794a3e65 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -250,7 +250,7 @@ let memop s =
 
 let block_type s =
   either [
-    (fun s -> VarBlockType (var_type s));
+    (fun s -> VarBlockType (at var_type s));
     (fun s -> expect 0x40 s ""; ValBlockType None);
     (fun s -> ValBlockType (Some (val_type s)));
   ] s
diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index 0a81fca01..da604a4fb 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -167,7 +167,7 @@ struct
   let block_type = function
     | ValBlockType None -> s33 (-0x40l)
     | ValBlockType (Some t) -> val_type t
-    | VarBlockType x -> var_type x
+    | VarBlockType x -> var_type x.it
 
   let local (n, loc) = len n; val_type loc.it.ltype
 
diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index c67d467af..23c442bde 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -115,7 +115,7 @@ let block_type (inst : module_inst) bt at =
   | ValBlockType None -> InstrT ([], [], [])
   | ValBlockType (Some t) -> InstrT ([], [dyn_val_type inst.types t], [])
   | VarBlockType x ->
-    let FuncT (ts1, ts2) = func_type inst (x @@ at) in InstrT (ts1, ts2, [])
+    let FuncT (ts1, ts2) = func_type inst x in InstrT (ts1, ts2, [])
 
 let take n (vs : 'a stack) at =
   try Lib.List.take n vs with Failure _ -> Crash.error at "stack underflow"
diff --git a/interpreter/syntax/ast.ml b/interpreter/syntax/ast.ml
index 421cf1038..01b18498d 100644
--- a/interpreter/syntax/ast.ml
+++ b/interpreter/syntax/ast.ml
@@ -135,7 +135,7 @@ type num = Value.num Source.phrase
 type vec = Value.vec Source.phrase
 type name = Utf8.unicode
 
-type block_type = VarBlockType of var | ValBlockType of val_type option
+type block_type = VarBlockType of idx | ValBlockType of val_type option
 
 type instr = instr' Source.phrase
 and instr' =
diff --git a/interpreter/syntax/free.ml b/interpreter/syntax/free.ml
index 41ee61378..a58475b76 100644
--- a/interpreter/syntax/free.ml
+++ b/interpreter/syntax/free.ml
@@ -93,7 +93,7 @@ let def_type = function
   | DefFuncT ft -> func_type ft
 
 let block_type = function
-  | VarBlockType x -> var_type x
+  | VarBlockType x -> var_type x.it
   | ValBlockType t -> opt val_type t
 
 let rec instr (e : instr) =
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index 1dd877b82..6af8f369c 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -431,7 +431,7 @@ let constop v = Dyn.string_of_num_type (type_of_num v) ^ ".const"
 let vec_constop v = Dyn.string_of_vec_type (type_of_vec v) ^ ".const i32x4"
 
 let block_type = function
-  | VarBlockType x -> [Node ("type " ^ nat32 x, [])]
+  | VarBlockType x -> [Node ("type " ^ var x, [])]
   | ValBlockType ts -> decls "result" (list_of_opt ts)
 
 let rec instr e =
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index e0660a13b..8a6c35816 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -610,7 +610,7 @@ block :
     { let at1 = ati 1 in
       fun c -> let ft, es = $2 c in
       let x = inline_func_type_explicit c ($1 c) ft at1 in
-      VarBlockType x.it, es }
+      VarBlockType x, es }
   | block_param_body  /* Sugar */
     { let at = at () in
       fun c -> let ft, es = $1 c in
@@ -618,7 +618,7 @@ block :
         match ft with
         | FuncT ([], []) -> ValBlockType None
         | FuncT ([], [t]) -> ValBlockType (Some t)
-        | ft ->  VarBlockType (inline_func_type c ft at).it
+        | ft ->  VarBlockType (inline_func_type c ft at)
       in bt, es }
 
 block_param_body :
@@ -691,7 +691,7 @@ if_block :
     { let at = at () in
       fun c c' -> let ft, es = $2 c c' in
       let x = inline_func_type_explicit c ($1 c) ft at in
-      VarBlockType x.it, es }
+      VarBlockType x, es }
   | if_block_param_body  /* Sugar */
     { let at = at () in
       fun c c' -> let ft, es = $1 c c' in
@@ -699,7 +699,7 @@ if_block :
         match ft with
         | FuncT ([], []) -> ValBlockType None
         | FuncT ([], [t]) -> ValBlockType (Some t)
-        | ft ->  VarBlockType (inline_func_type c ft at).it
+        | ft ->  VarBlockType (inline_func_type c ft at)
       in bt, es }
 
 if_block_param_body :
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index eaa80959d..2ed07c74e 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -309,7 +309,7 @@ let check_block_type (c : context) (bt : block_type) at : instr_type =
   | ValBlockType None -> InstrT ([], [], [])
   | ValBlockType (Some t) -> check_val_type c t at; InstrT ([], [t], [])
   | VarBlockType x ->
-    let FuncT (ts1, ts2) = func_type c (x @@ at) in InstrT (ts1, ts2, [])
+    let FuncT (ts1, ts2) = func_type c x in InstrT (ts1, ts2, [])
 
 let check_local (c : context) (loc : local) : local_type =
   check_val_type c loc.it.ltype loc.at;

From 959999dfbbfd737758637d3ccc734e1895095021 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Fri, 26 Aug 2022 18:50:33 +0200
Subject: [PATCH 191/285] Remove unneeded assumption type

---
 interpreter/exec/eval.ml      |   6 +-
 interpreter/runtime/global.ml |   4 +-
 interpreter/runtime/table.ml  |   2 +-
 interpreter/script/run.ml     |   2 +-
 interpreter/valid/match.ml    | 144 ++++++++++++++++------------------
 interpreter/valid/match.mli   |  42 +++++-----
 interpreter/valid/valid.ml    |  14 ++--
 7 files changed, 102 insertions(+), 112 deletions(-)

diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index 23c442bde..1a3a67d01 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -231,7 +231,7 @@ let rec step (c : config) : config =
       | CallIndirect (x, y), Num (I32 i) :: vs ->
         let f = func_ref c.frame.inst x i e.at in
         if
-          Match.Dyn.eq_func_type () [] (func_type c.frame.inst y) (Func.type_of f)
+          Match.Dyn.eq_func_type () (func_type c.frame.inst y) (Func.type_of f)
         then
           vs, [Invoke f @@ e.at]
         else
@@ -738,7 +738,7 @@ let invoke (func : func_inst) (vs : value list) : value list =
   let FuncT (ts1, _ts2) = Func.type_of func in
   if List.length vs <> List.length ts1 then
     Crash.error at "wrong number of arguments";
-  if not (List.for_all2 (fun v -> Match.Dyn.match_val_type () [] (type_of_value v)) vs ts1) then
+  if not (List.for_all2 (fun v -> Match.Dyn.match_val_type () (type_of_value v)) vs ts1) then
     Crash.error at "wrong types of arguments";
   let c = config empty_module_inst (List.rev vs) [Invoke func @@ at] in
   try List.rev (eval c) with Stack_overflow ->
@@ -802,7 +802,7 @@ let add_import (m : module_) (ext : extern) (im : import) (inst : module_inst)
   let it = Types.extern_type_of_import_type (import_type_of m im) in
   let et = Types.Dyn.dyn_extern_type inst.types it in
   let et' = extern_type_of inst.types ext in
-  if not (Match.Dyn.match_extern_type () [] et' et) then
+  if not (Match.Dyn.match_extern_type () et' et) then
     Link.error im.at ("incompatible import type for " ^
       "\"" ^ Utf8.encode im.it.module_name ^ "\" " ^
       "\"" ^ Utf8.encode im.it.item_name ^ "\": " ^
diff --git a/interpreter/runtime/global.ml b/interpreter/runtime/global.ml
index bf527ad6b..a6712c3e3 100644
--- a/interpreter/runtime/global.ml
+++ b/interpreter/runtime/global.ml
@@ -8,7 +8,7 @@ exception Type
 exception NotMutable
 
 let alloc (GlobalT (_mut, t) as ty) v =
-  if not (Match.Dyn.match_val_type () [] (type_of_value v) t) then raise Type;
+  if not (Match.Dyn.match_val_type () (type_of_value v) t) then raise Type;
   {ty; content = v}
 
 let type_of glob =
@@ -20,5 +20,5 @@ let load glob =
 let store glob v =
   let GlobalT (mut, t) = glob.ty in
   if mut <> Var then raise NotMutable;
-  if not (Match.Dyn.match_val_type () [] (type_of_value v) t) then raise Type;
+  if not (Match.Dyn.match_val_type () (type_of_value v) t) then raise Type;
   glob.content <- v
diff --git a/interpreter/runtime/table.ml b/interpreter/runtime/table.ml
index d698ba169..29690fec0 100644
--- a/interpreter/runtime/table.ml
+++ b/interpreter/runtime/table.ml
@@ -51,7 +51,7 @@ let load tab i =
 
 let store tab i r =
   let TableT (lim, t) = tab.ty in
-  if not (Match.Dyn.match_ref_type () [] (type_of_ref r) t) then raise Type;
+  if not (Match.Dyn.match_ref_type () (type_of_ref r) t) then raise Type;
   try Lib.Array32.set tab.content i r with Invalid_argument _ -> raise Bounds
 
 let blit tab offset rs =
diff --git a/interpreter/script/run.ml b/interpreter/script/run.ml
index f03381719..d0e5a523f 100644
--- a/interpreter/script/run.ml
+++ b/interpreter/script/run.ml
@@ -329,7 +329,7 @@ let run_action act : Value.t list =
       if List.length vs <> List.length ts1 then
         Script.error act.at "wrong number of arguments";
       List.iter2 (fun v t ->
-        if not (Match.Dyn.match_val_type () [] (Value.type_of_value v.it) t) then
+        if not (Match.Dyn.match_val_type () (Value.type_of_value v.it) t) then
           Script.error v.at "wrong type of argument"
       ) vs ts1;
       Eval.invoke f (List.map (fun v -> v.it) vs)
diff --git a/interpreter/valid/match.ml b/interpreter/valid/match.ml
index 84631b158..5b1dffc21 100644
--- a/interpreter/valid/match.ml
+++ b/interpreter/valid/match.ml
@@ -20,159 +20,151 @@ struct
   open Context
 
 
-  (* Assumptions *)
-
-  type assump = (var * var) list
-
-  let assuming a (x1, x2) =
-    List.find_opt (fun (y1, y2) -> eq_var x1 y1 && eq_var x2 y2) a <> None
-
-
   (* Equivalence *)
 
-  let eq_nullability c a nul1 nul2 =
+  let eq_nullability c nul1 nul2 =
     nul1 = nul2
 
-  let eq_mutability c a mut1 mut2 =
+  let eq_mutability c mut1 mut2 =
     mut1 = mut2
 
-  let eq_limits c a lim1 lim2 =
+  let eq_limits c lim1 lim2 =
     lim1.min = lim2.min && lim1.max = lim2.max
 
-  let eq_num_type c a t1 t2 =
+  let eq_num_type c t1 t2 =
     t1 = t2
 
-  let eq_vec_type c a t1 t2 =
+  let eq_vec_type c t1 t2 =
     t1 = t2
 
-  let rec eq_heap_type c a t1 t2 =
+  let rec eq_heap_type c t1 t2 =
     match t1, t2 with
-    | DefHT x1, DefHT x2 -> eq_var_type c a x1 x2
+    | DefHT x1, DefHT x2 -> eq_var_type c x1 x2
     | _, _ -> t1 = t2
 
-  and eq_ref_type c a t1 t2 =
+  and eq_ref_type c t1 t2 =
     match t1, t2 with
     | (nul1, t1'), (nul2, t2') ->
-      eq_nullability c a nul1 nul2 && eq_heap_type c a t1' t2'
+      eq_nullability c nul1 nul2 && eq_heap_type c t1' t2'
 
-  and eq_val_type c a t1 t2 =
+  and eq_val_type c t1 t2 =
     match t1, t2 with
-    | NumT t1', NumT t2' -> eq_num_type c a t1' t2'
-    | VecT t1', VecT t2' -> eq_vec_type c a t1' t2'
-    | RefT t1', RefT t2' -> eq_ref_type c a t1' t2'
+    | NumT t1', NumT t2' -> eq_num_type c t1' t2'
+    | VecT t1', VecT t2' -> eq_vec_type c t1' t2'
+    | RefT t1', RefT t2' -> eq_ref_type c t1' t2'
     | BotT, BotT -> true
     | _, _ -> false
 
-  and eq_result_type c a ts1 ts2 =
+  and eq_result_type c ts1 ts2 =
     List.length ts1 = List.length ts2 &&
-    List.for_all2 (eq_val_type c a) ts1 ts2
+    List.for_all2 (eq_val_type c) ts1 ts2
 
-  and eq_func_type c a (FuncT (ts11, ts12)) (FuncT (ts21, ts22)) =
-    eq_result_type c a ts11 ts21 && eq_result_type c a ts12 ts22
+  and eq_func_type c (FuncT (ts11, ts12)) (FuncT (ts21, ts22)) =
+    eq_result_type c ts11 ts21 && eq_result_type c ts12 ts22
 
-  and eq_def_type c a dt1 dt2 =
+  and eq_def_type c dt1 dt2 =
     match dt1, dt2 with
-    | DefFuncT ft1, DefFuncT ft2 -> eq_func_type c a ft1 ft2
+    | DefFuncT ft1, DefFuncT ft2 -> eq_func_type c ft1 ft2
 
-  and eq_var_type c a x1 x2 =
-    eq_var x1 x2 || assuming a (x1, x2) ||
-    eq_def_type c ((x1, x2)::a) (lookup c x1) (lookup c x2)
+  and eq_var_type c x1 x2 =
+    eq_var x1 x2 ||
+    eq_def_type c (lookup c x1) (lookup c x2)
 
 
-  let eq_table_type c a (TableT (lim1, t1)) (TableT (lim2, t2)) =
-    eq_limits c a lim1 lim2 && eq_ref_type c a t1 t2
+  let eq_table_type c (TableT (lim1, t1)) (TableT (lim2, t2)) =
+    eq_limits c lim1 lim2 && eq_ref_type c t1 t2
 
-  let eq_memory_type c a (MemoryT lim1) (MemoryT lim2) =
-    eq_limits c a lim1 lim2
+  let eq_memory_type c (MemoryT lim1) (MemoryT lim2) =
+    eq_limits c lim1 lim2
 
-  let eq_global_type c a (GlobalT (mut1, t1)) (GlobalT (mut2, t2)) =
-    eq_mutability c a mut1 mut2 && eq_val_type c a t1 t2
+  let eq_global_type c (GlobalT (mut1, t1)) (GlobalT (mut2, t2)) =
+    eq_mutability c mut1 mut2 && eq_val_type c t1 t2
 
-  let eq_extern_type c a et1 et2 =
+  let eq_extern_type c et1 et2 =
     match et1, et2 with
-    | ExternFuncT ft1, ExternFuncT ft2 -> eq_func_type c a ft1 ft2
-    | ExternTableT tt1, ExternTableT tt2 -> eq_table_type c a tt1 tt2
-    | ExternMemoryT mt1, ExternMemoryT mt2 -> eq_memory_type c a mt1 mt2
-    | ExternGlobalT gt1, ExternGlobalT gt2 -> eq_global_type c a gt1 gt2
+    | ExternFuncT ft1, ExternFuncT ft2 -> eq_func_type c ft1 ft2
+    | ExternTableT tt1, ExternTableT tt2 -> eq_table_type c tt1 tt2
+    | ExternMemoryT mt1, ExternMemoryT mt2 -> eq_memory_type c mt1 mt2
+    | ExternGlobalT gt1, ExternGlobalT gt2 -> eq_global_type c gt1 gt2
     | _, _ -> false
 
 
   (* Subtyping *)
 
-  let match_nullability c a nul1 nul2 =
+  let match_nullability c nul1 nul2 =
     match nul1, nul2 with
     | NoNull, Null -> true
     | _, _ -> nul1 = nul2
 
-  let match_limits c a lim1 lim2 =
+  let match_limits c lim1 lim2 =
     I32.ge_u lim1.min lim2.min &&
     match lim1.max, lim2.max with
     | _, None -> true
     | None, Some _ -> false
     | Some i, Some j -> I32.le_u i j
 
-  let match_num_type c a t1 t2 =
+  let match_num_type c t1 t2 =
     t1 = t2
 
-  let match_vec_type c a t1 t2 =
+  let match_vec_type c t1 t2 =
     t1 = t2
 
-  let rec match_heap_type c a t1 t2 =
+  let rec match_heap_type c t1 t2 =
     match t1, t2 with
     | DefHT x1, FuncHT ->
       (match lookup c x1 with
       | DefFuncT _ -> true
       )
-    | DefHT x1, DefHT x2 -> match_var_type c a x1 x2
+    | DefHT x1, DefHT x2 -> match_var_type c x1 x2
     | BotHT, _ -> true
-    | _, _ -> eq_heap_type c [] t1 t2
+    | _, _ -> eq_heap_type c t1 t2
 
-  and match_ref_type c a t1 t2 =
+  and match_ref_type c t1 t2 =
     match t1, t2 with
     | (nul1, t1'), (nul2, t2') ->
-      match_nullability c a nul1 nul2 && match_heap_type c a t1' t2'
+      match_nullability c nul1 nul2 && match_heap_type c t1' t2'
 
-  and match_val_type c a t1 t2 =
+  and match_val_type c t1 t2 =
     match t1, t2 with
-    | NumT t1', NumT t2' -> match_num_type c a t1' t2'
-    | VecT t1', VecT t2' -> match_vec_type c a t1' t2'
-    | RefT t1', RefT t2' -> match_ref_type c a t1' t2'
+    | NumT t1', NumT t2' -> match_num_type c t1' t2'
+    | VecT t1', VecT t2' -> match_vec_type c t1' t2'
+    | RefT t1', RefT t2' -> match_ref_type c t1' t2'
     | BotT, _ -> true
     | _, _ -> false
 
-  and match_result_type c a ts1 ts2 =
+  and match_result_type c ts1 ts2 =
     List.length ts1 = List.length ts2 &&
-    List.for_all2 (match_val_type c a) ts1 ts2
+    List.for_all2 (match_val_type c) ts1 ts2
 
-  and match_func_type c a ft1 ft2 =
-    eq_func_type c [] ft1 ft2
+  and match_func_type c ft1 ft2 =
+    eq_func_type c ft1 ft2
 
-  and match_def_type c a dt1 dt2 =
+  and match_def_type c dt1 dt2 =
     match dt1, dt2 with
-    | DefFuncT ft1, DefFuncT ft2 -> match_func_type c a ft1 ft2
+    | DefFuncT ft1, DefFuncT ft2 -> match_func_type c ft1 ft2
 
-  and match_var_type c a x1 x2 =
-    eq_var x1 x2 || assuming a (x1, x2) ||
-    match_def_type c ((x1, x2)::a) (lookup c x1) (lookup c x2)
+  and match_var_type c x1 x2 =
+    eq_var x1 x2 ||
+    match_def_type c (lookup c x1) (lookup c x2)
 
-  let match_table_type c a (TableT (lim1, t1)) (TableT (lim2, t2)) =
-    match_limits c a lim1 lim2 && eq_ref_type c [] t1 t2
+  let match_table_type c (TableT (lim1, t1)) (TableT (lim2, t2)) =
+    match_limits c lim1 lim2 && eq_ref_type c t1 t2
 
-  let match_memory_type c a (MemoryT lim1) (MemoryT lim2) =
-    match_limits c a lim1 lim2
+  let match_memory_type c (MemoryT lim1) (MemoryT lim2) =
+    match_limits c lim1 lim2
 
-  let match_global_type c a (GlobalT (mut1, t1)) (GlobalT (mut2, t2)) =
-    eq_mutability c [] mut1 mut2 &&
+  let match_global_type c (GlobalT (mut1, t1)) (GlobalT (mut2, t2)) =
+    eq_mutability c mut1 mut2 &&
     match mut1 with
-    | Cons -> match_val_type c a t1 t2
-    | Var -> eq_val_type c [] t1 t2
+    | Cons -> match_val_type c t1 t2
+    | Var -> eq_val_type c t1 t2
 
-  let match_extern_type c a et1 et2 =
+  let match_extern_type c et1 et2 =
     match et1, et2 with
-    | ExternFuncT ft1, ExternFuncT ft2 -> match_func_type c a ft1 ft2
-    | ExternTableT tt1, ExternTableT tt2 -> match_table_type c a tt1 tt2
-    | ExternMemoryT mt1, ExternMemoryT mt2 -> match_memory_type c a mt1 mt2
-    | ExternGlobalT gt1, ExternGlobalT gt2 -> match_global_type c a gt1 gt2
+    | ExternFuncT ft1, ExternFuncT ft2 -> match_func_type c ft1 ft2
+    | ExternTableT tt1, ExternTableT tt2 -> match_table_type c tt1 tt2
+    | ExternMemoryT mt1, ExternMemoryT mt2 -> match_memory_type c mt1 mt2
+    | ExternGlobalT gt1, ExternGlobalT gt2 -> match_global_type c gt1 gt2
     | _, _ -> false
 end
 
diff --git a/interpreter/valid/match.mli b/interpreter/valid/match.mli
index 516e87aa2..1350c0264 100644
--- a/interpreter/valid/match.mli
+++ b/interpreter/valid/match.mli
@@ -18,41 +18,39 @@ sig
   open Types.Make (Var)
   open Context
 
-  type assump = (var * var) list
-
   (* Equivalence *)
 
-  val eq_num_type : context -> assump -> num_type -> num_type -> bool
-  val eq_ref_type : context -> assump -> ref_type -> ref_type -> bool
-  val eq_val_type : context -> assump -> val_type -> val_type -> bool
+  val eq_num_type : context -> num_type -> num_type -> bool
+  val eq_ref_type : context -> ref_type -> ref_type -> bool
+  val eq_val_type : context -> val_type -> val_type -> bool
 
-  val eq_result_type : context -> assump -> result_type -> result_type -> bool
+  val eq_result_type : context -> result_type -> result_type -> bool
 
-  val eq_func_type : context -> assump -> func_type -> func_type -> bool
-  val eq_table_type : context -> assump -> table_type -> table_type -> bool
-  val eq_memory_type : context -> assump -> memory_type -> memory_type -> bool
-  val eq_global_type : context -> assump -> global_type -> global_type -> bool
+  val eq_func_type : context -> func_type -> func_type -> bool
+  val eq_table_type : context -> table_type -> table_type -> bool
+  val eq_memory_type : context -> memory_type -> memory_type -> bool
+  val eq_global_type : context -> global_type -> global_type -> bool
 
-  val eq_extern_type : context -> assump -> extern_type -> extern_type -> bool
+  val eq_extern_type : context -> extern_type -> extern_type -> bool
 
-  val eq_def_type : context -> assump -> def_type -> def_type -> bool
+  val eq_def_type : context -> def_type -> def_type -> bool
 
   (* Subtyping *)
 
-  val match_num_type : context -> assump -> num_type -> num_type -> bool
-  val match_ref_type : context -> assump -> ref_type -> ref_type -> bool
-  val match_val_type : context -> assump -> val_type -> val_type -> bool
+  val match_num_type : context -> num_type -> num_type -> bool
+  val match_ref_type : context -> ref_type -> ref_type -> bool
+  val match_val_type : context -> val_type -> val_type -> bool
 
-  val match_result_type : context -> assump -> result_type -> result_type -> bool
+  val match_result_type : context -> result_type -> result_type -> bool
 
-  val match_func_type : context -> assump -> func_type -> func_type -> bool
-  val match_table_type : context -> assump -> table_type -> table_type -> bool
-  val match_memory_type : context -> assump -> memory_type -> memory_type -> bool
-  val match_global_type : context -> assump -> global_type -> global_type -> bool
+  val match_func_type : context -> func_type -> func_type -> bool
+  val match_table_type : context -> table_type -> table_type -> bool
+  val match_memory_type : context -> memory_type -> memory_type -> bool
+  val match_global_type : context -> global_type -> global_type -> bool
 
-  val match_extern_type : context -> assump -> extern_type -> extern_type -> bool
+  val match_extern_type : context -> extern_type -> extern_type -> bool
 
-  val match_def_type : context -> assump -> def_type -> def_type -> bool
+  val match_def_type : context -> def_type -> def_type -> bool
 end
 
 
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index 2ed07c74e..167c80c11 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -160,7 +160,7 @@ let (-->...) ts1 ts2 = {ins = Ellipses, ts1; outs = Ellipses, ts2}
 let check_stack (c : context) ts1 ts2 at =
   require
     (List.length ts1 = List.length ts2 &&
-      List.for_all2 (match_val_type c.types []) ts1 ts2) at
+      List.for_all2 (match_val_type c.types) ts1 ts2) at
     ("type mismatch: instruction requires " ^ string_of_result_type ts2 ^
      " but stack has " ^ string_of_result_type ts1)
 
@@ -380,7 +380,7 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
       ("type mismatch: instruction requires type " ^ string_of_val_type t' ^
        " but label has " ^ string_of_result_type (label c x));
     let ts0, t1 = Lib.List.split_last (label c x) in
-    require (match_val_type c.types [] t' t1) e.at
+    require (match_val_type c.types t' t1) e.at
       ("type mismatch: instruction requires type " ^ string_of_val_type t' ^
        " but label has " ^ string_of_result_type (label c x));
     (ts0 @ [RefT (_nul, ht)]) --> ts0, []
@@ -399,14 +399,14 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
   | CallIndirect (x, y) ->
     let TableT (_lim, t) = table c x in
     let FuncT (ts1, ts2) = func_type c y in
-    require (match_ref_type c.types [] t (Null, FuncHT)) x.at
+    require (match_ref_type c.types t (Null, FuncHT)) x.at
       ("type mismatch: instruction requires table of function type" ^
        " but table has element type " ^ string_of_ref_type t);
     (ts1 @ [NumT I32T]) --> ts2, []
 
   | ReturnCallRef x ->
     let FuncT (ts1, ts2) = func_type c x in
-    require (match_result_type c.types [] ts2 c.results) e.at
+    require (match_result_type c.types ts2 c.results) e.at
       ("type mismatch: current function requires result type " ^
        string_of_result_type c.results ^
        " but callee returns " ^ string_of_result_type ts2);
@@ -457,7 +457,7 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
   | TableCopy (x, y) ->
     let TableT (_lim1, t1) = table c x in
     let TableT (_lim2, t2) = table c y in
-    require (match_ref_type c.types [] t2 t1) x.at
+    require (match_ref_type c.types t2 t1) x.at
       ("type mismatch: source element type " ^ string_of_ref_type t1 ^
        " does not match destination element type " ^ string_of_ref_type t2);
     [NumT I32T; NumT I32T; NumT I32T] --> [], []
@@ -465,7 +465,7 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
   | TableInit (x, y) ->
     let TableT (_lim1, t1) = table c x in
     let t2 = elem c y in
-    require (match_ref_type c.types [] t2 t1) x.at
+    require (match_ref_type c.types t2 t1) x.at
       ("type mismatch: element segment's type " ^ string_of_ref_type t1 ^
        " does not match table's element type " ^ string_of_ref_type t2);
     [NumT I32T; NumT I32T; NumT I32T] --> [], []
@@ -718,7 +718,7 @@ let check_elem_mode (c : context) (t : ref_type) (mode : segment_mode) =
   | Passive -> ()
   | Active {index; offset} ->
     let TableT (_lim, et) = table c index in
-    require (match_ref_type c.types [] t et) mode.at
+    require (match_ref_type c.types t et) mode.at
       ("type mismatch: element segment's type " ^ string_of_ref_type t ^
        " does not match table's element type " ^ string_of_ref_type et);
     check_const c offset (NumT I32T)

From 4bb213a57837c568e8c42542f4631188a0e6aea1 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Tue, 30 Aug 2022 18:46:38 +0200
Subject: [PATCH 192/285] [spec/test] Fix scoping of non-imported globals
 (#1525)

---
 document/core/valid/instructions.rst |  2 +-
 document/core/valid/modules.rst      | 44 ++++++++++++++--------------
 test/core/data.wast                  | 25 +++++++++++-----
 test/core/elem.wast                  | 23 +++++++++++----
 test/core/global.wast                |  9 ++++++
 5 files changed, 67 insertions(+), 36 deletions(-)

diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 9a98b78ef..b2d5fd13b 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -1641,7 +1641,7 @@ Constant Expressions
    }
 
 .. note::
-   Currently, constant expressions occurring as initializers of :ref:`globals <syntax-global>` are further constrained in that contained |GLOBALGET| instructions are only allowed to refer to *imported* globals.
+   Currently, constant expressions occurring in :ref:`globals <syntax-global>`, :ref:`element <syntax-elem>`, or :ref:`data <syntax-data>` segments are further constrained in that contained |GLOBALGET| instructions are only allowed to refer to *imported* globals.
    This is enforced in the :ref:`validation rule for modules <valid-module>` by constraining the context :math:`C` accordingly.
 
    The definition of constant expression may be extended in future versions of WebAssembly.
diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index 5b13ae7fc..4c8e7b6dd 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -546,24 +546,33 @@ Instead, the context :math:`C` for validation of the module's content is constru
 
   * all other fields are empty.
 
-* Under the context :math:`C`:
+* For each :math:`\functype_i` in :math:`\module.\MTYPES`,
+  the :ref:`function type <syntax-functype>` :math:`\functype_i` must be :ref:`valid <valid-functype>`.
 
-  * For each :math:`\functype_i` in :math:`\module.\MTYPES`,
-    the :ref:`function type <syntax-functype>` :math:`\functype_i` must be :ref:`valid <valid-functype>`.
+* Under the context :math:`C`:
 
   * For each :math:`\func_i` in :math:`\module.\MFUNCS`,
     the definition :math:`\func_i` must be :ref:`valid <valid-func>` with a :ref:`function type <syntax-functype>` :math:`\X{ft}_i`.
 
+  * If :math:`\module.\MSTART` is non-empty,
+    then :math:`\module.\MSTART` must be :ref:`valid <valid-start>`.
+
+  * For each :math:`\import_i` in :math:`\module.\MIMPORTS`,
+    the segment :math:`\import_i` must be :ref:`valid <valid-import>` with an :ref:`external type <syntax-externtype>` :math:`\X{it}_i`.
+
+  * For each :math:`\export_i` in :math:`\module.\MEXPORTS`,
+    the segment :math:`\export_i` must be :ref:`valid <valid-export>` with :ref:`external type <syntax-externtype>` :math:`\X{et}_i`.
+
+* Under the context :math:`C'`:
+
   * For each :math:`\table_i` in :math:`\module.\MTABLES`,
     the definition :math:`\table_i` must be :ref:`valid <valid-table>` with a :ref:`table type <syntax-tabletype>` :math:`\X{tt}_i`.
 
   * For each :math:`\mem_i` in :math:`\module.\MMEMS`,
     the definition :math:`\mem_i` must be :ref:`valid <valid-mem>` with a :ref:`memory type <syntax-memtype>` :math:`\X{mt}_i`.
 
-  * For each :math:`\global_i` in :math:`\module.\MGLOBALS`:
-
-    * Under the context :math:`C'`,
-      the definition :math:`\global_i` must be :ref:`valid <valid-global>` with a :ref:`global type <syntax-globaltype>` :math:`\X{gt}_i`.
+  * For each :math:`\global_i` in :math:`\module.\MGLOBALS`,
+    the definition :math:`\global_i` must be :ref:`valid <valid-global>` with a :ref:`global type <syntax-globaltype>` :math:`\X{gt}_i`.
 
   * For each :math:`\elem_i` in :math:`\module.\MELEMS`,
     the segment :math:`\elem_i` must be :ref:`valid <valid-elem>` with :ref:`reference type <syntax-reftype>` :math:`\X{rt}_i`.
@@ -571,15 +580,6 @@ Instead, the context :math:`C` for validation of the module's content is constru
   * For each :math:`\data_i` in :math:`\module.\MDATAS`,
     the segment :math:`\data_i` must be :ref:`valid <valid-data>`.
 
-  * If :math:`\module.\MSTART` is non-empty,
-    then :math:`\module.\MSTART` must be :ref:`valid <valid-start>`.
-
-  * For each :math:`\import_i` in :math:`\module.\MIMPORTS`,
-    the segment :math:`\import_i` must be :ref:`valid <valid-import>` with an :ref:`external type <syntax-externtype>` :math:`\X{it}_i`.
-
-  * For each :math:`\export_i` in :math:`\module.\MEXPORTS`,
-    the segment :math:`\export_i` must be :ref:`valid <valid-export>` with :ref:`external type <syntax-externtype>` :math:`\X{et}_i`.
-
 * The length of :math:`C.\CMEMS` must not be larger than :math:`1`.
 
 * All export names :math:`\export_i.\ENAME` must be different.
@@ -607,15 +607,15 @@ Instead, the context :math:`C` for validation of the module's content is constru
      \quad
      (C \vdashfunc \func : \X{ft})^\ast
      \quad
-     (C \vdashtable \table : \X{tt})^\ast
+     (C' \vdashtable \table : \X{tt})^\ast
      \quad
-     (C \vdashmem \mem : \X{mt})^\ast
+     (C' \vdashmem \mem : \X{mt})^\ast
      \quad
      (C' \vdashglobal \global : \X{gt})^\ast
      \\
-     (C \vdashelem \elem : \X{rt})^\ast
+     (C' \vdashelem \elem : \X{rt})^\ast
      \quad
-     (C \vdashdata \data \ok)^n
+     (C' \vdashdata \data \ok)^n
      \quad
      (C \vdashstart \start \ok)^?
      \quad
@@ -667,8 +667,8 @@ Instead, the context :math:`C` for validation of the module's content is constru
    However, this recursion is just a specification device.
    All types needed to construct :math:`C` can easily be determined from a simple pre-pass over the module that does not perform any actual validation.
 
-   Globals, however, are not recursive.
-   The effect of defining the limited context :math:`C'` for validating the module's globals is that their initialization expressions can only access functions and imported globals and nothing else.
+   Globals, however, are not recursive and not accessible within :ref:`constant expressions <valid-const>` when they are defined locally.
+   The effect of defining the limited context :math:`C'` for validating certain definitions is that they can only access functions and imported globals and nothing else.
 
 .. note::
    The restriction on the number of memories may be lifted in future versions of WebAssembly.
diff --git a/test/core/data.wast b/test/core/data.wast
index 4f339bed4..b1e123975 100644
--- a/test/core/data.wast
+++ b/test/core/data.wast
@@ -81,9 +81,15 @@
   (data (global.get $g) "a")
 )
 
-;; Use of internal globals in constant expressions is not allowed in MVP.
-;; (module (memory 1) (data (global.get 0) "a") (global i32 (i32.const 0)))
-;; (module (memory 1) (data (global.get $g) "a") (global $g i32 (i32.const 0)))
+(assert_invalid
+  (module (memory 1) (global i32 (i32.const 0)) (data (global.get 0) "a"))
+  "unknown global"
+)
+(assert_invalid
+  (module (memory 1) (global $g i32 (i32.const 0)) (data (global.get $g) "a"))
+  "unknown global"
+)
+
 
 ;; Corner cases
 
@@ -456,11 +462,14 @@
   "constant expression required"
 )
 
-;; Use of internal globals in constant expressions is not allowed in MVP.
-;; (assert_invalid
-;;   (module (memory 1) (data (global.get $g)) (global $g (mut i32) (i32.const 0)))
-;;   "constant expression required"
-;; )
+(assert_invalid
+  (module
+    (global $g (import "test" "g") (mut i32))
+    (memory 1)
+    (data (global.get $g))
+  )
+  "constant expression required"
+)
 
 (assert_invalid
    (module 
diff --git a/test/core/elem.wast b/test/core/elem.wast
index 575ecef81..af12fec63 100644
--- a/test/core/elem.wast
+++ b/test/core/elem.wast
@@ -148,6 +148,16 @@
 (assert_return (invoke "call-7") (i32.const 65))
 (assert_return (invoke "call-9") (i32.const 66))
 
+(assert_invalid
+  (module (table 1 funcref) (global i32 (i32.const 0)) (elem (global.get 0) $f) (func $f))
+  "unknown global"
+)
+(assert_invalid
+  (module (table 1 funcref) (global $g i32 (i32.const 0)) (elem (global.get $g) $f) (func $f))
+  "unknown global"
+)
+
+
 ;; Corner cases
 
 (module
@@ -425,11 +435,14 @@
   "constant expression required"
 )
 
-;; Use of internal globals in constant expressions is not allowed in MVP.
-;; (assert_invalid
-;;   (module (table 1 funcref) (elem (global.get $g)) (global $g i32 (i32.const 0)))
-;;   "constant expression required"
-;; )
+(assert_invalid
+  (module
+    (global $g (import "test" "g") (mut i32))
+    (table 1 funcref)
+    (elem (global.get $g))
+  )
+  "constant expression required"
+)
 
 (assert_invalid
    (module 
diff --git a/test/core/global.wast b/test/core/global.wast
index 9fa5e2231..e40a305f1 100644
--- a/test/core/global.wast
+++ b/test/core/global.wast
@@ -348,6 +348,15 @@
   "unknown global"
 )
 
+(assert_invalid
+  (module (global i32 (i32.const 0)) (global i32 (global.get 0)))
+  "unknown global"
+)
+(assert_invalid
+  (module (global $g i32 (i32.const 0)) (global i32 (global.get $g)))
+  "unknown global"
+)
+
 (assert_invalid
   (module (global i32 (global.get 1)) (global i32 (i32.const 0)))
   "unknown global"

From 94a8847567c12430eb13b809bc347310ba23e67b Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 31 Aug 2022 08:21:14 +0200
Subject: [PATCH 193/285] Fix test

---
 test/core/br_on_non_null.wast | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/test/core/br_on_non_null.wast b/test/core/br_on_non_null.wast
index 6cf7eff50..9c33bf694 100644
--- a/test/core/br_on_non_null.wast
+++ b/test/core/br_on_non_null.wast
@@ -26,10 +26,11 @@
   (func (export "nullable-f") (result i32) (call $n (ref.func $f)))
 
   (func (export "unreachable") (result i32)
-    (block $l
-      (return (call_ref $t (br_on_null $l (unreachable))))
+    (block $l (result (ref $t))
+      (br_on_non_null $l (unreachable))
+      (return (i32.const -1))
     )
-    (i32.const -1)
+    (call_ref $t)
   )
 )
 

From c651c82eb546706eb0a10d1fd62d5aff2c655949 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 31 Aug 2022 08:33:57 +0200
Subject: [PATCH 194/285] A couple of tests

---
 test/core/unreached-invalid.wast | 22 ++++++++++++++++++++++
 test/core/unreached-valid.wast   | 22 ++++++++++++++++++----
 2 files changed, 40 insertions(+), 4 deletions(-)

diff --git a/test/core/unreached-invalid.wast b/test/core/unreached-invalid.wast
index 849fee65c..1dfcf91f8 100644
--- a/test/core/unreached-invalid.wast
+++ b/test/core/unreached-invalid.wast
@@ -758,3 +758,25 @@
   ))
   "type mismatch"
 )
+
+
+(assert_invalid
+  (module
+    (type $t (func (param i32) (result i64)))
+    (func (result i32)
+      (unreachable)
+      (call_ref $t)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type $t (func (param i32) (result i32 i32)))
+    (func (result i32)
+      (unreachable)
+      (call_ref $t)
+    )
+  )
+  "type mismatch"
+)
diff --git a/test/core/unreached-valid.wast b/test/core/unreached-valid.wast
index b7ebabfdb..b32051efe 100644
--- a/test/core/unreached-valid.wast
+++ b/test/core/unreached-valid.wast
@@ -17,26 +17,32 @@
     (unreachable)
   )
 
-  (func (export "select_unreached_result_1") (result i32)
+  (func (export "select-unreached-result1") (result i32)
     (unreachable) (i32.add (select))
   )
 
-  (func (export "select_unreached_result_2") (result i64)
+  (func (export "select-unreached-result2") (result i64)
     (unreachable) (i64.add (select (i64.const 0) (i32.const 0)))
   )
 
-  (func (export "unreachable-num")
+  (func (export "select-unreached-num")
     (unreachable)
     (select)
     (i32.eqz)
     (drop)
   )
-  (func (export "unreachable-ref")
+  (func (export "select-unreached-ref")
     (unreachable)
     (select)
     (ref.is_null)
     (drop)
   )
+
+  (type $t (func (param i32) (result i32)))
+  (func (export "call_ref-unreached") (result i32)
+    (unreachable)
+    (call_ref $t)
+  )
 )
 
 (assert_trap (invoke "select-trap-left" (i32.const 1)) "unreachable")
@@ -44,6 +50,14 @@
 (assert_trap (invoke "select-trap-right" (i32.const 1)) "unreachable")
 (assert_trap (invoke "select-trap-right" (i32.const 0)) "unreachable")
 
+(assert_trap (invoke "select-unreached-result1") "unreachable")
+(assert_trap (invoke "select-unreached-result2") "unreachable")
+(assert_trap (invoke "select-unreached-num") "unreachable")
+(assert_trap (invoke "select-unreached-ref") "unreachable")
+
+(assert_trap (invoke "call_ref-unreached") "unreachable")
+
+
 ;; Validation after unreachable
 
 (module

From d07e0decdb709f1cfe431c72d5df63b404eb13af Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 31 Aug 2022 10:07:13 +0200
Subject: [PATCH 195/285] Performance improvement

---
 document/core/valid/instructions.rst | 24 +++++++++++-------------
 interpreter/valid/valid.ml           | 18 ++++++++----------
 2 files changed, 19 insertions(+), 23 deletions(-)

diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index b5cb94b92..0049ed116 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -1606,42 +1606,40 @@ Empty Instruction Sequence: :math:`\epsilon`
    }
 
 
-Non-empty Instruction Sequence: :math:`\instr^\ast~\instr_N`
-............................................................
+Non-empty Instruction Sequence: :math:`\instr~{\instr'}^\ast`
+.............................................................
 
-* The instruction sequence :math:`\instr^\ast` must be valid with type :math:`[t_1^\ast] \to_{x_1^\ast} [t_2^\ast]`,
-  for some sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
+* The instruction :math:`\instr` must be valid with some type :math:`[t_1^\ast] \to_{x_1^\ast} [t_0^\ast]`.
 
 * Let :math:`C'` be the same :ref:`context <context>` as :math:`C`,
   but with:
 
   * |CLOCALS| the same as in C, except that for every :ref:`local index <syntax-localidx>` :math:`x` in :math:`x_1^\ast`, the :ref:`local type <syntax-localtype>` :math:`\CLOCALS[x]` has been updated to :ref:`initialization status <syntax-init>` `\SET`.
 
-* Under context :math:`C'`, the instruction :math:`\instr_N` must be valid with type :math:`[t^\ast] \to_{x_2^\ast} [t_3^\ast]`,
-  for some sequences of :ref:`value types <syntax-valtype>` :math:`t^\ast` and :math:`t_3^\ast`.
+* The instruction sequence :math:`{\instr'}^\ast` must be valid with some type :math:`[{t'}^\ast] \to_{x_2^\ast} [t_3^\ast]`.
 
 * There must be a sequence of :ref:`value types <syntax-valtype>` :math:`t_0^\ast`,
-  such that :math:`t_2^\ast = t_0^\ast~{t'}^\ast` where the type sequence :math:`{t'}^\ast` is as long as :math:`t^\ast`.
+  such that :math:`t_0^\ast = t_2^\ast~t^\ast` where the type sequence :math:`t^\ast` is as long as :math:`{t'}^\ast`.
 
-* For each :ref:`value type <syntax-valtype>` :math:`t'_i` in :math:`{t'}^\ast` and corresponding type :math:`t_i` in :math:`t^\ast`, the type :math:`t'_i` must :ref:`match <match-valtype>` :math:`t_i`.
+* For each :ref:`value type <syntax-valtype>` :math:`t'_i` in :math:`{t'}^\ast` and corresponding type :math:`t_i` in :math:`t^\ast`, the type :math:`t_i` must :ref:`match <match-valtype>` :math:`t'_i`.
 
-* Then the combined instruction sequence is valid with type :math:`[t_1^\ast] \to_{x_1^\ast x_2^\ast} [t_0^\ast~t_3^\ast]`.
+* Then the combined instruction sequence is valid with type :math:`[t_1^\ast] \to_{x_1^\ast x_2^\ast} [t_2^\ast~t_3^\ast]`.
 
 .. math::
    \frac{
      \begin{array}{@{}c@{}}
-     C \vdashinstrseq \instr^\ast : [t_1^\ast] \to_{x_1^\ast} [t_0^\ast~{t'}^\ast]
+     C \vdashinstr \instr : [t_1^\ast] \to_{x_1^\ast} [t_2^\ast~t^\ast]
      \qquad
-     (C \vdashvaltypematch t' \matchesvaltype t)^\ast
+     (C \vdashvaltypematch t \matchesvaltype t')^\ast
      \qquad
-     C' \vdashinstr \instr_N : [t^\ast] \to_{x_2^\ast} [t_3^\ast]
+     C' \vdashinstrseq {\instr'}^\ast : [{t'}^\ast] \to_{x_2^\ast} [t_3^\ast]
      \\
      (\init~t = C.\CLOCALS[x_1])^\ast
      \qquad
      C' = C~(\with C.\CLOCALS[x_1] = \SET~t)^\ast
      \end{array}
    }{
-     C \vdashinstrseq \instr^\ast~\instr_N : [t_1^\ast] \to_{x_1^\ast x_2^\ast} [t_0^\ast~t_3^\ast]
+     C \vdashinstrseq \instr~{\instr'}^\ast : [t_1^\ast] \to_{x_1^\ast x_2^\ast} [t_2^\ast~t_3^\ast]
    }
 
 
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index 167c80c11..eadc87d68 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -311,11 +311,6 @@ let check_block_type (c : context) (bt : block_type) at : instr_type =
   | VarBlockType x ->
     let FuncT (ts1, ts2) = func_type c x in InstrT (ts1, ts2, [])
 
-let check_local (c : context) (loc : local) : local_type =
-  check_val_type c loc.it.ltype loc.at;
-  let init = if defaultable loc.it.ltype then Set else Unset in
-  LocalT (init, loc.it.ltype)
-
 let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_instr_type =
   match e.it with
   | Unreachable ->
@@ -644,11 +639,9 @@ and check_seq (c : context) (s : infer_result_type) (es : instr list)
   | [] ->
     s, []
 
-  | _ ->
-    let es', e = Lib.List.split_last es in
-    let s', xs = check_seq c s es' in
-    let {ins; outs}, xs' = check_instr (init_locals c xs) e s' in
-    push c outs (pop c ins s' e.at), xs @ xs'
+  | e::es' ->
+    let {ins; outs}, xs = check_instr c e s in
+    check_seq (init_locals c xs) (push c outs (pop c ins s e.at)) es'
 
 and check_block (c : context) (es : instr list) (it : instr_type) at =
   let InstrT (ts1, ts2, _xs) = it in
@@ -673,6 +666,11 @@ and check_block (c : context) (es : instr list) (it : instr_type) at =
  *   x : variable
  *)
 
+let check_local (c : context) (loc : local) : local_type =
+  check_val_type c loc.it.ltype loc.at;
+  let init = if defaultable loc.it.ltype then Set else Unset in
+  LocalT (init, loc.it.ltype)
+
 let check_func (c : context) (f : func) =
   let {ftype; locals; body} = f.it in
   let FuncT (ts1, ts2) = func_type c ftype in

From 01a5790ea5e6a3f193c37b50674b66710cdebe59 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 31 Aug 2022 10:15:49 +0200
Subject: [PATCH 196/285] Typo

---
 document/core/valid/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 0049ed116..67bbd7cc3 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -13,7 +13,7 @@ In most cases, this is empty.
 .. note::
    For example, the instruction :math:`\I32.\ADD` has type :math:`[\I32~\I32] \to [\I32]`,
    consuming two |I32| values and producing one.
-   The instruction :math:`LOCALSET~x` has type :math:`[t] \to_x []`, provided :math:`t` is the type declared for the local :math:`x`.
+   The instruction :math:`\LOCALSET~x` has type :math:`[t] \to_x []`, provided :math:`t` is the type declared for the local :math:`x`.
 
 Typing extends to :ref:`instruction sequences <valid-instr-seq>` :math:`\instr^\ast`.
 Such a sequence has an instruction type :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]` if the accumulative effect of executing the instructions is consuming values of types :math:`t_1^\ast` off the operand stack, pushing new values of types :math:`t_2^\ast`, and setting all locals :math:`x^\ast`.

From 5acd6842fdf45e0767206262d4eacec83d376de6 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 31 Aug 2022 10:17:42 +0200
Subject: [PATCH 197/285] Another typo

---
 document/core/valid/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 67bbd7cc3..a2a89103e 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -1614,7 +1614,7 @@ Non-empty Instruction Sequence: :math:`\instr~{\instr'}^\ast`
 * Let :math:`C'` be the same :ref:`context <context>` as :math:`C`,
   but with:
 
-  * |CLOCALS| the same as in C, except that for every :ref:`local index <syntax-localidx>` :math:`x` in :math:`x_1^\ast`, the :ref:`local type <syntax-localtype>` :math:`\CLOCALS[x]` has been updated to :ref:`initialization status <syntax-init>` `\SET`.
+  * |CLOCALS| the same as in C, except that for every :ref:`local index <syntax-localidx>` :math:`x` in :math:`x_1^\ast`, the :ref:`local type <syntax-localtype>` :math:`\CLOCALS[x]` has been updated to :ref:`initialization status <syntax-init>` :math:`\SET`.
 
 * The instruction sequence :math:`{\instr'}^\ast` must be valid with some type :math:`[{t'}^\ast] \to_{x_2^\ast} [t_3^\ast]`.
 

From fa8aacd545e50d84de07763f7364aa6887c4b995 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 1 Sep 2022 19:27:30 +0200
Subject: [PATCH 198/285] [spec] Fix language config

---
 document/core/conf.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/conf.py b/document/core/conf.py
index 8980bae6f..22a578a2d 100644
--- a/document/core/conf.py
+++ b/document/core/conf.py
@@ -88,7 +88,7 @@
 #
 # This is also used if you do content translation via gettext catalogs.
 # Usually you set "language" from the command line for these cases.
-language = None
+language = 'en'
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:

From cb16e5aa1fa310b12739f735fc15d691e3935417 Mon Sep 17 00:00:00 2001
From: James Browning <thejamesernator@gmail.com>
Date: Mon, 12 Sep 2022 22:19:51 +1200
Subject: [PATCH 199/285] Fix null subtyping being wrong way around (#79)

---
 document/core/valid/matching.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/valid/matching.rst b/document/core/valid/matching.rst
index e3d976555..6e6a0fea7 100644
--- a/document/core/valid/matching.rst
+++ b/document/core/valid/matching.rst
@@ -106,7 +106,7 @@ A :ref:`reference type <syntax-reftype>` :math:`\REF~\NULL_1^?~heaptype_1` match
    \frac{
      C \vdashheaptypematch \heaptype_1 \matchesheaptype \heaptype_2
    }{
-     C \vdashreftypematch \REF~\NULL~\heaptype_1 \matchesreftype \REF~\NULL^?~\heaptype_2
+     C \vdashreftypematch \REF~\NULL^?~\heaptype_1 \matchesreftype \REF~\NULL~\heaptype_2
    }
 
 

From 04beeb7d3f1b3470970eb3672edfde92413138b0 Mon Sep 17 00:00:00 2001
From: whirlicote <78504913+whirlicote@users.noreply.github.com>
Date: Tue, 20 Sep 2022 08:26:57 +0200
Subject: [PATCH 200/285] [spec] Fix naming typo (#1532)

---
 document/core/exec/modules.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index 99eeb2756..ed647cc57 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -313,7 +313,7 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 
 2. Let :math:`a` be the first free :ref:`element address <syntax-elemaddr>` in :math:`S`.
 
-3. Let :math:`\eleminst` be the :ref:`element instance <syntax-eleminst>` :math:`\{ \EITYPE~t, \EIELEM~\reff^\ast \}`.
+3. Let :math:`\eleminst` be the :ref:`element instance <syntax-eleminst>` :math:`\{ \EITYPE~\reftype, \EIELEM~\reff^\ast \}`.
 
 4. Append :math:`\eleminst` to the |SELEMS| of :math:`S`.
 

From ed6031dc6ceab8e050ac9091fa7de108889dd998 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Tue, 20 Sep 2022 13:27:54 +0200
Subject: [PATCH 201/285] Defunctorise types again

---
 interpreter/binary/decode.ml    |   2 +-
 interpreter/binary/encode.ml    |   5 +-
 interpreter/exec/eval.ml        |  26 +-
 interpreter/exec/eval_num.ml    |   2 +-
 interpreter/host/env.ml         |   6 +-
 interpreter/host/spectest.ml    |   4 +-
 interpreter/runtime/func.ml     |   6 +-
 interpreter/runtime/func.mli    |  12 +-
 interpreter/runtime/global.ml   |   6 +-
 interpreter/runtime/global.mli  |   2 +-
 interpreter/runtime/instance.ml |   6 +-
 interpreter/runtime/memory.ml   |   2 +-
 interpreter/runtime/memory.mli  |   2 +-
 interpreter/runtime/table.ml    |   4 +-
 interpreter/runtime/table.mli   |   2 +-
 interpreter/runtime/value.ml    |   2 +-
 interpreter/script/import.ml    |   4 +-
 interpreter/script/import.mli   |   2 +-
 interpreter/script/js.ml        |  13 +-
 interpreter/script/run.ml       |  10 +-
 interpreter/script/script.ml    |   2 +-
 interpreter/syntax/free.ml      |   5 +-
 interpreter/syntax/types.ml     | 535 +++++++++++++++-----------------
 interpreter/text/arrange.ml     |   8 +-
 interpreter/text/parser.mly     |   4 +-
 interpreter/valid/match.ml      | 333 +++++++++-----------
 interpreter/valid/match.mli     |  87 ++----
 interpreter/valid/valid.ml      |   9 +-
 28 files changed, 494 insertions(+), 607 deletions(-)

diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 7794a3e65..9c86b567c 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -166,7 +166,7 @@ let var_type s =
 let heap_type s =
   let pos = pos s in
   either [
-    (fun s -> DefHT (var_type s));
+    (fun s -> DefHT (Stat (var_type s)));
     (fun s ->
       match s7 s with
       | -0x10 -> FuncHT
diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index da604a4fb..d2810202f 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -96,7 +96,8 @@ struct
   open Types
 
   let var_type = function
-    | x -> s33 x
+    | Stat x -> s33 x
+    | Dyn _ -> assert false
 
   let num_type = function
     | I32T -> s7 (-0x01)
@@ -167,7 +168,7 @@ struct
   let block_type = function
     | ValBlockType None -> s33 (-0x40l)
     | ValBlockType (Some t) -> val_type t
-    | VarBlockType x -> var_type x.it
+    | VarBlockType x -> s33 x.it
 
   let local (n, loc) = len n; val_type loc.it.ltype
 
diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index 1a3a67d01..0e850eb81 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -1,7 +1,7 @@
 open Ast
 open Pack
 open Source
-open Types.Dyn
+open Types
 open Value
 open Instance
 
@@ -231,7 +231,7 @@ let rec step (c : config) : config =
       | CallIndirect (x, y), Num (I32 i) :: vs ->
         let f = func_ref c.frame.inst x i e.at in
         if
-          Match.Dyn.eq_func_type () (func_type c.frame.inst y) (Func.type_of f)
+          Match.eq_func_type [] (func_type c.frame.inst y) (Func.type_of f)
         then
           vs, [Invoke f @@ e.at]
         else
@@ -702,7 +702,7 @@ let rec step (c : config) : config =
       | Func.AstFunc (_, inst', func) ->
         let {locals; body; _} = func.it in
         let m = Lib.Promise.value inst' in
-        let ts = List.map (fun loc -> Types.Dyn.dyn_val_type m.types loc.it.ltype) locals in
+        let ts = List.map (fun loc -> Types.dyn_val_type m.types loc.it.ltype) locals in
         let locs' = List.(rev (map Option.some args) @ map default_value ts) in
         let frame' = {inst = m; locals = List.map ref locs'} in
         let instr' = [Label (n2, [], ([], List.map plain body)) @@ func.at] in
@@ -738,7 +738,7 @@ let invoke (func : func_inst) (vs : value list) : value list =
   let FuncT (ts1, _ts2) = Func.type_of func in
   if List.length vs <> List.length ts1 then
     Crash.error at "wrong number of arguments";
-  if not (List.for_all2 (fun v -> Match.Dyn.match_val_type () (type_of_value v)) vs ts1) then
+  if not (List.for_all2 (fun v -> Match.match_val_type [] (type_of_value v)) vs ts1) then
     Crash.error at "wrong types of arguments";
   let c = config empty_module_inst (List.rev vs) [Invoke func @@ at] in
   try List.rev (eval c) with Stack_overflow ->
@@ -754,14 +754,14 @@ let eval_const (inst : module_inst) (const : const) : value =
 (* Modules *)
 
 let create_type (_ : type_) : type_inst =
-  Types.Dyn.alloc_uninit ()
+  Types.alloc_uninit ()
 
 let create_func (inst : module_inst) (f : func) : func_inst =
   Func.alloc (type_ inst f.it.ftype) (Lib.Promise.make ()) f
 
 let create_table (inst : module_inst) (tab : table) : table_inst =
   let {ttype; tinit} = tab.it in
-  let tt = Types.Dyn.dyn_table_type inst.types ttype in
+  let tt = Types.dyn_table_type inst.types ttype in
   let r =
     match eval_const inst tinit with
     | Ref r -> r
@@ -771,12 +771,12 @@ let create_table (inst : module_inst) (tab : table) : table_inst =
 
 let create_memory (inst : module_inst) (mem : memory) : memory_inst =
   let {mtype} = mem.it in
-  Memory.alloc (Types.Dyn.dyn_memory_type inst.types mtype)
+  Memory.alloc (Types.dyn_memory_type inst.types mtype)
 
 let create_global (inst : module_inst) (glob : global) : global_inst =
   let {gtype; ginit} = glob.it in
   let v = eval_const inst ginit in
-  Global.alloc (Types.Dyn.dyn_global_type inst.types gtype) v
+  Global.alloc (Types.dyn_global_type inst.types gtype) v
 
 let create_export (inst : module_inst) (ex : export) : export_inst =
   let {name; edesc} = ex.it in
@@ -800,14 +800,14 @@ let create_data (inst : module_inst) (seg : data_segment) : data_inst =
 let add_import (m : module_) (ext : extern) (im : import) (inst : module_inst)
   : module_inst =
   let it = Types.extern_type_of_import_type (import_type_of m im) in
-  let et = Types.Dyn.dyn_extern_type inst.types it in
+  let et = Types.dyn_extern_type inst.types it in
   let et' = extern_type_of inst.types ext in
-  if not (Match.Dyn.match_extern_type () et' et) then
+  if not (Match.match_extern_type [] et' et) then
     Link.error im.at ("incompatible import type for " ^
       "\"" ^ Utf8.encode im.it.module_name ^ "\" " ^
       "\"" ^ Utf8.encode im.it.item_name ^ "\": " ^
-      "expected " ^ Types.Dyn.string_of_extern_type et ^
-      ", got " ^ Types.Dyn.string_of_extern_type et');
+      "expected " ^ Types.string_of_extern_type et ^
+      ", got " ^ Types.string_of_extern_type et');
   match ext with
   | ExternFunc func -> {inst with funcs = func :: inst.funcs}
   | ExternTable tab -> {inst with tables = tab :: inst.tables}
@@ -816,7 +816,7 @@ let add_import (m : module_) (ext : extern) (im : import) (inst : module_inst)
 
 
 let init_type (inst : module_inst) (type_ : type_) (x : type_inst) =
-  Types.Dyn.init x (Types.Dyn.dyn_def_type inst.types type_.it)
+  Types.init x (Types.dyn_def_type inst.types type_.it)
 
 let init_func (inst : module_inst) (func : func_inst) =
   match func with
diff --git a/interpreter/exec/eval_num.ml b/interpreter/exec/eval_num.ml
index a42c302f6..8b2c1268c 100644
--- a/interpreter/exec/eval_num.ml
+++ b/interpreter/exec/eval_num.ml
@@ -1,4 +1,4 @@
-open Types.Dyn
+open Types
 open Value
 
 
diff --git a/interpreter/host/env.ml b/interpreter/host/env.ml
index f82d9a663..637b2f30b 100644
--- a/interpreter/host/env.ml
+++ b/interpreter/host/env.ml
@@ -4,7 +4,7 @@
  * we have agreement on what libc should look like.
  *)
 
-open Types.Dyn
+open Types
 open Value
 open Instance
 
@@ -42,7 +42,7 @@ let exit vs =
 let lookup name et =
   match Utf8.encode name, et with
   | "abort", ExternFuncT ft ->
-    ExternFunc (Func.alloc_host (Types.Dyn.alloc (DefFuncT ft)) abort)
+    ExternFunc (Func.alloc_host (Types.alloc (DefFuncT ft)) abort)
   | "exit", ExternFuncT ft ->
-    ExternFunc (Func.alloc_host (Types.Dyn.alloc (DefFuncT ft)) exit)
+    ExternFunc (Func.alloc_host (Types.alloc (DefFuncT ft)) exit)
   | _ -> raise Not_found
diff --git a/interpreter/host/spectest.ml b/interpreter/host/spectest.ml
index ffab91ce3..1573253ac 100644
--- a/interpreter/host/spectest.ml
+++ b/interpreter/host/spectest.ml
@@ -2,7 +2,7 @@
  * Simple collection of functions useful for writing test cases.
  *)
 
-open Types.Dyn
+open Types
 open Value
 open Instance
 
@@ -23,7 +23,7 @@ let table =
   Table.alloc (TableT ({min = 10l; max = Some 20l}, (Null, FuncHT)))
     (NullRef FuncHT)
 let memory = Memory.alloc (MemoryT {min = 1l; max = Some 2l})
-let func f ft = Func.alloc_host (Types.Dyn.alloc (DefFuncT ft)) (f ft)
+let func f ft = Func.alloc_host (Types.alloc (DefFuncT ft)) (f ft)
 
 let print_value v =
   Printf.printf "%s : %s\n"
diff --git a/interpreter/runtime/func.ml b/interpreter/runtime/func.ml
index 7d1123733..e4828dd45 100644
--- a/interpreter/runtime/func.ml
+++ b/interpreter/runtime/func.ml
@@ -1,10 +1,10 @@
-open Types.Dyn
+open Types
 open Value
 
 type 'inst t = 'inst func
 and 'inst func =
-  | AstFunc of var * 'inst * Ast.func
-  | HostFunc of var * (value list -> value list)
+  | AstFunc of type_addr * 'inst * Ast.func
+  | HostFunc of type_addr * (value list -> value list)
 
 let alloc x inst f = AstFunc (x, inst, f)
 let alloc_host x f = HostFunc (x, f)
diff --git a/interpreter/runtime/func.mli b/interpreter/runtime/func.mli
index 814e2c280..880ddc5c7 100644
--- a/interpreter/runtime/func.mli
+++ b/interpreter/runtime/func.mli
@@ -1,13 +1,13 @@
-open Types.Dyn
+open Types
 open Value
 
 type 'inst t = 'inst func
 and 'inst func =
-  | AstFunc of var * 'inst * Ast.func
-  | HostFunc of var * (value list -> value list)
+  | AstFunc of type_addr * 'inst * Ast.func
+  | HostFunc of type_addr * (value list -> value list)
 
-val alloc : var -> 'inst -> Ast.func -> 'inst func
-val alloc_host : var -> (value list -> value list) -> 'inst func
+val alloc : type_addr -> 'inst -> Ast.func -> 'inst func
+val alloc_host : type_addr -> (value list -> value list) -> 'inst func
 
 val type_of : 'inst func -> func_type
-val type_inst_of : 'inst func -> var
+val type_inst_of : 'inst func -> type_addr
diff --git a/interpreter/runtime/global.ml b/interpreter/runtime/global.ml
index a6712c3e3..a7df8e692 100644
--- a/interpreter/runtime/global.ml
+++ b/interpreter/runtime/global.ml
@@ -1,4 +1,4 @@
-open Types.Dyn
+open Types
 open Value
 
 type global = {ty : global_type; mutable content : value}
@@ -8,7 +8,7 @@ exception Type
 exception NotMutable
 
 let alloc (GlobalT (_mut, t) as ty) v =
-  if not (Match.Dyn.match_val_type () (type_of_value v) t) then raise Type;
+  if not (Match.match_val_type [] (type_of_value v) t) then raise Type;
   {ty; content = v}
 
 let type_of glob =
@@ -20,5 +20,5 @@ let load glob =
 let store glob v =
   let GlobalT (mut, t) = glob.ty in
   if mut <> Var then raise NotMutable;
-  if not (Match.Dyn.match_val_type () (type_of_value v) t) then raise Type;
+  if not (Match.match_val_type [] (type_of_value v) t) then raise Type;
   glob.content <- v
diff --git a/interpreter/runtime/global.mli b/interpreter/runtime/global.mli
index b38aa8f31..bf93c1a8c 100644
--- a/interpreter/runtime/global.mli
+++ b/interpreter/runtime/global.mli
@@ -1,4 +1,4 @@
-open Types.Dyn
+open Types
 open Value
 
 type global
diff --git a/interpreter/runtime/instance.ml b/interpreter/runtime/instance.ml
index 29d42f533..13989bf38 100644
--- a/interpreter/runtime/instance.ml
+++ b/interpreter/runtime/instance.ml
@@ -1,4 +1,4 @@
-open Types.Dyn
+open Types
 
 type module_inst =
 {
@@ -12,7 +12,7 @@ type module_inst =
   exports : export_inst list;
 }
 
-and type_inst = var
+and type_inst = type_addr
 and func_inst = module_inst Lib.Promise.t Func.t
 and table_inst = Table.t
 and memory_inst = Memory.t
@@ -35,7 +35,7 @@ type Value.ref_ += FuncRef of func_inst
 let () =
   let type_of_ref' = !Value.type_of_ref' in
   Value.type_of_ref' := function
-    | FuncRef f -> DefHT (Func.type_inst_of f)
+    | FuncRef f -> DefHT (Dyn (Func.type_inst_of f))
     | r -> type_of_ref' r
 
 let () =
diff --git a/interpreter/runtime/memory.ml b/interpreter/runtime/memory.ml
index 9b6a42a35..91fb44211 100644
--- a/interpreter/runtime/memory.ml
+++ b/interpreter/runtime/memory.ml
@@ -1,4 +1,4 @@
-open Types.Dyn
+open Types
 open Pack
 open Value
 open Bigarray
diff --git a/interpreter/runtime/memory.mli b/interpreter/runtime/memory.mli
index 960c754e4..f32482867 100644
--- a/interpreter/runtime/memory.mli
+++ b/interpreter/runtime/memory.mli
@@ -1,4 +1,4 @@
-open Types.Dyn
+open Types
 open Value
 
 type memory
diff --git a/interpreter/runtime/table.ml b/interpreter/runtime/table.ml
index 29690fec0..3d8a1c3f2 100644
--- a/interpreter/runtime/table.ml
+++ b/interpreter/runtime/table.ml
@@ -1,4 +1,4 @@
-open Types.Dyn
+open Types
 open Value
 
 type size = int32
@@ -51,7 +51,7 @@ let load tab i =
 
 let store tab i r =
   let TableT (lim, t) = tab.ty in
-  if not (Match.Dyn.match_ref_type () (type_of_ref r) t) then raise Type;
+  if not (Match.match_ref_type [] (type_of_ref r) t) then raise Type;
   try Lib.Array32.set tab.content i r with Invalid_argument _ -> raise Bounds
 
 let blit tab offset rs =
diff --git a/interpreter/runtime/table.mli b/interpreter/runtime/table.mli
index 7da1ac3f0..2d95b7411 100644
--- a/interpreter/runtime/table.mli
+++ b/interpreter/runtime/table.mli
@@ -1,4 +1,4 @@
-open Types.Dyn
+open Types
 open Value
 
 type table
diff --git a/interpreter/runtime/value.ml b/interpreter/runtime/value.ml
index f9679fff3..e24fc3da5 100644
--- a/interpreter/runtime/value.ml
+++ b/interpreter/runtime/value.ml
@@ -1,4 +1,4 @@
-open Types.Dyn
+open Types
 
 
 (* Values and operators *)
diff --git a/interpreter/script/import.ml b/interpreter/script/import.ml
index 95b48b8d2..cac9a8d83 100644
--- a/interpreter/script/import.ml
+++ b/interpreter/script/import.ml
@@ -1,6 +1,6 @@
 open Source
 open Ast
-open Types.Dyn
+open Types
 
 module Unknown = Error.Make ()
 exception Unknown = Unknown.Error  (* indicates unknown import name *)
@@ -17,5 +17,5 @@ let lookup (ImportT (et, module_name, item_name)) at : Instance.extern =
         "\".\"" ^ Types.string_of_name item_name ^ "\"")
 
 let link m =
-  let ModuleT (_, its, _) = Types.Dyn.dyn_module_type (module_type_of m) in
+  let ModuleT (_, its, _) = Types.dyn_module_type (module_type_of m) in
   List.map2 lookup its (List.map Source.at m.it.imports)
diff --git a/interpreter/script/import.mli b/interpreter/script/import.mli
index 23f3b3239..7919297e1 100644
--- a/interpreter/script/import.mli
+++ b/interpreter/script/import.mli
@@ -4,5 +4,5 @@ val link : Ast.module_ -> Instance.extern list (* raises Unknown *)
 
 val register :
   Ast.name ->
-  (Ast.name -> Types.Dyn.extern_type -> Instance.extern (* raises Not_found *)) ->
+  (Ast.name -> Types.extern_type -> Instance.extern (* raises Not_found *)) ->
   unit
diff --git a/interpreter/script/js.ml b/interpreter/script/js.ml
index c07932557..8ef244d77 100644
--- a/interpreter/script/js.ml
+++ b/interpreter/script/js.ml
@@ -265,12 +265,13 @@ let abs_mask_of = function
   | I64T | F64T -> I64 Int64.max_int
 
 let null_heap_type_of = function
-  | Types.Dyn.FuncHT -> FuncHT
-  | Types.Dyn.ExternHT -> ExternHT
-  | Types.Dyn.BotHT -> assert false
-  | Types.Dyn.DefHT x ->
-    match Types.Dyn.def_of x with
-    | Types.Dyn.DefFuncT _ -> FuncHT
+  | Types.FuncHT -> FuncHT
+  | Types.ExternHT -> ExternHT
+  | Types.BotHT -> assert false
+  | Types.DefHT (Stat _) -> assert false
+  | Types.DefHT (Dyn a) ->
+    match Types.def_of a with
+    | Types.DefFuncT _ -> FuncHT
 
 let value v =
   match v.it with
diff --git a/interpreter/script/run.ml b/interpreter/script/run.ml
index d0e5a523f..31aefb65f 100644
--- a/interpreter/script/run.ml
+++ b/interpreter/script/run.ml
@@ -220,14 +220,14 @@ let print_module x_opt m =
 let print_values vs =
   let ts = List.map Value.type_of_value vs in
   Printf.printf "%s : %s\n%!"
-    (Value.string_of_values vs) (Types.Dyn.string_of_result_type ts)
+    (Value.string_of_values vs) (Types.string_of_result_type ts)
 
 let string_of_nan = function
   | CanonicalNan -> "nan:canonical"
   | ArithmeticNan -> "nan:arithmetic"
 
 let type_of_result r =
-  let open Types.Dyn in
+  let open Types in
   match r with
   | NumResult (NumPat n) -> NumT (Value.type_of_num n.it)
   | NumResult (NanPat n) -> NumT (Value.type_of_num n.it)
@@ -268,7 +268,7 @@ let string_of_results = function
 let print_results rs =
   let ts = List.map type_of_result rs in
   Printf.printf "%s : %s\n%!"
-    (string_of_results rs) (Types.Dyn.string_of_result_type ts)
+    (string_of_results rs) (Types.string_of_result_type ts)
 
 
 (* Configuration *)
@@ -325,11 +325,11 @@ let run_action act : Value.t list =
     let inst = lookup_instance x_opt act.at in
     (match Instance.export inst name with
     | Some (Instance.ExternFunc f) ->
-      let Types.Dyn.FuncT (ts1, _ts2) = Func.type_of f in
+      let Types.FuncT (ts1, _ts2) = Func.type_of f in
       if List.length vs <> List.length ts1 then
         Script.error act.at "wrong number of arguments";
       List.iter2 (fun v t ->
-        if not (Match.Dyn.match_val_type () (Value.type_of_value v.it) t) then
+        if not (Match.match_val_type [] (Value.type_of_value v.it) t) then
           Script.error v.at "wrong type of argument"
       ) vs ts1;
       Eval.invoke f (List.map (fun v -> v.it) vs)
diff --git a/interpreter/script/script.ml b/interpreter/script/script.ml
index 067028ddb..a822c30d0 100644
--- a/interpreter/script/script.ml
+++ b/interpreter/script/script.ml
@@ -70,7 +70,7 @@ exception Syntax of Source.region * string
 let () =
   let type_of_ref' = !Value.type_of_ref' in
   Value.type_of_ref' := function
-    | ExternRef _ -> Types.Dyn.ExternHT
+    | ExternRef _ -> Types.ExternHT
     | r -> type_of_ref' r
 
 let () =
diff --git a/interpreter/syntax/free.ml b/interpreter/syntax/free.ml
index a58475b76..4b779697a 100644
--- a/interpreter/syntax/free.ml
+++ b/interpreter/syntax/free.ml
@@ -63,7 +63,8 @@ let opt free xo = Lib.Option.get (Option.map free xo) empty
 let list free xs = List.fold_left union empty (List.map free xs)
 
 let var_type = function
-  | x -> types (idx' x)
+  | Stat x -> types (idx' x)
+  | Dyn x -> empty
 
 let num_type = function
   | I32T | I64T | F32T | F64T -> empty
@@ -93,7 +94,7 @@ let def_type = function
   | DefFuncT ft -> func_type ft
 
 let block_type = function
-  | VarBlockType x -> var_type x.it
+  | VarBlockType x -> types (idx x)
   | ValBlockType t -> opt val_type t
 
 let rec instr (e : instr) =
diff --git a/interpreter/syntax/types.ml b/interpreter/syntax/types.ml
index 25b74c1f7..997eba49f 100644
--- a/interpreter/syntax/types.ml
+++ b/interpreter/syntax/types.ml
@@ -1,341 +1,294 @@
 (* Generic Types *)
 
-module type Var =
-sig
-  type var
-  val eq_var : var -> var -> bool
-  val string_of_var : var -> string
-end
+type type_idx = int32
+type local_idx = int32
+type name = Utf8.unicode
+
+type null = NoNull | Null
+type mut = Cons | Var
+type init = Set | Unset
+type 'a limits = {min : 'a; max : 'a option}
+
+type type_addr = ..
+type var = Stat of type_idx | Dyn of type_addr
+
+type num_type = I32T | I64T | F32T | F64T
+type vec_type = V128T
+type heap_type = FuncHT | ExternHT | DefHT of var | BotHT
+type ref_type = null * heap_type
+type val_type = NumT of num_type | VecT of vec_type | RefT of ref_type | BotT
+
+type result_type = val_type list
+type instr_type = InstrT of result_type * result_type * local_idx list
+type func_type = FuncT of result_type * result_type
+type def_type = DefFuncT of func_type
+
+type table_type = TableT of Int32.t limits * ref_type
+type memory_type = MemoryT of Int32.t limits
+type global_type = GlobalT of mut * val_type
+type local_type = LocalT of init * val_type
+type extern_type =
+  | ExternFuncT of func_type
+  | ExternTableT of table_type
+  | ExternMemoryT of memory_type
+  | ExternGlobalT of global_type
+
+type export_type = ExportT of extern_type * name
+type import_type = ImportT of extern_type * name * name
+type module_type =
+  | ModuleT of def_type list * import_type list * export_type list
+
+
+(* Attributes *)
+
+let num_size : num_type -> int = function
+  | I32T | F32T -> 4
+  | I64T | F64T -> 8
+
+let vec_size : vec_type -> int = function
+  | V128T -> 16
+
+let is_num_type : val_type -> bool = function
+  | NumT _ | BotT -> true
+  | _ -> false
+
+let is_vec_type : val_type -> bool = function
+  | VecT _ | BotT -> true
+  | _ -> false
+
+let is_ref_type : val_type -> bool = function
+  | RefT _ | BotT -> true
+  | _ -> false
+
+let defaultable : val_type -> bool = function
+  | NumT _ -> true
+  | VecT _ -> true
+  | RefT (nul, _) -> nul = Null
+  | BotT -> assert false
 
-module Make (Var : Var) =
-struct
-  include Var
-
-  type type_idx = int32
-  type local_idx = int32
-  type name = Utf8.unicode
-
-  type null = NoNull | Null
-  type mut = Cons | Var
-  type init = Set | Unset
-  type 'a limits = {min : 'a; max : 'a option}
-
-  type num_type = I32T | I64T | F32T | F64T
-  type vec_type = V128T
-  type heap_type = FuncHT | ExternHT | DefHT of var | BotHT
-  type ref_type = null * heap_type
-  type val_type = NumT of num_type | VecT of vec_type | RefT of ref_type | BotT
-
-  type result_type = val_type list
-  type instr_type = InstrT of result_type * result_type * local_idx list
-  type func_type = FuncT of result_type * result_type
-  type def_type = DefFuncT of func_type
-
-  type table_type = TableT of Int32.t limits * ref_type
-  type memory_type = MemoryT of Int32.t limits
-  type global_type = GlobalT of mut * val_type
-  type local_type = LocalT of init * val_type
-  type extern_type =
-    | ExternFuncT of func_type
-    | ExternTableT of table_type
-    | ExternMemoryT of memory_type
-    | ExternGlobalT of global_type
-
-  type export_type = ExportT of extern_type * name
-  type import_type = ImportT of extern_type * name * name
-  type module_type =
-    | ModuleT of def_type list * import_type list * export_type list
-
-
-  (* Attributes *)
-
-  let num_size : num_type -> int = function
-    | I32T | F32T -> 4
-    | I64T | F64T -> 8
-
-  let vec_size : vec_type -> int = function
-    | V128T -> 16
-
-  let is_num_type : val_type -> bool = function
-    | NumT _ | BotT -> true
-    | _ -> false
-
-  let is_vec_type : val_type -> bool = function
-    | VecT _ | BotT -> true
-    | _ -> false
-
-  let is_ref_type : val_type -> bool = function
-    | RefT _ | BotT -> true
-    | _ -> false
-
-  let defaultable : val_type -> bool = function
-    | NumT _ -> true
-    | VecT _ -> true
-    | RefT (nul, _) -> nul = Null
-    | BotT -> assert false
-
-
-  (* Projections *)
-
-  let as_func_def_type (dt : def_type) : func_type =
-    match dt with
-    | DefFuncT ft -> ft
-
-  let extern_type_of_import_type (ImportT (et, _, _)) = et
-  let extern_type_of_export_type (ExportT (et, _)) = et
-
-
-  (* Filters *)
-
-  let funcs (ets : extern_type list) : func_type list =
-    Lib.List.map_filter (function ExternFuncT ft -> Some ft | _ -> None) ets
-  let tables (ets : extern_type list) : table_type list =
-    Lib.List.map_filter (function ExternTableT tt -> Some tt | _ -> None) ets
-  let memories (ets : extern_type list) : memory_type list =
-    Lib.List.map_filter (function ExternMemoryT mt -> Some mt | _ -> None) ets
-  let globals (ets : extern_type list) : global_type list =
-    Lib.List.map_filter (function ExternGlobalT gt -> Some gt | _ -> None) ets
-
-
-  (* String conversion *)
-
-  let string_of_idx x =
-    I32.to_string_u x
-
-  let string_of_name n =
-    let b = Buffer.create 16 in
-    let escape uc =
-      if uc < 0x20 || uc >= 0x7f then
-        Buffer.add_string b (Printf.sprintf "\\u{%02x}" uc)
-      else begin
-        let c = Char.chr uc in
-        if c = '\"' || c = '\\' then Buffer.add_char b '\\';
-        Buffer.add_char b c
-      end
-    in
-    List.iter escape n;
-    Buffer.contents b
 
-  let string_of_null : null -> string = function
-    | NoNull -> ""
-    | Null -> "null "
+(* Projections *)
+
+let as_func_def_type (dt : def_type) : func_type =
+  match dt with
+  | DefFuncT ft -> ft
+
+let extern_type_of_import_type (ImportT (et, _, _)) = et
+let extern_type_of_export_type (ExportT (et, _)) = et
+
+
+(* Filters *)
+
+let funcs (ets : extern_type list) : func_type list =
+  Lib.List.map_filter (function ExternFuncT ft -> Some ft | _ -> None) ets
+let tables (ets : extern_type list) : table_type list =
+  Lib.List.map_filter (function ExternTableT tt -> Some tt | _ -> None) ets
+let memories (ets : extern_type list) : memory_type list =
+  Lib.List.map_filter (function ExternMemoryT mt -> Some mt | _ -> None) ets
+let globals (ets : extern_type list) : global_type list =
+  Lib.List.map_filter (function ExternGlobalT gt -> Some gt | _ -> None) ets
+
+
+(* String conversion *)
 
-  let string_of_num_type : num_type -> string = function
-    | I32T -> "i32"
-    | I64T -> "i64"
-    | F32T -> "f32"
-    | F64T -> "f64"
+let string_of_idx x =
+  I32.to_string_u x
+
+let string_of_name n =
+  let b = Buffer.create 16 in
+  let escape uc =
+    if uc < 0x20 || uc >= 0x7f then
+      Buffer.add_string b (Printf.sprintf "\\u{%02x}" uc)
+    else begin
+      let c = Char.chr uc in
+      if c = '\"' || c = '\\' then Buffer.add_char b '\\';
+      Buffer.add_char b c
+    end
+  in
+  List.iter escape n;
+  Buffer.contents b
 
-  let string_of_vec_type : vec_type -> string = function
-    | V128T -> "v128"
+let string_of_null : null -> string = function
+  | NoNull -> ""
+  | Null -> "null "
 
-  let string_of_heap_type : heap_type -> string = function
-    | FuncHT -> "func"
-    | ExternHT -> "extern"
-    | DefHT x -> string_of_var x
-    | BotHT -> "something"
+let string_of_addr' = ref (fun (a : type_addr) -> assert false)
+let string_of_addr a = !string_of_addr' a
 
-  let string_of_ref_type : ref_type -> string = function
-    | (nul, t) ->
-      "(ref " ^ string_of_null nul ^ string_of_heap_type t ^ ")"
+let string_of_var : var -> string = function
+  | Stat x -> I32.to_string_u x
+  | Dyn a -> string_of_addr a
 
-  let string_of_val_type : val_type -> string = function
-    | NumT t -> string_of_num_type t
-    | VecT t -> string_of_vec_type t
-    | RefT t -> string_of_ref_type t
-    | BotT -> "(something)"
+let string_of_num_type : num_type -> string = function
+  | I32T -> "i32"
+  | I64T -> "i64"
+  | F32T -> "f32"
+  | F64T -> "f64"
 
-  let string_of_result_type : result_type -> string = function
-    | ts -> "[" ^ String.concat " " (List.map string_of_val_type ts) ^ "]"
+let string_of_vec_type : vec_type -> string = function
+  | V128T -> "v128"
 
-  let string_of_func_type : func_type -> string = function
-    | FuncT (ts1, ts2) ->
-      string_of_result_type ts1 ^ " -> " ^ string_of_result_type ts2
+let string_of_heap_type : heap_type -> string = function
+  | FuncHT -> "func"
+  | ExternHT -> "extern"
+  | DefHT x -> string_of_var x
+  | BotHT -> "something"
 
-  let string_of_def_type : def_type -> string = function
-    | DefFuncT ft -> "func " ^ string_of_func_type ft
+let string_of_ref_type : ref_type -> string = function
+  | (nul, t) ->
+    "(ref " ^ string_of_null nul ^ string_of_heap_type t ^ ")"
 
+let string_of_val_type : val_type -> string = function
+  | NumT t -> string_of_num_type t
+  | VecT t -> string_of_vec_type t
+  | RefT t -> string_of_ref_type t
+  | BotT -> "(something)"
 
-  let string_of_limits : I32.t limits -> string = function
-    | {min; max} ->
-      I32.to_string_u min ^
-      (match max with None -> "" | Some n -> " " ^ I32.to_string_u n)
+let string_of_result_type : result_type -> string = function
+  | ts -> "[" ^ String.concat " " (List.map string_of_val_type ts) ^ "]"
 
-  let string_of_memory_type : memory_type -> string = function
-    | MemoryT lim -> string_of_limits lim
+let string_of_func_type : func_type -> string = function
+  | FuncT (ts1, ts2) ->
+    string_of_result_type ts1 ^ " -> " ^ string_of_result_type ts2
 
-  let string_of_table_type : table_type -> string = function
-    | TableT (lim, t) -> string_of_limits lim ^ " " ^ string_of_ref_type t
+let string_of_def_type : def_type -> string = function
+  | DefFuncT ft -> "func " ^ string_of_func_type ft
 
-  let string_of_global_type : global_type -> string = function
-    | GlobalT (Cons, t) -> string_of_val_type t
-    | GlobalT (Var, t) -> "(mut " ^ string_of_val_type t ^ ")"
 
-  let string_of_local_type : local_type -> string = function
-    | LocalT (Set, t) -> string_of_val_type t
-    | LocalT (Unset, t) -> "(unset " ^ string_of_val_type t ^ ")"
+let string_of_limits : I32.t limits -> string = function
+  | {min; max} ->
+    I32.to_string_u min ^
+    (match max with None -> "" | Some n -> " " ^ I32.to_string_u n)
 
-  let string_of_extern_type : extern_type -> string = function
-    | ExternFuncT ft -> "func " ^ string_of_func_type ft
-    | ExternTableT tt -> "table " ^ string_of_table_type tt
-    | ExternMemoryT mt -> "memory " ^ string_of_memory_type mt
-    | ExternGlobalT gt -> "global " ^ string_of_global_type gt
+let string_of_memory_type : memory_type -> string = function
+  | MemoryT lim -> string_of_limits lim
 
+let string_of_table_type : table_type -> string = function
+  | TableT (lim, t) -> string_of_limits lim ^ " " ^ string_of_ref_type t
 
-  let string_of_export_type : export_type -> string = function
-    | ExportT (et, name) ->
-      "\"" ^ string_of_name name ^ "\" : " ^ string_of_extern_type et
+let string_of_global_type : global_type -> string = function
+  | GlobalT (Cons, t) -> string_of_val_type t
+  | GlobalT (Var, t) -> "(mut " ^ string_of_val_type t ^ ")"
 
-  let string_of_import_type : import_type -> string = function
-    | ImportT (et, module_name, name) ->
-      "\"" ^ string_of_name module_name ^ "\" \"" ^
-        string_of_name name ^ "\" : " ^ string_of_extern_type et
-
-  let string_of_module_type : module_type -> string = function
-    | ModuleT (dts, its, ets) ->
-      String.concat "" (
-        List.mapi (fun i dt -> "type " ^ string_of_int i ^ " = " ^ string_of_def_type dt ^ "\n") dts @
-        List.map (fun it -> "import " ^ string_of_import_type it ^ "\n") its @
-        List.map (fun et -> "export " ^ string_of_export_type et ^ "\n") ets
-      )
-end
+let string_of_local_type : local_type -> string = function
+  | LocalT (Set, t) -> string_of_val_type t
+  | LocalT (Unset, t) -> "(unset " ^ string_of_val_type t ^ ")"
 
+let string_of_extern_type : extern_type -> string = function
+  | ExternFuncT ft -> "func " ^ string_of_func_type ft
+  | ExternTableT tt -> "table " ^ string_of_table_type tt
+  | ExternMemoryT mt -> "memory " ^ string_of_memory_type mt
+  | ExternGlobalT gt -> "global " ^ string_of_global_type gt
+
+
+let string_of_export_type : export_type -> string = function
+  | ExportT (et, name) ->
+    "\"" ^ string_of_name name ^ "\" : " ^ string_of_extern_type et
 
-(* Static Types *)
-
-module StatVar =
-struct
-  type var = int32
-  let eq_var = (=)
-  let string_of_var = I32.to_string_u
-end
-
-module Stat = Make (StatVar)
-
-include Stat
+let string_of_import_type : import_type -> string = function
+  | ImportT (et, module_name, name) ->
+    "\"" ^ string_of_name module_name ^ "\" \"" ^
+      string_of_name name ^ "\" : " ^ string_of_extern_type et
+
+let string_of_module_type : module_type -> string = function
+  | ModuleT (dts, its, ets) ->
+    String.concat "" (
+      List.mapi (fun i dt -> "type " ^ string_of_int i ^ " = " ^ string_of_def_type dt ^ "\n") dts @
+      List.map (fun it -> "import " ^ string_of_import_type it ^ "\n") its @
+      List.map (fun et -> "export " ^ string_of_export_type et ^ "\n") ets
+    )
 
 
 (* Dynamic Types *)
 
-module DynVar =
-struct
-  (* Use extensible type, since recursive modules won't work *)
-  type var = ..
-
-  let eq_var = (==)
-
-  let string_of_var' = ref (fun (x : var) -> assert false)
-  let string_of_var x = !string_of_var' x
-end
-
-module Dyn =
-struct
-  include Make (DynVar)
+type type_addr += Addr of def_type Lib.Promise.t
 
-  type DynVar.var += Addr of def_type Lib.Promise.t
+let unwrap = function
+  | Addr p -> p
+  | _ -> assert false
 
-  let unwrap = function
-    | Addr p -> p
-    | _ -> assert false
+let alloc_uninit () = Addr (Lib.Promise.make ())
+let init x dt = Lib.Promise.fulfill (unwrap x) dt
+let alloc dt = let x = alloc_uninit () in init x dt; x
+let def_of x = Lib.Promise.value (unwrap x)
 
-  let alloc_uninit () = Addr (Lib.Promise.make ())
-  let init x dt = Lib.Promise.fulfill (unwrap x) dt
-  let alloc dt = let x = alloc_uninit () in init x dt; x
-  let def_of x = Lib.Promise.value (unwrap x)
+let () = string_of_addr' :=
+  let inner = ref false in
+  fun x ->
+    if !inner then "..." else
+    ( inner := true;
+      try
+        let s = string_of_def_type (def_of x) in
+        inner := false; "(" ^ s ^ ")"
+      with exn -> inner := false; raise exn
+    )
 
-  let () = DynVar.string_of_var' :=
-    let inner = ref false in
-    fun x ->
-      if !inner then "..." else
-      ( inner := true;
-        try
-          let s = string_of_def_type (def_of x) in
-          inner := false; "(" ^ s ^ ")"
-        with exn -> inner := false; raise exn
-      )
 
-  (* Conversion *)
+(* Instantiation *)
 
-  let dyn_null c : Stat.null -> null = function
-    | Stat.Null -> Null
-    | Stat.NoNull -> NoNull
+let dyn_var_type c = function
+  | Stat x -> Dyn (Lib.List32.nth c x)
+  | Dyn a -> assert false
 
-  let dyn_mut c : Stat.mut -> mut = function
-    | Stat.Cons -> Cons
-    | Stat.Var -> Var
+let dyn_num_type c = function
+  | t -> t
 
-  let dyn_init c : Stat.init -> init = function
-    | Stat.Set -> Set
-    | Stat.Unset -> Unset
+let dyn_vec_type c = function
+  | t -> t
 
-  let dyn_limits c : 'a Stat.limits -> 'a limits = function
-    | Stat.{min; max} -> {min; max}
+let dyn_heap_type c = function
+  | FuncHT -> FuncHT
+  | ExternHT -> ExternHT
+  | DefHT x -> DefHT (dyn_var_type c x)
+  | BotHT -> BotHT
 
-  let dyn_var_type c (x : Stat.var) : var = Lib.List32.nth c x
+let dyn_ref_type c = function
+  | (nul, t) -> (nul, dyn_heap_type c t)
 
-  let dyn_num_type c : Stat.num_type -> num_type = function
-    | Stat.I32T -> I32T
-    | Stat.I64T -> I64T
-    | Stat.F32T -> F32T
-    | Stat.F64T -> F64T
+let dyn_val_type c = function
+  | NumT t -> NumT (dyn_num_type c t)
+  | VecT t -> VecT (dyn_vec_type c t)
+  | RefT t -> RefT (dyn_ref_type c t)
+  | BotT -> BotT
 
-  let dyn_vec_type c : Stat.vec_type -> vec_type = function
-    | Stat.V128T -> V128T
+let dyn_result_type c = function
+  | ts -> List.map (dyn_val_type c) ts
 
-  let dyn_heap_type c : Stat.heap_type -> heap_type = function
-    | Stat.FuncHT -> FuncHT
-    | Stat.ExternHT -> ExternHT
-    | Stat.DefHT x -> DefHT (dyn_var_type c x)
-    | Stat.BotHT -> BotHT
+let dyn_func_type c = function
+  | FuncT (ts1, ts2) -> FuncT (dyn_result_type c ts1, dyn_result_type c ts2)
 
-  let dyn_ref_type c : Stat.ref_type -> ref_type = function
-    | (nul, t) -> (dyn_null c nul, dyn_heap_type c t)
+let dyn_def_type c = function
+  | DefFuncT ft -> DefFuncT (dyn_func_type c ft)
 
-  let dyn_val_type c : Stat.val_type -> val_type = function
-    | Stat.NumT t -> NumT (dyn_num_type c t)
-    | Stat.VecT t -> VecT (dyn_vec_type c t)
-    | Stat.RefT t -> RefT (dyn_ref_type c t)
-    | Stat.BotT -> BotT
+let dyn_local_type c = function
+  | LocalT (init, t) -> LocalT (init, dyn_val_type c t)
 
-  let dyn_result_type c : Stat.result_type -> result_type = function
-    | ts -> List.map (dyn_val_type c) ts
+let dyn_memory_type c = function
+  | MemoryT lim -> MemoryT lim
 
-  let dyn_func_type c : Stat.func_type -> func_type = function
-    | Stat.FuncT (ts1, ts2) -> FuncT (dyn_result_type c ts1, dyn_result_type c ts2)
+let dyn_table_type c = function
+  | TableT (lim, t) -> TableT (lim, dyn_ref_type c t)
 
-  let dyn_def_type c : Stat.def_type -> def_type = function
-    | Stat.DefFuncT ft -> DefFuncT (dyn_func_type c ft)
+let dyn_global_type c = function
+  | GlobalT (mut, t) -> GlobalT (mut, dyn_val_type c t)
 
-  let dyn_local_type c : Stat.local_type -> local_type = function
-    | Stat.LocalT (init, t) -> LocalT (dyn_init c init, dyn_val_type c t)
+let dyn_extern_type c = function
+  | ExternFuncT ft -> ExternFuncT (dyn_func_type c ft)
+  | ExternTableT tt -> ExternTableT (dyn_table_type c tt)
+  | ExternMemoryT mt -> ExternMemoryT (dyn_memory_type c mt)
+  | ExternGlobalT gt -> ExternGlobalT (dyn_global_type c gt)
 
-  let dyn_memory_type c : Stat.memory_type -> memory_type = function
-    | Stat.MemoryT lim -> MemoryT (dyn_limits c lim)
+let dyn_export_type c = function
+  | ExportT (et, name) -> ExportT (dyn_extern_type c et, name)
 
-  let dyn_table_type c : Stat.table_type -> table_type = function
-    | Stat.TableT (lim, t) -> TableT (dyn_limits c lim, dyn_ref_type c t)
+let dyn_import_type c = function
+  | ImportT (et, module_name, name) ->
+    ImportT (dyn_extern_type c et, module_name, name)
 
-  let dyn_global_type c : Stat.global_type -> global_type = function
-    | Stat.GlobalT (mut, t) -> GlobalT (dyn_mut c mut, dyn_val_type c t)
-
-  let dyn_extern_type c : Stat.extern_type -> extern_type = function
-    | Stat.ExternFuncT ft -> ExternFuncT (dyn_func_type c ft)
-    | Stat.ExternTableT tt -> ExternTableT (dyn_table_type c tt)
-    | Stat.ExternMemoryT mt -> ExternMemoryT (dyn_memory_type c mt)
-    | Stat.ExternGlobalT gt -> ExternGlobalT (dyn_global_type c gt)
-
-  let dyn_export_type c : Stat.export_type -> export_type = function
-    | Stat.ExportT (et, name) -> ExportT (dyn_extern_type c et, name)
-
-  let dyn_import_type c : Stat.import_type -> import_type = function
-    | Stat.ImportT (et, module_name, name) ->
-      ImportT (dyn_extern_type c et, module_name, name)
-
-  let dyn_module_type : Stat.module_type -> module_type = function
-    | Stat.ModuleT (dts, its, ets) ->
-      let c = List.map (fun _ -> alloc_uninit ()) dts in
-      List.iter2 (fun x dt -> init x (dyn_def_type c dt)) c dts;
-      let its = List.map (dyn_import_type c) its in
-      let ets = List.map (dyn_export_type c) ets in
-      ModuleT ([], its, ets)
-end
+let dyn_module_type = function
+  | ModuleT (dts, its, ets) ->
+    let c = List.map (fun _ -> alloc_uninit ()) dts in
+    List.iter2 (fun a dt -> init a (dyn_def_type c dt)) c dts;
+    let its = List.map (dyn_import_type c) its in
+    let ets = List.map (dyn_export_type c) ets in
+    ModuleT ([], its, ets)
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index 6af8f369c..c0c65c2a4 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -355,7 +355,7 @@ struct
 end
 
 let oper (iop, fop) op =
-  Dyn.string_of_num_type (type_of_num op) ^ "." ^
+  string_of_num_type (type_of_num op) ^ "." ^
   (match op with
   | I32 o -> iop "32" o
   | I64 o -> iop "64" o
@@ -427,8 +427,8 @@ let vec_laneop instr (op, i) =
 let var x = nat32 x.it
 let num v = string_of_num v.it
 let vec v = string_of_vec v.it
-let constop v = Dyn.string_of_num_type (type_of_num v) ^ ".const"
-let vec_constop v = Dyn.string_of_vec_type (type_of_vec v) ^ ".const i32x4"
+let constop v = string_of_num_type (type_of_num v) ^ ".const"
+let vec_constop v = string_of_vec_type (type_of_vec v) ^ ".const i32x4"
 
 let block_type = function
   | VarBlockType x -> [Node ("type " ^ var x, [])]
@@ -669,7 +669,7 @@ let num mode = if mode = `Binary then hex_string_of_num else string_of_num
 let vec mode = if mode = `Binary then hex_string_of_vec else string_of_vec
 
 let ref_ = function
-  | NullRef t -> Node ("ref.null " ^ Types.Dyn.string_of_heap_type t, [])
+  | NullRef t -> Node ("ref.null " ^ Types.string_of_heap_type t, [])
   | Script.ExternRef n -> Node ("ref.extern " ^ nat32 n, [])
   | _ -> assert false
 
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index 8a6c35816..807ee1c2d 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -316,7 +316,7 @@ null_opt :
 heap_type :
   | FUNC { fun c -> FuncHT }
   | EXTERN { fun c -> ExternHT }
-  | var { fun c -> DefHT ($1 c type_).it }
+  | var { fun c -> DefHT (Stat ($1 c type_).it) }
 
 ref_type :
   | LPAR REF null_opt heap_type RPAR { fun c -> ($3, $4 c) }
@@ -1197,7 +1197,7 @@ literal_vec :
 
 literal_ref :
   | LPAR REF_NULL heap_type RPAR
-    { Value.NullRef (Types.Dyn.dyn_heap_type [] ($3 (empty_context ()))) }
+    { Value.NullRef (Types.dyn_heap_type [] ($3 (empty_context ()))) }
   | LPAR REF_EXTERN NAT RPAR { Script.ExternRef (nat32 $3 (ati 3)) }
 
 literal :
diff --git a/interpreter/valid/match.ml b/interpreter/valid/match.ml
index 5b1dffc21..e49e33811 100644
--- a/interpreter/valid/match.ml
+++ b/interpreter/valid/match.ml
@@ -1,197 +1,164 @@
-(* Generic Matching *)
+open Types
 
-module type Context =
-sig
-  type var
-  type def_type
-  type context
-  val lookup : context -> var -> def_type
-end
 
-module Make
-  (Var : Types.Var)
-  (Context : Context
-    with type var = Var.var
-    with type def_type = Types.Make(Var).def_type
-  ) =
-struct
+(* Context *)
 
-  open Types.Make (Var)
-  open Context
+type context = def_type list
 
+let lookup c = function
+  | Stat x -> Lib.List32.nth c x
+  | Dyn a -> def_of a
 
-  (* Equivalence *)
-
-  let eq_nullability c nul1 nul2 =
-    nul1 = nul2
 
-  let eq_mutability c mut1 mut2 =
-    mut1 = mut2
-
-  let eq_limits c lim1 lim2 =
-    lim1.min = lim2.min && lim1.max = lim2.max
-
-  let eq_num_type c t1 t2 =
-    t1 = t2
-
-  let eq_vec_type c t1 t2 =
-    t1 = t2
-
-  let rec eq_heap_type c t1 t2 =
-    match t1, t2 with
-    | DefHT x1, DefHT x2 -> eq_var_type c x1 x2
-    | _, _ -> t1 = t2
-
-  and eq_ref_type c t1 t2 =
-    match t1, t2 with
-    | (nul1, t1'), (nul2, t2') ->
-      eq_nullability c nul1 nul2 && eq_heap_type c t1' t2'
-
-  and eq_val_type c t1 t2 =
-    match t1, t2 with
-    | NumT t1', NumT t2' -> eq_num_type c t1' t2'
-    | VecT t1', VecT t2' -> eq_vec_type c t1' t2'
-    | RefT t1', RefT t2' -> eq_ref_type c t1' t2'
-    | BotT, BotT -> true
-    | _, _ -> false
-
-  and eq_result_type c ts1 ts2 =
-    List.length ts1 = List.length ts2 &&
-    List.for_all2 (eq_val_type c) ts1 ts2
-
-  and eq_func_type c (FuncT (ts11, ts12)) (FuncT (ts21, ts22)) =
-    eq_result_type c ts11 ts21 && eq_result_type c ts12 ts22
-
-  and eq_def_type c dt1 dt2 =
-    match dt1, dt2 with
-    | DefFuncT ft1, DefFuncT ft2 -> eq_func_type c ft1 ft2
-
-  and eq_var_type c x1 x2 =
-    eq_var x1 x2 ||
-    eq_def_type c (lookup c x1) (lookup c x2)
-
-
-  let eq_table_type c (TableT (lim1, t1)) (TableT (lim2, t2)) =
-    eq_limits c lim1 lim2 && eq_ref_type c t1 t2
-
-  let eq_memory_type c (MemoryT lim1) (MemoryT lim2) =
-    eq_limits c lim1 lim2
-
-  let eq_global_type c (GlobalT (mut1, t1)) (GlobalT (mut2, t2)) =
-    eq_mutability c mut1 mut2 && eq_val_type c t1 t2
-
-  let eq_extern_type c et1 et2 =
-    match et1, et2 with
-    | ExternFuncT ft1, ExternFuncT ft2 -> eq_func_type c ft1 ft2
-    | ExternTableT tt1, ExternTableT tt2 -> eq_table_type c tt1 tt2
-    | ExternMemoryT mt1, ExternMemoryT mt2 -> eq_memory_type c mt1 mt2
-    | ExternGlobalT gt1, ExternGlobalT gt2 -> eq_global_type c gt1 gt2
-    | _, _ -> false
+(* Equivalence *)
 
+let eq_var x1 x2 =
+  match x1, x2 with
+  | Stat x1, Stat x2 -> x1 = x2
+  | Dyn a1, Dyn a2 -> a1 == a2
+  | _, _ -> false
 
-  (* Subtyping *)
-
-  let match_nullability c nul1 nul2 =
-    match nul1, nul2 with
-    | NoNull, Null -> true
-    | _, _ -> nul1 = nul2
-
-  let match_limits c lim1 lim2 =
-    I32.ge_u lim1.min lim2.min &&
-    match lim1.max, lim2.max with
-    | _, None -> true
-    | None, Some _ -> false
-    | Some i, Some j -> I32.le_u i j
-
-  let match_num_type c t1 t2 =
-    t1 = t2
+let eq_nullability c nul1 nul2 =
+  nul1 = nul2
 
-  let match_vec_type c t1 t2 =
-    t1 = t2
+let eq_mutability c mut1 mut2 =
+  mut1 = mut2
 
-  let rec match_heap_type c t1 t2 =
-    match t1, t2 with
-    | DefHT x1, FuncHT ->
-      (match lookup c x1 with
-      | DefFuncT _ -> true
-      )
-    | DefHT x1, DefHT x2 -> match_var_type c x1 x2
-    | BotHT, _ -> true
-    | _, _ -> eq_heap_type c t1 t2
+let eq_limits c lim1 lim2 =
+  lim1.min = lim2.min && lim1.max = lim2.max
 
-  and match_ref_type c t1 t2 =
-    match t1, t2 with
-    | (nul1, t1'), (nul2, t2') ->
-      match_nullability c nul1 nul2 && match_heap_type c t1' t2'
-
-  and match_val_type c t1 t2 =
-    match t1, t2 with
-    | NumT t1', NumT t2' -> match_num_type c t1' t2'
-    | VecT t1', VecT t2' -> match_vec_type c t1' t2'
-    | RefT t1', RefT t2' -> match_ref_type c t1' t2'
-    | BotT, _ -> true
-    | _, _ -> false
-
-  and match_result_type c ts1 ts2 =
-    List.length ts1 = List.length ts2 &&
-    List.for_all2 (match_val_type c) ts1 ts2
-
-  and match_func_type c ft1 ft2 =
-    eq_func_type c ft1 ft2
-
-  and match_def_type c dt1 dt2 =
-    match dt1, dt2 with
-    | DefFuncT ft1, DefFuncT ft2 -> match_func_type c ft1 ft2
-
-  and match_var_type c x1 x2 =
-    eq_var x1 x2 ||
-    match_def_type c (lookup c x1) (lookup c x2)
-
-  let match_table_type c (TableT (lim1, t1)) (TableT (lim2, t2)) =
-    match_limits c lim1 lim2 && eq_ref_type c t1 t2
-
-  let match_memory_type c (MemoryT lim1) (MemoryT lim2) =
-    match_limits c lim1 lim2
+let eq_num_type c t1 t2 =
+  t1 = t2
 
-  let match_global_type c (GlobalT (mut1, t1)) (GlobalT (mut2, t2)) =
-    eq_mutability c mut1 mut2 &&
-    match mut1 with
-    | Cons -> match_val_type c t1 t2
-    | Var -> eq_val_type c t1 t2
-
-  let match_extern_type c et1 et2 =
-    match et1, et2 with
-    | ExternFuncT ft1, ExternFuncT ft2 -> match_func_type c ft1 ft2
-    | ExternTableT tt1, ExternTableT tt2 -> match_table_type c tt1 tt2
-    | ExternMemoryT mt1, ExternMemoryT mt2 -> match_memory_type c mt1 mt2
-    | ExternGlobalT gt1, ExternGlobalT gt2 -> match_global_type c gt1 gt2
-    | _, _ -> false
-end
+let eq_vec_type c t1 t2 =
+  t1 = t2
 
+let rec eq_heap_type c t1 t2 =
+  match t1, t2 with
+  | DefHT x1, DefHT x2 -> eq_var_type c x1 x2
+  | _, _ -> t1 = t2
 
-(* Static Matching *)
-
-module StatContext =
-struct
-  type var = Types.Stat.var
-  type def_type = Types.Stat.def_type
-  type context = def_type list
-  let lookup c x = Lib.List32.nth c x
-end
-
-module Stat = Make (Types.StatVar) (StatContext)
-
-include Stat
-
-
-(* Dynamic Matching *)
-
-module DynContext =
-struct
-  type var = Types.Dyn.var
-  type def_type = Types.Dyn.def_type
-  type context = unit
-  let lookup _c x = Types.Dyn.def_of x
-end
-
-module Dyn = Make (Types.DynVar) (DynContext)
+and eq_ref_type c t1 t2 =
+  match t1, t2 with
+  | (nul1, t1'), (nul2, t2') ->
+    eq_nullability c nul1 nul2 && eq_heap_type c t1' t2'
+
+and eq_val_type c t1 t2 =
+  match t1, t2 with
+  | NumT t1', NumT t2' -> eq_num_type c t1' t2'
+  | VecT t1', VecT t2' -> eq_vec_type c t1' t2'
+  | RefT t1', RefT t2' -> eq_ref_type c t1' t2'
+  | BotT, BotT -> true
+  | _, _ -> false
+
+and eq_result_type c ts1 ts2 =
+  List.length ts1 = List.length ts2 &&
+  List.for_all2 (eq_val_type c) ts1 ts2
+
+and eq_func_type c (FuncT (ts11, ts12)) (FuncT (ts21, ts22)) =
+  eq_result_type c ts11 ts21 && eq_result_type c ts12 ts22
+
+and eq_def_type c dt1 dt2 =
+  match dt1, dt2 with
+  | DefFuncT ft1, DefFuncT ft2 -> eq_func_type c ft1 ft2
+
+and eq_var_type c x1 x2 =
+  eq_var x1 x2 ||
+  eq_def_type c (lookup c x1) (lookup c x2)
+
+
+let eq_table_type c (TableT (lim1, t1)) (TableT (lim2, t2)) =
+  eq_limits c lim1 lim2 && eq_ref_type c t1 t2
+
+let eq_memory_type c (MemoryT lim1) (MemoryT lim2) =
+  eq_limits c lim1 lim2
+
+let eq_global_type c (GlobalT (mut1, t1)) (GlobalT (mut2, t2)) =
+  eq_mutability c mut1 mut2 && eq_val_type c t1 t2
+
+let eq_extern_type c et1 et2 =
+  match et1, et2 with
+  | ExternFuncT ft1, ExternFuncT ft2 -> eq_func_type c ft1 ft2
+  | ExternTableT tt1, ExternTableT tt2 -> eq_table_type c tt1 tt2
+  | ExternMemoryT mt1, ExternMemoryT mt2 -> eq_memory_type c mt1 mt2
+  | ExternGlobalT gt1, ExternGlobalT gt2 -> eq_global_type c gt1 gt2
+  | _, _ -> false
+
+
+(* Subtyping *)
+
+let match_nullability c nul1 nul2 =
+  match nul1, nul2 with
+  | NoNull, Null -> true
+  | _, _ -> nul1 = nul2
+
+let match_limits c lim1 lim2 =
+  I32.ge_u lim1.min lim2.min &&
+  match lim1.max, lim2.max with
+  | _, None -> true
+  | None, Some _ -> false
+  | Some i, Some j -> I32.le_u i j
+
+let match_num_type c t1 t2 =
+  t1 = t2
+
+let match_vec_type c t1 t2 =
+  t1 = t2
+
+let rec match_heap_type c t1 t2 =
+  match t1, t2 with
+  | DefHT x1, FuncHT ->
+    (match lookup c x1 with
+    | DefFuncT _ -> true
+    )
+  | DefHT x1, DefHT x2 -> match_var_type c x1 x2
+  | BotHT, _ -> true
+  | _, _ -> eq_heap_type c t1 t2
+
+and match_ref_type c t1 t2 =
+  match t1, t2 with
+  | (nul1, t1'), (nul2, t2') ->
+    match_nullability c nul1 nul2 && match_heap_type c t1' t2'
+
+and match_val_type c t1 t2 =
+  match t1, t2 with
+  | NumT t1', NumT t2' -> match_num_type c t1' t2'
+  | VecT t1', VecT t2' -> match_vec_type c t1' t2'
+  | RefT t1', RefT t2' -> match_ref_type c t1' t2'
+  | BotT, _ -> true
+  | _, _ -> false
+
+and match_result_type c ts1 ts2 =
+  List.length ts1 = List.length ts2 &&
+  List.for_all2 (match_val_type c) ts1 ts2
+
+and match_func_type c ft1 ft2 =
+  eq_func_type c ft1 ft2
+
+and match_def_type c dt1 dt2 =
+  match dt1, dt2 with
+  | DefFuncT ft1, DefFuncT ft2 -> match_func_type c ft1 ft2
+
+and match_var_type c x1 x2 =
+  eq_var x1 x2 ||
+  match_def_type c (lookup c x1) (lookup c x2)
+
+let match_table_type c (TableT (lim1, t1)) (TableT (lim2, t2)) =
+  match_limits c lim1 lim2 && eq_ref_type c t1 t2
+
+let match_memory_type c (MemoryT lim1) (MemoryT lim2) =
+  match_limits c lim1 lim2
+
+let match_global_type c (GlobalT (mut1, t1)) (GlobalT (mut2, t2)) =
+  eq_mutability c mut1 mut2 &&
+  match mut1 with
+  | Cons -> match_val_type c t1 t2
+  | Var -> eq_val_type c t1 t2
+
+let match_extern_type c et1 et2 =
+  match et1, et2 with
+  | ExternFuncT ft1, ExternFuncT ft2 -> match_func_type c ft1 ft2
+  | ExternTableT tt1, ExternTableT tt2 -> match_table_type c tt1 tt2
+  | ExternMemoryT mt1, ExternMemoryT mt2 -> match_memory_type c mt1 mt2
+  | ExternGlobalT gt1, ExternGlobalT gt2 -> match_global_type c gt1 gt2
+  | _, _ -> false
diff --git a/interpreter/valid/match.mli b/interpreter/valid/match.mli
index 1350c0264..201709fb4 100644
--- a/interpreter/valid/match.mli
+++ b/interpreter/valid/match.mli
@@ -1,76 +1,39 @@
-(* Generic Matching *)
+open Types
 
-module type Context =
-sig
-  type var
-  type def_type
-  type context
-  val lookup : context -> var -> def_type
-end
+(* Context *)
 
-module Make
-  (Var : Types.Var)
-  (Context : Context
-    with type var = Var.var
-    with type def_type = Types.Make(Var).def_type
-  ) :
-sig
-  open Types.Make (Var)
-  open Context
+type context = def_type list
 
-  (* Equivalence *)
+(* Equivalence *)
 
-  val eq_num_type : context -> num_type -> num_type -> bool
-  val eq_ref_type : context -> ref_type -> ref_type -> bool
-  val eq_val_type : context -> val_type -> val_type -> bool
+val eq_num_type : context -> num_type -> num_type -> bool
+val eq_ref_type : context -> ref_type -> ref_type -> bool
+val eq_val_type : context -> val_type -> val_type -> bool
 
-  val eq_result_type : context -> result_type -> result_type -> bool
+val eq_result_type : context -> result_type -> result_type -> bool
 
-  val eq_func_type : context -> func_type -> func_type -> bool
-  val eq_table_type : context -> table_type -> table_type -> bool
-  val eq_memory_type : context -> memory_type -> memory_type -> bool
-  val eq_global_type : context -> global_type -> global_type -> bool
+val eq_func_type : context -> func_type -> func_type -> bool
+val eq_table_type : context -> table_type -> table_type -> bool
+val eq_memory_type : context -> memory_type -> memory_type -> bool
+val eq_global_type : context -> global_type -> global_type -> bool
 
-  val eq_extern_type : context -> extern_type -> extern_type -> bool
+val eq_extern_type : context -> extern_type -> extern_type -> bool
 
-  val eq_def_type : context -> def_type -> def_type -> bool
+val eq_def_type : context -> def_type -> def_type -> bool
 
-  (* Subtyping *)
+(* Subtyping *)
 
-  val match_num_type : context -> num_type -> num_type -> bool
-  val match_ref_type : context -> ref_type -> ref_type -> bool
-  val match_val_type : context -> val_type -> val_type -> bool
+val match_num_type : context -> num_type -> num_type -> bool
+val match_ref_type : context -> ref_type -> ref_type -> bool
+val match_val_type : context -> val_type -> val_type -> bool
 
-  val match_result_type : context -> result_type -> result_type -> bool
+val match_result_type : context -> result_type -> result_type -> bool
 
-  val match_func_type : context -> func_type -> func_type -> bool
-  val match_table_type : context -> table_type -> table_type -> bool
-  val match_memory_type : context -> memory_type -> memory_type -> bool
-  val match_global_type : context -> global_type -> global_type -> bool
+val match_func_type : context -> func_type -> func_type -> bool
+val match_table_type : context -> table_type -> table_type -> bool
+val match_memory_type : context -> memory_type -> memory_type -> bool
+val match_global_type : context -> global_type -> global_type -> bool
 
-  val match_extern_type : context -> extern_type -> extern_type -> bool
+val match_extern_type : context -> extern_type -> extern_type -> bool
 
-  val match_def_type : context -> def_type -> def_type -> bool
-end
-
-
-(* Static Matching *)
-
-module StatContext : Context
-  with type var = Types.Stat.var
-  with type def_type = Types.Stat.def_type
-  with type context = Types.Stat.def_type list
-
-module Stat : module type of Make (Types.StatVar) (StatContext)
-
-include module type of Stat
-
-
-(* Dynamic Matching *)
-
-module DynContext : Context
-  with type var = Types.Dyn.var
-  with type def_type = Types.Dyn.def_type
-  with type context = unit
-
-module Dyn : module type of Make (Types.DynVar) (DynContext)
+val match_def_type : context -> def_type -> def_type -> bool
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index eadc87d68..b227df254 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -95,7 +95,8 @@ let check_heap_type (c : context) (t : heap_type) at =
   match t with
   | FuncHT -> ()
   | ExternHT -> ()
-  | DefHT x -> ignore (type_ c (x @@ at))
+  | DefHT (Stat x) -> ignore (type_ c (x @@ at))
+  | DefHT (Dyn _) -> assert false
   | BotHT -> assert false
 
 let check_ref_type (c : context) (t : ref_type) at =
@@ -389,7 +390,7 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
 
   | CallRef x ->
     let FuncT (ts1, ts2) = func_type c x in
-    (ts1 @ [RefT (Null, DefHT x.it)]) --> ts2, []
+    (ts1 @ [RefT (Null, DefHT (Stat x.it))]) --> ts2, []
 
   | CallIndirect (x, y) ->
     let TableT (_lim, t) = table c x in
@@ -405,7 +406,7 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
       ("type mismatch: current function requires result type " ^
        string_of_result_type c.results ^
        " but callee returns " ^ string_of_result_type ts2);
-    (ts1 @ [RefT (Null, DefHT x.it)]) -->... [], []
+    (ts1 @ [RefT (Null, DefHT (Stat x.it))]) -->... [], []
 
   | LocalGet x ->
     let LocalT (init, t) = local c x in
@@ -538,7 +539,7 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
     let ft = func c x in
     let y = Lib.Option.force (Lib.List32.index_of (DefFuncT ft) c.types) in
     refer_func c x;
-    [] --> [RefT (NoNull, DefHT y)], []
+    [] --> [RefT (NoNull, DefHT (Stat y))], []
 
   | Const v ->
     let t = NumT (type_num v.it) in

From 5900d839f38641989a9d8df2df4aee0513365d39 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Tue, 20 Sep 2022 13:51:35 +0200
Subject: [PATCH 202/285] [spec] Add citation for WasmCert (#1533)

---
 document/core/appendix/properties.rst | 8 ++++++--
 document/core/util/macros.def         | 4 ++++
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index 364b5f04a..c37823219 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -807,7 +807,7 @@ Theorems
 ~~~~~~~~
 
 Given the definition of :ref:`valid configurations <valid-config>`,
-the standard soundness theorems hold. [#cite-cpp2018]_
+the standard soundness theorems hold. [#cite-cpp2018]_ [#cite-fm2021]_
 
 **Theorem (Preservation).**
 If a :ref:`configuration <syntax-config>` :math:`S;T` is :ref:`valid <valid-config>` with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]` (i.e., :math:`\vdashconfig S;T : [t^\ast]`),
@@ -839,5 +839,9 @@ Consequently, given a :ref:`valid store <valid-store>`, no computation defined b
    Andreas Haas, Andreas Rossberg, Derek Schuff, Ben Titzer, Dan Gohman, Luke Wagner, Alon Zakai, JF Bastien, Michael Holman. |PLDI2017|_. Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2017). ACM 2017.
 
 .. [#cite-cpp2018]
-   A machine-verified version of the formalization and soundness proof is described in the following article:
+   A machine-verified version of the formalization and soundness proof of the PLDI 2017 paper is described in the following article:
    Conrad Watt. |CPP2018|_. Proceedings of the 7th ACM SIGPLAN Conference on Certified Programs and Proofs (CPP 2018). ACM 2018.
+
+.. [#cite-fm2021]
+   Machine-verified formalizations and soundness proofs of the semantics from the official specification are described in the following article:
+   Conrad Watt, Xiaojia Rao, Jean Pichon-Pharabod, Martin Bodin, Philippa Gardner. |FM2021|_. Proceedings of the 24th International Symposium on Formal Methods (FM 2021). Springer 2021.
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index d66a8d6fe..aaefc4069 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -38,6 +38,7 @@
 .. |MediaType| replace:: Media Type
 .. _MediaType: https://www.iana.org/assignments/media-types/media-types.xhtml
 
+
 .. Literature
 .. ----------
 
@@ -47,6 +48,9 @@
 .. |CPP2018| replace:: Mechanising and Verifying the WebAssembly Specification
 .. _CPP2018: https://dl.acm.org/citation.cfm?id=3167082
 
+.. |FM2021| replace:: Two Mechanisations of WebAssembly 1.0
+.. _FM2021: https://link.springer.com/chapter/10.1007/978-3-030-90870-6_4
+
 .. |TAPL| replace:: Types and Programming Languages
 .. _TAPL: https://www.cis.upenn.edu/~bcpierce/tapl/
 

From 2da4104f7f9fc499ed6d9206c65c6db733c8db56 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@igalia.com>
Date: Tue, 20 Sep 2022 15:36:08 +0200
Subject: [PATCH 203/285] [test] Fix async_index.js

---
 test/harness/async_index.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/harness/async_index.js b/test/harness/async_index.js
index c200019ac..6d804bd56 100644
--- a/test/harness/async_index.js
+++ b/test/harness/async_index.js
@@ -267,6 +267,7 @@ function assert_return(action, ...expected) {
     .then(
       values => {
         uniqueTest(_ => {
+          let actual = values[0];
           if (actual === undefined) {
             actual = [];
           } else if (!Array.isArray(actual)) {

From 82a613da5ea18515bf6f16593b8f7b608f47380f Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@igalia.com>
Date: Tue, 20 Sep 2022 14:44:58 +0200
Subject: [PATCH 204/285] [test] Enable the i64 tests in imports.wast.

Fixes #1514.
---
 test/core/imports.wast      | 15 +++++----------
 test/harness/async_index.js |  2 ++
 test/harness/sync_index.js  |  2 ++
 3 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/test/core/imports.wast b/test/core/imports.wast
index 35e8c917f..69f76a0bb 100644
--- a/test/core/imports.wast
+++ b/test/core/imports.wast
@@ -30,11 +30,9 @@
   (type $func_f64 (func (param f64)))
 
   (import "spectest" "print_i32" (func (param i32)))
-  ;; JavaScript can't handle i64 yet.
-  ;; (func (import "spectest" "print_i64") (param i64))
+  (func (import "spectest" "print_i64") (param i64))
   (import "spectest" "print_i32" (func $print_i32 (param i32)))
-  ;; JavaScript can't handle i64 yet.
-  ;; (import "spectest" "print_i64" (func $print_i64 (param i64)))
+  (import "spectest" "print_i64" (func $print_i64 (param i64)))
   (import "spectest" "print_f32" (func $print_f32 (param f32)))
   (import "spectest" "print_f64" (func $print_f64 (param f64)))
   (import "spectest" "print_i32_f32" (func $print_i32_f32 (param i32 f32)))
@@ -72,14 +70,12 @@
   (func (export "print64") (param $i i64)
     (local $x f64)
     (local.set $x (f64.convert_i64_s (call $i64->i64 (local.get $i))))
-    ;; JavaScript can't handle i64 yet.
-    ;; (call 1 (local.get $i))
+    (call 1 (local.get $i))
     (call $print_f64_f64
       (f64.add (local.get $x) (f64.const 1))
       (f64.const 53)
     )
-    ;; JavaScript can't handle i64 yet.
-    ;; (call $print_i64 (local.get $i))
+    (call $print_i64 (local.get $i))
     (call $print_f64 (local.get $x))
     (call $print_f64-2 (local.get $x))
     (call_indirect (type $func_f64) (local.get $x) (i32.const 1))
@@ -234,8 +230,7 @@
   (import "spectest" "global_i32" (global $x i32))
   (global $y (import "spectest" "global_i32") i32)
 
-  ;; JavaScript can't handle i64 yet.
-  ;; (import "spectest" "global_i64" (global i64))
+  (import "spectest" "global_i64" (global i64))
   (import "spectest" "global_f32" (global f32))
   (import "spectest" "global_f64" (global f64))
 
diff --git a/test/harness/async_index.js b/test/harness/async_index.js
index 6d804bd56..bb7d4cf5d 100644
--- a/test/harness/async_index.js
+++ b/test/harness/async_index.js
@@ -93,11 +93,13 @@ function reinitializeRegistry() {
       eq_funcref: eq_funcref,
       print: console.log.bind(console),
       print_i32: console.log.bind(console),
+      print_i64: console.log.bind(console),
       print_i32_f32: console.log.bind(console),
       print_f64_f64: console.log.bind(console),
       print_f32: console.log.bind(console),
       print_f64: console.log.bind(console),
       global_i32: 666,
+      global_i64: 666n,
       global_f32: 666,
       global_f64: 666,
       table: new WebAssembly.Table({
diff --git a/test/harness/sync_index.js b/test/harness/sync_index.js
index 7ed9f2915..79469ee9b 100644
--- a/test/harness/sync_index.js
+++ b/test/harness/sync_index.js
@@ -103,11 +103,13 @@ function reinitializeRegistry() {
         eq_funcref: eq_funcref,
         print: console.log.bind(console),
         print_i32: console.log.bind(console),
+        print_i64: console.log.bind(console),
         print_i32_f32: console.log.bind(console),
         print_f64_f64: console.log.bind(console),
         print_f32: console.log.bind(console),
         print_f64: console.log.bind(console),
         global_i32: 666,
+        global_i64: 666n,
         global_f32: 666,
         global_f64: 666,
         table: new WebAssembly.Table({initial: 10, maximum: 20, element: 'anyfunc'}),

From c4eef9a897dbff5389bce55b222b6f68706ff449 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 21 Sep 2022 14:57:34 +0200
Subject: [PATCH 205/285] Minor tweak

---
 interpreter/valid/valid.ml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index b227df254..3df24e20c 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -366,11 +366,11 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
     (ts @ [NumT I32T]) -->... [], []
 
   | BrOnNull x ->
-    let (_nul, ht) = peek_ref 0 s e.at in
+    let (_, ht) = peek_ref 0 s e.at in
     (label c x @ [RefT (Null, ht)]) --> (label c x @ [RefT (NoNull, ht)]), []
 
   | BrOnNonNull x ->
-    let (_nul, ht) = peek_ref 0 s e.at in
+    let (_, ht) = peek_ref 0 s e.at in
     let t' = RefT (NoNull, ht) in
     require (label c x <> []) e.at
       ("type mismatch: instruction requires type " ^ string_of_val_type t' ^
@@ -379,7 +379,7 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
     require (match_val_type c.types t' t1) e.at
       ("type mismatch: instruction requires type " ^ string_of_val_type t' ^
        " but label has " ^ string_of_result_type (label c x));
-    (ts0 @ [RefT (_nul, ht)]) --> ts0, []
+    (ts0 @ [RefT (Null, ht)]) --> ts0, []
 
   | Return ->
     c.results -->... [], []

From c0312a87b05278d28e8ea9c0bbab098cf03f698f Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@igalia.com>
Date: Tue, 27 Sep 2022 13:40:35 +0200
Subject: [PATCH 206/285] [js-api][web-api] Editorial: Fix some minor issues.

Fixes #1064.
---
 document/js-api/index.bs  | 47 +++++++++++++++++++++------------------
 document/web-api/index.bs |  9 +-------
 2 files changed, 26 insertions(+), 30 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index f99f9f578..fcfdbf833 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -34,6 +34,9 @@ urlPrefix: https://tc39.github.io/ecma262/; spec: ECMASCRIPT
         text: TypeError; url: sec-native-error-types-used-in-this-standard-typeerror
         text: RangeError; url: sec-native-error-types-used-in-this-standard-rangeerror
     type: dfn
+        url: sec-returnifabrupt-shorthands
+            text: !
+            text: ?
         text: agent cluster; url: sec-agent-clusters
         text: agent; url: agent
         text: data block; url: sec-data-blocks
@@ -355,9 +358,9 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
     1. If |module|.[=imports=] [=list/is empty|is not empty=], and |importObject| is undefined, throw a {{TypeError}} exception.
     1. Let |imports| be « ».
     1. [=list/iterate|For each=] (|moduleName|, |componentName|, |externtype|) of [=module_imports=](|module|),
-        1. Let |o| be ? [=Get=](|importObject|, |moduleName|).
+        1. Let |o| be [=?=] [=Get=](|importObject|, |moduleName|).
         1. If [=Type=](|o|) is not Object, throw a {{TypeError}} exception.
-        1. Let |v| be ? [=Get=](|o|, |componentName|).
+        1. Let |v| be [=?=] [=Get=](|o|, |componentName|).
         1. If |externtype| is of the form [=func=] |functype|,
             1. If [=IsCallable=](|v|) is false, throw a {{LinkError}} exception.
             1. If |v| has a \[[FunctionAddress]] internal slot, and therefore is an [=Exported Function=],
@@ -403,7 +406,7 @@ The verification of WebAssembly type requirements is deferred to the
 
 <div algorithm>
   To <dfn>create an exports object</dfn> from a WebAssembly module |module| and instance |instance|, perform the following steps:
-    1. Let |exportsObject| be ! [=ObjectCreate=](null).
+    1. Let |exportsObject| be [=!=] [=ObjectCreate=](null).
     1. [=list/iterate|For each=] (|name|, |externtype|) of [=module_exports=](|module|),
         1. Let |externval| be [=instance_export=](|instance|, |name|).
         1. Assert: |externval| is not [=error=].
@@ -427,11 +430,11 @@ The verification of WebAssembly type requirements is deferred to the
             1. Let [=external value|table=] |tableaddr| be |externval|.
             1. Let |table| be [=create a Table object|a new Table object=] created from |tableaddr|.
             1. Let |value| be |table|.
-        1. Let |status| be ! [=CreateDataProperty=](|exportsObject|, |name|, |value|).
+        1. Let |status| be [=!=] [=CreateDataProperty=](|exportsObject|, |name|, |value|).
         1. Assert: |status| is true.
 
         Note: the validity and uniqueness checks performed during [=WebAssembly module validation=] ensure that each property name is valid and no properties are defined twice.
-    1. Perform ! [=SetIntegrityLevel=](|exportsObject|, `"frozen"`).
+    1. Perform [=!=] [=SetIntegrityLevel=](|exportsObject|, `"frozen"`).
     1. Return |exportsObject|.
 </div>
 
@@ -687,7 +690,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. Let |map| be the [=surrounding agent=]'s associated [=Memory object cache=].
     1. Assert: |map|[|memaddr|] [=map/exists=].
     1. Let |memory| be |map|[|memaddr|].
-    1. Perform ! [=DetachArrayBuffer=](|memory|.\[[BufferObject]], "WebAssembly.Memory").
+    1. Perform [=!=] [=DetachArrayBuffer=](|memory|.\[[BufferObject]], "WebAssembly.Memory").
     1. Let |buffer| be the result of [=create a memory buffer|creating a memory buffer=] from |memaddr|.
     1. Set |memory|.\[[BufferObject]] to |buffer|.
 </div>
@@ -777,7 +780,7 @@ Each {{Table}} object has a \[[Table]] internal slot, which is a [=table address
     1. If |value| is missing,
         1. Let |ref| be [=DefaultValue=](|elementType|).
     1. Otherwise,
-        1. Let |ref| be ? [=ToWebAssemblyValue=](|value|, |elementType|).
+        1. Let |ref| be [=?=] [=ToWebAssemblyValue=](|value|, |elementType|).
     1. Let |type| be the [=table type=] {[=table type|min=] |initial|, [=table type|max=] |maximum|} |elementType|.
     1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let (|store|, |tableaddr|) be [=table_alloc=](|store|, |type|, |ref|). <!-- TODO(littledan): Report allocation failure https://github.com/WebAssembly/spec/issues/584 -->
@@ -794,7 +797,7 @@ Each {{Table}} object has a \[[Table]] internal slot, which is a [=table address
     1. If |value| is missing,
         1. Let |ref| be [=DefaultValue=](|elementType|).
     1. Otherwise,
-        1. Let |ref| be ? [=ToWebAssemblyValue=](|value|, |elementType|).
+        1. Let |ref| be [=?=] [=ToWebAssemblyValue=](|value|, |elementType|).
     1. Let |result| be [=table_grow=](|store|, |tableaddr|, |delta|, |ref|).
     1. If |result| is [=error=], throw a {{RangeError}} exception.
 
@@ -827,7 +830,7 @@ Each {{Table}} object has a \[[Table]] internal slot, which is a [=table address
     1. If |value| is missing,
         1. Let |ref| be [=DefaultValue=](|elementType|).
     1. Otherwise,
-        1. Let |ref| be ? [=ToWebAssemblyValue=](|value|, |elementType|).
+        1. Let |ref| be [=?=] [=ToWebAssemblyValue=](|value|, |elementType|).
     1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let |store| be [=table_write=](|store|, |tableaddr|, |index|, |ref|).
     1. If |store| is [=error=], throw a {{RangeError}} exception.
@@ -977,7 +980,7 @@ This slot holds a [=function address=] relative to the [=surrounding agent=]'s [
         1. Let |moduleinst| be |funcinst|.module.
         1. Assert: |funcaddr| is contained in |moduleinst|.funcaddrs.
         1. Let |index| be the index of |moduleinst|.funcaddrs where |funcaddr| is found.
-    1. Return ! [=ToString=](|index|).
+    1. Return [=!=] [=ToString=](|index|).
 </div>
 
 <div algorithm>
@@ -1004,7 +1007,7 @@ This slot holds a [=function address=] relative to the [=surrounding agent=]'s [
 
     1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let |functype| be [=func_type=](|store|, |funcaddr|).
-    1. Let [|parameters|] → [<var ignore>results</var>] be |functype|.
+    1. Let [|parameters|] → [|results|] be |functype|.
     1. If |parameters| or |results| contain [=v128=], throw a {{TypeError}}.
 
         Note: the above error is thrown each time the \[[Call]] method is invoked.
@@ -1035,19 +1038,19 @@ Note: Exported Functions do not have a \[[Construct]] method and thus it is not
 <div algorithm>
   To <dfn>run a host function</dfn> from the JavaScript object |func|, type |functype|, and [=list=] of [=WebAssembly values=] |arguments|, perform the following steps:
 
-    1. Let [<var ignore>parameters</var>] → [|results|] be |functype|.
+    1. Let [|parameters|] → [|results|] be |functype|.
     1. If |parameters| or |results| contain [=v128=], throw a {{TypeError}}.
     1. Let |jsArguments| be « ».
     1. [=list/iterate|For each=] |arg| of |arguments|,
-        1. [=list/Append=] ! [=ToJSValue=](|arg|) to |jsArguments|.
-    1. Let |ret| be ? [=Call=](|func|, undefined, |jsArguments|).
+        1. [=list/Append=] [=!=] [=ToJSValue=](|arg|) to |jsArguments|.
+    1. Let |ret| be [=?=] [=Call=](|func|, undefined, |jsArguments|).
     1. Let |resultsSize| be |results|'s [=list/size=].
     1. If |resultsSize| is 0, return « ».
-    1. Otherwise, if |resultsSize| is 1, return « ? [=ToWebAssemblyValue=](|ret|, |results|[0]) ».
+    1. Otherwise, if |resultsSize| is 1, return « [=?=] [=ToWebAssemblyValue=](|ret|, |results|[0]) ».
     1. Otherwise,
-        1. Let |method| be ? [=GetMethod=](|ret|, [=@@iterator=]).
+        1. Let |method| be [=?=] [=GetMethod=](|ret|, [=@@iterator=]).
         1. If |method| is undefined, [=throw=] a {{TypeError}}.
-        1. Let |values| be ? [=IterableToList=](|ret|, |method|).
+        1. Let |values| be [=?=] [=IterableToList=](|ret|, |method|).
         1. Let |wasmValues| be a new, empty [=list=].
         1. If |values|'s [=list/size=] is not |resultsSize|, throw a {{TypeError}} exception.
         1. For each |value| and |resultType| in |values| and |results|, paired linearly,
@@ -1109,16 +1112,16 @@ The algorithm <dfn>ToWebAssemblyValue</dfn>(|v|, |type|) coerces a JavaScript va
 
 1. Assert: |type| is not [=v128=].
 1. If |type| is [=i64=],
-    1. Let |i64| be ? [=ToBigInt64=](|v|).
+    1. Let |i64| be [=?=] [=ToBigInt64=](|v|).
     1. Return [=i64.const=] |i64|.
 1. If |type| is [=i32=],
-    1. Let |i32| be ? [=ToInt32=](|v|).
+    1. Let |i32| be [=?=] [=ToInt32=](|v|).
     1. Return [=i32.const=] |i32|.
 1. If |type| is [=f32=],
-    1. Let |f32| be ? [=ToNumber=](|v|) rounded to the nearest representable value using IEEE 754-2008 round to nearest, ties to even mode.
+    1. Let |f32| be [=?=] [=ToNumber=](|v|) rounded to the nearest representable value using IEEE 754-2008 round to nearest, ties to even mode.
     1. Return [=f32.const=] |f32|.
 1. If |type| is [=f64=],
-    1. Let |f64| be ? [=ToNumber=](|v|).
+    1. Let |f64| be [=?=] [=ToNumber=](|v|).
     1. Return [=f64.const=] |f64|.
 1. If |type| is [=funcref=],
     1. If |v| is null,
@@ -1150,7 +1153,7 @@ When the [=namespace object=] for the {{WebAssembly}} namespace is [=create a na
 1.  Let |namespaceObject| be the [=namespace object=].
 1.  [=list/iterate|For each=] |error| of « "CompileError", "LinkError", "RuntimeError" »,
     1.  Let |constructor| be a new object, implementing the [=NativeError Object Structure=], with <var ignore>NativeError</var> set to |error|.
-    1.  ! [$CreateMethodProperty$](|namespaceObject|, |error|,  |constructor|).
+    1.  [=!=] [$CreateMethodProperty$](|namespaceObject|, |error|,  |constructor|).
 
 </div>
 
diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index 602222129..1e74e0941 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -32,12 +32,6 @@ Prepare For TR: true
     "title": "WebAssembly JS Integration Specification",
     "publisher": "W3C WebAssembly Community Group",
     "status": "Draft"
-  },
-  "SECURECONTEXTS": {
-    "href": "https://w3c.github.io/webappsec-secure-contexts/",
-    "title": "Secure Contexts",
-    "publisher": "WebAppSec WG",
-    "status": "Candidate Recommendation"
   }
 }
 </pre>
@@ -71,7 +65,6 @@ urlPrefix: https://webassembly.github.io/spec/js-api/; spec: WASMJS
         text: Exported Function; url: #exported-function
 url:https://html.spec.whatwg.org/#cors-same-origin;text:CORS-same-origin;type:dfn;spec:HTML
 url:https://fetch.spec.whatwg.org/#concept-body-consume-body;text:consume body;type:dfn;spec:FETCH
-url:https://w3c.github.io/webappsec-secure-contexts/#environment-settings-object-contextually-secure; text:contextually secure; type: dfn; spec: SECURECONTEXTS
 </pre>
 
 <pre class='link-defaults'>
@@ -151,7 +144,7 @@ The [=serialization steps=], given |value|, |serialized|, and |forStorage|, are:
 
     1. Set |serialized|.\[[AgentCluster]] to the [=current Realm=]'s corresponding [=agent cluster=].
 
-The [=deserialization steps=], given |serialized| and |value|, are:
+The [=deserialization steps=], given |serialized|, |value|, and |targetRealm| are:
 
     1. Let |bytes| be the [=sub-deserialization=] of |serialized|.\[[Bytes]].
 

From 8a352708cffeb71206ca49a0f743bdc57269fb1a Mon Sep 17 00:00:00 2001
From: Adam Lancaster <Adzz@users.noreply.github.com>
Date: Fri, 30 Sep 2022 21:01:15 +0100
Subject: [PATCH 207/285] Update README.md (#1540)

Improve wording.
---
 interpreter/README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/interpreter/README.md b/interpreter/README.md
index 11258ae62..418b84501 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -10,7 +10,7 @@ The interpreter can
 * *export* test scripts to self-contained JavaScript test cases
 * *run* as an interactive interpreter
 
-The text format defines modules in S-expression syntax. Moreover, it is generalised to a (very dumb) form of *script* that can define multiples module and a batch of invocations, assertions, and conversions between them. As such it is richer than the binary format, with the additional functionality purely intended as testing infrastructure. (See [below](#scripts) for details.)
+The text format defines modules in S-expression syntax. Moreover, it is generalised to a form of *script* that can define multiples module and a batch of invocations, assertions, and conversions between them. As such it is richer than the binary format, with the additional functionality purely intended as testing infrastructure. (See [below](#scripts) for details.)
 
 
 ## Building
@@ -373,7 +373,7 @@ In particular, comments of the latter form nest properly.
 
 ## Scripts
 
-In order to be able to check and run modules for testing purposes, the S-expression format is interpreted as a very simple and dumb notion of "script", with commands as follows:
+In order to be able to check and run modules for testing purposes, the S-expression format is interpreted as a very simple notion of "script", with commands as follows:
 
 ```
 script: <cmd>*

From 793b3ff77c6315d5e1376919cb49e7682a76d739 Mon Sep 17 00:00:00 2001
From: Julien Cretin <cretin@google.com>
Date: Tue, 4 Oct 2022 08:48:52 +0200
Subject: [PATCH 208/285] [spec] Fix typo in element execution (#1544)

---
 document/core/exec/modules.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index ed647cc57..4242488db 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -729,8 +729,8 @@ where:
 .. math::
    \begin{array}{@{}l}
    \F{runelem}_i(\{\ETYPE~\X{et}, \EINIT~\reff^n, \EMODE~\EPASSIVE\}) \quad=\quad \epsilon \\
-   \F{runelem}_i(\{\ETYPE~\X{et}, \EINIT~\reff^n, \EMODE~\EACTIVE \{\ETABLE~0, \EOFFSET~\instr^\ast~\END\}\}) \quad=\\ \qquad
-     \instr^\ast~(\I32.\CONST~0)~(\I32.\CONST~n)~(\TABLEINIT~i)~(\ELEMDROP~i) \\
+   \F{runelem}_i(\{\ETYPE~\X{et}, \EINIT~\reff^n, \EMODE~\EACTIVE \{\ETABLE~x, \EOFFSET~\instr^\ast~\END\}\}) \quad=\\ \qquad
+     \instr^\ast~(\I32.\CONST~0)~(\I32.\CONST~n)~(\TABLEINIT~x~i)~(\ELEMDROP~i) \\
    \F{runelem}_i(\{\ETYPE~\X{et}, \EINIT~\reff^n, \EMODE~\EDECLARATIVE\}) \quad=\\ \qquad
      (\ELEMDROP~i) \\[1ex]
    \F{rundata}_i(\{\DINIT~b^n, \DMODE~\DPASSIVE\}) \quad=\quad \epsilon \\

From 58cd4c33f093038d2f9395ee976f716fc0e365c1 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Tue, 4 Oct 2022 15:31:24 +0200
Subject: [PATCH 209/285] [spec] Remove obsolete note (#1545)

---
 document/core/syntax/modules.rst | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/document/core/syntax/modules.rst b/document/core/syntax/modules.rst
index 84e0bb6a7..ec32935c8 100644
--- a/document/core/syntax/modules.rst
+++ b/document/core/syntax/modules.rst
@@ -272,10 +272,6 @@ The |EOFFSET| is given by a :ref:`constant <valid-constant>` :ref:`expression <s
 
 Element segments are referenced through :ref:`element indices <syntax-elemidx>`.
 
-.. note::
-   In the current version of WebAssembly, only tables of element type |FUNCREF| can be initialized with an element segment.
-   This limitation may be lifted in the future.
-
 
 .. index:: ! data, active, passive, data index, memory, memory index, expression, constant, byte, vector
    pair: abstract syntax; data

From 47d862cd9a11b87bf308011fecd5f36680a90ddc Mon Sep 17 00:00:00 2001
From: Keith Winstein <keithw@cs.stanford.edu>
Date: Wed, 5 Oct 2022 02:24:27 -0700
Subject: [PATCH 210/285] 
 cccccc[klghketetivvtnnhvntikigrnueuhdkkukljgjuest/meta/generate_*.js: sync
 upstream JS with tests (#1546)

---
 test/meta/generate_memory_copy.js | 16 ++++++++--------
 test/meta/generate_memory_fill.js |  4 ++--
 test/meta/generate_memory_init.js | 23 +++++++++++------------
 test/meta/generate_table_copy.js  | 16 ++++++++--------
 test/meta/generate_table_init.js  | 25 ++++++++++++-------------
 5 files changed, 41 insertions(+), 43 deletions(-)

diff --git a/test/meta/generate_memory_copy.js b/test/meta/generate_memory_copy.js
index e5b7c0c99..36751b86a 100644
--- a/test/meta/generate_memory_copy.js
+++ b/test/meta/generate_memory_copy.js
@@ -103,7 +103,7 @@ function mem_copy(min, max, shared, srcOffs, targetOffs, len) {
     (i32.load8_u (local.get 0))))
 
 (assert_trap (invoke "run" (i32.const ${targetOffs}) (i32.const ${srcOffs}) (i32.const ${len}))
-             "out of bounds")
+             "out of bounds memory access")
 `);
 
     let immediateOOB = copyDown && (srcOffs + len > memLength || targetOffs + len > memLength);
@@ -227,7 +227,7 @@ print(
   (memory 1 1)
   (func (export "test")
     (memory.copy (i32.const 0xFF00) (i32.const 0x8000) (i32.const 257))))
-(assert_trap (invoke "test") "out of bounds")
+(assert_trap (invoke "test") "out of bounds memory access")
 `);
 
 // Destination wraparound the end of 32-bit offset space
@@ -236,7 +236,7 @@ print(
   (memory 1 1)
   (func (export "test")
     (memory.copy (i32.const 0xFFFFFF00) (i32.const 0x4000) (i32.const 257))))
-(assert_trap (invoke "test") "out of bounds")
+(assert_trap (invoke "test") "out of bounds memory access")
 `);
 
 // Source range invalid
@@ -245,7 +245,7 @@ print(
   (memory 1 1)
   (func (export "test")
     (memory.copy (i32.const 0x8000) (i32.const 0xFF00) (i32.const 257))))
-(assert_trap (invoke "test") "out of bounds")
+(assert_trap (invoke "test") "out of bounds memory access")
 `);
 
 // Source wraparound the end of 32-bit offset space
@@ -254,7 +254,7 @@ print(
  (memory 1 1)
  (func (export "test")
    (memory.copy (i32.const 0x4000) (i32.const 0xFFFFFF00) (i32.const 257))))
-(assert_trap (invoke "test") "out of bounds")
+(assert_trap (invoke "test") "out of bounds memory access")
 `);
 
 // Zero len with both offsets in-bounds is a no-op
@@ -286,7 +286,7 @@ print(
   (memory 1 1)
   (func (export "test")
     (memory.copy (i32.const 0x20000) (i32.const 0x7000) (i32.const 0))))
-(assert_trap (invoke "test") "out of bounds")
+(assert_trap (invoke "test") "out of bounds memory access")
 `);
 
 // Zero len with src offset out-of-bounds at the end of memory is allowed
@@ -304,7 +304,7 @@ print(
   (memory 1 1)
   (func (export "test")
     (memory.copy (i32.const 0x9000) (i32.const 0x20000) (i32.const 0))))
-(assert_trap (invoke "test") "out of bounds")
+(assert_trap (invoke "test") "out of bounds memory access")
 `);
 
 // Zero len with both dest and src offsets out-of-bounds at the end of memory is allowed
@@ -322,7 +322,7 @@ print(
   (memory 1 1)
   (func (export "test")
     (memory.copy (i32.const 0x20000) (i32.const 0x20000) (i32.const 0))))
-(assert_trap (invoke "test") "out of bounds")
+(assert_trap (invoke "test") "out of bounds memory access")
 `);
 
 // 100 random fills followed by 100 random copies, in a single-page buffer,
diff --git a/test/meta/generate_memory_fill.js b/test/meta/generate_memory_fill.js
index 0dba569e9..3a8f485f1 100644
--- a/test/meta/generate_memory_fill.js
+++ b/test/meta/generate_memory_fill.js
@@ -62,7 +62,7 @@ print(
   ${PREAMBLE}
   (func (export "test")
     (memory.fill (i32.const 0x20000) (i32.const 0x55) (i32.const 0))))
-(assert_trap (invoke "test") "out of bounds")
+(assert_trap (invoke "test") "out of bounds memory access")
 `);
 
 // Very large range
@@ -141,7 +141,7 @@ function mem_fill(min, max, shared, backup, write=backup*2) {
     let val = 37;
     print(
 `(assert_trap (invoke "run" (i32.const ${offs}) (i32.const ${val}) (i32.const ${write}))
-              "out of bounds")
+              "out of bounds memory access")
 `);
     checkRange(0, min, 0);
 }
diff --git a/test/meta/generate_memory_init.js b/test/meta/generate_memory_init.js
index 64fb07f95..f8075cc33 100644
--- a/test/meta/generate_memory_init.js
+++ b/test/meta/generate_memory_init.js
@@ -65,7 +65,7 @@ print(
    (module
      (func (export "test")
        (data.drop 0)))
-   "unknown memory 0")
+   "unknown data segment")
 `);
 
 // drop with data seg ix out of range
@@ -95,7 +95,7 @@ print(
   (func (export "test")
     (data.drop 0)
     (memory.init 0 (i32.const 1234) (i32.const 1) (i32.const 1))))
-(assert_trap (invoke "test") "out of bounds")
+(assert_trap (invoke "test") "out of bounds memory access")
 `);
 
 // init with data seg ix indicating an active segment
@@ -105,7 +105,7 @@ print(
    (data (i32.const 0) "\\37")
    (func (export "test")
      (memory.init 0 (i32.const 1234) (i32.const 1) (i32.const 1))))
-(assert_trap (invoke "test") "out of bounds")
+(assert_trap (invoke "test") "out of bounds memory access")
 `);
 
 // init with no memory
@@ -143,7 +143,7 @@ print(
   ${PREAMBLE}
   (func (export "test")
     (memory.init 0 (i32.const 1234) (i32.const 0) (i32.const 5))))
-(assert_trap (invoke "test") "out of bounds")
+(assert_trap (invoke "test") "out of bounds memory access")
 `);
 
 // init: seg ix is valid passive, but implies copying beyond end of seg
@@ -152,7 +152,7 @@ print(
   ${PREAMBLE}
   (func (export "test")
     (memory.init 0 (i32.const 1234) (i32.const 2) (i32.const 3))))
-(assert_trap (invoke "test") "out of bounds")
+(assert_trap (invoke "test") "out of bounds memory access")
 `);
 
 // init: seg ix is valid passive, but implies copying beyond end of dst
@@ -161,7 +161,7 @@ print(
   ${PREAMBLE}
   (func (export "test")
     (memory.init 0 (i32.const 0xFFFE) (i32.const 1) (i32.const 3))))
-(assert_trap (invoke "test") "out of bounds")
+(assert_trap (invoke "test") "out of bounds memory access")
 `);
 
 // init: seg ix is valid passive, src offset past the end, zero len is invalid
@@ -170,7 +170,7 @@ print(
   ${PREAMBLE}
   (func (export "test")
     (memory.init 0 (i32.const 1234) (i32.const 4) (i32.const 0))))
-(assert_trap (invoke "test") "out of bounds")
+(assert_trap (invoke "test") "out of bounds memory access")
 `);
 
 // init: seg ix is valid passive, zero len, src offset at the end
@@ -188,7 +188,7 @@ print(
   ${PREAMBLE}
   (func (export "test")
     (memory.init 0 (i32.const 0x10001) (i32.const 0) (i32.const 0))))
-(assert_trap (invoke "test") "out of bounds")
+(assert_trap (invoke "test") "out of bounds memory access")
 `);
 
 // init: seg ix is valid passive, zero len, but dst offset at the end
@@ -216,7 +216,7 @@ print(
   ${PREAMBLE}
   (func (export "test")
     (memory.init 0 (i32.const 0x10001) (i32.const 4) (i32.const 0))))
-(assert_trap (invoke "test") "out of bounds")
+(assert_trap (invoke "test") "out of bounds memory access")
 `);
 
 // invalid argument types.  TODO: can add anyfunc etc here.
@@ -265,7 +265,7 @@ function mem_init(min, max, shared, backup, write) {
     let offs = min*PAGESIZE - backup;
     print(
 `(assert_trap (invoke "run" (i32.const ${offs}) (i32.const ${write}))
-              "out of bounds")
+              "out of bounds memory access")
 `);
     checkRange(0, min, 0);
 }
@@ -309,5 +309,4 @@ print(
   (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
   (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
   (data "")
-  (func (memory.init 64 (i32.const 0) (i32.const 0) (i32.const 0))))
-`)
+  (func (memory.init 64 (i32.const 0) (i32.const 0) (i32.const 0))))`)
diff --git a/test/meta/generate_table_copy.js b/test/meta/generate_table_copy.js
index 63aa53b06..f7fd47dcb 100644
--- a/test/meta/generate_table_copy.js
+++ b/test/meta/generate_table_copy.js
@@ -203,22 +203,22 @@ for ( let dest of ["$t0","$t1"] ) {
     // copy: dst range invalid
     tab_test2(`(table.copy ${dest} $t0 (i32.const 28) (i32.const 1) (i32.const 3))`,
               "",
-              "out of bounds");
+              "out of bounds table access");
 
     // copy: dst wraparound end of 32 bit offset space
     tab_test2(`(table.copy ${dest} $t0 (i32.const 0xFFFFFFFE) (i32.const 1) (i32.const 2))`,
               "",
-              "out of bounds");
+              "out of bounds table access");
 
     // copy: src range invalid
     tab_test2(`(table.copy ${dest} $t0 (i32.const 15) (i32.const 25) (i32.const 6))`,
               "",
-              "out of bounds");
+              "out of bounds table access");
 
     // copy: src wraparound end of 32 bit offset space
     tab_test2(`(table.copy ${dest} $t0 (i32.const 15) (i32.const 0xFFFFFFFE) (i32.const 2))`,
               "",
-              "out of bounds");
+              "out of bounds table access");
 
     // copy: zero length with both offsets in-bounds is OK
     tab_test_nofail(
@@ -233,7 +233,7 @@ for ( let dest of ["$t0","$t1"] ) {
     // copy: zero length with dst offset out of bounds past the end of the table is not allowed
     tab_test2(`(table.copy ${dest} $t0 (i32.const 31) (i32.const 15) (i32.const 0))`,
               "",
-              "out of bounds");
+              "out of bounds table access");
 
     // copy: zero length with src offset out of bounds at the end of the table is allowed
     tab_test2(`(table.copy ${dest} $t0 (i32.const 15) (i32.const 30) (i32.const 0))`,
@@ -243,7 +243,7 @@ for ( let dest of ["$t0","$t1"] ) {
     // copy: zero length with src offset out of bounds past the end of the table is not allowed
     tab_test2(`(table.copy ${dest} $t0 (i32.const 15) (i32.const 31) (i32.const 0))`,
               "",
-              "out of bounds");
+              "out of bounds table access");
 
     // copy: zero length with both dst and src offset out of bounds at the end of the table is allowed
     tab_test2(`(table.copy ${dest} $t0 (i32.const 30) (i32.const 30) (i32.const 0))`,
@@ -253,7 +253,7 @@ for ( let dest of ["$t0","$t1"] ) {
     // copy: zero length with both dst and src offset out of bounds past the end of the table is not allowed
     tab_test2(`(table.copy ${dest} $t0 (i32.const 31) (i32.const 31) (i32.const 0))`,
               "",
-              "out of bounds");
+              "out of bounds table access");
 }
 
 // table.copy: out of bounds of the table for the source or target, but should
@@ -320,7 +320,7 @@ function tbl_copy(min, max, srcOffs, targetOffs, len) {
     let immediateOOB = copyDown && (srcOffs + len > tblLength || targetOffs + len > tblLength);
 
     print(`(assert_trap (invoke "run" (i32.const ${targetOffs}) (i32.const ${srcOffs}) (i32.const ${len}))
-             "out of bounds")`);
+             "out of bounds table access")`);
 
     var s = 0;
     var i = 0;
diff --git a/test/meta/generate_table_init.js b/test/meta/generate_table_init.js
index 2f5ec4c77..16b9a8406 100644
--- a/test/meta/generate_table_init.js
+++ b/test/meta/generate_table_init.js
@@ -113,7 +113,7 @@ print(
   (module
     (func (export "test")
       (elem.drop 0)))
-  "unknown table 0")
+  "unknown elem segment 0")
 `);
 
 // table.init requires a table, minimally
@@ -133,7 +133,7 @@ print(
     (func (result i32) (i32.const 0))
     (func (export "test")
       (elem.drop 4)))
-  "unknown table 0")
+  "unknown elem segment 4")
 `);
 
 // init with elem seg ix out of range
@@ -197,7 +197,7 @@ tab_test1("(elem.drop 2)", 0,
 
 // init with elem seg ix indicating an active segment
 tab_test1("(table.init 2 (i32.const 12) (i32.const 1) (i32.const 1))", 0,
-          "out of bounds");
+          "out of bounds table access");
 
 // init, using an elem seg ix more than once is OK
 tab_test2(
@@ -213,15 +213,15 @@ tab_test2("(elem.drop 1)",
 // drop, then init
 tab_test2("(elem.drop 1)",
           "(table.init 1 (i32.const 12) (i32.const 1) (i32.const 1))",
-          "out of bounds");
+          "out of bounds table access");
 
 // init: seg ix is valid passive, but length to copy > len of seg
 tab_test1("(table.init 1 (i32.const 12) (i32.const 0) (i32.const 5))", 0,
-          "out of bounds");
+          "out of bounds table access");
 
 // init: seg ix is valid passive, but implies copying beyond end of seg
 tab_test1("(table.init 1 (i32.const 12) (i32.const 2) (i32.const 3))", 0,
-          "out of bounds");
+          "out of bounds table access");
 
 // Tables are of different length with t1 shorter than t0, to test that we're not
 // using t0's limit for t1's bound
@@ -230,7 +230,7 @@ for ( let [table, oobval] of [[0,30],[1,28]] ) {
     // init: seg ix is valid passive, but implies copying beyond end of dst
     tab_test1(`(table.init $t${table} 1 (i32.const ${oobval-2}) (i32.const 1) (i32.const 3))`,
               table,
-              "out of bounds");
+              "out of bounds table access");
 
     // init: seg ix is valid passive, zero len, and src offset out of bounds at the
     // end of the table - this is allowed
@@ -242,7 +242,7 @@ for ( let [table, oobval] of [[0,30],[1,28]] ) {
     // end of the table - this is not allowed
     tab_test1(`(table.init $t${table} 1 (i32.const 12) (i32.const 5) (i32.const 0))`,
               table,
-              "out of bounds");
+              "out of bounds table access");
 
     // init: seg ix is valid passive, zero len, and dst offset out of bounds at the
     // end of the table - this is allowed
@@ -254,7 +254,7 @@ for ( let [table, oobval] of [[0,30],[1,28]] ) {
     // end of the table - this is not allowed
     tab_test1(`(table.init $t${table} 1 (i32.const ${oobval+1}) (i32.const 2) (i32.const 0))`,
               table,
-              "out of bounds");
+              "out of bounds table access");
 
     // init: seg ix is valid passive, zero len, and dst and src offsets out of bounds
     // at the end of the table - this is allowed
@@ -266,7 +266,7 @@ for ( let [table, oobval] of [[0,30],[1,28]] ) {
     // end of the table - this is not allowed
     tab_test1(`(table.init $t${table} 1 (i32.const ${oobval+1}) (i32.const 5) (i32.const 0))`,
               table,
-              "out of bounds");
+              "out of bounds table access");
 }
 
 // invalid argument types
@@ -338,7 +338,7 @@ function tbl_init(min, max, backup, write, segoffs=0) {
     // A fill reading past the end of the segment should throw *and* have filled
     // table with as much data as was available.
     let offs = min - backup;
-    print(`(assert_trap (invoke "run" (i32.const ${offs}) (i32.const ${write})) "out of bounds")`);
+    print(`(assert_trap (invoke "run" (i32.const ${offs}) (i32.const ${write})) "out of bounds table access")`);
     for (let i=0; i < min; i++) {
         print(`(assert_trap (invoke "test" (i32.const ${i})) "uninitialized element")`);
     }
@@ -383,5 +383,4 @@ print(
   (elem funcref) (elem funcref) (elem funcref) (elem funcref)
   (elem funcref) (elem funcref) (elem funcref) (elem funcref)
   (elem funcref)
-  (func (table.init 64 (i32.const 0) (i32.const 0) (i32.const 0))))
-`)
+  (func (table.init 64 (i32.const 0) (i32.const 0) (i32.const 0))))`)

From 5a12e3f002cc0392a3e9dc6b63f77730c926a0d1 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Tue, 4 Oct 2022 10:51:49 +0200
Subject: [PATCH 211/285] [spec] Editorial tweak

---
 document/core/text/values.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/text/values.rst b/document/core/text/values.rst
index 1f4c1bbfd..2b869d251 100644
--- a/document/core/text/values.rst
+++ b/document/core/text/values.rst
@@ -131,7 +131,7 @@ Furthermore, arbitrary NaN values may be expressed by providing an explicit payl
      z{:}\Tfloat &\Rightarrow& \ieee_N(z) & (\iff \ieee_N(z) \neq \pm \infty) \\ &&|&
      z{:}\Thexfloat &\Rightarrow& \ieee_N(z) & (\iff \ieee_N(z) \neq \pm \infty) \\ &&|&
      \text{inf} &\Rightarrow& \infty \\ &&|&
-     \text{nan} &\Rightarrow& \NAN(2^{\significand(N)-1}) \\ &&|&
+     \text{nan} &\Rightarrow& \NAN(\canon_N) \\ &&|&
      \text{nan{:}0x}~n{:}\Thexnum &\Rightarrow& \NAN(n) & (\iff 1 \leq n < 2^{\significand(N)}) \\
    \end{array}
 

From f2b7c60c6726d0857f137d9243107a74f8538668 Mon Sep 17 00:00:00 2001
From: Keith Winstein <keithw@cs.stanford.edu>
Date: Wed, 5 Oct 2022 02:41:51 -0700
Subject: [PATCH 212/285] [test] test segment/table mismatch and externref
 segment (#1547)

---
 test/core/elem.wast | 56 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

diff --git a/test/core/elem.wast b/test/core/elem.wast
index af12fec63..8dc04e6e4 100644
--- a/test/core/elem.wast
+++ b/test/core/elem.wast
@@ -600,3 +600,59 @@
 (assert_return (invoke $module1 "call-7") (i32.const 67))
 (assert_return (invoke $module1 "call-8") (i32.const 69))
 (assert_return (invoke $module1 "call-9") (i32.const 70))
+
+;; Element segments must match element type of table
+
+(assert_invalid
+  (module (func $f) (table 1 externref) (elem (i32.const 0) $f))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (table 1 funcref) (elem (i32.const 0) externref (ref.null extern)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $f)
+    (table $t 1 externref)
+    (elem $e funcref (ref.func $f))
+    (func (table.init $t $e (i32.const 0) (i32.const 0) (i32.const 1))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table $t 1 funcref)
+    (elem $e externref (ref.null extern))
+    (func (table.init $t $e (i32.const 0) (i32.const 0) (i32.const 1))))
+  "type mismatch"
+)
+
+;; Initializing a table with an externref-type element segment
+
+(module $m
+	(table $t (export "table") 2 externref)
+	(func (export "get") (param $i i32) (result externref)
+	      (table.get $t (local.get $i)))
+	(func (export "set") (param $i i32) (param $x externref)
+	      (table.set $t (local.get $i) (local.get $x))))
+
+(register "exporter" $m)
+
+(assert_return (invoke $m "get" (i32.const 0)) (ref.null extern))
+(assert_return (invoke $m "get" (i32.const 1)) (ref.null extern))
+
+(assert_return (invoke $m "set" (i32.const 0) (ref.extern 42)))
+(assert_return (invoke $m "set" (i32.const 1) (ref.extern 137)))
+
+(assert_return (invoke $m "get" (i32.const 0)) (ref.extern 42))
+(assert_return (invoke $m "get" (i32.const 1)) (ref.extern 137))
+
+(module
+  (import "exporter" "table" (table $t 2 externref))
+  (elem (i32.const 0) externref (ref.null extern)))
+
+(assert_return (invoke $m "get" (i32.const 0)) (ref.null extern))
+(assert_return (invoke $m "get" (i32.const 1)) (ref.extern 137))

From 7f3e78eb15194fa1694f126f1eaef54d3206a37b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Daniel=20Hillerstr=C3=B6m?= <daniel.hillerstrom@ed.ac.uk>
Date: Wed, 5 Oct 2022 15:47:38 +0100
Subject: [PATCH 213/285] [interpreter] Remove duplicate token declarations
 (#1548)

---
 interpreter/text/parser.mly | 70 +++++++++++--------------------------
 1 file changed, 20 insertions(+), 50 deletions(-)

diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index 1eb6be286..535a05d51 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -205,8 +205,11 @@ let inline_type_explicit (c : context) x ft at =
 %}
 
 %token LPAR RPAR
-%token NAT INT FLOAT STRING VAR
-%token NUM_TYPE VEC_TYPE VEC_SHAPE FUNCREF EXTERNREF EXTERN MUT
+%token<string> NAT INT FLOAT STRING VAR
+%token<Types.num_type> NUM_TYPE
+%token<Types.vec_type> VEC_TYPE
+%token<V128.shape> VEC_SHAPE
+%token FUNCREF EXTERNREF EXTERN MUT
 %token UNREACHABLE NOP DROP SELECT
 %token BLOCK END IF THEN ELSE LOOP BR BR_IF BR_TABLE
 %token CALL CALL_INDIRECT RETURN
@@ -214,61 +217,28 @@ let inline_type_explicit (c : context) x ft at =
 %token TABLE_GET TABLE_SET
 %token TABLE_SIZE TABLE_GROW TABLE_FILL TABLE_COPY TABLE_INIT ELEM_DROP
 %token MEMORY_SIZE MEMORY_GROW MEMORY_FILL MEMORY_COPY MEMORY_INIT DATA_DROP
-%token LOAD STORE OFFSET_EQ_NAT ALIGN_EQ_NAT
-%token CONST UNARY BINARY TEST COMPARE CONVERT
+%token<int option -> Memory.offset -> Ast.instr'> LOAD STORE
+%token<string> OFFSET_EQ_NAT ALIGN_EQ_NAT
+%token<string Source.phrase -> Ast.instr' * Values.num> CONST
+%token<Ast.instr'> UNARY BINARY TEST COMPARE CONVERT
 %token REF_NULL REF_FUNC REF_EXTERN REF_IS_NULL
-%token VEC_LOAD VEC_STORE VEC_LOAD_LANE VEC_STORE_LANE
-%token VEC_CONST VEC_UNARY VEC_BINARY VEC_TERNARY VEC_TEST
-%token VEC_SHIFT VEC_BITMASK VEC_SHUFFLE
-%token VEC_EXTRACT VEC_REPLACE
+%token<int option -> Memory.offset -> Ast.instr'> VEC_LOAD VEC_STORE
+%token<int option -> Memory.offset -> int -> Ast.instr'> VEC_LOAD_LANE VEC_STORE_LANE
+%token<V128.shape -> string Source.phrase list -> Source.region -> Ast.instr' * Values.vec> VEC_CONST
+%token<Ast.instr'> VEC_UNARY VEC_BINARY VEC_TERNARY VEC_TEST
+%token<Ast.instr'> VEC_SHIFT VEC_BITMASK VEC_SPLAT
+%token VEC_SHUFFLE
+%token<int -> Ast.instr'> VEC_EXTRACT VEC_REPLACE
 %token FUNC START TYPE PARAM RESULT LOCAL GLOBAL
 %token TABLE ELEM MEMORY DATA DECLARE OFFSET ITEM IMPORT EXPORT
 %token MODULE BIN QUOTE
 %token SCRIPT REGISTER INVOKE GET
-%token ASSERT_MALFORMED ASSERT_INVALID ASSERT_SOFT_INVALID ASSERT_UNLINKABLE
+%token ASSERT_MALFORMED ASSERT_INVALID ASSERT_UNLINKABLE
 %token ASSERT_RETURN ASSERT_TRAP ASSERT_EXHAUSTION
-%token NAN
+%token<Script.nan> NAN
 %token INPUT OUTPUT
 %token EOF
 
-%token<string> NAT
-%token<string> INT
-%token<string> FLOAT
-%token<string> STRING
-%token<string> VAR
-%token<Types.num_type> NUM_TYPE
-%token<Types.vec_type> VEC_TYPE
-%token<string Source.phrase -> Ast.instr' * Values.num> CONST
-%token<V128.shape -> string Source.phrase list -> Source.region -> Ast.instr' * Values.vec> VEC_CONST
-%token<Ast.instr'> UNARY
-%token<Ast.instr'> BINARY
-%token<Ast.instr'> TEST
-%token<Ast.instr'> COMPARE
-%token<Ast.instr'> CONVERT
-%token<int option -> Memory.offset -> Ast.instr'> LOAD
-%token<int option -> Memory.offset -> Ast.instr'> STORE
-%token<int option -> Memory.offset -> Ast.instr'> VEC_LOAD
-%token<int option -> Memory.offset -> Ast.instr'> VEC_STORE
-%token<int option -> Memory.offset -> int -> Ast.instr'> VEC_LOAD_LANE
-%token<int option -> Memory.offset -> int -> Ast.instr'> VEC_STORE_LANE
-%token<Ast.instr'> VEC_UNARY
-%token<Ast.instr'> VEC_BINARY
-%token<Ast.instr'> VEC_TERNARY
-%token<Ast.instr'> VEC_TEST
-%token<Ast.instr'> VEC_SHIFT
-%token<Ast.instr'> VEC_BITMASK
-%token<Ast.instr'> VEC_SPLAT
-%token<int -> Ast.instr'> VEC_EXTRACT
-%token<int -> Ast.instr'> VEC_REPLACE
-%token<string> OFFSET_EQ_NAT
-%token<string> ALIGN_EQ_NAT
-%token<V128.shape> VEC_SHAPE
-
-%token<Script.nan> NAN
-
-%nonassoc LOW
-%nonassoc VAR
-
 %start script script1 module1
 %type<Script.script> script
 %type<Script.script> script1
@@ -367,7 +337,7 @@ bind_var :
   | VAR { $1 @@ at () }
 
 labeling_opt :
-  | /* empty */ %prec LOW
+  | /* empty */
     { fun c xs ->
       List.iter (fun x -> error x.at "mismatching label") xs;
       anon_label c }
@@ -378,7 +348,7 @@ labeling_opt :
       bind_label c $1 }
 
 labeling_end_opt :
-  | /* empty */ %prec LOW { [] }
+  | /* empty */ { [] }
   | bind_var { [$1] }
 
 offset_opt :

From c86b2fb374464833c3a599c15c4c1298f4c2b1d9 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Sat, 8 Oct 2022 14:20:36 +0200
Subject: [PATCH 214/285] Update Soundness appendix (#72)

---
 document/core/appendix/embedding.rst   |  38 ++--
 document/core/appendix/index-rules.rst |   4 +-
 document/core/appendix/properties.rst  | 269 +++++++++++++++++++------
 document/core/exec/index.rst           |   1 +
 document/core/exec/instructions.rst    |  39 ++--
 document/core/exec/modules.rst         | 227 ++++-----------------
 document/core/exec/runtime.rst         |  24 ++-
 document/core/exec/types.rst           |  54 ++---
 document/core/exec/values.rst          | 164 +++++++++++++++
 document/core/syntax/types.rst         |  29 +--
 document/core/util/macros.def          |  23 ++-
 document/core/valid/conventions.rst    |  22 +-
 document/core/valid/instructions.rst   |  14 +-
 document/core/valid/matching.rst       |   8 +-
 document/core/valid/modules.rst        |  26 +--
 document/core/valid/types.rst          |  12 +-
 16 files changed, 571 insertions(+), 383 deletions(-)
 create mode 100644 document/core/exec/values.rst

diff --git a/document/core/appendix/embedding.rst b/document/core/appendix/embedding.rst
index c8ec4e3d6..dc185b0a8 100644
--- a/document/core/appendix/embedding.rst
+++ b/document/core/appendix/embedding.rst
@@ -167,7 +167,7 @@ Modules
 :math:`\F{module\_imports}(\module) : (\name, \name, \externtype)^\ast`
 .......................................................................
 
-1. Pre-condition: :math:`\module` is :ref:`valid <valid-module>` with the :ref:`semantic <syntax-type-sem>` external import types :math:`\externtype^\ast` and external export types :math:`{\externtype'}^\ast`.
+1. Pre-condition: :math:`\module` is :ref:`valid <valid-module>` with the :ref:`dynamic <syntax-type-dyn>` external import types :math:`\externtype^\ast` and external export types :math:`{\externtype'}^\ast`.
 
 2. Let :math:`\import^\ast` be the :ref:`imports <syntax-import>` :math:`\module.\MIMPORTS`.
 
@@ -179,7 +179,7 @@ Modules
 
 5. Return the concatenation of all :math:`\X{result}_i`, in index order.
 
-6. Post-condition: each :ref:`semantic <syntax-type-sem>` :math:`\externtype_i` is :ref:`valid <valid-externtype>`.
+6. Post-condition: each :ref:`dynamic <syntax-type-dyn>` :math:`\externtype_i` is :ref:`valid <valid-externtype>`.
 
 .. math::
    ~ \\
@@ -195,7 +195,7 @@ Modules
 :math:`\F{module\_exports}(\module) : (\name, \externtype)^\ast`
 ................................................................
 
-1. Pre-condition: :math:`\module` is :ref:`valid <valid-module>` with the :ref:`semantic <syntax-type-sem>` external import types :math:`\externtype^\ast` and external export types :math:`{\externtype'}^\ast`.
+1. Pre-condition: :math:`\module` is :ref:`valid <valid-module>` with the :ref:`dynamic <syntax-type-dyn>` external import types :math:`\externtype^\ast` and external export types :math:`{\externtype'}^\ast`.
 
 2. Let :math:`\export^\ast` be the :ref:`exports <syntax-export>` :math:`\module.\MEXPORTS`.
 
@@ -207,7 +207,7 @@ Modules
 
 5. Return the concatenation of all :math:`\X{result}_i`, in index order.
 
-6. Post-condition: each :ref:`semantic <syntax-type-sem>` :math:`\externtype'_i` is :ref:`valid <valid-externtype>`.
+6. Post-condition: each :ref:`dynamic <syntax-type-dyn>` :math:`\externtype'_i` is :ref:`valid <valid-externtype>`.
 
 .. math::
    ~ \\
@@ -257,7 +257,7 @@ Types
 :math:`\F{type\_alloc}(\store, \functype) : (\store, \typeaddr)`
 ...........................................................................
 
-1. Pre-condition: the :ref:`semantic <syntax-type-sem>` :math:`\functype` is :ref:`valid <valid-functype>`.
+1. Pre-condition: the :ref:`dynamic <syntax-type-dyn>` :math:`\functype` is :ref:`valid <valid-functype>`.
 
 2. Let :math:`\typeaddr` be the result of :ref:`allocating a type <alloc-type>` in :math:`\store` for :ref:`function type <syntax-functype>` :math:`\functype`.
 
@@ -277,18 +277,18 @@ Functions
 
 .. _embed-func-alloc:
 
-:math:`\F{func\_alloc}(\store, \functype, \hostfunc) : (\store, \funcaddr)`
+:math:`\F{func\_alloc}(\store, \typeaddr, \hostfunc) : (\store, \funcaddr)`
 ...........................................................................
 
-1. Pre-condition: the :ref:`semantic <syntax-type-sem>` :math:`\functype` is :ref:`valid <valid-functype>`.
+1. Pre-condition: the :ref:`dynamic <syntax-type-dyn>` :math:`\functype` is :ref:`valid <valid-functype>`.
 
-2. Let :math:`\funcaddr` be the result of :ref:`allocating a host function <alloc-func>` in :math:`\store` with :ref:`function type <syntax-functype>` :math:`\functype` and host function code :math:`\hostfunc`.
+2. Let :math:`\funcaddr` be the result of :ref:`allocating a host function <alloc-func>` in :math:`\store` with :ref:`type address <syntax-typeaddr>` :math:`\typeaddr` and host function code :math:`\hostfunc`.
 
 3. Return the new store paired with :math:`\funcaddr`.
 
 .. math::
    \begin{array}{lclll}
-   \F{func\_alloc}(S, \X{ft}, \X{code}) &=& (S', \X{a}) && (\iff \allochostfunc(S, \X{ft}, \X{code}) = S', \X{a}) \\
+   \F{func\_alloc}(S, \X{ta}, \X{code}) &=& (S', \X{a}) && (\iff \allochostfunc(S, \X{ta}, \X{code}) = S', \X{a}) \\
    \end{array}
 
 .. note::
@@ -302,13 +302,15 @@ Functions
 :math:`\F{func\_type}(\store, \funcaddr) : \functype`
 .....................................................
 
-1. Return :math:`S.\SFUNCS[a].\FITYPE`.
+1. Let :math:`\typeaddr` be the :ref:`type address <syntax-typeaddr>` :math:`S.\SFUNCS[a].\FITYPE`.
 
-2. Post-condition: the returned :ref:`semantic <syntax-type-sem>` :ref:`function type <syntax-functype>` is :ref:`valid <valid-functype>`.
+2. Return :math:`S.\STYPES[\typeaddr]`.
+
+3. Post-condition: the returned :ref:`dynamic <syntax-type-dyn>` :ref:`function type <syntax-functype>` is :ref:`valid <valid-functype>`.
 
 .. math::
    \begin{array}{lclll}
-   \F{func\_type}(S, a) &=& S.\SFUNCS[a].\FITYPE \\
+   \F{func\_type}(S, a) &=& S.\STYPES[S.\SFUNCS[a].\FITYPE] \\
    \end{array}
 
 
@@ -348,7 +350,7 @@ Tables
 :math:`\F{table\_alloc}(\store, \tabletype) : (\store, \tableaddr, \reff)`
 ..........................................................................
 
-1. Pre-condition: the :ref:`semantic <syntax-type-sem>` :math:`\tabletype` is :ref:`valid <valid-tabletype>`.
+1. Pre-condition: the :ref:`dynamic <syntax-type-dyn>` :math:`\tabletype` is :ref:`valid <valid-tabletype>`.
 
 2. Let :math:`\tableaddr` be the result of :ref:`allocating a table <alloc-table>` in :math:`\store` with :ref:`table type <syntax-tabletype>` :math:`\tabletype` and initialization value :math:`\reff`.
 
@@ -367,7 +369,7 @@ Tables
 
 1. Return :math:`S.\STABLES[a].\TITYPE`.
 
-2. Post-condition: the returned :ref:`semantic <syntax-type-sem>` :ref:`table type <syntax-tabletype>` is :ref:`valid <valid-tabletype>`.
+2. Post-condition: the returned :ref:`dynamic <syntax-type-dyn>` :ref:`table type <syntax-tabletype>` is :ref:`valid <valid-tabletype>`.
 
 .. math::
    \begin{array}{lclll}
@@ -460,7 +462,7 @@ Memories
 :math:`\F{mem\_alloc}(\store, \memtype) : (\store, \memaddr)`
 ................................................................
 
-1. Pre-condition: the :ref:`semantic <syntax-type-sem>` :math:`\memtype` is :ref:`valid <valid-memtype>`.
+1. Pre-condition: the :ref:`dynamic <syntax-type-dyn>` :math:`\memtype` is :ref:`valid <valid-memtype>`.
 
 2. Let :math:`\memaddr` be the result of :ref:`allocating a memory <alloc-mem>` in :math:`\store` with :ref:`memory type <syntax-memtype>` :math:`\memtype`.
 
@@ -479,7 +481,7 @@ Memories
 
 1. Return :math:`S.\SMEMS[a].\MITYPE`.
 
-2. Post-condition: the returned :ref:`semantic <syntax-type-sem>` :ref:`memory type <syntax-memtype>` is :ref:`valid <valid-memtype>`.
+2. Post-condition: the returned :ref:`dynamic <syntax-type-dyn>` :ref:`memory type <syntax-memtype>` is :ref:`valid <valid-memtype>`.
 
 .. math::
    \begin{array}{lclll}
@@ -573,7 +575,7 @@ Globals
 :math:`\F{global\_alloc}(\store, \globaltype, \val) : (\store, \globaladdr)`
 ............................................................................
 
-1. Pre-condition: the :ref:`semantic <syntax-type-sem>` :math:`\globaltype` is :ref:`valid <valid-globaltype>`.
+1. Pre-condition: the :ref:`dynamic <syntax-type-dyn>` :math:`\globaltype` is :ref:`valid <valid-globaltype>`.
 
 2. Let :math:`\globaladdr` be the result of :ref:`allocating a global <alloc-global>` in :math:`\store` with :ref:`global type <syntax-globaltype>` :math:`\globaltype` and initialization value :math:`\val`.
 
@@ -592,7 +594,7 @@ Globals
 
 1. Return :math:`S.\SGLOBALS[a].\GITYPE`.
 
-2. Post-condition: the returned :ref:`semantic <syntax-type-sem>` :ref:`global type <syntax-globaltype>` is :ref:`valid <valid-globaltype>`.
+2. Post-condition: the returned :ref:`dynamic <syntax-type-dyn>` :ref:`global type <syntax-globaltype>` is :ref:`valid <valid-globaltype>`.
 
 .. math::
    \begin{array}{lclll}
diff --git a/document/core/appendix/index-rules.rst b/document/core/appendix/index-rules.rst
index acfad73ee..852296799 100644
--- a/document/core/appendix/index-rules.rst
+++ b/document/core/appendix/index-rules.rst
@@ -29,7 +29,7 @@ Construct                                        Judgement
 :ref:`Instruction <valid-instr>`                 :math:`S;C \vdashinstr \instr : \functype`
 :ref:`Instruction sequence <valid-instr-seq>`    :math:`S;C \vdashinstrseq \instr^\ast : \functype`
 :ref:`Expression <valid-expr>`                   :math:`C \vdashexpr \expr : \resulttype`
-:ref:`Function <valid-func>`                     :math:`C \vdashfunc \func : \functype`
+:ref:`Function <valid-func>`                     :math:`C \vdashfunc \func : \typeid`
 :ref:`Local <valid-local>`                       :math:`C \vdashlocal \local : \localtype`
 :ref:`Table <valid-table>`                       :math:`C \vdashtable \table : \tabletype`
 :ref:`Memory <valid-mem>`                        :math:`C \vdashmem \mem : \memtype`
@@ -58,6 +58,7 @@ Construct                                        Judgement
 :ref:`Value <valid-val>`                         :math:`S \vdashval \val : \valtype`
 :ref:`Result <valid-result>`                     :math:`S \vdashresult \result : \resulttype`
 :ref:`External value <valid-externval>`          :math:`S \vdashexternval \externval : \externtype`
+:ref:`Type instance <valid-typeinst>`            :math:`S \vdashtypeinst \typeinst \ok`
 :ref:`Function instance <valid-funcinst>`        :math:`S \vdashfuncinst \funcinst : \functype`
 :ref:`Table instance <valid-tableinst>`          :math:`S \vdashtableinst \tableinst : \tabletype`
 :ref:`Memory instance <valid-meminst>`           :math:`S \vdashmeminst \meminst : \memtype`
@@ -120,6 +121,7 @@ Store Extension
 ===============================================  ===============================================================================
 Construct                                        Judgement
 ===============================================  ===============================================================================
+:ref:`Type instance <extend-typeinst>`           :math:`\vdashtypeinstextends \typeinst_1 \extendsto \typeinst_2`
 :ref:`Function instance <extend-funcinst>`       :math:`\vdashfuncinstextends \funcinst_1 \extendsto \funcinst_2`
 :ref:`Table instance <extend-tableinst>`         :math:`\vdashtableinstextends \tableinst_1 \extendsto \tableinst_2`
 :ref:`Memory instance <extend-meminst>`          :math:`\vdashmeminstextends \meminst_1 \extendsto \meminst_2`
diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index 3cb07e907..5292708d2 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -4,12 +4,6 @@
 Soundness
 ---------
 
-.. todo:: need to operate wrt semantic types
-.. todo:: define "S \vdash t ok"
-.. _valid-typeinst:
-.. todo:: define valid-typeinst as well
-.. todo:: ensure wf of guessed valtypes
-
 The :ref:`type system <type-system>` of WebAssembly is *sound*, implying both *type safety* and *memory safety* with respect to the WebAssembly semantics. For example:
 
 * All types declared and derived during validation are respected at run time;
@@ -32,14 +26,14 @@ In order to state and prove soundness precisely, the typing rules must be extend
 Results
 ~~~~~~~
 
-:ref:`Results <syntax-result>` can be classified by :ref:`result types <syntax-resulttype>` as follows.
+:ref:`Results <syntax-result>` can be classified by :ref:`dynamic <syntax-type-dyn>` :ref:`result types <syntax-resulttype>` as follows.
 
 :ref:`Results <syntax-result>` :math:`\val^\ast`
 ................................................
 
 * For each :ref:`value <syntax-val>` :math:`\val_i` in :math:`\val^\ast`:
 
-  * The value :math:`\val_i` is :ref:`valid <valid-val>` with some :ref:`value type <syntax-valtype>` :math:`t_i`.
+  * The value :math:`\val_i` is :ref:`valid <valid-val>` with some :ref:`dynamic <syntax-type-dyn>` :ref:`value type <syntax-valtype>` :math:`t_i`.
 
 * Let :math:`t^\ast` be the concatenation of all :math:`t_i`.
 
@@ -56,7 +50,7 @@ Results
 :ref:`Results <syntax-result>` :math:`\TRAP`
 ............................................
 
-* The result is valid with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`, for any :ref:`valid <valid-resulttype>` :ref:`semantic <syntax-type-sem>` :ref:`result types <syntax-resulttype>`.
+* The result is valid with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`, for any :ref:`valid <valid-resulttype>` :ref:`dynamic <syntax-type-dyn>` :ref:`result types <syntax-resulttype>`.
 
 .. math::
    \frac{
@@ -86,7 +80,9 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 :ref:`Store <syntax-store>` :math:`S`
 .....................................
 
-* Each :ref:`function instance <syntax-funcinst>` :math:`\funcinst_i` in :math:`S.\SFUNCS` must be :ref:`valid <valid-funcinst>` with some :ref:`function type <syntax-functype>` :math:`\functype_i`.
+* Each :ref:`type instance <syntax-typeinst>` :math:`\typeinst_i` in :math:`S.\STYPES` must be :ref:`valid <valid-functype>` in a store :math:`S'_i` only containing the sequence :math:`\typeinst_0 \dots \typeinst_{i-1}` of preceding type instances.
+
+* Each :ref:`function instance <syntax-funcinst>` :math:`\funcinst_i` in :math:`S.\SFUNCS` must be :ref:`valid <valid-funcinst>` with some :ref:`type address <syntax-typeaddr>` :math:`\typeaddr_i`.
 
 * Each :ref:`table instance <syntax-tableinst>` :math:`\tableinst_i` in :math:`S.\STABLES` must be :ref:`valid <valid-tableinst>` with some :ref:`table type <syntax-tabletype>` :math:`\tabletype_i`.
 
@@ -104,7 +100,11 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
    ~\\[-1ex]
    \frac{
      \begin{array}{@{}c@{}}
-     (S \vdashfuncinst \funcinst : \functype)^\ast
+     a^n = 0 \dots (n-1)
+     \qquad
+     (\{\STYPES~\typeinst^n[0 \slice a]\} \vdashtypeinst \typeinst \ok)^n
+     \\
+     (S \vdashfuncinst \funcinst : \typeaddr)^\ast
      \qquad
      (S \vdashtableinst \tableinst : \tabletype)^\ast
      \\
@@ -117,53 +117,81 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
      (S \vdashdatainst \datainst \ok)^\ast
      \\
      S = \{
+       \begin{array}[t]{@{}l@{}}
+       \STYPES~\typeinst^n,
        \SFUNCS~\funcinst^\ast,
+       \SGLOBALS~\globalinst^\ast, \\
        \STABLES~\tableinst^\ast,
        \SMEMS~\meminst^\ast,
-       \SGLOBALS~\globalinst^\ast,
        \SELEMS~\eleminst^\ast,
        \SDATAS~\datainst^\ast \}
+       \end{array}
      \end{array}
    }{
      \vdashstore S \ok
    }
 
+.. note::
+   The validity condition on type instances ensures the absence of cyclic types.
+
+
+.. index:: function type, type instance
+.. _valid-typeinst:
+
+:ref:`Type Instances <syntax-typeinst>` :math:`\functype`
+.........................................................
+
+* The :ref:`dynamic <syntax-type-dyn>` :ref:`function type <syntax-functype>` :math:`\functype` must be :ref:`valid <valid-functype>`.
+
+* Then it is valid as a type instance.
+
+.. math::
+   \frac{
+     S \vdashfunctype \functype \ok
+   }{
+     S \vdashtypeinst \functype \ok
+   }
+
 
 .. index:: function type, function instance
 .. _valid-funcinst:
 
-:ref:`Function Instances <syntax-funcinst>` :math:`\{\FITYPE~\functype, \FIMODULE~\moduleinst, \FICODE~\func\}`
+:ref:`Function Instances <syntax-funcinst>` :math:`\{\FITYPE~\typeaddr, \FIMODULE~\moduleinst, \FICODE~\func\}`
 .......................................................................................................................
 
-* The :ref:`function type <syntax-functype>` :math:`\functype` must be :ref:`valid <valid-functype>`.
-
 * The :ref:`module instance <syntax-moduleinst>` :math:`\moduleinst` must be :ref:`valid <valid-moduleinst>` with some :ref:`context <context>` :math:`C`.
 
-* Under :ref:`context <context>` :math:`C`, the :ref:`function <syntax-func>` :math:`\func` must be :ref:`valid <valid-func>` with :ref:`function type <syntax-functype>` :math:`\functype`.
+* Under :ref:`context <context>` :math:`C`:
 
-* Then the function instance is valid with :ref:`function type <syntax-functype>` :math:`\functype`.
+  * The :ref:`function <syntax-func>` :math:`\func` must be :ref:`valid <valid-func>` with :ref:`static <syntax-type-stat>` :ref:`type identifier <syntax-typeid>` :math:`\typeidx`.
+
+  * The :ref:`static <syntax-type-stat>` :ref:`heap type <syntax-heaptype>` :math:`\typeidx` must :ref:`match <match-heaptype>` the :ref:`dynamic <syntax-type-dyn>` :ref:`heap type <syntax-heaptype>` :math:`\typeaddr`.
+
+* Then the function instance is valid with :ref:`type address <syntax-typeaddr>` :math:`\typeaddr`.
 
 .. math::
    \frac{
-     \vdashfunctype \functype \ok
-     \qquad
+     \begin{array}{@{}c@{}}
      S \vdashmoduleinst \moduleinst : C
+     \\
+     C \vdashfunc \func : \typeidx
      \qquad
-     C \vdashfunc \func : \functype
+     C; S \vdashheaptypematch \typeidx \matchesheaptype \typeaddr
+     \end{array}
    }{
-     S \vdashfuncinst \{\FITYPE~\functype, \FIMODULE~\moduleinst, \FICODE~\func\} : \functype
+     S \vdashfuncinst \{\FITYPE~\typeaddr, \FIMODULE~\moduleinst, \FICODE~\func\} : \typeaddr
    }
 
 
 .. index:: function type, function instance, host function
 .. _valid-hostfuncinst:
 
-:ref:`Host Function Instances <syntax-funcinst>` :math:`\{\FITYPE~\functype, \FIHOSTCODE~\X{hf}\}`
+:ref:`Host Function Instances <syntax-funcinst>` :math:`\{\FITYPE~\typeaddr, \FIHOSTCODE~\X{hf}\}`
 ..................................................................................................
 
-* The :ref:`function type <syntax-functype>` :math:`\functype` must be :ref:`valid <valid-functype>`.
+* The :ref:`type instance <syntax-typeinst>` :math:`S.\STYPES[\typeaddr]` must exist.
 
-* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`\functype`.
+* Let the :ref:`dynamic <syntax-type-dyn>` :ref:`function type <syntax-functype>` :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`type instance <syntax-typeinst>` :math:`S.\STYPES[\typeaddr]`.
 
 * For every :ref:`valid <valid-store>` :ref:`store <syntax-store>` :math:`S_1` :ref:`extending <extend-store>` :math:`S` and every sequence :math:`\val^\ast` of :ref:`values <syntax-val>` whose :ref:`types <valid-val>` coincide with :math:`t_1^\ast`:
 
@@ -175,12 +203,12 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 
     * Or :math:`R` consists of a :ref:`valid <valid-store>` :ref:`store <syntax-store>` :math:`S_2` :ref:`extending <extend-store>` :math:`S_1` and a :ref:`result <syntax-result>` :math:`\result` whose :ref:`type <valid-result>` coincides with :math:`[t_2^\ast]`.
 
-* Then the function instance is valid with :ref:`function type <syntax-functype>` :math:`\functype`.
+* Then the function instance is valid with :ref:`type address <syntax-typeaddr>` :math:`\typeaddr`.
 
 .. math::
    \frac{
      \begin{array}[b]{@{}l@{}}
-     \vdashfunctype [t_1^\ast] \to [t_2^\ast] \ok \\
+     S.\STYPES[\typeaddr] = [t_1^\ast] \to [t_2^\ast] \\
      \end{array}
      \quad
      \begin{array}[b]{@{}l@{}}
@@ -199,7 +227,7 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
        R = (S_2; \result)
      \end{array}
    }{
-     S \vdashfuncinst \{\FITYPE~[t_1^\ast] \to [t_2^\ast], \FIHOSTCODE~\X{hf}\} : [t_1^\ast] \to [t_2^\ast]
+     S \vdashfuncinst \{\FITYPE~\typeaddr, \FIHOSTCODE~\X{hf}\} : \typeaddr
    }
 
 .. note::
@@ -216,7 +244,7 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 :ref:`Table Instances <syntax-tableinst>` :math:`\{ \TITYPE~(\limits~t), \TIELEM~\reff^\ast \}`
 ...............................................................................................
 
-* The :ref:`table type <syntax-tabletype>` :math:`\limits~t` must be :ref:`valid <valid-tabletype>`.
+* The :ref:`dynamic <syntax-type-dyn>` :ref:`table type <syntax-tabletype>` :math:`\limits~t` must be :ref:`valid <valid-tabletype>`.
 
 * The length of :math:`\reff^\ast` must equal :math:`\limits.\LMIN`.
 
@@ -228,17 +256,15 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 
 * Then the table instance is valid with :ref:`table type <syntax-tabletype>` :math:`\limits~t`.
 
-.. todo:: reftypematch needs C
-
 .. math::
    \frac{
-     \vdashtabletype \limits~t \ok
+     S \vdashtabletype \limits~t \ok
      \qquad
      n = \limits.\LMIN
      \qquad
      (S \vdash \reff : t')^n
      \qquad
-     (C \vdashreftypematch t' \matchesvaltype t)^n
+     (S \vdashreftypematch t' \matchesvaltype t)^n
    }{
      S \vdashtableinst \{ \TITYPE~(\limits~t), \TIELEM~\reff^n \} : \limits~t
    }
@@ -250,7 +276,7 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 :ref:`Memory Instances <syntax-meminst>` :math:`\{ \MITYPE~\limits, \MIDATA~b^\ast \}`
 ......................................................................................
 
-* The :ref:`memory type <syntax-memtype>` :math:`\{\LMIN~n, \LMAX~m^?\}` must be :ref:`valid <valid-memtype>`.
+* The :ref:`dynamic <syntax-type-dyn>` :ref:`memory type <syntax-memtype>` :math:`\{\LMIN~n, \LMAX~m^?\}` must be :ref:`valid <valid-memtype>`.
 
 * The length of :math:`b^\ast` must equal :math:`\limits.\LMIN` multiplied by the :ref:`page size <page-size>` :math:`64\,\F{Ki}`.
 
@@ -258,7 +284,7 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 
 .. math::
    \frac{
-     \vdashmemtype \limits \ok
+     S \vdashmemtype \limits \ok
      \qquad
      n = \limits.\LMIN \cdot 64\,\F{Ki}
    }{
@@ -272,7 +298,7 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 :ref:`Global Instances <syntax-globalinst>` :math:`\{ \GITYPE~(\mut~t), \GIVALUE~\val \}`
 .........................................................................................
 
-* The :ref:`global type <syntax-globaltype>` :math:`\mut~t` must be :ref:`valid <valid-globaltype>`.
+* The :ref:`dynamic <syntax-type-dyn>` :ref:`global type <syntax-globaltype>` :math:`\mut~t` must be :ref:`valid <valid-globaltype>`.
 
 * The :ref:`value <syntax-val>` :math:`\val` must be :ref:`valid <valid-val>` with some :ref:`value type <syntax-valtype>` :math:`t'`.
 
@@ -282,11 +308,11 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 
 .. math::
    \frac{
-     \vdashglobaltype \mut~t \ok
+     S \vdashglobaltype \mut~t \ok
      \qquad
      S \vdashval \val : t'
      \qquad
-     \vdashvaltypematch t' \matchesvaltype t
+     S \vdashvaltypematch t' \matchesvaltype t
    }{
      S \vdashglobalinst \{ \GITYPE~(\mut~t), \GIVALUE~\val \} : \mut~t
    }
@@ -298,6 +324,8 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 :ref:`Element Instances <syntax-eleminst>` :math:`\{ \EIELEM~\X{fa}^\ast \}`
 ............................................................................
 
+* The :ref:`dynamic <syntax-type-dyn>` :ref:`reference type <syntax-reftype>` :math:`t` must be :ref:`valid <valid-reftype>`.
+
 * For each :ref:`reference <syntax-ref>` :math:`\reff_i` in the elements :math:`\reff^n`:
 
   * The :ref:`reference <syntax-ref>` :math:`\reff_i` must be :ref:`valid <valid-ref>` with some :ref:`reference type <syntax-reftype>` :math:`t'_i`.
@@ -306,13 +334,13 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 
 * Then the element instance is valid with :ref:`reference type <syntax-reftype>` :math:`t`.
 
-.. todo:: reftypematch needs C
-
 .. math::
    \frac{
+     S \vdashreftype t \ok
+     \qquad
      (S \vdash \reff : t')^\ast
      \qquad
-     (C \vdashreftypematch t' \matchesvaltype t)^\ast
+     (S \vdashreftypematch t' \matchesvaltype t)^\ast
    }{
      S \vdasheleminst \{ \EITYPE~t, \EIELEM~\reff^\ast \} : t
    }
@@ -357,9 +385,9 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 :ref:`Module Instances <syntax-moduleinst>` :math:`\moduleinst`
 ...............................................................
 
-* Each :ref:`function type <syntax-functype>` :math:`\functype_i` in :math:`\moduleinst.\MITYPES` must be :ref:`valid <valid-functype>`.
+* For each :ref:`type address <syntax-typeaddr>` :math:`\typeaddr_i` in :math:`\moduleinst.\MITYPES`, the :ref:`type instance <syntax-typeinst>` :math:`\typeinst_i` at :math:`S.\STYPES[\typeaddr_i]` must be :ref:`valid <valid-typeinst>`.
 
-* For each :ref:`function address <syntax-funcaddr>` :math:`\funcaddr_i` in :math:`\moduleinst.\MIFUNCS`, the :ref:`external value <syntax-externval>` :math:`\EVFUNC~\funcaddr_i` must be :ref:`valid <valid-externval-func>` with some :ref:`external type <syntax-externtype>` :math:`\ETFUNC~\functype'_i`.
+* For each :ref:`function address <syntax-funcaddr>` :math:`\funcaddr_i` in :math:`\moduleinst.\MIFUNCS`, the :ref:`external value <syntax-externval>` :math:`\EVFUNC~\funcaddr_i` must be :ref:`valid <valid-externval-func>` with some :ref:`external type <syntax-externtype>` :math:`\ETFUNC~\typeaddr'_i`.
 
 * For each :ref:`table address <syntax-tableaddr>` :math:`\tableaddr_i` in :math:`\moduleinst.\MITABLES`, the :ref:`external value <syntax-externval>` :math:`\EVTABLE~\tableaddr_i` must be :ref:`valid <valid-externval-table>` with some :ref:`external type <syntax-externtype>` :math:`\ETTABLE~\tabletype_i`.
 
@@ -375,7 +403,9 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 
 * For each :ref:`export instance <syntax-exportinst>` :math:`\exportinst_i` in :math:`\moduleinst.\MIEXPORTS`, the :ref:`name <syntax-name>` :math:`\exportinst_i.\EINAME` must be different from any other name occurring in :math:`\moduleinst.\MIEXPORTS`.
 
-* Let :math:`{\functype'}^\ast` be the concatenation of all :math:`\functype'_i` in order.
+* Let :math:`\typeinst^\ast` be the concatenation of all :math:`\typeinst_i` in order.
+
+* Let :math:`\typeaddr'^\ast` be the concatenation of all :math:`\typeaddr'_i` in order.
 
 * Let :math:`\tabletype^\ast` be the concatenation of all :math:`\tabletype_i` in order.
 
@@ -388,15 +418,15 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 * Let :math:`n` be the length of :math:`\moduleinst.\MIDATAS`.
 
 * Then the module instance is valid with :ref:`context <context>`
-  :math:`\{\CTYPES~\functype^\ast,` :math:`\CFUNCS~{\functype'}^\ast,` :math:`\CTABLES~\tabletype^\ast,` :math:`\CMEMS~\memtype^\ast,` :math:`\CGLOBALS~\globaltype^\ast,` :math:`\CELEMS~\reftype^\ast,` :math:`\CDATAS~{\ok}^n\}`.
+  :math:`\{\CTYPES~\typeinst^\ast,` :math:`\CFUNCS~{\typeaddr'}^\ast,` :math:`\CTABLES~\tabletype^\ast,` :math:`\CMEMS~\memtype^\ast,` :math:`\CGLOBALS~\globaltype^\ast,` :math:`\CELEMS~\reftype^\ast,` :math:`\CDATAS~{\ok}^n\}`.
 
 .. math::
    ~\\[-1ex]
    \frac{
      \begin{array}{@{}c@{}}
-     (\vdashfunctype \functype \ok)^\ast
+     (S \vdashtypeinst S.\STYPES[\typeaddr] \ok)^\ast
      \\
-     (S \vdashexternval \EVFUNC~\funcaddr : \ETFUNC~\functype')^\ast
+     (S \vdashexternval \EVFUNC~\funcaddr : \ETFUNC~\typeaddr')^\ast
      \qquad
      (S \vdashexternval \EVTABLE~\tableaddr : \ETTABLE~\tabletype)^\ast
      \\
@@ -415,7 +445,7 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
    }{
      S \vdashmoduleinst \{
        \begin{array}[t]{@{}l@{~}l@{}}
-       \MITYPES & \functype^\ast, \\
+       \MITYPES & \typeaddr^\ast, \\
        \MIFUNCS & \funcaddr^\ast, \\
        \MITABLES & \tableaddr^\ast, \\
        \MIMEMS & \memaddr^\ast, \\
@@ -424,8 +454,8 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
        \MIDATAS & \dataaddr^n, \\
        \MIEXPORTS & \exportinst^\ast ~\} : \{
          \begin{array}[t]{@{}l@{~}l@{}}
-         \CTYPES & \functype^\ast, \\
-         \CFUNCS & {\functype'}^\ast, \\
+         \CTYPES & S.\STYPES[\typeaddr]^\ast, \\
+         \CFUNCS & {\typeaddr'}^\ast, \\
          \CTABLES & \tabletype^\ast, \\
          \CMEMS & \memtype^\ast, \\
          \CGLOBALS & \globaltype^\ast, \\
@@ -435,6 +465,54 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
        \end{array}
    }
 
+.. note::
+   The context derived for a module instance consists of :ref:`dynamic types <syntax-type-dyn>`.
+
+
+.. scratch
+  .. index:: context, store, frame
+  .. _valid-context:
+
+  Context Validity
+  ~~~~~~~~~~~~~~~~
+
+  A :ref:`context <context>` :math:`C` is valid when every type occurring in it is valid.
+
+  .. math::
+     \frac{
+       \begin{array}{@{}c@{}}
+       x^n = 0 \dots (n-1)
+       \qquad
+       (S; \{CTYPES~\functype^n[0 \slice x]\} \vdashfunctype \functype \ok)^n
+       \\
+       (S; C \vdashfunctype \functype' \ok)^\ast
+       \qquad
+       (S; C \vdashtabletype \tabletype \ok)^\ast
+       \\
+       (S; C \vdashmemtype \memtype \ok)^\ast
+       \qquad
+       (S; C \vdashglobaltype \globaltype \ok)^\ast
+       \qquad
+       (S; C \vdashreftype \reftype \ok)^\ast
+       \\
+       C = \{
+         \begin{array}[t]{@{}l@{~}l@{}}
+         \CTYPES & \functype^n, \\
+         \CFUNCS & {\functype'}^\ast, \\
+         \CTABLES & \tabletype^\ast, \\
+         \CMEMS & \memtype^\ast, \\
+         \CGLOBALS & \globaltype^\ast, \\
+         \CELEMS & \reftype^\ast, \\
+         \CDATAS & {\ok}^\ast ~\}
+         \end{array}
+       \end{array}
+     }{
+       S \vdashcontext C \ok
+     }
+
+  .. note::
+     It is an invariant of the semantics that every context either consists of only static types or only dynamic types.
+
 
 .. index:: configuration, administrative instruction, store, frame
 .. _frame-context:
@@ -508,7 +586,7 @@ Finally, :ref:`frames <syntax-frame>` are classified with *frame contexts*, whic
 :ref:`Frames <syntax-frame>` :math:`\{\ALOCALS~\val^\ast, \AMODULE~\moduleinst\}`
 .................................................................................
 
-* The :ref:`module instance <syntax-moduleinst>` :math:`\moduleinst` must be :ref:`valid <valid-moduleinst>` with some :ref:`module context <module-context>` :math:`C`.
+* The :ref:`module instance <syntax-moduleinst>` :math:`\moduleinst` must be :ref:`valid <valid-moduleinst>` with some :ref:`dynamic <syntax-type-dyn>` :ref:`module context <module-context>` :math:`C`.
 
 * Each :ref:`value <syntax-val>` :math:`\val_i` in :math:`\val^\ast` must be :ref:`valid <valid-val>` with some :ref:`value type <syntax-valtype>` :math:`t_i`.
 
@@ -536,6 +614,7 @@ Administrative Instructions
 
 Typing rules for :ref:`administrative instructions <syntax-instr-admin>` are specified as follows.
 In addition to the :ref:`context <context>` :math:`C`, typing of these instructions is defined under a given :ref:`store <syntax-store>` :math:`S`.
+
 To that end, all previous typing judgements :math:`C \vdash \X{prop}` are generalized to include the store, as in :math:`S; C \vdash \X{prop}`, by implicitly adding :math:`S` to all rules -- :math:`S` is never modified by the pre-existing rules, but it is accessed in the extra rules for :ref:`administrative instructions <valid-instr-admin>` given below.
 
 
@@ -544,11 +623,11 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
 :math:`\TRAP`
 .............
 
-* The instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`, for any sequences of :ref:`valid <valid-instrtype>` :ref:`instruction type <syntax-instrtype>` of the form :math:`[t_1^\ast] \to [t_2^\ast]`.
+* The instruction is valid with any :ref:`valid <valid-instrtype>` :ref:`dynamic <syntax-type-dyn>` :ref:`instruction type <syntax-instrtype>` of the form :math:`[t_1^\ast] \to [t_2^\ast]`.
 
 .. math::
    \frac{
-     S \vdashinstrtype [t_1^\ast] \to [t_2^\ast] \ok
+     S; C \vdashinstrtype [t_1^\ast] \to [t_2^\ast] \ok
    }{
      S; C \vdashadmininstr \TRAP : [t_1^\ast] \to [t_2^\ast]
    }
@@ -559,12 +638,12 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
 :math:`\REFEXTERNADDR~\externaddr`
 ..................................
 
-* The instruction is valid with type :math:`[] \to [(\REF~\NULL~\EXTERN)]`.
+* The instruction is valid with type :math:`[] \to [(\REF~\EXTERN)]`.
 
 .. math::
    \frac{
    }{
-     S; C \vdashadmininstr \REFEXTERNADDR~\externaddr : [] \to [(\REF~\NULL~\EXTERN)]
+     S; C \vdashadmininstr \REFEXTERNADDR~\externaddr : [] \to [(\REF~\EXTERN)]
    }
 
 
@@ -573,30 +652,41 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
 :math:`\REFFUNCADDR~\funcaddr`
 ..............................
 
-* The :ref:`external function value <syntax-externval>` :math:`\EVFUNC~\funcaddr` must be :ref:`valid <valid-externval-func>` with :ref:`external function type <syntax-externtype>` :math:`\ETFUNC~\functype`.
+* The :ref:`external function value <syntax-externval>` :math:`\EVFUNC~\funcaddr` must be :ref:`valid <valid-externval>` with :ref:`dynamic <syntax-type-dyn>` :ref:`external function type <syntax-externtype>` :math:`\ETFUNC~a'`.
 
-* Then the instruction is valid with type :math:`[] \to [(\REF~\NULL~\FUNC)]`.
+* Then the instruction is valid with type :math:`[] \to [(\REF~a')]`.
 
 .. math::
    \frac{
-     S \vdashexternval \EVFUNC~\funcaddr : \ETFUNC~\functype
+     S \vdashexternval \EVFUNC~a : \ETFUNC~a'
    }{
-     S; C \vdashadmininstr \REFFUNCADDR~\funcaddr : [] \to [(\REF~\NULL~\FUNC)]
+     S; C \vdashadmininstr \REFFUNCADDR~a : [] \to [(\REF~a')]
    }
 
+.. note::
+   This typing rule yields a :ref:`dynamic <syntax-type-dyn>` type.
+   The function may originate from outside the current module,
+   so that a definition for its type may not exist in context :math:`C`.
+
 
 .. index:: function address, extern value, extern type, function type
 
 :math:`\INVOKE~\funcaddr`
 .........................
 
-* The :ref:`external function value <syntax-externval>` :math:`\EVFUNC~\funcaddr` must be :ref:`valid <valid-externval-func>` with :ref:`external function type <syntax-externtype>` :math:`\ETFUNC ([t_1^\ast] \to [t_2^\ast])`.
+* The :ref:`external function value <syntax-externval>` :math:`\EVFUNC~\funcaddr` must be :ref:`valid <valid-externval-func>` with :ref:`external function type <syntax-externtype>` :math:`\ETFUNC a'`.
+
+* Assert: The :ref:`type address <syntax-typeaddr>` :math:`S.\STYPES[a']` is defined in the store.
+
+* Let :math:`[t_1^\ast] \to [t_2^\ast])` be the :ref:`function type <syntax-functype>` :math:`S.\STYPES[a']`.
 
 * Then the instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`.
 
 .. math::
    \frac{
-     S \vdashexternval \EVFUNC~\funcaddr : \ETFUNC~[t_1^\ast] \to [t_2^\ast]
+     S \vdashexternval \EVFUNC~\funcaddr : \ETFUNC~a'
+     \qquad
+     S.\STYPES[a'] = [t_1^\ast] \to [t_2^\ast]
    }{
      S; C \vdashadmininstr \INVOKE~\funcaddr : [t_1^\ast] \to [t_2^\ast]
    }
@@ -631,7 +721,7 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
 :math:`\FRAME_n\{F\}~\instr^\ast~\END`
 ...........................................
 
-* Under the :ref:`valid <valid-resulttype>` return type :math:`[t^n]`,
+* Under the :ref:`valid <valid-resulttype>` :ref:`dynamic <syntax-type-dyn>` return type :math:`[t^n]`,
   the :ref:`thread <syntax-frame>` :math:`F; \instr^\ast` must be :ref:`valid <valid-frame>` with :ref:`result type <syntax-resulttype>` :math:`[t^n]`.
 
 * Then the compound instruction is valid with type :math:`[] \to [t^n]`.
@@ -645,6 +735,11 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
      S; C \vdashadmininstr \FRAME_n\{F\}~\instr^\ast~\END : [] \to [t^n]
    }
 
+.. note::
+   This typing rule yields a :ref:`dynamic <syntax-type-dyn>` type.
+   The frame's function may originate from outside the current module,
+   so that the :math:`t^n` may reference type definitions that do not exist in context :math:`C`.
+
 
 .. index:: ! store extension, store
 .. _extend:
@@ -671,6 +766,8 @@ a store state :math:`S'` extends state :math:`S`, written :math:`S \extendsto S'
 :ref:`Store <syntax-store>` :math:`S`
 .....................................
 
+* The length of :math:`S.\STYPES` must not shrink.
+
 * The length of :math:`S.\SFUNCS` must not shrink.
 
 * The length of :math:`S.\STABLES` must not shrink.
@@ -683,6 +780,8 @@ a store state :math:`S'` extends state :math:`S`, written :math:`S \extendsto S'
 
 * The length of :math:`S.\SDATAS` must not shrink.
 
+* For each :ref:`type instance <syntax-typeinst>` :math:`\typeinst_i` in the original :math:`S.\STYPES`, the new type instance must be an :ref:`extension <extend-typeinst>` of the old.
+
 * For each :ref:`function instance <syntax-funcinst>` :math:`\funcinst_i` in the original :math:`S.\SFUNCS`, the new function instance must be an :ref:`extension <extend-funcinst>` of the old.
 
 * For each :ref:`table instance <syntax-tableinst>` :math:`\tableinst_i` in the original :math:`S.\STABLES`, the new table instance must be an :ref:`extension <extend-tableinst>` of the old.
@@ -698,6 +797,9 @@ a store state :math:`S'` extends state :math:`S`, written :math:`S \extendsto S'
 .. math::
    \frac{
      \begin{array}{@{}ccc@{}}
+     S_1.\STYPES = \typeinst_1^\ast &
+     S_2.\STYPES = {\typeinst'_1}^\ast~\typeinst_2^\ast &
+     (\vdashtypeinstextends \typeinst_1 \extendsto \typeinst'_1)^\ast \\
      S_1.\SFUNCS = \funcinst_1^\ast &
      S_2.\SFUNCS = {\funcinst'_1}^\ast~\funcinst_2^\ast &
      (\vdashfuncinstextends \funcinst_1 \extendsto \funcinst'_1)^\ast \\
@@ -722,6 +824,21 @@ a store state :math:`S'` extends state :math:`S`, written :math:`S \extendsto S'
    }
 
 
+.. index:: type instance
+.. _extend-typeinst:
+
+:ref:`Type Instance <syntax-typeinst>` :math:`\typeinst`
+........................................................
+
+* A type instance must remain unchanged.
+
+.. math::
+   \frac{
+   }{
+     \vdashtypeinstextends \typeinst \extendsto \typeinst
+   }
+
+
 .. index:: function instance
 .. _extend-funcinst:
 
@@ -799,13 +916,22 @@ a store state :math:`S'` extends state :math:`S`, written :math:`S \extendsto S'
 :ref:`Element Instance <syntax-eleminst>` :math:`\eleminst`
 ...........................................................
 
-* The vector :math:`\eleminst.\EIELEM` must either remain unchanged or shrink to length :math:`0`.
+* The vector :math:`\eleminst.\EIELEM` must:
+
+  * either remain unchanged,
+
+  * or shrink to length :math:`0`.
 
 .. math::
    \frac{
-     \X{fa}_1^\ast = \X{fa}_2^\ast \vee \X{fa}_2^\ast = \epsilon
    }{
-     \vdasheleminstextends \{\EIELEM~\X{fa}_1^\ast\} \extendsto \{\EIELEM~\X{fa}_2^\ast\}
+     \vdasheleminstextends \{\EIELEM~a^\ast\} \extendsto \{\EIELEM~a^\ast\}
+   }
+
+.. math::
+   \frac{
+   }{
+     \vdasheleminstextends \{\EIELEM~a^\ast\} \extendsto \{\EIELEM~\epsilon\}
    }
 
 
@@ -815,13 +941,22 @@ a store state :math:`S'` extends state :math:`S`, written :math:`S \extendsto S'
 :ref:`Data Instance <syntax-datainst>` :math:`\datainst`
 ........................................................
 
-* The vector :math:`\datainst.\DIDATA` must either remain unchanged or shrink to length :math:`0`.
+* The vector :math:`\datainst.\DIDATA` must:
+
+  * either remain unchanged,
+
+  * or shrink to length :math:`0`.
+
+.. math::
+   \frac{
+   }{
+     \vdashdatainstextends \{\DIDATA~b^\ast\} \extendsto \{\DIDATA~b^\ast\}
+   }
 
 .. math::
    \frac{
-     b_1^\ast = b_2^\ast \vee b_2^\ast = \epsilon
    }{
-     \vdashdatainstextends \{\DIDATA~b_1^\ast\} \extendsto \{\DIDATA~b_2^\ast\}
+     \vdashdatainstextends \{\DIDATA~b^\ast\} \extendsto \{\DIDATA~\epsilon\}
    }
 
 
diff --git a/document/core/exec/index.rst b/document/core/exec/index.rst
index b74d87139..38764308b 100644
--- a/document/core/exec/index.rst
+++ b/document/core/exec/index.rst
@@ -10,5 +10,6 @@ Execution
    runtime
    numerics
    types
+   values
    instructions
    modules
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index ee37c00b5..73fa5bb78 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -2869,9 +2869,9 @@ Control Instructions
 
 6. Assert: due to :ref:`validation <valid-call_indirect>`, :math:`F.\AMODULE.\MITYPES[y]` exists.
 
-7. Let :math:`\X{ta}` be the :ref:`type address <syntax-typeaddr>` :math:`F.\AMODULE.\MITYPES[y]`.
+7. Let :math:`\X{ta}_{\F{expect}}` be the :ref:`type address <syntax-typeaddr>` :math:`F.\AMODULE.\MITYPES[y]`.
 
-8. Let :math:`\X{ft}_{\F{expect}}` be the :ref:`function type <syntax-functype>` :math:`S.\STYPES[\X{ta}]`.
+8. Let :math:`\X{ft}_{\F{expect}}` be the :ref:`function type <syntax-functype>` :math:`S.\STYPES[\X{ta}_{\F{expect}}]`.
 
 9. Assert: due to :ref:`validation <valid-call_indirect>`, a value with :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
 
@@ -2895,13 +2895,15 @@ Control Instructions
 
 17. Let :math:`\X{f}` be the :ref:`function instance <syntax-funcinst>` :math:`S.\SFUNCS[a]`.
 
-18. Let :math:`\X{ft}_{\F{actual}}` be the :ref:`function type <syntax-functype>` :math:`\X{f}.\FITYPE`.
+18. Let :math:`\X{ta}_{\F{actual}}` be the :ref:`type address <syntax-typeaddr>` :math:`\X{f}.\FITYPE`.
 
-19. If :math:`\X{ft}_{\F{actual}}` and :math:`\X{ft}_{\F{expect}}` differ, then:
+19. Let :math:`\X{ft}_{\F{actual}}` be the :ref:`function type <syntax-functype>` :math:`S.\STYPES[\X{ta}_{\F{actual}}]`.
+
+20. If :math:`\X{ft}_{\F{actual}}` and :math:`\X{ft}_{\F{expect}}` differ, then:
 
     a. Trap.
 
-20. :ref:`Invoke <exec-invoke>` the function instance at address :math:`a`.
+21. :ref:`Invoke <exec-invoke>` the function instance at address :math:`a`.
 
 .. math::
    ~\\[-1ex]
@@ -2913,7 +2915,7 @@ Control Instructions
      \begin{array}[t]{@{}r@{~}l@{}}
      (\iff & S.\STABLES[F.\AMODULE.\MITABLES[x]].\TIELEM[i] = \REFFUNCADDR~a \\
      \wedge & S.\SFUNCS[a] = f \\
-     \wedge & S \vdashfunctypematch S.\STYPES[F.\AMODULE.\MITYPES[y]] \matchesfunctype f.\FITYPE)
+     \wedge & S \vdashfunctypematch S.\STYPES[F.\AMODULE.\MITYPES[y]] \matchesfunctype S.\STYPES[f.\FITYPE])
      \end{array}
    \\[1ex]
    \begin{array}{lcl@{\qquad}l}
@@ -2997,23 +2999,25 @@ Invocation of :ref:`function address <syntax-funcaddr>` :math:`a`
 
 2. Let :math:`f` be the :ref:`function instance <syntax-funcinst>`, :math:`S.\SFUNCS[a]`.
 
-3. Let :math:`[t_1^n] \to [t_2^m]` be the :ref:`function type <syntax-functype>` :math:`f.\FITYPE`.
+3. Let :math:`\X{ta}` be the :ref:`type address <syntax-typeaddr>` :math:`\X{f}.\FITYPE`.
+
+4. Let :math:`[t_1^n] \to [t_2^m]` be the :ref:`function type <syntax-functype>` :math:`S.\STYPES[\X{ta}]`.
 
-4. Let :math:`\local^\ast` be the list of :ref:`locals <syntax-local>` :math:`f.\FICODE.\FLOCALS`.
+5. Let :math:`\local^\ast` be the list of :ref:`locals <syntax-local>` :math:`f.\FICODE.\FLOCALS`.
 
-5. Let :math:`\instr^\ast~\END` be the :ref:`expression <syntax-expr>` :math:`f.\FICODE.\FBODY`.
+6. Let :math:`\instr^\ast~\END` be the :ref:`expression <syntax-expr>` :math:`f.\FICODE.\FBODY`.
 
-6. Assert: due to :ref:`validation <valid-call>`, :math:`n` values are on the top of the stack.
+7. Assert: due to :ref:`validation <valid-call>`, :math:`n` values are on the top of the stack.
 
-7. Pop the values :math:`\val^n` from the stack.
+8. Pop the values :math:`\val^n` from the stack.
 
-8. Let :math:`F` be the :ref:`frame <syntax-frame>` :math:`\{ \AMODULE~f.\FIMODULE, \ALOCALS~\val^n~(\default_t)^\ast \}`.
+9. Let :math:`F` be the :ref:`frame <syntax-frame>` :math:`\{ \AMODULE~f.\FIMODULE, \ALOCALS~\val^n~(\default_t)^\ast \}`.
 
-9. Push the activation of :math:`F` with arity :math:`m` to the stack.
+10. Push the activation of :math:`F` with arity :math:`m` to the stack.
 
-10. Let :math:`L` be the :ref:`label <syntax-label>` whose arity is :math:`m` and whose continuation is the end of the function.
+11. Let :math:`L` be the :ref:`label <syntax-label>` whose arity is :math:`m` and whose continuation is the end of the function.
 
-11. :ref:`Enter <exec-instr-seq-enter>` the instruction sequence :math:`\instr^\ast` with label :math:`L`.
+12. :ref:`Enter <exec-instr-seq-enter>` the instruction sequence :math:`\instr^\ast` with label :math:`L`.
 
 .. math::
    ~\\[-1ex]
@@ -3024,7 +3028,7 @@ Invocation of :ref:`function address <syntax-funcaddr>` :math:`a`
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
      (\iff & S.\SFUNCS[a] = f \\
-     \wedge & f.\FITYPE = [t_1^n] \to [t_2^m] \\
+     \wedge & S.\STYPES[f.\FITYPE] = [t_1^n] \to [t_2^m] \\
      \wedge & f.\FICODE = \{ \FTYPE~x, \FLOCALS~\{\LTYPE~t\}^k, \FBODY~\instr^\ast~\END \} \\
      \wedge & F = \{ \AMODULE~f.\FIMODULE, ~\ALOCALS~\val^n~(\default_t)^k \})
      \end{array} \\
@@ -3087,7 +3091,8 @@ Furthermore, the resulting store must be :ref:`valid <valid-store>`, i.e., all d
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
-     (\iff & S.\SFUNCS[a] = \{ \FITYPE~[t_1^n] \to [t_2^m], \FIHOSTCODE~\X{hf} \} \\
+     (\iff & S.\SFUNCS[a] = \{ \FITYPE~\X{ta}, \FIHOSTCODE~\X{hf} \} \\
+     \wedge & S.\STYPES[\X{ta}] = [t_1^n] \to [t_2^m] \\
      \wedge & (S'; \result) \in \X{hf}(S; \val^n)) \\
      \end{array} \\
    \begin{array}{lcl@{\qquad}l}
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index af2774bc9..a84ae40f0 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -3,151 +3,6 @@ Modules
 
 For modules, the execution semantics primarily defines :ref:`instantiation <exec-instantiation>`, which :ref:`allocates <alloc>` instances for a module and its contained definitions, initializes :ref:`tables <syntax-table>` and :ref:`memories <syntax-mem>` from contained :ref:`element <syntax-elem>` and :ref:`data <syntax-data>` segments, and invokes the :ref:`start function <syntax-start>` if present. It also includes :ref:`invocation <exec-invocation>` of exported functions.
 
-Instantiation depends on a number of auxiliary notions for :ref:`allocating <alloc>` instances.
-
-
-.. index:: external value, external type, validation, import, store
-.. _valid-externval:
-
-External Typing
-~~~~~~~~~~~~~~~
-
-For the purpose of checking :ref:`external values <syntax-externval>` against :ref:`imports <syntax-import>`,
-such values are classified by :ref:`external types <syntax-externtype>`.
-The following auxiliary typing rules specify this typing relation relative to a :ref:`store <syntax-store>` :math:`S` in which the referenced instances live.
-
-
-.. index:: function type, function address
-.. _valid-externval-func:
-
-:math:`\EVFUNC~a`
-.................
-
-* The store entry :math:`S.\SFUNCS[a]` must exist.
-
-* Then :math:`\EVFUNC~a` is valid with :ref:`external type <syntax-externtype>` :math:`\ETFUNC~S.\SFUNCS[a].\FITYPE`.
-
-.. math::
-   \frac{
-   }{
-     S \vdashexternval \EVFUNC~a : \ETFUNC~S.\SFUNCS[a].\FITYPE
-   }
-
-
-.. index:: table type, table address
-.. _valid-externval-table:
-
-:math:`\EVTABLE~a`
-..................
-
-* The store entry :math:`S.\STABLES[a]` must exist.
-
-* Then :math:`\EVTABLE~a` is valid with :ref:`external type <syntax-externtype>` :math:`\ETTABLE~S.\STABLES[a].\TITYPE`.
-
-.. math::
-   \frac{
-   }{
-     S \vdashexternval \EVTABLE~a : \ETTABLE~S.\STABLES[a].\TITYPE
-   }
-
-
-.. index:: memory type, memory address
-.. _valid-externval-mem:
-
-:math:`\EVMEM~a`
-................
-
-* The store entry :math:`S.\SMEMS[a]` must exist.
-
-* Then :math:`\EVMEM~a` is valid with :ref:`external type <syntax-externtype>` :math:`\ETMEM~S.\SMEMS[a].\MITYPE`.
-
-.. math::
-   \frac{
-   }{
-     S \vdashexternval \EVMEM~a : \ETMEM~S.\SMEMS[a].\MITYPE
-   }
-
-
-.. index:: global type, global address, value type, mutability
-.. _valid-externval-global:
-
-:math:`\EVGLOBAL~a`
-...................
-
-* The store entry :math:`S.\SGLOBALS[a]` must exist.
-
-* Then :math:`\EVGLOBAL~a` is valid with :ref:`external type <syntax-externtype>` :math:`\ETGLOBAL~S.\SGLOBALS[a].\GITYPE`.
-
-.. math::
-   \frac{
-   }{
-     S \vdashexternval \EVGLOBAL~a : \ETGLOBAL~S.\SGLOBALS[a].\GITYPE
-   }
-
-
-.. index:: value, value type, validation
-.. _valid-val:
-
-Value Typing
-~~~~~~~~~~~~
-
-For the purpose of checking argument :ref:`values <syntax-externval>` against the parameter types of exported :ref:`functions <syntax-func>`,
-values are classified by :ref:`value types <syntax-valtype>`.
-The following auxiliary typing rules specify this typing relation relative to a :ref:`store <syntax-store>` :math:`S` in which possibly referenced addresses live.
-
-.. _valid-num:
-
-:ref:`Numeric Values <syntax-val>` :math:`t.\CONST~c`
-.....................................................
-
-* The value is valid with :ref:`number type <syntax-numtype>` :math:`t`.
-
-.. math::
-   \frac{
-   }{
-     S \vdashval t.\CONST~c : t
-   }
-
-.. _valid-ref:
-
-:ref:`Null References <syntax-ref>` :math:`\REFNULL~t`
-......................................................
-
-* The value is valid with :ref:`reference type <syntax-reftype>` :math:`t`.
-
-.. math::
-   \frac{
-   }{
-     S \vdashval \REFNULL~t : t
-   }
-
-
-:ref:`Function References <syntax-ref>` :math:`\REFFUNCADDR~a`
-..............................................................
-
-* The :ref:`external value <syntax-externval>` :math:`\EVFUNC~a` must be :ref:`valid <valid-externval>`.
-
-* Then the value is valid with :ref:`reference type <syntax-reftype>` :math:`\FUNCREF`.
-
-.. math::
-   \frac{
-     S \vdashexternval \EVFUNC~a : \ETFUNC~\functype
-   }{
-     S \vdashval \REFFUNCADDR~a : \FUNCREF
-   }
-
-
-:ref:`External References <syntax-ref.extern>` :math:`\REFEXTERNADDR~a`
-.......................................................................
-
-* The value is valid with :ref:`reference type <syntax-reftype>` :math:`\EXTERNREF`.
-
-.. math::
-   \frac{
-   }{
-     S \vdashval \REFEXTERNADDR~a : \EXTERNREF
-   }
-
 
 .. index:: ! allocation, store, address
 .. _alloc:
@@ -164,7 +19,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 :ref:`Types <syntax-typeinst>`
 ..............................
 
-1. Let :math:`\functype` be the :ref:`semantic type <syntax-type-sem>`.
+1. Let :math:`\functype` be the :ref:`dynamic type <syntax-type-dyn>`.
 
 2. Let :math:`a` be the first free :ref:`type address <syntax-typeaddr>` in :math:`S`.
 
@@ -190,13 +45,11 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 
 1. Let :math:`\func` be the :ref:`function <syntax-func>` to allocate and :math:`\moduleinst` its :ref:`module instance <syntax-moduleinst>`.
 
-2. Let :math:`a` be the first free :ref:`function address <syntax-funcaddr>` in :math:`S`.
+2. Let :math:`\typeaddr` be the :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.\MITYPES[\func.\FTYPE]`.
 
-3. Let :math:`\typeaddr` be the :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.\MITYPES[\func.\FTYPE]`.
+3. Let :math:`a` be the first free :ref:`function address <syntax-funcaddr>` in :math:`S`.
 
-4. Let :math:`\functype` be the :ref:`semantic <syntax-type-sem>` :ref:`function type <syntax-functype>` :math:`S.\STYPES[\typeaddr]`.
-
-5. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`\{ \FITYPE~\functype', \FIMODULE~\moduleinst, \FICODE~\func \}`.
+4. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`\{ \FITYPE~\typeaddr', \FIMODULE~\moduleinst, \FICODE~\func \}`.
 
 6. Append :math:`\funcinst` to the |SFUNCS| of :math:`S`.
 
@@ -207,9 +60,9 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
    \begin{array}{rlll}
    \allocfunc(S, \func, \moduleinst) &=& S', \funcaddr \\[1ex]
    \mbox{where:} \hfill \\
+   \typeaddr &=& \moduleinst.\MITYPES[\func.\FTYPE] \\
    \funcaddr &=& |S.\SFUNCS| \\
-   \functype &=& S.\STYPES[\moduleinst.\MITYPES[\func.\FTYPE]] \\
-   \funcinst &=& \{ \FITYPE~\functype, \FIMODULE~\moduleinst, \FICODE~\func \} \\
+   \funcinst &=& \{ \FITYPE~\typeaddr, \FIMODULE~\moduleinst, \FICODE~\func \} \\
    S' &=& S \compose \{\SFUNCS~\funcinst\} \\
    \end{array}
 
@@ -220,11 +73,11 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 :ref:`Host Functions <syntax-hostfunc>`
 .......................................
 
-1. Let :math:`\hostfunc` be the :ref:`host function <syntax-hostfunc>` to allocate and :math:`\functype` its :ref:`semantic <syntax-type-sem>` :ref:`function type <syntax-functype>`.
+1. Let :math:`\hostfunc` be the :ref:`host function <syntax-hostfunc>` to allocate and :math:`\typeaddr` its :ref:`dynamic <syntax-type-dyn>` :ref:`function type <syntax-functype>`.
 
 2. Let :math:`a` be the first free :ref:`function address <syntax-funcaddr>` in :math:`S`.
 
-3. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`\{ \FITYPE~\functype, \FIHOSTCODE~\hostfunc \}`.
+3. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`\{ \FITYPE~\typeaddr, \FIHOSTCODE~\hostfunc \}`.
 
 4. Append :math:`\funcinst` to the |SFUNCS| of :math:`S`.
 
@@ -233,10 +86,10 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 .. math::
    ~\\[-1ex]
    \begin{array}{rlll}
-   \allochostfunc(S, \functype, \hostfunc) &=& S', \funcaddr \\[1ex]
+   \allochostfunc(S, \typeaddr, \hostfunc) &=& S', \funcaddr \\[1ex]
    \mbox{where:} \hfill \\
    \funcaddr &=& |S.\SFUNCS| \\
-   \funcinst &=& \{ \FITYPE~\functype, \FIHOSTCODE~\hostfunc \} \\
+   \funcinst &=& \{ \FITYPE~\typeaddr, \FIHOSTCODE~\hostfunc \} \\
    S' &=& S \compose \{\SFUNCS~\funcinst\} \\
    \end{array}
 
@@ -251,7 +104,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 :ref:`Tables <syntax-tableinst>`
 ................................
 
-1. Let :math:`\tabletype` be the :ref:`semantic <syntax-type-sem>` :ref:`table type <syntax-tabletype>` of the table to allocate and :math:`\reff` the initialization value.
+1. Let :math:`\tabletype` be the :ref:`dynamic <syntax-type-dyn>` :ref:`table type <syntax-tabletype>` of the table to allocate and :math:`\reff` the initialization value.
 
 2. Let :math:`(\{\LMIN~n, \LMAX~m^?\}~\reftype)` be the structure of :ref:`table type <syntax-tabletype>` :math:`\tabletype`.
 
@@ -282,7 +135,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 :ref:`Memories <syntax-meminst>`
 ................................
 
-1. Let :math:`\memtype` be the :ref:`semantic <syntax-type-sem>` :ref:`memory type <syntax-memtype>` of the memory to allocate.
+1. Let :math:`\memtype` be the :ref:`dynamic <syntax-type-dyn>` :ref:`memory type <syntax-memtype>` of the memory to allocate.
 
 2. Let :math:`\{\LMIN~n, \LMAX~m^?\}` be the structure of :ref:`memory type <syntax-memtype>` :math:`\memtype`.
 
@@ -311,7 +164,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 :ref:`Globals <syntax-globalinst>`
 ..................................
 
-1. Let :math:`\globaltype` be the :ref:`semantic <syntax-type-sem>` :ref:`global type <syntax-globaltype>` of the global to allocate and :math:`\val` its initialization :ref:`value <syntax-val>`.
+1. Let :math:`\globaltype` be the :ref:`dynamic <syntax-type-dyn>` :ref:`global type <syntax-globaltype>` of the global to allocate and :math:`\val` its initialization :ref:`value <syntax-val>`.
 
 2. Let :math:`a` be the first free :ref:`global address <syntax-globaladdr>` in :math:`S`.
 
@@ -337,7 +190,7 @@ New instances of :ref:`types <syntax-typeinst>`, :ref:`functions <syntax-funcins
 :ref:`Element segments <syntax-eleminst>`
 .........................................
 
-1. Let :math:`\reftype` be the elements' :ref:`semantic <syntax-type-sem>` type and :math:`\reff^\ast` the vector of :ref:`references <syntax-ref>` to allocate.
+1. Let :math:`\reftype` be the elements' :ref:`dynamic <syntax-type-dyn>` type and :math:`\reff^\ast` the vector of :ref:`references <syntax-ref>` to allocate.
 
 2. Let :math:`a` be the first free :ref:`element address <syntax-elemaddr>` in :math:`S`.
 
@@ -471,7 +324,7 @@ and list of :ref:`reference <syntax-ref>` vectors for the module's :ref:`element
 
 2. For each :ref:`function type <syntax-functype>` :math:`\functype_i` in :math:`\module.\MTYPES`, do:
 
-   a. Let :math:`\functype'_i` be the :ref:`semantic <syntax-type-sem>` :ref:`function type <syntax-functype>` obtained from :math:`\functype_i` in :math:`\moduleinst` defined below.
+   a. Let :math:`\functype'_i` be the :ref:`dynamic <syntax-type-dyn>` :ref:`function type <syntax-functype>` obtained from :math:`\functype_i` in :math:`\moduleinst` defined below.
 
    b. Let :math:`\typeaddr_i` be the :ref:`type address <syntax-typeaddr>` resulting from :ref:`allocating <alloc-type>` :math:`\functype'_i`.
 
@@ -481,26 +334,26 @@ and list of :ref:`reference <syntax-ref>` vectors for the module's :ref:`element
 
 4. For each :ref:`table <syntax-table>` :math:`\table_i` in :math:`\module.\MTABLES`, do:
 
-   a. Let :math:`\limits_i~t_i` be the :ref:`semantic <syntax-type-sem>` :ref:`table type <syntax-tabletype>` obtained from :math:`\table_i.\TTYPE` in :math:`\moduleinst` defined below.
+   a. Let :math:`\limits_i~t_i` be the :ref:`dynamic <syntax-type-dyn>` :ref:`table type <syntax-tabletype>` obtained from :math:`\table_i.\TTYPE` in :math:`\moduleinst` defined below.
 
    b. Let :math:`\tableaddr_i` be the :ref:`table address <syntax-tableaddr>` resulting from :ref:`allocating <alloc-table>` :math:`\table_i.\TTYPE`
    with initialization value :math:`\reff_{\F{t}}^\ast[i]`.
 
 5. For each :ref:`memory <syntax-mem>` :math:`\mem_i` in :math:`\module.\MMEMS`, do:
 
-   a. Let :math:`\memtype_i` be the :ref:`semantic <syntax-type-sem>` :ref:`memory type <syntax-memtype>` obtained from :math:`\mem_i.\MTYPE` in :math:`\moduleinst` defined below.
+   a. Let :math:`\memtype_i` be the :ref:`dynamic <syntax-type-dyn>` :ref:`memory type <syntax-memtype>` obtained from :math:`\mem_i.\MTYPE` in :math:`\moduleinst` defined below.
 
    b. Let :math:`\memaddr_i` be the :ref:`memory address <syntax-memaddr>` resulting from :ref:`allocating <alloc-mem>` :math:`\memtype_i`.
 
 6. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\MGLOBALS`, do:
 
-   a. Let :math:`\globaltype_i` be the :ref:`semantic <syntax-type-sem>` :ref:`global type <syntax-globaltype>` obtained from :math:`\global_i.\GTYPE` in :math:`\moduleinst` defined below.
+   a. Let :math:`\globaltype_i` be the :ref:`dynamic <syntax-type-dyn>` :ref:`global type <syntax-globaltype>` obtained from :math:`\global_i.\GTYPE` in :math:`\moduleinst` defined below.
 
    b. Let :math:`\globaladdr_i` be the :ref:`global address <syntax-globaladdr>` resulting from :ref:`allocating <alloc-global>` :math:`\globaltype_i` with initializer value :math:`\val_{\F{g}}^\ast[i]`.
 
 7. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEMS`, do:
 
-   a. Let :math:`\reftype_i` be the :ref:`semantic <syntax-type-sem>` element :ref:`reference type <syntax-reftype>` obtained from :math:`\elem_i.\ETYPE` in :math:`\moduleinst` defined below.
+   a. Let :math:`\reftype_i` be the :ref:`dynamic <syntax-type-dyn>` element :ref:`reference type <syntax-reftype>` obtained from :math:`\elem_i.\ETYPE` in :math:`\moduleinst` defined below.
 
    b. Let :math:`\elemaddr_i` be the :ref:`element address <syntax-elemaddr>` resulting from :ref:`allocating <alloc-elem>` a :ref:`element instance <syntax-eleminst>` of :ref:`reference type <syntax-reftype>` :math:`\reftype_i` with contents :math:`(\reff_{\F{e}}^\ast)^\ast[i]`.
 
@@ -577,20 +430,20 @@ where:
      \MIEXPORTS~\exportinst^\ast ~\}
      \end{array} \\[1ex]
    S_1, \typeaddr^\ast &=&
-     \alloctype^\ast(S, \sem_{\moduleinst}(\module.\MTYPES)) \\
+     \alloctype^\ast(S, \dyn_{\moduleinst}(\module.\MTYPES)) \\
    S_2, \funcaddr^\ast &=&
      \allocfunc^\ast(S_1, \module.\MFUNCS, \moduleinst) \\
    S_3, \tableaddr^\ast &=&
-     \alloctable^\ast(S_2, \sem_{\moduleinst}(\table.\TTYPE)^\ast, \reff_{\F{t}}^\ast)
+     \alloctable^\ast(S_2, \dyn_{\moduleinst}(\table.\TTYPE)^\ast, \reff_{\F{t}}^\ast)
      \quad (\where (\table.\TTYPE)^\ast = (\limits~t)^\ast) \\
    S_4, \memaddr^\ast &=&
-     \allocmem^\ast(S_3, \sem_{\moduleinst}(\mem.\MTYPE)^\ast) \\
+     \allocmem^\ast(S_3, \dyn_{\moduleinst}(\mem.\MTYPE)^\ast) \\
    S_5, \globaladdr^\ast &=&
-     \allocglobal^\ast(S_3, \sem_{\moduleinst}(\global.\GTYPE)^\ast, \val_{\F{g}}^\ast) \\
+     \allocglobal^\ast(S_3, \dyn_{\moduleinst}(\global.\GTYPE)^\ast, \val_{\F{g}}^\ast) \\
    S_6, \elemaddr^\ast &=&
-     \allocelem^\ast(S_5, \sem_{\moduleinst}(\elem.\ETYPE)^\ast, (\reff_{\F{e}}^\ast)^\ast) \\
+     \allocelem^\ast(S_5, \dyn_{\moduleinst}(\elem.\ETYPE)^\ast, (\reff_{\F{e}}^\ast)^\ast) \\
    S', \dataaddr^\ast &=&
-     \allocdata^\ast(S_6, \sem_{\moduleinst}(\data.\DINIT)^\ast) \\
+     \allocdata^\ast(S_6, \dyn_{\moduleinst}(\data.\DINIT)^\ast) \\
    \exportinst^\ast &=&
      \{ \EINAME~(\export.\ENAME), \EIVALUE~\externval_{\F{ex}} \}^\ast \\[1ex]
    \evfuncs(\externval_{\F{ex}}^\ast) &=& (\moduleinst.\MIFUNCS[x])^\ast
@@ -659,7 +512,7 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
       i. Fail.
 
-   b. Let :math:`\externtype''_i` be the :ref:`semantic <syntax-type-sem>` :ref:`external type <syntax-externtype>` obtained by :ref:`instantiating <sem>` :math:`\externtype'_i` in :math:`\moduleinst` defined below.
+   b. Let :math:`\externtype''_i` be the :ref:`dynamic <syntax-type-dyn>` :ref:`external type <syntax-externtype>` obtained by :ref:`instantiating <dyn>` :math:`\externtype'_i` in :math:`\moduleinst` defined below.
 
    c. If :math:`\externtype_i` does not :ref:`match <match-externtype>` :math:`\externtype''_i`, then:
 
@@ -768,7 +621,7 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
    &(\iff
      & \vdashmodule \module : \externtype_{\F{im}}^k \to \externtype_{\F{ex}}^\ast \\
      &\wedge& (S' \vdashexternval \externval : \externtype)^k \\
-     &\wedge& (S' \vdashexterntypematch \externtype \matchesexterntype \sem_{\moduleinst}(\externtype_{\F{im}}))^k \\[1ex]
+     &\wedge& (S' \vdashexterntypematch \externtype \matchesexterntype \dyn_{\moduleinst}(\externtype_{\F{im}}))^k \\[1ex]
      &\wedge& \module.\MGLOBALS = \global^\ast \\
      &\wedge& \module.\MELEMS = \elem^n \\
      &\wedge& \module.\MDATAS = \data^m \\
@@ -790,18 +643,18 @@ where:
 
 .. math::
    \begin{array}{@{}l}
-   \F{runelem}_i(\{\ETYPE~\X{et}, \EINIT~\reff^n, \EMODE~\EPASSIVE\}) \quad=\quad \epsilon \\
+   \F{runelem}_i(\{\ETYPE~\X{et}, \EINIT~\reff^n, \EMODE~\EPASSIVE\}) \quad=\\ \qquad \epsilon \\
    \F{runelem}_i(\{\ETYPE~\X{et}, \EINIT~\reff^n, \EMODE~\EACTIVE \{\ETABLE~0, \EOFFSET~\instr^\ast~\END\}\}) \quad=\\ \qquad
      \instr^\ast~(\I32.\CONST~0)~(\I32.\CONST~n)~(\TABLEINIT~i)~(\ELEMDROP~i) \\
    \F{runelem}_i(\{\ETYPE~\X{et}, \EINIT~\reff^n, \EMODE~\EDECLARATIVE\}) \quad=\\ \qquad
      (\ELEMDROP~i) \\[1ex]
-   \F{rundata}_i(\{\DINIT~b^n, \DMODE~\DPASSIVE\}) \quad=\quad \epsilon \\
+   \F{rundata}_i(\{\DINIT~b^n, \DMODE~\DPASSIVE\}) \quad=\\ \qquad \epsilon \\
    \F{rundata}_i(\{\DINIT~b^n, \DMODE~\DACTIVE \{\DMEM~0, \DOFFSET~\instr^\ast~\END\}\}) \quad=\\ \qquad
      \instr^\ast~(\I32.\CONST~0)~(\I32.\CONST~n)~(\MEMORYINIT~i)~(\DATADROP~i) \\
    \end{array}
 
 .. note::
-   Checking import types assumes that the :ref:`module instance <syntax-moduleinst>` has already been :ref:`allocated <alloc-module>` and the resulting :ref:`type addresses <syntax-typeaddr>` are available, in order to :ref:`instantiate <sem>` all relevant types.
+   Checking import types assumes that the :ref:`module instance <syntax-moduleinst>` has already been :ref:`allocated <alloc-module>` and the resulting :ref:`type addresses <syntax-typeaddr>` are available, in order to :ref:`instantiate <dyn>` all relevant types.
    However, this forward reference merely is a way to simplify the specification.
    In practice, implementations will likely allocate or canonicalize types beforehand, when *compiling* a module, in a stage before instantiation and before imports are checked.
 
@@ -838,25 +691,29 @@ The following steps are performed:
 
 2. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`S.\SFUNCS[\funcaddr]`.
 
-3. Let :math:`[t_1^n] \to [t_2^m]` be the :ref:`function type <syntax-functype>` :math:`\funcinst.\FITYPE`.
+3. Let :math:`\typeaddr` be the :ref:`type address <syntax-typeaddr>` :math:`\funcinst.\FITYPE`.
+
+4. Assert: :math:`S.\STYPES[\typeaddr]` exists.
+
+5. Let :math:`[t_1^n] \to [t_2^m]` be the :ref:`dynamic <syntax-type-dyn>` :ref:`function type <syntax-functype>` :math:`S.\STYPES[\typeaddr]`.
 
-4. If the length :math:`|\val^\ast|` of the provided argument values is different from the number :math:`n` of expected arguments, then:
+6. If the length :math:`|\val^\ast|` of the provided argument values is different from the number :math:`n` of expected arguments, then:
 
    a. Fail.
 
-5. For each :ref:`value type <syntax-valtype>` :math:`t_i` in :math:`t_1^n` and corresponding :ref:`value <syntax-val>` :math:`val_i` in :math:`\val^\ast`, do:
+7. For each :ref:`value type <syntax-valtype>` :math:`t_i` in :math:`t_1^n` and corresponding :ref:`value <syntax-val>` :math:`val_i` in :math:`\val^\ast`, do:
 
    a. If :math:`\val_i` is not :ref:`valid <valid-val>` with value type :math:`t_i`, then:
 
       i. Fail.
 
-6. Let :math:`F` be the dummy :ref:`frame <syntax-frame>` :math:`\{ \AMODULE~\{\}, \ALOCALS~\epsilon \}`.
+8. Let :math:`F` be the dummy :ref:`frame <syntax-frame>` :math:`\{ \AMODULE~\{\}, \ALOCALS~\epsilon \}`.
 
-7. Push the frame :math:`F` to the stack.
+9. Push the frame :math:`F` to the stack.
 
-8. Push the values :math:`\val^\ast` to the stack.
+10. Push the values :math:`\val^\ast` to the stack.
 
-9. :ref:`Invoke <exec-invoke>` the function instance at address :math:`\funcaddr`.
+11. :ref:`Invoke <exec-invoke>` the function instance at address :math:`\funcaddr`.
 
 Once the function has returned, the following steps are executed:
 
@@ -870,7 +727,7 @@ The values :math:`\val_{\F{res}}^m` are returned as the results of the invocatio
    ~\\[-1ex]
    \begin{array}{@{}lcl}
    \invoke(S, \funcaddr, \val^n) &=& S; F; \val^n~(\INVOKE~\funcaddr) \\
-     &(\iff & S.\SFUNCS[\funcaddr].\FITYPE = [t_1^n] \to [t_2^m] \\
+     &(\iff & S.\STYPES[S.\SFUNCS[\funcaddr].\FITYPE] = [t_1^n] \to [t_2^m] \\
      &\wedge& (S \vdashval \val : t_1)^n \\
      &\wedge& F = \{ \AMODULE~\{\}, \ALOCALS~\epsilon \}) \\
    \end{array}
diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index f014ac6e4..9e2eef9df 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -200,6 +200,24 @@ even where this identity is not observable from within WebAssembly code itself
    hence logical addresses can be arbitrarily large natural numbers.
 
 
+.. _free-typeaddr:
+.. _free-funcaddr:
+.. _free-tableaddr:
+.. _free-memaddr:
+.. _free-globaladdr:
+.. _free-elemaddr:
+.. _free-dataaddr:
+.. _free-localaddr:
+.. _free-labeladdr:
+.. _free-addr:
+
+Conventions
+...........
+
+* The notation :math:`\F{addr}(A)` denotes the set of addresses from address space :math:`\X{addr}` occurring free in :math:`A`. We sometimes reinterpret this set as the :ref:`vector <syntax-vec>` of its elements.
+
+
+
 .. index:: ! instance, function type, type instance, function instance, table instance, memory instance, global instance, element instance, data instance, export instance, table address, memory address, global address, element address, data address, index, name
    pair: abstract syntax; module instance
    pair: module; instance
@@ -242,7 +260,7 @@ Type Instances
 ~~~~~~~~~~~~~~
 
 A *type instance* is the runtime representation of a :ref:`function type <syntax-functype>`.
-It is a :ref:`semantic type <syntax-type-sem>` equivalent to the respective :ref:`syntactic type <syntax-type-syn>` that appeared in the module.
+It is a :ref:`dynamic type <syntax-type-dyn>` equivalent to the respective :ref:`static type <syntax-type-stat>` that appeared in the module.
 
 .. math::
    \begin{array}{llll}
@@ -267,8 +285,8 @@ The module instance is used to resolve references to other definitions during ex
 .. math::
    \begin{array}{llll}
    \production{(function instance)} & \funcinst &::=&
-     \{ \FITYPE~\functype, \FIMODULE~\moduleinst, \FICODE~\func \} \\ &&|&
-     \{ \FITYPE~\functype, \FIHOSTCODE~\hostfunc \} \\
+     \{ \FITYPE~\typeaddr, \FIMODULE~\moduleinst, \FICODE~\func \} \\ &&|&
+     \{ \FITYPE~\typeaddr, \FIHOSTCODE~\hostfunc \} \\
    \production{(host function)} & \hostfunc &::=& \dots \\
    \end{array}
 
diff --git a/document/core/exec/types.rst b/document/core/exec/types.rst
index b1773fb5c..19175460c 100644
--- a/document/core/exec/types.rst
+++ b/document/core/exec/types.rst
@@ -1,11 +1,11 @@
-.. index:: type, semantic type
+.. index:: type, dynamic type
 .. _exec-type:
 
 Types
 -----
 
 Execution has to check and compare :ref:`types <syntax-type>` and :ref:`type instances <syntax-typeinst>` in a few places, such as :ref:`executing <exec-call_indirect>` |CALLINDIRECT| or :ref:`instantiating <exec-instantiation>` :ref:`modules <syntax-module>`.
-During execution, types of all forms are represented as :ref:`semantic <syntax-type-sem>` types, where all occurring :ref:`type identifiers <syntax-typeid>` are interpreted as :ref:`type addresses <syntax-typeaddr>`.
+During execution, types of all forms are represented as :ref:`dynamic <syntax-type-dyn>` types, where all occurring :ref:`type identifiers <syntax-typeid>` are interpreted as :ref:`type addresses <syntax-typeaddr>`.
 Relevant type relations need to be redefined accordingly.
 
 .. note::
@@ -34,61 +34,39 @@ During execution, :ref:`type identifiers <syntax-typeid>` are represented as :re
    \frac{
      S.\STYPES[\typeaddr] = \functype
    }{
-     S \vdashtypeid \typeaddr : \functype
+     S; C \vdashtypeid \typeaddr : \functype
    }
 
 .. note::
    Unlike :ref:`type indices <syntax-typeidx>` recorded in a context, the number of type addresses in a store is not bounded by :math:`2^{32}`.
 
 
-.. index:: type identifier, type index, type address, type instantiation, module instance, semantic type
+.. index:: type identifier, type index, type address, type instantiation, module instance, dynamic type
 
-.. _sem:
+.. _dyn:
 
 Instantiation
 ~~~~~~~~~~~~~
 
-Any form of :ref:`syntactic <syntax-type-syn>` :ref:`type <syntax-type>` can be *instantiated* into a :ref:`semantic <syntax-type-sem>` type inside a :ref:`module instance <syntax-moduleinst>` by :ref:`substituting <notation-subst>` each :ref:`type index <syntax-typeidx>` :math:`x` occurring in it with the corresponding :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.\MITYPES[x]`.
+Any form of :ref:`static <syntax-type-stat>` :ref:`type <syntax-type>` can be *instantiated* into a :ref:`dynamic <syntax-type-dyn>` type inside a :ref:`module instance <syntax-moduleinst>` by :ref:`substituting <notation-subst>` each :ref:`type index <syntax-typeidx>` :math:`x` occurring in it with the corresponding :ref:`type address <syntax-typeaddr>` :math:`\moduleinst.\MITYPES[x]`.
 
 .. math::
-   \sem_{\moduleinst}(t) = t[\subst \moduleinst.\MITYPES]
+   \dyn_{\moduleinst}(t) = t[\subst \moduleinst.\MITYPES]
 
 
-.. index:: type, matching, store, semantic types, validity
-.. _exec-match:
+.. index:: type, matching, store, dynamic types, validity
 .. _exec-valid-type:
+.. _exec-match:
 
-Matching and Validity
-~~~~~~~~~~~~~~~~~~~~~
-
-For each *static* :ref:`matching relation <match>` on syntactic types, operating relative to a :ref:`context <context>`, an analogous *dynamic* validity or matching relation is defined, operating relative to a :ref:`store <syntax-store>`.
-
-Formally, for each judgement
-
-.. math:: C \vdash T_1 \matches T_2
-
-on syntactic types :math:`T_1` and :math:`T_2`, an analogous judgement
-
-.. math:: S \vdash T'_1 \matches T'_2
-
-on corresponding semantic types :math:`T'_1` and :math:`T'_2` is introduced. It is defined analogously, by replacing all occurrences of a :ref:`context <context>` :math:`C` in the associated rules with a :ref:`store <syntax-store>` :math:`S`.
-
-.. note::
-   Where the static rules invoke :ref:`static lookup <valid-typeidx>` for :ref:`type indices <syntax-typeidx>` in the context, the dynamic rules thereby invoke :ref:`dynamic lookup <valid-typeaddr>` for :ref:`type addresses <syntax-typeaddr>` in the store.
-
-Likewise, for each *static* :ref:`validity rule <valid-type>` on syntactic types, operating relative to a :ref:`context <context>`, an analogous *dynamic* validity rule is defined, operating relative to a :ref:`store <syntax-store>`.
-
-Formally, for each judgement
-
-.. math:: C \vdash T \ok
-
-on syntactic type :math:`T`, an analogous judgement
+Dynamic Typing
+~~~~~~~~~~~~~~
 
-.. math:: S \vdash T' \ok
+To handle :ref:`dynamic <syntax-type-dyn>` types, all static judgements :math:`C \vdash \X{prop}` on types (such as :ref:`validity <valid-type>` and :ref:`matching <match>`) are generalized to include the store, as in :math:`S; C \vdash \X{prop}`, by implicitly adding a :ref:`store <syntax-store>` :math:`S` to all rules -- :math:`S` is never modified by the pre-existing rules, but it is accessed in the extra rule for :ref:`type addresses <syntax-typeaddr>` given :ref:`above <valid-typeaddr>`.
 
-on corresponding semantic types :math:`T'` is introduced. It is defined analogously, by replacing all occurrences of a :ref:`context <context>` :math:`C` in the associated rules with a :ref:`store <syntax-store>` :math:`S`.
+It is an invariant of the semantics that all types inspected by execution rules are dynamic, i.e., the :ref:`context <context>` is always empty and never used.
+To avoid unnecessary clutter, empty contexts are omitted from the rules, writing just :math:`S \vdash \X{prop}`.
 
 .. note::
-   Dynamic validity rules are not needed for the semantics,
-   but to prove :ref:`soundness <soundness-statement>`
+   Only matching rules are invoked during execution.
+   Dynamic validity is only needed to prove :ref:`type soundness <soundness>`
    and for specifying parts of the :ref:`embedder <embed>` interface.
diff --git a/document/core/exec/values.rst b/document/core/exec/values.rst
new file mode 100644
index 000000000..f5a873495
--- /dev/null
+++ b/document/core/exec/values.rst
@@ -0,0 +1,164 @@
+.. index:: value
+.. exec-val:
+
+Values
+------
+
+.. index:: value, value type, validation
+.. _valid-val:
+
+Value Typing
+~~~~~~~~~~~~
+
+For the purpose of checking argument :ref:`values <syntax-externval>` against the parameter types of exported :ref:`functions <syntax-func>`,
+values are classified by :ref:`dynamic <syntax-type-dyn>` :ref:`value types <syntax-valtype>`.
+The following auxiliary typing rules specify this typing relation relative to a :ref:`store <syntax-store>` :math:`S` in which possibly referenced addresses live.
+
+.. _valid-num:
+
+:ref:`Numeric Values <syntax-val>` :math:`t.\CONST~c`
+.....................................................
+
+* The value is valid with :ref:`number type <syntax-numtype>` :math:`t`.
+
+.. math::
+   \frac{
+   }{
+     S \vdashval t.\CONST~c : t
+   }
+
+.. _valid-vec:
+
+:ref:`Vector Values <syntax-val>` :math:`t.\CONST~c`
+....................................................
+
+* The value is valid with :ref:`vector type <syntax-vectype>` :math:`t`.
+
+.. math::
+   \frac{
+   }{
+     S \vdashval t.\CONST~c : t
+   }
+
+.. _valid-ref:
+
+:ref:`Null References <syntax-ref>` :math:`\REFNULL~t`
+......................................................
+
+* The :ref:`dynamic <syntax-type-dyn>` :ref:`heap type <syntax-heaptype>` must be :ref:`valid <valid-heaptype>`.
+
+* Then value is valid with :ref:`reference type <syntax-reftype>` :math:`(\REF~\NULL~t)`.
+
+.. math::
+   \frac{
+     S \vdashheaptype t \ok
+   }{
+     S \vdashval \REFNULL~t : (\REF~\NULL~t)
+   }
+
+
+:ref:`Function References <syntax-ref>` :math:`\REFFUNCADDR~a`
+..............................................................
+
+* The :ref:`external value <syntax-externval>` :math:`\EVFUNC~a` must be :ref:`valid <valid-externval>` with :ref:`dynamic <syntax-type-dyn>` :ref:`external type <syntax-externtype>` :math:`\ETFUNC~a'`.
+
+* Then the value is valid with :ref:`dynamic <syntax-type-dyn>` :ref:`reference type <syntax-reftype>` :math:`(\REF~a')`.
+
+.. math::
+   \frac{
+     S \vdashexternval \EVFUNC~a : \ETFUNC~a'
+   }{
+     S \vdashval \REFFUNCADDR~a : \REF~a'
+   }
+
+
+:ref:`External References <syntax-ref.extern>` :math:`\REFEXTERNADDR~a`
+.......................................................................
+
+* The value is valid with :ref:`reference type <syntax-reftype>` :math:`(\REF~\EXTERN)`.
+
+.. math::
+   \frac{
+   }{
+     S \vdashval \REFEXTERNADDR~a : (\REF~\EXTERN)
+   }
+
+
+
+.. index:: external value, external type, validation, import, store
+.. _valid-externval:
+
+External Typing
+~~~~~~~~~~~~~~~
+
+For the purpose of checking :ref:`external values <syntax-externval>` against :ref:`imports <syntax-import>`,
+such values are classified by :ref:`dynamic <syntax-type-dyn>` :ref:`external types <syntax-externtype>`.
+The following auxiliary typing rules specify this typing relation relative to a :ref:`store <syntax-store>` :math:`S` in which the referenced instances live.
+
+
+.. index:: function type, function address
+.. _valid-externval-func:
+
+:math:`\EVFUNC~a`
+.................
+
+* The store entry :math:`S.\SFUNCS[a]` must exist.
+
+* Then :math:`\EVFUNC~a` is valid with :ref:`external type <syntax-externtype>` :math:`\ETFUNC~S.\SFUNCS[a].\FITYPE`.
+
+.. math::
+   \frac{
+   }{
+     S \vdashexternval \EVFUNC~a : \ETFUNC~S.\SFUNCS[a].\FITYPE
+   }
+
+
+.. index:: table type, table address
+.. _valid-externval-table:
+
+:math:`\EVTABLE~a`
+..................
+
+* The store entry :math:`S.\STABLES[a]` must exist.
+
+* Then :math:`\EVTABLE~a` is valid with :ref:`external type <syntax-externtype>` :math:`\ETTABLE~S.\STABLES[a].\TITYPE`.
+
+.. math::
+   \frac{
+   }{
+     S \vdashexternval \EVTABLE~a : \ETTABLE~S.\STABLES[a].\TITYPE
+   }
+
+
+.. index:: memory type, memory address
+.. _valid-externval-mem:
+
+:math:`\EVMEM~a`
+................
+
+* The store entry :math:`S.\SMEMS[a]` must exist.
+
+* Then :math:`\EVMEM~a` is valid with :ref:`external type <syntax-externtype>` :math:`\ETMEM~S.\SMEMS[a].\MITYPE`.
+
+.. math::
+   \frac{
+   }{
+     S \vdashexternval \EVMEM~a : \ETMEM~S.\SMEMS[a].\MITYPE
+   }
+
+
+.. index:: global type, global address, value type, mutability
+.. _valid-externval-global:
+
+:math:`\EVGLOBAL~a`
+...................
+
+* The store entry :math:`S.\SGLOBALS[a]` must exist.
+
+* Then :math:`\EVGLOBAL~a` is valid with :ref:`external type <syntax-externtype>` :math:`\ETGLOBAL~S.\SGLOBALS[a].\GITYPE`.
+
+.. math::
+   \frac{
+   }{
+     S \vdashexternval \EVGLOBAL~a : \ETGLOBAL~S.\SGLOBALS[a].\GITYPE
+   }
diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index a921fe9cd..e22087513 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -10,11 +10,11 @@ Types are checked during :ref:`validation <valid>`, :ref:`instantiation <exec-in
 
 
 
-.. index:: ! type identifier, type index, type address
+.. index:: ! type identifier, type index, type address, ! static type, ! dynamic type
    pair: abstract syntax; type identifier
 .. _syntax-typeid:
-.. _syntax-type-syn:
-.. _syntax-type-sem:
+.. _syntax-type-stat:
+.. _syntax-type-dyn:
 
 Type Identifiers
 ~~~~~~~~~~~~~~~~
@@ -22,10 +22,11 @@ Type Identifiers
 Defined types like :ref:`function types <syntax-functype>` are not embedded directly into other types, such as :ref:`reference types <syntax-reftype>`.
 Instead, they are referred to indirectly.
 
-In a :ref:`module <syntax-module>` and during validation, this indirection is expressed through a :ref:`type index <syntax-typeidx>`, whose meaning is confined to one module.
-During instantiation and execution, where types from multiple modules may interact, it is expressed through :ref:`type addresses <syntax-typeaddr>` that refer to the global :ref:`store <store>`.
+In a :ref:`module <syntax-module>` and during :ref:`validation <valid>`, this indirection is expressed through a :ref:`type index <syntax-typeidx>`, whose meaning is confined to one module.
 
-The type grammar hence is conceptually parameterized by its interpretation of :ref:`type identifiers <syntax-typeid>`.
+During :ref:`execution <exec>`, where types from multiple modules may interact, it is expressed through :ref:`type addresses <syntax-typeaddr>` that refer to the global :ref:`store <store>`.
+
+The type grammar hence allows multiple representations of type identifiers:
 
 .. math::
    \begin{array}{llll}
@@ -33,18 +34,20 @@ The type grammar hence is conceptually parameterized by its interpretation of :r
      \typeidx ~|~ \typeaddr
    \end{array}
 
-Types represented with type indices are referred to as *syntactic types*,
-whereas types represented with type addresses are referred to as *semantic types*.
+Types represented with type indices are referred to as *static types*,
+whereas types represented with type addresses are referred to as *dynamic types*.
+
+Static types are transformed into dynamic types during module :ref:`instantiation <exec-instantiation>`.
 
-It is an invariant of the semantics that no syntactic type refers to a semantic type and vice versa, i.e., both universes are disjoint.
-Syntactic types are transformed into semantic types during module :ref:`instantiation <exec-instantiation>`.
+It is an invariant of the semantics that only static types arise during :ref:`validation <valid>`, while only dynamic types are used during :ref:`execution <exec>`.
+However, for the proof of :ref:`type soundness <soundness>`, both forms of types must be considered together, and static types may refer to dynamic types.
 
 .. _notation-subst:
 
 Convention
 ..........
 
-The following notation expresses conversion between syntactic and semantic types:
+The following notation expresses conversion between static and dynamic types:
 
 * :math:`t[x^\ast \subst a^\ast]` denotes the parallel substitution of :ref:`type indices <syntax-typeidx>` :math:`x^\ast` with :ref:`type addresses <syntax-typeaddr>` :math:`a^\ast`, provided :math:`|x^\ast| = |a^\ast|`.
 
@@ -377,7 +380,7 @@ External Types
 .. math::
    \begin{array}{llll}
    \production{external types} & \externtype &::=&
-     \ETFUNC~\functype ~|~
+     \ETFUNC~\typeid ~|~
      \ETTABLE~\tabletype ~|~
      \ETMEM~\memtype ~|~
      \ETGLOBAL~\globaltype \\
@@ -390,7 +393,7 @@ Conventions
 The following auxiliary notation is defined for sequences of external types.
 It filters out entries of a specific kind in an order-preserving fashion:
 
-* :math:`\etfuncs(\externtype^\ast) = [\functype ~|~ (\ETFUNC~\functype) \in \externtype^\ast]`
+* :math:`\etfuncs(\externtype^\ast) = [\typeid ~|~ (\ETFUNC~\typeid) \in \externtype^\ast]`
 
 * :math:`\ettables(\externtype^\ast) = [\tabletype ~|~ (\ETTABLE~\tabletype) \in \externtype^\ast]`
 
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index 746cccfd3..c1cdb692b 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -939,7 +939,7 @@
 .. |vdashglobaltype| mathdef:: \xref{valid/types}{valid-globaltype}{\vdash}
 .. |vdashexterntype| mathdef:: \xref{valid/types}{valid-externtype}{\vdash}
 
-.. |vdashinstrtype| mathdef:: \xref{valid/instructions}{valid-instrtype}{\vdash}
+.. |vdashinstrtype| mathdef:: \xref{valid/types}{valid-instrtype}{\vdash}
 
 .. |vdashvaltypedefaultable| mathdef:: \xref{valid/types}{valid-defaultable}{\vdash}
 
@@ -994,7 +994,7 @@
 
 .. Allocation
 
-.. |sem| mathdef:: \xref{exec/types}{sem}{\F{sem}}
+.. |dyn| mathdef:: \xref{exec/types}{dyn}{\F{dyn}}
 
 .. |alloctype| mathdef:: \xref{exec/modules}{alloc-type}{\F{alloctype}}
 .. |allocfunc| mathdef:: \xref{exec/modules}{alloc-func}{\F{allocfunc}}
@@ -1022,6 +1022,18 @@
 .. |dataaddr| mathdef:: \xref{exec/runtime}{syntax-dataaddr}{\X{dataaddr}}
 .. |externaddr| mathdef:: \xref{exec/runtime}{syntax-externaddr}{\X{externaddr}}
 
+
+.. Address, meta functions
+
+.. |freetypeaddr| mathdef:: \xref{syntax/modules}{syntax-typeaddr}{\F{typeaddr}}
+.. |freefuncaddr| mathdef:: \xref{syntax/modules}{syntax-funcaddr}{\F{funcaddr}}
+.. |freetableaddr| mathdef:: \xref{syntax/modules}{syntax-tableaddr}{\F{tableaddr}}
+.. |freememaddr| mathdef:: \xref{syntax/modules}{syntax-memaddr}{\F{memaddr}}
+.. |freeglobaladdr| mathdef:: \xref{syntax/modules}{syntax-globaladdr}{\F{globaladdr}}
+.. |freeelemaddr| mathdef:: \xref{syntax/modules}{syntax-elemaddr}{\F{elemaddr}}
+.. |freedataaddr| mathdef:: \xref{syntax/modules}{syntax-dataaddr}{\F{dataaddr}}
+
+
 .. Instances, terminals
 
 .. |FITYPE| mathdef:: \xref{exec/runtime}{syntax-funcinst}{\K{type}}
@@ -1123,7 +1135,7 @@
 
 .. Administrative Instructions, terminals
 
-.. |REFFUNCADDR| mathdef:: \xref{exec/runtime}{syntax-ref}{\K{ref}}
+.. |REFFUNCADDR| mathdef:: \xref{exec/runtime}{syntax-ref}{\K{ref{.}func}}
 .. |REFEXTERNADDR| mathdef:: \xref{exec/runtime}{syntax-ref.extern}{\K{ref{.}extern}}
 .. |TRAP| mathdef:: \xref{exec/runtime}{syntax-trap}{\K{trap}}
 .. |INVOKE| mathdef:: \xref{exec/runtime}{syntax-invoke}{\K{invoke}}
@@ -1272,7 +1284,7 @@
 
 .. Judgements
 
-.. |vdashexternval| mathdef:: \xref{exec/modules}{valid-externval}{\vdash}
+.. |vdashexternval| mathdef:: \xref{exec/values}{valid-externval}{\vdash}
 
 
 .. Soundness
@@ -1285,6 +1297,7 @@
 .. |vdashval| mathdef:: \xref{appendix/properties}{valid-val}{\vdash}
 .. |vdashresult| mathdef:: \xref{appendix/properties}{valid-result}{\vdash}
 
+.. |vdashtypeinst| mathdef:: \xref{appendix/properties}{valid-typeinst}{\vdash}
 .. |vdashfuncinst| mathdef:: \xref{appendix/properties}{valid-funcinst}{\vdash}
 .. |vdashtableinst| mathdef:: \xref{appendix/properties}{valid-tableinst}{\vdash}
 .. |vdashmeminst| mathdef:: \xref{appendix/properties}{valid-meminst}{\vdash}
@@ -1294,11 +1307,13 @@
 .. |vdashexportinst| mathdef:: \xref{appendix/properties}{valid-exportinst}{\vdash}
 .. |vdashmoduleinst| mathdef:: \xref{appendix/properties}{valid-moduleinst}{\vdash}
 
+.. |vdashcontext| mathdef:: \xref{appendix/properties}{valid-context}{\vdash}
 .. |vdashstore| mathdef:: \xref{appendix/properties}{valid-store}{\vdash}
 .. |vdashconfig| mathdef:: \xref{appendix/properties}{valid-config}{\vdash}
 .. |vdashthread| mathdef:: \xref{appendix/properties}{valid-thread}{\vdash}
 .. |vdashframe| mathdef:: \xref{appendix/properties}{valid-frame}{\vdash}
 
+.. |vdashtypeinstextends| mathdef:: \xref{appendix/properties}{extend-typeinst}{\vdash}
 .. |vdashfuncinstextends| mathdef:: \xref{appendix/properties}{extend-funcinst}{\vdash}
 .. |vdashtableinstextends| mathdef:: \xref{appendix/properties}{extend-tableinst}{\vdash}
 .. |vdashmeminstextends| mathdef:: \xref{appendix/properties}{extend-meminst}{\vdash}
diff --git a/document/core/valid/conventions.rst b/document/core/valid/conventions.rst
index 326b8ee6f..25d6c0b34 100644
--- a/document/core/valid/conventions.rst
+++ b/document/core/valid/conventions.rst
@@ -33,16 +33,16 @@ Contexts
 Validity of an individual definition is specified relative to a *context*,
 which collects relevant information about the surrounding :ref:`module <syntax-module>` and the definitions in scope:
 
-* *Types*: the list of types defined in the current module.
-* *Functions*: the list of functions declared in the current module, represented by their function type.
-* *Tables*: the list of tables declared in the current module, represented by their table type.
-* *Memories*: the list of memories declared in the current module, represented by their memory type.
-* *Globals*: the list of globals declared in the current module, represented by their global type.
-* *Element Segments*: the list of element segments declared in the current module, represented by their element type.
-* *Data Segments*: the list of data segments declared in the current module, each represented by an |ok| entry.
-* *Locals*: the list of locals declared in the current function (including parameters), represented by their local type.
-* *Labels*: the stack of labels accessible from the current position, represented by their result type.
-* *Return*: the return type of the current function, represented as an optional result type that is absent when no return is allowed, as in free-standing expressions.
+* *Types*: the list of :ref:`types <syntax-type>` defined in the current module.
+* *Functions*: the list of :ref:`functions <syntax-func>` declared in the current module, represented by a :ref:`type identifier <syntax-typeid>` for their :ref:`function type <syntax-functype>`.
+* *Tables*: the list of :ref:`tables <syntax-table>` declared in the current module, represented by their :ref:`table type <syntax-tabletype>`.
+* *Memories*: the list of :ref:`memories <syntax-mem>` declared in the current module, represented by their :ref:`memory type <syntax-memtype>`.
+* *Globals*: the list of :ref:`globals <syntax-global>` declared in the current module, represented by their :ref:`global type <syntax-globaltype>`.
+* *Element Segments*: the list of :ref:`element segments <syntax-elem>` declared in the current module, represented by the elements' :ref:`reference type <syntax-reftype>`.
+* *Data Segments*: the list of :ref:`data segments <syntax-data>` declared in the current module, each represented by an |ok| entry.
+* *Locals*: the list of :ref:`locals <syntax-local>` declared in the current :ref:`function <syntax-func>` (including parameters), represented by their :ref:`local type <syntax-localtype>`.
+* *Labels*: the stack of :ref:`labels <syntax-label>` accessible from the current position, represented by their :ref:`result type <syntax-resulttype>`.
+* *Return*: the return type of the current :ref:`function <syntax-func>`, represented as an optional :ref:`result type <syntax-resulttype>` that is absent when no return is allowed, as in free-standing expressions.
 * *References*: the list of :ref:`function indices <syntax-funcidx>` that occur in the module outside functions and can hence be used to form references inside them.
 
 In other words, a context contains a sequence of suitable :ref:`types <syntax-type>` for each :ref:`index space <syntax-index>`,
@@ -57,7 +57,7 @@ More concretely, contexts are defined as :ref:`records <notation-record>` :math:
    \production{(context)} & C &::=&
      \begin{array}[t]{l@{~}ll}
      \{ & \CTYPES & \functype^\ast, \\
-        & \CFUNCS & \functype^\ast, \\
+        & \CFUNCS & \typeid^\ast, \\
         & \CTABLES & \tabletype^\ast, \\
         & \CMEMS & \memtype^\ast, \\
         & \CGLOBALS & \globaltype^\ast, \\
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 9d9543659..e103a8f36 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -189,7 +189,7 @@ Reference Instructions
 
 * The function :math:`C.\CFUNCS[x]` must be defined in the context.
 
-* There must exist a :ref:`type index <syntax-typeidx>` :math:`y` such that :math:`C.\CTYPES[y]` is the same :ref:`function type <syntax-functype>` as :math:`C.\CFUNCS[x]`.
+* Let :math:`y` be the :ref:`type index <syntax-typeidx>` :math:`C.\CFUNCS[x]`.
 
 * The :ref:`function index <syntax-funcidx>` :math:`x` must be contained in :math:`C.\CREFS`.
 
@@ -197,7 +197,7 @@ Reference Instructions
 
 .. math::
    \frac{
-     C.\CFUNCS[x] = C.\CTYPES[y]
+     C.\CFUNCS[x] = y
      \qquad
      x \in C.\CREFS
    }{
@@ -1526,11 +1526,17 @@ Control Instructions
 
 * The function :math:`C.\CFUNCS[x]` must be defined in the context.
 
-* Then the instruction is valid with type :math:`C.\CFUNCS[x]`.
+* Let :math:`y` be the :ref:`type index <syntax-typeidx>` :math:`C.\CFUNCS[x]`.
+
+* Assert: The type :math:`C.\CTYPES[y]` is defined in the context.
+
+* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[y]`.
+
+* Then the instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`.
 
 .. math::
    \frac{
-     C.\CFUNCS[x] = [t_1^\ast] \to [t_2^\ast]
+     C.\CTYPES[C.\CFUNCS[x]] = [t_1^\ast] \to [t_2^\ast]
    }{
      C \vdashinstr \CALL~x : [t_1^\ast] \to [t_2^\ast]
    }
diff --git a/document/core/valid/matching.rst b/document/core/valid/matching.rst
index 6e6a0fea7..4c1c6fa45 100644
--- a/document/core/valid/matching.rst
+++ b/document/core/valid/matching.rst
@@ -306,16 +306,16 @@ External Types
 Functions
 .........
 
-An :ref:`external type <syntax-externtype>` :math:`\ETFUNC~\functype_1` matches :math:`\ETFUNC~\functype_2` if and only if:
+An :ref:`external type <syntax-externtype>` :math:`\ETFUNC~\typeid_1` matches :math:`\ETFUNC~\typeid_2` if and only if:
 
-* Function type :math:`\functype_1` :ref:`matches <match-functype>` :math:`\functype_2`.
+* The :ref:`heap type <syntax-heaptype>` :math:`\typeid_1` :ref:`matches <match-heaptype>` :math:`\typeid_2`.
 
 .. math::
    ~\\[-1ex]
    \frac{
-     C \vdashfunctypematch \functype_1 \matchesfunctype \functype_2
+     C \vdashheaptypematch \typeid_1 \matchesheaptype \typeid_2
    }{
-     C \vdashexterntypematch \ETFUNC~\functype_1 \matchesexterntype \ETFUNC~\functype_2
+     C \vdashexterntypematch \ETFUNC~\typeid_1 \matchesexterntype \ETFUNC~\typeid_2
    }
 
 
diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index e5c146831..cafb84e60 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -14,7 +14,7 @@ Furthermore, most definitions are themselves classified with a suitable type.
 Functions
 ~~~~~~~~~
 
-Functions :math:`\func` are classified by :ref:`function types <syntax-functype>` of the form :math:`[t_1^\ast] \to [t_2^\ast]`.
+Functions :math:`\func` are classified by :ref:`type indices <syntax-typeidx>` referring to :ref:`function types <syntax-functype>` of the form :math:`[t_1^\ast] \to [t_2^\ast]`.
 
 
 :math:`\{ \FTYPE~x, \FLOCALS~t^\ast, \FBODY~\expr \}`
@@ -52,7 +52,7 @@ Functions :math:`\func` are classified by :ref:`function types <syntax-functype>
      \qquad
      C,\CLOCALS\,(\SET~t_1)^\ast~(\init~t)^\ast,\CLABELS~[t_2^\ast],\CRETURN~[t_2^\ast] \vdashexpr \expr : [t_2^\ast]
    }{
-     C \vdashfunc \{ \FTYPE~x, \FLOCALS~t^\ast, \FBODY~\expr \} : [t_1^\ast] \to [t_2^\ast]
+     C \vdashfunc \{ \FTYPE~x, \FLOCALS~t^\ast, \FBODY~\expr \} : x
    }
 
 
@@ -375,14 +375,18 @@ Start function declarations :math:`\start` are not classified by any type.
 
 * The function :math:`C.\CFUNCS[x]` must be defined in the context.
 
-* The type of :math:`C.\CFUNCS[x]` must be :math:`[] \to []`.
+* Let :math:`y` be the :ref:`type index <syntax-typeidx>` :math:`C.\CFUNCS[x]`.
+
+* Assert: The type :math:`C.\CTYPES[y]` is defined in the context.
+
+* The type :math:`C.\CTYPES[y]` must be the :ref:`function type <syntax-functype>` :math:`[] \to []`.
 
 * Then the start function is valid.
 
 
 .. math::
    \frac{
-     C.\CFUNCS[x] = [] \to []
+     C.\CTYPES[C.\CFUNCS[x]] = [] \to []
    }{
      C \vdashstart \{ \SFUNC~x \} \ok
    }
@@ -424,9 +428,9 @@ Exports :math:`\export` and export descriptions :math:`\exportdesc` are classifi
 
 .. math::
    \frac{
-     C.\CFUNCS[x] = \functype
+     C.\CFUNCS[x] = \typeid
    }{
-     C \vdashexportdesc \EDFUNC~x : \ETFUNC~\functype
+     C \vdashexportdesc \EDFUNC~x : \ETFUNC~\typeid
    }
 
 
@@ -505,17 +509,15 @@ Imports :math:`\import` and import descriptions :math:`\importdesc` are classifi
 :math:`\IDFUNC~x`
 .................
 
-* The function type :math:`C.\CTYPES[x]` must be defined in the context.
+* The :ref:`function type <syntax-functype>` :math:`C.\CTYPES[x]` must be defined in the context.
 
-* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[x]`.
-
-* Then the import description is valid with type :math:`\ETFUNC~[t_1^\ast] \to [t_2^\ast]`.
+* Then the import description is valid with type :math:`\ETFUNC~x`.
 
 .. math::
    \frac{
-     C.\CTYPES[x] = [t_1^\ast] \to [t_2^\ast]
+     C.\CTYPES[x] = \functype
    }{
-     C \vdashimportdesc \IDFUNC~x : \ETFUNC~[t_1^\ast] \to [t_2^\ast]
+     C \vdashimportdesc \IDFUNC~x : \ETFUNC~x
    }
 
 
diff --git a/document/core/valid/types.rst b/document/core/valid/types.rst
index 2fd8b458f..097e82f6e 100644
--- a/document/core/valid/types.rst
+++ b/document/core/valid/types.rst
@@ -35,7 +35,7 @@ During validation, :ref:`type identifiers <syntax-typeid>` are represented as :r
    }
 
 .. note::
-   :ref:`Semantic types <syntax-type-sem>` do not arise during validation.
+   :ref:`Dynamic types <syntax-type-dyn>` do not arise during validation.
    They only need to be :ref:`looked up <valid-typeaddr>` during :ref:`execution <exec-type>`.
 
 
@@ -417,18 +417,18 @@ Global Types
 External Types
 ~~~~~~~~~~~~~~
 
-:math:`\ETFUNC~\functype`
-.........................
+:math:`\ETFUNC~\typeidx`
+........................
 
-* The :ref:`function type <syntax-functype>` :math:`\functype` must be :ref:`valid <valid-functype>`.
+* The :ref:`function type <syntax-functype>` :math:`C.\CTYPES[x]` must be defined in the context.
 
 * Then the external type is valid.
 
 .. math::
    \frac{
-     C \vdashfunctype \functype \ok
+     C.\CTYPES[x] = \functype
    }{
-     C \vdashexterntype \ETFUNC~\functype \ok
+     C \vdashexterntype \ETFUNC~x
    }
 
 :math:`\ETTABLE~\tabletype`

From 683e40265dc1665a6967b193afe167397a1004ee Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Tue, 11 Oct 2022 10:27:43 +0200
Subject: [PATCH 215/285] [spec] Formatting eps

---
 document/core/syntax/instructions.rst | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index 87f805e5c..eae802cbd 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -195,7 +195,7 @@ Occasionally, it is convenient to group operators together according to the foll
 Vector Instructions
 ~~~~~~~~~~~~~~~~~~~
 
-Vector instructions (also known as *SIMD* instructions, single instruction multiple data) provide basic operations over :ref:`values <syntax-value>` of :ref:`vector type <syntax-vectype>`.
+Vector instructions (also known as *SIMD* instructions, *single instruction multiple data*) provide basic operations over :ref:`values <syntax-value>` of :ref:`vector type <syntax-vectype>`.
 
 .. math::
    \begin{array}{llcl}
@@ -208,6 +208,10 @@ Vector instructions (also known as *SIMD* instructions, single instruction multi
    \production{half} & \half &::=&
      \K{low} ~|~ \K{high} \\
    \production{lane index} & \laneidx &::=& \u8 \\
+   \end{array}
+
+.. math::
+   \begin{array}{llcl}
    \production{instruction} & \instr &::=&
      \dots \\&&|&
      \K{v128.}\VCONST~\i128 \\&&|&
@@ -271,6 +275,10 @@ Vector instructions (also known as *SIMD* instructions, single instruction multi
      \K{f64x2.}\VCONVERT\K{\_low\_i32x4\_}\sx ~|~
      \K{f64x2.}\VPROMOTE\K{\_low\_f32x4} \\&&|&
      \dots \\
+   \end{array}
+
+.. math::
+   \begin{array}{llcl}
    \production{vector bitwise unary operator} & \vvunop &::=&
      \K{not} \\
    \production{vector bitwise binary operator} & \vvbinop &::=&

From c27d6c7e8377687a5bd90629267510e44eed627d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=96mer=20Sinan=20A=C4=9Facan?= <omeragacan@gmail.com>
Date: Wed, 12 Oct 2022 13:39:51 +0300
Subject: [PATCH 216/285] Remove oboslete note in README (#82)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 16f672b08..19f7b19cd 100644
--- a/README.md
+++ b/README.md
@@ -7,7 +7,7 @@ It is meant for discussion, prototype specification and implementation of a prop
 
 * See the [overview](proposals/function-references/Overview.md) for a summary of the proposal.
 
-* See the [modified spec](https://webassembly.github.io/function-references/core) for details.  (Note, link is 404.)
+* See the [modified spec](https://webassembly.github.io/function-references/core) for details.
 
 The repository is now based on the [bulk operations proposal](proposals/bulk-memory-operations/Overview.md) and includes all respective changes.
 

From 89353e06c8676d8d0bb04dc04b3c7b8adf5ba820 Mon Sep 17 00:00:00 2001
From: gahaas <ahaas@google.com>
Date: Mon, 24 Oct 2022 13:14:25 +0200
Subject: [PATCH 217/285] Add `print_i64` to generated spec tests

https://github.com/WebAssembly/spec/commit/82a613da5ea18515bf6f16593b8f7b608f47380f added `print_i64` to the standalone test files, but not to the ones generated by the spec interpreter.
---
 interpreter/script/js.ml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/interpreter/script/js.ml b/interpreter/script/js.ml
index 093da2463..2eb849a6c 100644
--- a/interpreter/script/js.ml
+++ b/interpreter/script/js.ml
@@ -37,6 +37,7 @@ let spectest = {
   eq_funcref: eq_funcref,
   print: console.log.bind(console),
   print_i32: console.log.bind(console),
+  print_i64: console.log.bind(console),
   print_i32_f32: console.log.bind(console),
   print_f64_f64: console.log.bind(console),
   print_f32: console.log.bind(console),

From 9789e1758434c22d7366d18c6a6997571b129884 Mon Sep 17 00:00:00 2001
From: B Szilvasy <beatrice.szilvasy@gmail.com>
Date: Wed, 26 Oct 2022 00:35:54 +0100
Subject: [PATCH 218/285] [test] Tweak binary-leb128 and simd_lane (#1555)

---
 test/core/binary-leb128.wast  | 2 +-
 test/core/simd/simd_lane.wast | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/core/binary-leb128.wast b/test/core/binary-leb128.wast
index 1d6721958..1b642261a 100644
--- a/test/core/binary-leb128.wast
+++ b/test/core/binary-leb128.wast
@@ -290,7 +290,7 @@
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\01\08\01"                          ;; type section
+    "\01\0c\01"                          ;; type section
     "\60"                                ;; func type
     "\02"                                ;; num params
     "\7f\7e"                             ;; param type
diff --git a/test/core/simd/simd_lane.wast b/test/core/simd/simd_lane.wast
index 9d4b5fd72..9b66f53b1 100644
--- a/test/core/simd/simd_lane.wast
+++ b/test/core/simd/simd_lane.wast
@@ -447,8 +447,8 @@
 (assert_invalid (module (func (result v128) (i16x8.replace_lane 255 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
 (assert_invalid (module (func (result v128) (i32x4.replace_lane 4 (v128.const i32x4 0 0 0 0) (i32.const 1)))) "invalid lane index")
 (assert_invalid (module (func (result v128) (i32x4.replace_lane 255 (v128.const i32x4 0 0 0 0) (i32.const 1)))) "invalid lane index")
-(assert_invalid (module (func (result v128) (f32x4.replace_lane 4 (v128.const f32x4 0 0 0 0) (i32.const 1)))) "invalid lane index")
-(assert_invalid (module (func (result v128) (f32x4.replace_lane 255 (v128.const f32x4 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 4 (v128.const f32x4 0 0 0 0) (f32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 255 (v128.const f32x4 0 0 0 0) (f32.const 1)))) "invalid lane index")
 (assert_invalid (module (func (result i64) (i64x2.extract_lane 2 (v128.const i64x2 0 0)))) "invalid lane index")
 (assert_invalid (module (func (result i64) (i64x2.extract_lane 255 (v128.const i64x2 0 0)))) "invalid lane index")
 (assert_invalid (module (func (result f64) (f64x2.extract_lane 2 (v128.const f64x2 0 0)))) "invalid lane index")
@@ -466,7 +466,7 @@
 (assert_invalid (module (func (result i32) (f32x4.extract_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
 (assert_invalid (module (func (result v128) (i16x8.replace_lane 8 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
 (assert_invalid (module (func (result v128) (i32x4.replace_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
-(assert_invalid (module (func (result v128) (f32x4.replace_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (f32.const 1)))) "invalid lane index")
 (assert_invalid (module (func (result i64) (i64x2.extract_lane 2 (v128.const i64x2 0 0)))) "invalid lane index")
 (assert_invalid (module (func (result f64) (f64x2.extract_lane 2 (v128.const f64x2 0 0)))) "invalid lane index")
 (assert_invalid (module (func (result v128) (i64x2.replace_lane 2 (v128.const i64x2 0 0) (i64.const 1)))) "invalid lane index")

From 1831a38898f7b2a509cc8c4229ee315948fc679c Mon Sep 17 00:00:00 2001
From: Thomas Lively <tlively123@gmail.com>
Date: Fri, 28 Oct 2022 00:26:35 -0500
Subject: [PATCH 219/285] [spec] Allow explicit keyword definitions (#1553)

Rather than describing keyword tokens as always being defined implicitly by terminal symbols in syntactic productions, describe them as being defined implicitly or explicitly. This accounts for the explicit definitions of `offset` and `align` phrases, which are lexically keywords, later in the chapter.

Fixes #1552.
---
 document/core/text/lexical.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/text/lexical.rst b/document/core/text/lexical.rst
index 0c40a58d1..f46646662 100644
--- a/document/core/text/lexical.rst
+++ b/document/core/text/lexical.rst
@@ -58,7 +58,7 @@ That is, the next token always consists of the longest possible sequence of char
 Tokens can be separated by :ref:`white space <text-space>`,
 but except for strings, they cannot themselves contain whitespace.
 
-The set of *keyword* tokens is defined implicitly, by all occurrences of a :ref:`terminal symbol <text-grammar>` in literal form, such as :math:`\text{keyword}`, in a :ref:`syntactic <text-syntactic>` production of this chapter.
+*Keyword* tokens are defined either implicitly by an occurrence of a :ref:`terminal symbol <text-grammar>` in literal form, such as :math:`\text{keyword}`, in a :ref:`syntactic <text-syntactic>` production of this chapter, or explicitly where they arise in this chapter.
 
 Any token that does not fall into any of the other categories is considered *reserved*, and cannot occur in source text.
 

From f9b461a312426a60f2f81dcb19b39b66b90a5447 Mon Sep 17 00:00:00 2001
From: Asumu Takikawa <asumu@igalia.com>
Date: Tue, 8 Nov 2022 11:50:50 -0800
Subject: [PATCH 220/285] [js-api] editorial: adjust link for v128 type

---
 document/js-api/index.bs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index fcfdbf833..b22e825ca 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -157,6 +157,7 @@ urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: df
         text: i64
         text: f32
         text: f64
+    url: syntax/types.html#vector-types
         text: v128
     url: syntax/types.html#syntax-reftype
         text: reftype

From 7642173b706d7bfc0559c6445063fb1ffe865210 Mon Sep 17 00:00:00 2001
From: "Ben L. Titzer" <ben.titzer@gmail.com>
Date: Thu, 10 Nov 2022 06:24:05 -0500
Subject: [PATCH 221/285] Factor local init tests to local_init.wast; add more
 (#84)

---
 test/core/local_get.wast  | 40 ---------------------
 test/core/local_init.wast | 74 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 74 insertions(+), 40 deletions(-)
 create mode 100644 test/core/local_init.wast

diff --git a/test/core/local_get.wast b/test/core/local_get.wast
index b56aeec30..45dbcaeeb 100644
--- a/test/core/local_get.wast
+++ b/test/core/local_get.wast
@@ -223,43 +223,3 @@
   (module (func $large-mixed (param i64) (local i32 i64) (local.get 214324343) drop))
   "unknown local"
 )
-
-
-;; Uninitialized undefaulted locals
-
-(module
-  (func (export "get-after-set") (param $p (ref extern)) (result (ref extern))
-    (local $x (ref extern))
-    (local.set $x (local.get $p))
-    (local.get $x)
-  )
-  (func (export "get-after-tee") (param $p (ref extern)) (result (ref extern))
-    (local $x (ref extern))
-    (drop (local.tee $x (local.get $p)))
-    (local.get $x)
-  )
-  (func (export "get-in-block-after-set") (param $p (ref extern)) (result (ref extern))
-    (local $x (ref extern))
-    (local.set $x (local.get $p))
-    (block (result (ref extern)) (local.get $x))
-  )
-)
-
-(assert_return (invoke "get-after-set" (ref.extern 1)) (ref.extern 1))
-(assert_return (invoke "get-after-tee" (ref.extern 2)) (ref.extern 2))
-(assert_return (invoke "get-in-block-after-set" (ref.extern 3)) (ref.extern 3))
-
-(assert_invalid
-  (module (func $uninit (local $x (ref extern)) (drop (local.get $x))))
-  "uninitialized local"
-)
-(assert_invalid
-  (module
-    (func $uninit-after-end (param $p (ref extern))
-      (local $x (ref extern))
-      (block (local.set $x (local.get $p)) (drop (local.tee $x (local.get $p))))
-      (drop (local.get $x))
-    )
-  )
-  "uninitialized local"
-)
diff --git a/test/core/local_init.wast b/test/core/local_init.wast
new file mode 100644
index 000000000..176ccc64b
--- /dev/null
+++ b/test/core/local_init.wast
@@ -0,0 +1,74 @@
+;; Uninitialized undefaulted locals
+
+(module
+  (func (export "get-after-set") (param $p (ref extern)) (result (ref extern))
+    (local $x (ref extern))
+    (local.set $x (local.get $p))
+    (local.get $x)
+  )
+  (func (export "get-after-tee") (param $p (ref extern)) (result (ref extern))
+    (local $x (ref extern))
+    (drop (local.tee $x (local.get $p)))
+    (local.get $x)
+  )
+  (func (export "get-in-block-after-set") (param $p (ref extern)) (result (ref extern))
+    (local $x (ref extern))
+    (local.set $x (local.get $p))
+    (block (result (ref extern)) (local.get $x))
+  )
+)
+
+(assert_return (invoke "get-after-set" (ref.extern 1)) (ref.extern 1))
+(assert_return (invoke "get-after-tee" (ref.extern 2)) (ref.extern 2))
+(assert_return (invoke "get-in-block-after-set" (ref.extern 3)) (ref.extern 3))
+
+(assert_invalid
+  (module (func $uninit (local $x (ref extern)) (drop (local.get $x))))
+  "uninitialized local"
+)
+(assert_invalid
+  (module
+    (func $uninit-after-end (param $p (ref extern))
+      (local $x (ref extern))
+      (block (local.set $x (local.get $p)) (drop (local.tee $x (local.get $p))))
+      (drop (local.get $x))
+    )
+  )
+  "uninitialized local"
+)
+(assert_invalid
+  (module
+    (func $uninit-in-else (param $p (ref extern))
+      (local $x (ref extern))
+      (if (i32.const 0)
+        (then (local.set $x (local.get $p)))
+	(else (local.get $x))
+      )
+    )
+  )
+  "uninitialized local"
+)
+
+(assert_invalid
+  (module
+    (func $uninit-from-if (param $p (ref extern))
+      (local $x (ref extern))
+      (if (i32.const 0)
+        (then (local.set $x (local.get $p)))
+	(else (local.set $x (local.get $p)))
+      )
+      (drop (local.get $x))
+    )
+  )
+  "uninitialized local"
+)
+
+(module
+  (func (export "tee-init") (param $p (ref extern)) (result (ref extern))
+    (local $x (ref extern))
+    (drop (local.tee $x (local.get $p)))
+    (local.get $x)
+  )
+)
+
+(assert_return (invoke "tee-init" (ref.extern 1)) (ref.extern 1))

From 97359b47ea2897d8bd469703850148bbe74c57e8 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 23 Nov 2022 11:08:11 +0100
Subject: [PATCH 222/285] Update JS API for no-frills

---
 proposals/function-references/Overview.md | 63 ++++++++++++++++++-----
 1 file changed, 50 insertions(+), 13 deletions(-)

diff --git a/proposals/function-references/Overview.md b/proposals/function-references/Overview.md
index 08c537cde..24e932370 100644
--- a/proposals/function-references/Overview.md
+++ b/proposals/function-references/Overview.md
@@ -340,15 +340,8 @@ The second byte is reserved for possible future extensions.
 
 ## JS API
 
-Based on the [JS type reflection proposal](https://github.com/WebAssembly/js-types).
-
-### Type Representation
-
-* A `ValueType` can be described by an object of the form `{ref: ConsType, ...}`
-  - `type ValueType = ... | {ref: ConsType, nullable: bool}`
-
-* A `ConsType` can be described by a suitable union type
-  - `type ConsType = "func" | "extern" | DefType`
+The group decided to go with the "no-frills" approach for the JS API for the time being.
+In the context of this proposal, that means that conversions (or type reflection) at concrete reference type throws a `TypeError` exception.
 
 
 ### Value Conversions
@@ -357,11 +350,9 @@ Based on the [JS type reflection proposal](https://github.com/WebAssembly/js-typ
 
 In addition to the rules for basic reference types:
 
-* Any function that is an instance of `WebAssembly.Function` with type `<functype>` is allowed as `ref <functype>` or `ref null <functype>`.
-
-* Any non-null external reference is allowed as `ref extern`.
+* If the target type of a ToWebAssemblyValue is a concrete reference type, then throw `TypeError`.
 
-* The `null` value is allowed as `ref null ht`.
+* If the source type of a ToJSValue is a concrete reference type, then throw `TypeError`.
 
 
 ### Constructors
@@ -377,6 +368,52 @@ In addition to the rules for basic reference types:
 * The `Table` method `grow` gets an additional optional argument `init` that is used to initialise the new table slots. It defaults to `null`. A `TypeError` is produced if the argument is omitted and the table's element type is not defaultable.
 
 
+### Type Reflection
+
+In the presence of the [JS type reflection proposal](https://github.com/WebAssembly/js-types):
+
+* `Global.type` throws `TypeError` when encountering a concrete reference type.
+
+* `Table.type` throws `TypeError` when encountering a concrete reference type as element type.
+
+* `Function.type` throws `TypeError` when encountering a concrete reference type as parameter or result type.
+
+* `Module.imports` throws `TypeError` when encountering a concrete reference type in any of the global, table or function types of imports.
+
+* `Module.exports` throws `TypeError` when encountering a concrete reference type in any of the global, table or function types of exports.
+
+Note: The [GC proposal](https://github.com/WebAssembly/gc) is expected to at least add `anyref` as a recognised `RefType`, but possibly throw on other abstract reference types.
+
+
+### Possible Extension: Full Type Reflection
+
+Post-MVP, the type reflection abilities of the JS API could be refined based on the [JS type reflection proposal](https://github.com/WebAssembly/js-types).
+
+### Type Representation
+
+* A `RefType` can be described by an object of the form `{ref: HeapType, ...}`
+  - `type RefType = ... | {ref: HeapType, nullable: bool}`
+
+* A `HeapType` can be described by a suitable union type
+  - `type HeapType = "func" | "extern" | DefType`
+
+Note: The [GC proposal](https://github.com/WebAssembly/gc) adds additional heap types.
+
+
+### Value Conversions
+
+#### Reference Types
+
+In addition to the rules for basic reference types:
+
+* Any function that is an instance of `WebAssembly.Function` with type `<functype>` is allowed as `ref <functype>` or `ref null <functype>`.
+
+* Any non-null external reference is allowed as `ref extern`.
+
+* The `null` value is allowed as `ref null ht`.
+
+Note: The [GC proposal](https://github.com/WebAssembly/gc) is expected to allow additional conversions for `anyref`.
+
 
 ## Possible Extension: Function Subtyping
 

From ff149b4c52c6bccd1c6a00eec984535c0e0d8a0b Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Mon, 5 Dec 2022 17:57:38 +0100
Subject: [PATCH 223/285] [spec] Add missing case for declarative elem segments

Fixes #1562.
---
 document/core/exec/modules.rst | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index 4242488db..16cd23fe2 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -655,7 +655,7 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
 13. Push the frame :math:`F` to the stack.
 
-14. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEMS` whose :ref:`mode <syntax-elemmode>` is of the form :math:`\EACTIVE~\{ \ETABLE~\tableidx_i, \EOFFSET~\X{einstr}^\ast_i~\END \}`, do:
+14. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEMS` whose :ref:`mode <syntax-elemmode>` is either of the form :math:`\EDECLARATIVE` or :math:`\EACTIVE~\{ \ETABLE~\tableidx_i, \EOFFSET~\X{einstr}^\ast_i~\END \}`, do:
 
     a. Let :math:`n` be the length of the vector :math:`\elem_i.\EINIT`.
 
@@ -685,15 +685,19 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
     g. :ref:`Execute <exec-data.drop>` the instruction :math:`\DATADROP~i`.
 
-16. If the :ref:`start function <syntax-start>` :math:`\module.\MSTART` is not empty, then:
+16. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATAS` whose :ref:`mode <syntax-datamode>` is of the form :math:`\DDECLARATIVE`, do:
+
+    a. :ref:`Execute <exec-data.drop>` the instruction :math:`\DATADROP~i`.
+
+17. If the :ref:`start function <syntax-start>` :math:`\module.\MSTART` is not empty, then:
 
     a. Let :math:`\start` be the :ref:`start function <syntax-start>` :math:`\module.\MSTART`.
 
     b. :ref:`Execute <exec-call>` the instruction :math:`\CALL~\start.\SFUNC`.
 
-17. Assert: due to :ref:`validation <valid-module>`, the frame :math:`F` is now on the top of the stack.
+18. Assert: due to :ref:`validation <valid-module>`, the frame :math:`F` is now on the top of the stack.
 
-18. Pop the frame :math:`F` from the stack.
+19. Pop the frame :math:`F` from the stack.
 
 
 .. math::

From 11c4cc25df26182b56040b2b3c65fe03a0ff101b Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Mon, 5 Dec 2022 18:10:42 +0100
Subject: [PATCH 224/285] [spec] Hotfix last accidental commit

---
 document/core/exec/modules.rst | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index 16cd23fe2..4dfdb9735 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -655,7 +655,7 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
 13. Push the frame :math:`F` to the stack.
 
-14. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEMS` whose :ref:`mode <syntax-elemmode>` is either of the form :math:`\EDECLARATIVE` or :math:`\EACTIVE~\{ \ETABLE~\tableidx_i, \EOFFSET~\X{einstr}^\ast_i~\END \}`, do:
+14. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEMS` whose :ref:`mode <syntax-elemmode>` is of the form :math:`\EACTIVE~\{ \ETABLE~\tableidx_i, \EOFFSET~\X{einstr}^\ast_i~\END \}`, do:
 
     a. Let :math:`n` be the length of the vector :math:`\elem_i.\EINIT`.
 
@@ -669,7 +669,11 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
     f. :ref:`Execute <exec-elem.drop>` the instruction :math:`\ELEMDROP~i`.
 
-15. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATAS` whose :ref:`mode <syntax-datamode>` is of the form :math:`\DACTIVE~\{ \DMEM~\memidx_i, \DOFFSET~\X{dinstr}^\ast_i~\END \}`, do:
+15. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEMS` whose :ref:`mode <syntax-elemmode>` is of the form :math:`\EDECLARATIVE`, do:
+
+    a. :ref:`Execute <exec-elem.drop>` the instruction :math:`\ELEMDROP~i`.
+
+16. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATAS` whose :ref:`mode <syntax-datamode>` is of the form :math:`\DACTIVE~\{ \DMEM~\memidx_i, \DOFFSET~\X{dinstr}^\ast_i~\END \}`, do:
 
     a. Assert: :math:`\memidx_i` is :math:`0`.
 
@@ -685,10 +689,6 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
     g. :ref:`Execute <exec-data.drop>` the instruction :math:`\DATADROP~i`.
 
-16. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATAS` whose :ref:`mode <syntax-datamode>` is of the form :math:`\DDECLARATIVE`, do:
-
-    a. :ref:`Execute <exec-data.drop>` the instruction :math:`\DATADROP~i`.
-
 17. If the :ref:`start function <syntax-start>` :math:`\module.\MSTART` is not empty, then:
 
     a. Let :math:`\start` be the :ref:`start function <syntax-start>` :math:`\module.\MSTART`.

From 6cc9fa15b4fee6d9e6ecc7bc7522802adef970d8 Mon Sep 17 00:00:00 2001
From: Michael Ficarra <github@michael.ficarra.me>
Date: Mon, 5 Dec 2022 10:10:57 -0800
Subject: [PATCH 225/285] [spec] Fix hyperref (#1563)

---
 document/core/exec/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index c7586d074..c253a17ed 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -2679,7 +2679,7 @@ Control Instructions
 :math:`\BRTABLE~l^\ast~l_N`
 ...........................
 
-1. Assert: due to :ref:`validation <valid-if>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+1. Assert: due to :ref:`validation <valid-br-table>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
 
 2. Pop the value :math:`\I32.\CONST~i` from the stack.
 

From 1fb0f3ea01e2afc8f61c04eb4665607a8bf359b4 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Mon, 5 Dec 2022 19:23:18 +0100
Subject: [PATCH 226/285] [spec] Bump sphinx version to fix Python problem

---
 .github/workflows/main.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 9a7a111a1..00b70e8f0 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -63,7 +63,7 @@ jobs:
       - run: pip install bikeshed && bikeshed update
       - run: pip install six
       - run: sudo apt-get update -y && sudo apt-get install -y latexmk texlive-latex-recommended texlive-latex-extra texlive-fonts-recommended
-      - run: pip install sphinx==4.0.0
+      - run: pip install sphinx==5.1.0
       - run: cd document/core && make all
       - uses: actions/upload-artifact@v2
         with:

From 62aa16e9085999dfd66d32b9a12f76f26605a7b8 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Wed, 7 Dec 2022 18:29:56 +0100
Subject: [PATCH 227/285] [spec] Fix minor errors and inconsistencies (#1564)

---
 document/core/appendix/properties.rst |  2 +-
 document/core/exec/instructions.rst   | 46 ++++++++++---------
 document/core/exec/runtime.rst        | 66 +++++++++++++--------------
 document/core/valid/instructions.rst  |  2 +-
 4 files changed, 59 insertions(+), 57 deletions(-)

diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index c37823219..d9b6a3548 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -237,7 +237,7 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 :ref:`Memory Instances <syntax-meminst>` :math:`\{ \MITYPE~\limits, \MIDATA~b^\ast \}`
 ......................................................................................
 
-* The :ref:`memory type <syntax-memtype>` :math:`\{\LMIN~n, \LMAX~m^?\}` must be :ref:`valid <valid-memtype>`.
+* The :ref:`memory type <syntax-memtype>` :math:`\limits` must be :ref:`valid <valid-memtype>`.
 
 * The length of :math:`b^\ast` must equal :math:`\limits.\LMIN` multiplied by the :ref:`page size <page-size>` :math:`64\,\F{Ki}`.
 
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index c253a17ed..6b0280603 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -1256,7 +1256,7 @@ Table Instructions
 .. math::
    \begin{array}{l}
    \begin{array}{lcl@{\qquad}l}
-   S; F; \TABLESIZE~x &\stepto& S; F; (\I32.\CONST~\X{sz})
+   S; F; (\TABLESIZE~x) &\stepto& S; F; (\I32.\CONST~\X{sz})
    \end{array}
    \\ \qquad
      (\iff |S.\STABLES[F.\AMODULE.\MITABLES[x]].\TIELEM| = \X{sz}) \\
@@ -1288,19 +1288,21 @@ Table Instructions
 
 10. Pop the value :math:`\val` from the stack.
 
-11. Either, try :ref:`growing <grow-table>` :math:`\X{table}` by :math:`n` entries with initialization value :math:`\val`:
+11. Let :math:`\X{err}` be the |i32| value :math:`2^{32}-1`, for which :math:`\signed_{32}(\X{err})` is :math:`-1`.
+
+12. Either, try :ref:`growing <grow-table>` :math:`\X{table}` by :math:`n` entries with initialization value :math:`\val`:
 
    a. If it succeeds, push the value :math:`\I32.\CONST~\X{sz}` to the stack.
 
-   b. Else, push the value :math:`\I32.\CONST~(-1)` to the stack.
+   b. Else, push the value :math:`\I32.\CONST~\X{err}` to the stack.
 
-12. Or, push the value :math:`\I32.\CONST~(-1)` to the stack.
+13. Or, push the value :math:`\I32.\CONST~\X{err}` to the stack.
 
 .. math::
    ~\\[-1ex]
    \begin{array}{l}
    \begin{array}{lcl@{\qquad}l}
-   S; F; \val~(\I32.\CONST~n)~\TABLEGROW~x &\stepto& S'; F; (\I32.\CONST~\X{sz})
+   S; F; \val~(\I32.\CONST~n)~(\TABLEGROW~x) &\stepto& S'; F; (\I32.\CONST~\X{sz})
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
@@ -1310,7 +1312,7 @@ Table Instructions
      \end{array}
    \\[1ex]
    \begin{array}{lcl@{\qquad}l}
-   S; F; (\I32.\CONST~n)~\TABLEGROW~x &\stepto& S; F; (\I32.\CONST~{-1})
+   S; F; (\I32.\CONST~n)~(\TABLEGROW~x) &\stepto& S; F; (\I32.\CONST~\signed_{32}^{-1}(-1))
    \end{array}
    \end{array}
 
@@ -1511,7 +1513,7 @@ Table Instructions
      \quad\stepto
      \\ \qquad S; F;
        \begin{array}[t]{@{}l@{}}
-       (\I32.\CONST~d+n-1)~(\I32.\CONST~s+n-1)~(\TABLEGET~y)~(\TABLESET~x) \\
+       (\I32.\CONST~d+n)~(\I32.\CONST~s+n)~(\TABLEGET~y)~(\TABLESET~x) \\
        (\I32.\CONST~d)~(\I32.\CONST~s)~(\I32.\CONST~n)~(\TABLECOPY~x~y) \\
        \end{array}
      \\ \qquad
@@ -1722,7 +1724,7 @@ Memory Instructions
      \end{array}
    \\[1ex]
    \begin{array}{lcl@{\qquad}l}
-   S; F; (\I32.\CONST~k)~(t.\LOAD({N}\K{\_}\sx)^?~\memarg) &\stepto& S; F; \TRAP
+   S; F; (\I32.\CONST~i)~(t.\LOAD({N}\K{\_}\sx)^?~\memarg) &\stepto& S; F; \TRAP
    \end{array}
    \\ \qquad
      (\otherwise) \\
@@ -1783,7 +1785,7 @@ Memory Instructions
      \end{array}
    \\[1ex]
    \begin{array}{lcl@{\qquad}l}
-   S; F; (\I32.\CONST~k)~(\V128.\LOAD{M}\K{x}N\K{\_}\sx~\memarg) &\stepto& S; F; \TRAP
+   S; F; (\I32.\CONST~i)~(\V128.\LOAD{M}\K{x}N\K{\_}\sx~\memarg) &\stepto& S; F; \TRAP
    \end{array}
    \\ \qquad
      (\otherwise) \\
@@ -1840,7 +1842,7 @@ Memory Instructions
      \end{array}
    \\[1ex]
    \begin{array}{lcl@{\qquad}l}
-   S; F; (\I32.\CONST~k)~(\V128.\LOAD{N}\K{\_splat}~\memarg) &\stepto& S; F; \TRAP
+   S; F; (\I32.\CONST~i)~(\V128.\LOAD{N}\K{\_splat}~\memarg) &\stepto& S; F; \TRAP
    \end{array}
    \\ \qquad
      (\otherwise) \\
@@ -1895,7 +1897,7 @@ Memory Instructions
      \end{array}
    \\[1ex]
    \begin{array}{lcl@{\qquad}l}
-   S; F; (\I32.\CONST~k)~(\V128.\LOAD{N}\K{\_zero}~\memarg) &\stepto& S; F; \TRAP
+   S; F; (\I32.\CONST~i)~(\V128.\LOAD{N}\K{\_zero}~\memarg) &\stepto& S; F; \TRAP
    \end{array}
    \\ \qquad
      (\otherwise) \\
@@ -1957,7 +1959,7 @@ Memory Instructions
      \end{array}
    \\[1ex]
    \begin{array}{lcl@{\qquad}l}
-   S; F; (\I32.\CONST~k)~(\V128.\CONST~v)~(\V128.\LOAD{N}\K{\_lane}~\memarg~x) &\stepto& S; F; \TRAP
+   S; F; (\I32.\CONST~i)~(\V128.\CONST~v)~(\V128.\LOAD{N}\K{\_lane}~\memarg~x) &\stepto& S; F; \TRAP
    \end{array}
    \\ \qquad
      (\otherwise) \\
@@ -2034,7 +2036,7 @@ Memory Instructions
      \end{array}
    \\[1ex]
    \begin{array}{lcl@{\qquad}l}
-   S; F; (\I32.\CONST~k)~(t.\CONST~c)~(t.\STORE{N}^?~\memarg) &\stepto& S; F; \TRAP
+   S; F; (\I32.\CONST~i)~(t.\CONST~c)~(t.\STORE{N}^?~\memarg) &\stepto& S; F; \TRAP
    \end{array}
    \\ \qquad
      (\otherwise) \\
@@ -2091,7 +2093,7 @@ Memory Instructions
      \end{array}
    \\[1ex]
    \begin{array}{lcl@{\qquad}l}
-   S; F; (\I32.\CONST~k)~(\V128.\CONST~c)~(\V128.\STORE{N}\K{\_lane}~\memarg~x) &\stepto& S; F; \TRAP
+   S; F; (\I32.\CONST~i)~(\V128.\CONST~c)~(\V128.\STORE{N}\K{\_lane}~\memarg~x) &\stepto& S; F; \TRAP
    \end{array}
    \\ \qquad
      (\otherwise) \\
@@ -2368,8 +2370,8 @@ Memory Instructions
      \quad\stepto
      \\ \qquad S; F;
        \begin{array}[t]{@{}l@{}}
-       (\I32.\CONST~d+n-1) \\
-       (\I32.\CONST~s+n-1)~(\I32\K{.}\LOAD\K{8\_u}~\{ \OFFSET~0, \ALIGN~0 \}) \\
+       (\I32.\CONST~d+n) \\
+       (\I32.\CONST~s+n)~(\I32\K{.}\LOAD\K{8\_u}~\{ \OFFSET~0, \ALIGN~0 \}) \\
        (\I32\K{.}\STORE\K{8}~\{ \OFFSET~0, \ALIGN~0 \}) \\
        (\I32.\CONST~d)~(\I32.\CONST~s)~(\I32.\CONST~n)~\MEMORYCOPY \\
        \end{array}
@@ -2679,7 +2681,7 @@ Control Instructions
 :math:`\BRTABLE~l^\ast~l_N`
 ...........................
 
-1. Assert: due to :ref:`validation <valid-br-table>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+1. Assert: due to :ref:`validation <valid-br_table>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
 
 2. Pop the value :math:`\I32.\CONST~i` from the stack.
 
@@ -2858,22 +2860,22 @@ Exiting :math:`\instr^\ast` with label :math:`L`
 
 When the end of a block is reached without a jump or trap aborting it, then the following steps are performed.
 
-1. Let :math:`m` be the number of values on the top of the stack.
+1. Let :math:`n` be the number of values on the top of the stack.
 
-2. Pop the values :math:`\val^m` from the stack.
+2. Pop the values :math:`\val^n` from the stack.
 
-3. Assert: due to :ref:`validation <valid-instr-seq>`, the label :math:`L` is now on the top of the stack.
+3. Assert: due to :ref:`validation <valid-instr-seq>`, the label :math:`L` is now on the top of the stack and has arity :math:`n`.
 
 4. Pop the label from the stack.
 
-5. Push :math:`\val^m` back to the stack.
+5. Push :math:`\val^n` back to the stack.
 
 6. Jump to the position after the |END| of the :ref:`structured control instruction <syntax-instr-control>` associated with the label :math:`L`.
 
 .. math::
    ~\\[-1ex]
    \begin{array}{lcl@{\qquad}l}
-   \LABEL_n\{\instr^\ast\}~\val^m~\END &\stepto& \val^m
+   \LABEL_n\{\instr^\ast\}~\val^n~\END &\stepto& \val^n
    \end{array}
 
 .. note::
diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index 149a53a8b..9ee7eccc9 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -30,18 +30,18 @@ or *external references* pointing to an uninterpreted form of :ref:`extern addre
 
 .. math::
    \begin{array}{llcl}
-   \production{(number)} & \num &::=&
+   \production{number} & \num &::=&
      \I32.\CONST~\i32 \\&&|&
      \I64.\CONST~\i64 \\&&|&
      \F32.\CONST~\f32 \\&&|&
      \F64.\CONST~\f64 \\
-   \production{(vector)} & \vecc &::=&
+   \production{vector} & \vecc &::=&
      \V128.\CONST~\i128 \\
-   \production{(reference)} & \reff &::=&
+   \production{reference} & \reff &::=&
      \REFNULL~t \\&&|&
      \REFFUNCADDR~\funcaddr \\&&|&
      \REFEXTERNADDR~\externaddr \\
-   \production{(value)} & \val &::=&
+   \production{value} & \val &::=&
      \num ~|~ \vecc ~|~ \reff \\
    \end{array}
 
@@ -79,7 +79,7 @@ It is either a sequence of :ref:`values <syntax-val>` or a :ref:`trap <syntax-tr
 
 .. math::
    \begin{array}{llcl}
-   \production{(result)} & \result &::=&
+   \production{result} & \result &::=&
      \val^\ast \\&&|&
      \TRAP
    \end{array}
@@ -101,7 +101,7 @@ Syntactically, the store is defined as a :ref:`record <notation-record>` listing
 
 .. math::
    \begin{array}{llll}
-   \production{(store)} & \store &::=& \{~
+   \production{store} & \store &::=& \{~
      \begin{array}[t]{l@{~}ll}
      \SFUNCS & \funcinst^\ast, \\
      \STABLES & \tableinst^\ast, \\
@@ -157,21 +157,21 @@ In addition, an :ref:`embedder <embedder>` may supply an uninterpreted set of *h
 
 .. math::
    \begin{array}{llll}
-   \production{(address)} & \addr &::=&
+   \production{address} & \addr &::=&
      0 ~|~ 1 ~|~ 2 ~|~ \dots \\
-   \production{(function address)} & \funcaddr &::=&
+   \production{function address} & \funcaddr &::=&
      \addr \\
-   \production{(table address)} & \tableaddr &::=&
+   \production{table address} & \tableaddr &::=&
      \addr \\
-   \production{(memory address)} & \memaddr &::=&
+   \production{memory address} & \memaddr &::=&
      \addr \\
-   \production{(global address)} & \globaladdr &::=&
+   \production{global address} & \globaladdr &::=&
      \addr \\
-   \production{(element address)} & \elemaddr &::=&
+   \production{element address} & \elemaddr &::=&
      \addr \\
-   \production{(data address)} & \dataaddr &::=&
+   \production{data address} & \dataaddr &::=&
      \addr \\
-   \production{(extern address)} & \externaddr &::=&
+   \production{extern address} & \externaddr &::=&
      \addr \\
    \end{array}
 
@@ -204,7 +204,7 @@ and collects runtime representations of all entities that are imported, defined,
 
 .. math::
    \begin{array}{llll}
-   \production{(module instance)} & \moduleinst &::=& \{
+   \production{module instance} & \moduleinst &::=& \{
      \begin{array}[t]{l@{~}ll}
      \MITYPES & \functype^\ast, \\
      \MIFUNCS & \funcaddr^\ast, \\
@@ -238,10 +238,10 @@ The module instance is used to resolve references to other definitions during ex
 
 .. math::
    \begin{array}{llll}
-   \production{(function instance)} & \funcinst &::=&
+   \production{function instance} & \funcinst &::=&
      \{ \FITYPE~\functype, \FIMODULE~\moduleinst, \FICODE~\func \} \\ &&|&
      \{ \FITYPE~\functype, \FIHOSTCODE~\hostfunc \} \\
-   \production{(host function)} & \hostfunc &::=& \dots \\
+   \production{host function} & \hostfunc &::=& \dots \\
    \end{array}
 
 A *host function* is a function expressed outside WebAssembly but passed to a :ref:`module <syntax-module>` as an :ref:`import <syntax-import>`.
@@ -268,7 +268,7 @@ It records its :ref:`type <syntax-tabletype>` and holds a vector of :ref:`refere
 
 .. math::
    \begin{array}{llll}
-   \production{(table instance)} & \tableinst &::=&
+   \production{table instance} & \tableinst &::=&
      \{ \TITYPE~\tabletype, \TIELEM~\vec(\reff) \} \\
    \end{array}
 
@@ -292,7 +292,7 @@ It records its :ref:`type <syntax-memtype>` and holds a vector of :ref:`bytes <s
 
 .. math::
    \begin{array}{llll}
-   \production{(memory instance)} & \meminst &::=&
+   \production{memory instance} & \meminst &::=&
      \{ \MITYPE~\memtype, \MIDATA~\vec(\byte) \} \\
    \end{array}
 
@@ -316,7 +316,7 @@ It records its :ref:`type <syntax-globaltype>` and holds an individual :ref:`val
 
 .. math::
    \begin{array}{llll}
-   \production{(global instance)} & \globalinst &::=&
+   \production{global instance} & \globalinst &::=&
      \{ \GITYPE~\globaltype, \GIVALUE~\val \} \\
    \end{array}
 
@@ -338,7 +338,7 @@ It holds a vector of references and their common :ref:`type <syntax-reftype>`.
 
 .. math::
   \begin{array}{llll}
-  \production{(element instance)} & \eleminst &::=&
+  \production{element instance} & \eleminst &::=&
     \{ \EITYPE~\reftype, \EIELEM~\vec(\reff) \} \\
   \end{array}
 
@@ -356,7 +356,7 @@ It holds a vector of :ref:`bytes <syntax-byte>`.
 
 .. math::
   \begin{array}{llll}
-  \production{(data instance)} & \datainst &::=&
+  \production{data instance} & \datainst &::=&
     \{ \DIDATA~\vec(\byte) \} \\
   \end{array}
 
@@ -374,7 +374,7 @@ It defines the export's :ref:`name <syntax-name>` and the associated :ref:`exter
 
 .. math::
    \begin{array}{llll}
-   \production{(export instance)} & \exportinst &::=&
+   \production{export instance} & \exportinst &::=&
      \{ \EINAME~\name, \EIVALUE~\externval \} \\
    \end{array}
 
@@ -392,7 +392,7 @@ It is an :ref:`address <syntax-addr>` denoting either a :ref:`function instance
 
 .. math::
    \begin{array}{llcl}
-   \production{(external value)} & \externval &::=&
+   \production{external value} & \externval &::=&
      \EVFUNC~\funcaddr \\&&|&
      \EVTABLE~\tableaddr \\&&|&
      \EVMEM~\memaddr \\&&|&
@@ -456,7 +456,7 @@ Labels carry an argument arity :math:`n` and their associated branch *target*, w
 
 .. math::
    \begin{array}{llll}
-   \production{(label)} & \label &::=&
+   \production{label} & \label &::=&
      \LABEL_n\{\instr^\ast\} \\
    \end{array}
 
@@ -485,9 +485,9 @@ and a reference to the function's own :ref:`module instance <syntax-moduleinst>`
 
 .. math::
    \begin{array}{llll}
-   \production{(activation)} & \X{activation} &::=&
+   \production{activation} & \X{activation} &::=&
      \FRAME_n\{\frame\} \\
-   \production{(frame)} & \frame &::=&
+   \production{frame} & \frame &::=&
      \{ \ALOCALS~\val^\ast, \AMODULE~\moduleinst \} \\
    \end{array}
 
@@ -529,7 +529,7 @@ In order to express the reduction of :ref:`traps <trap>`, :ref:`calls <syntax-ca
 
 .. math::
    \begin{array}{llcl}
-   \production{(administrative instruction)} & \instr &::=&
+   \production{administrative instruction} & \instr &::=&
      \dots \\ &&|&
      \TRAP \\ &&|&
      \REFFUNCADDR~\funcaddr \\ &&|&
@@ -590,9 +590,9 @@ In order to specify the reduction of :ref:`branches <syntax-instr-control>`, the
 
 .. math::
    \begin{array}{llll}
-   \production{(block contexts)} & \XB^0 &::=&
+   \production{block contexts} & \XB^0 &::=&
      \val^\ast~[\_]~\instr^\ast \\
-   \production{(block contexts)} & \XB^{k+1} &::=&
+   \production{block contexts} & \XB^{k+1} &::=&
      \val^\ast~\LABEL_n\{\instr^\ast\}~\XB^k~\END~\instr^\ast \\
    \end{array}
 
@@ -624,9 +624,9 @@ that operates relative to a current :ref:`frame <syntax-frame>` referring to the
 
 .. math::
    \begin{array}{llcl}
-   \production{(configuration)} & \config &::=&
+   \production{configuration} & \config &::=&
      \store; \thread \\
-   \production{(thread)} & \thread &::=&
+   \production{thread} & \thread &::=&
      \frame; \instr^\ast \\
    \end{array}
 
@@ -645,7 +645,7 @@ Finally, the following definition of *evaluation context* and associated structu
 
 .. math::
    \begin{array}{llll}
-   \production{(evaluation contexts)} & E &::=&
+   \production{evaluation contexts} & E &::=&
      [\_] ~|~
      \val^\ast~E~\instr^\ast ~|~
      \LABEL_n\{\instr^\ast\}~E~\END \\
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index b2d5fd13b..afcda69c0 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -1625,7 +1625,7 @@ Constant Expressions
    \qquad
    \frac{
    }{
-     C \vdashinstrconst \REFNULL \const
+     C \vdashinstrconst \REFNULL~t \const
    }
    \qquad
    \frac{

From 7094e3c73c1c7ed3997cbca724e11cc54afcc6b4 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Fri, 9 Dec 2022 16:31:49 +0100
Subject: [PATCH 228/285] Spacing

---
 document/core/syntax/types.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index e22087513..41045f38f 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -158,7 +158,7 @@ Reference Types
 
 A reference type is characterised by the :ref:`heap type <syntax-heaptype>` it points to.
 
-In addition, a reference type of the form :math:`\REF \NULL \X{ht}` is *nullable*, meaning that it can either be a proper reference to :math:`\X{ht}` or :ref:`null <syntax-null>`.
+In addition, a reference type of the form :math:`\REF~\NULL~\X{ht}` is *nullable*, meaning that it can either be a proper reference to :math:`\X{ht}` or :ref:`null <syntax-null>`.
 Other references are *non-null*.
 
 Reference types are *opaque*, meaning that neither their size nor their bit pattern can be observed.

From 85e55e814113ae409dea443eba108a8c4e901ef7 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Fri, 9 Dec 2022 17:15:14 +0100
Subject: [PATCH 229/285] Fix a couple more superfluous brackets

---
 document/core/appendix/embedding.rst | 2 +-
 document/core/exec/runtime.rst       | 2 +-
 document/core/syntax/types.rst       | 4 ++--
 document/core/text/conventions.rst   | 2 +-
 document/core/valid/conventions.rst  | 2 +-
 5 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/document/core/appendix/embedding.rst b/document/core/appendix/embedding.rst
index dc185b0a8..e9c7dbd2e 100644
--- a/document/core/appendix/embedding.rst
+++ b/document/core/appendix/embedding.rst
@@ -33,7 +33,7 @@ Failure of an interface operation is indicated by an auxiliary syntactic class:
 
 .. math::
    \begin{array}{llll}
-   \production{(error)} & \error &::=& \ERROR \\
+   \production{error} & \error &::=& \ERROR \\
    \end{array}
 
 In addition to the error conditions specified explicitly in this section, implementations may also return errors when specific :ref:`implementation limitations <impl>` are reached.
diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index 450eb8762..86680d84a 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -264,7 +264,7 @@ It is a :ref:`dynamic type <syntax-type-dyn>` equivalent to the respective :ref:
 
 .. math::
    \begin{array}{llll}
-   \production{(type instance)} & \typeinst &::=&
+   \production{type instance} & \typeinst &::=&
      \functype
    \end{array}
 
diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index 41045f38f..c8994a2d7 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -249,9 +249,9 @@ Local Types
 
 .. math::
    \begin{array}{llll}
-   \production{(initialization status)} & \init &::=&
+   \production{initialization status} & \init &::=&
      \SET ~|~ \UNSET \\
-   \production{(local type)} & \localtype &::=&
+   \production{local type} & \localtype &::=&
      \init~\valtype \\
    \end{array}
 
diff --git a/document/core/text/conventions.rst b/document/core/text/conventions.rst
index 12c8b7dfc..0bd32e033 100644
--- a/document/core/text/conventions.rst
+++ b/document/core/text/conventions.rst
@@ -117,7 +117,7 @@ It is convenient to define identifier contexts as :ref:`records <notation-record
 
 .. math::
    \begin{array}{llll}
-   \production{(identifier context)} & I &::=&
+   \production{identifier context} & I &::=&
      \begin{array}[t]{l@{~}ll}
      \{ & \ITYPES & (\Tid^?)^\ast, \\
         & \IFUNCS & (\Tid^?)^\ast, \\
diff --git a/document/core/valid/conventions.rst b/document/core/valid/conventions.rst
index 25d6c0b34..00e517dc7 100644
--- a/document/core/valid/conventions.rst
+++ b/document/core/valid/conventions.rst
@@ -54,7 +54,7 @@ More concretely, contexts are defined as :ref:`records <notation-record>` :math:
 
 .. math::
    \begin{array}{llll}
-   \production{(context)} & C &::=&
+   \production{context} & C &::=&
      \begin{array}[t]{l@{~}ll}
      \{ & \CTYPES & \functype^\ast, \\
         & \CFUNCS & \typeid^\ast, \\

From 937fc7d63efb9e18f36334a9e761a8a040ac44b7 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Fri, 9 Dec 2022 17:20:54 +0100
Subject: [PATCH 230/285] [spec] Eps

---
 document/core/appendix/embedding.rst | 2 +-
 document/core/text/conventions.rst   | 2 +-
 document/core/valid/conventions.rst  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/document/core/appendix/embedding.rst b/document/core/appendix/embedding.rst
index b2995f2f1..27aac4b31 100644
--- a/document/core/appendix/embedding.rst
+++ b/document/core/appendix/embedding.rst
@@ -33,7 +33,7 @@ Failure of an interface operation is indicated by an auxiliary syntactic class:
 
 .. math::
    \begin{array}{llll}
-   \production{(error)} & \error &::=& \ERROR \\
+   \production{error} & \error &::=& \ERROR \\
    \end{array}
 
 In addition to the error conditions specified explicitly in this section, implementations may also return errors when specific :ref:`implementation limitations <impl>` are reached.
diff --git a/document/core/text/conventions.rst b/document/core/text/conventions.rst
index 12c8b7dfc..0bd32e033 100644
--- a/document/core/text/conventions.rst
+++ b/document/core/text/conventions.rst
@@ -117,7 +117,7 @@ It is convenient to define identifier contexts as :ref:`records <notation-record
 
 .. math::
    \begin{array}{llll}
-   \production{(identifier context)} & I &::=&
+   \production{identifier context} & I &::=&
      \begin{array}[t]{l@{~}ll}
      \{ & \ITYPES & (\Tid^?)^\ast, \\
         & \IFUNCS & (\Tid^?)^\ast, \\
diff --git a/document/core/valid/conventions.rst b/document/core/valid/conventions.rst
index fbd4f6e20..ad860ccc1 100644
--- a/document/core/valid/conventions.rst
+++ b/document/core/valid/conventions.rst
@@ -54,7 +54,7 @@ More concretely, contexts are defined as :ref:`records <notation-record>` :math:
 
 .. math::
    \begin{array}{llll}
-   \production{(context)} & C &::=&
+   \production{context} & C &::=&
      \begin{array}[t]{l@{~}ll}
      \{ & \CTYPES & \functype^\ast, \\
         & \CFUNCS & \functype^\ast, \\

From ef01de5ef4e7d5cc772110af2e30cc4fb722784a Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Mon, 12 Dec 2022 23:37:45 +0100
Subject: [PATCH 231/285] [interpreter] Refactor parser to handle select &
 call_indirect correctly (#1567)

---
 interpreter/text/parser.mly  | 100 +++++++++++------------------------
 test/core/call_indirect.wast |  20 +++++++
 test/core/select.wast        |  17 ++++++
 3 files changed, 67 insertions(+), 70 deletions(-)

diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index 535a05d51..7489acf72 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -366,12 +366,16 @@ align_opt :
 
 /* Instructions & Expressions */
 
-instr :
+instr_list :
+  | /* empty */ { fun c -> [] }
+  | instr1 instr_list { fun c -> $1 c @ $2 c }
+  | select_instr_instr_list { $1 }
+  | call_instr_instr_list { $1 }
+
+instr1 :
   | plain_instr { let at = at () in fun c -> [$1 c @@ at] }
-  | select_instr_instr { fun c -> let e, es = $1 c in e :: es }
-  | call_instr_instr { fun c -> let e, es = $1 c in e :: es }
   | block_instr { let at = at () in fun c -> [$1 c @@ at] }
-  | expr { $1 } /* Sugar */
+  | expr { $1 }  /* Sugar */
 
 plain_instr :
   | UNREACHABLE { fun c -> unreachable }
@@ -442,89 +446,51 @@ plain_instr :
   | VEC_REPLACE NAT { let at = at () in fun c -> $1 (vec_lane_index $2 at) }
 
 
-select_instr :
-  | SELECT select_instr_results
-    { let at = at () in fun c -> let b, ts = $2 in
-      select (if b then (Some ts) else None) @@ at }
-
-select_instr_results :
-  | LPAR RESULT value_type_list RPAR select_instr_results
-    { let _, ts = $5 in true, $3 @ ts }
-  | /* empty */
-    { false, [] }
-
-select_instr_instr :
-  | SELECT select_instr_results_instr
+select_instr_instr_list :
+  | SELECT select_instr_results_instr_list
     { let at1 = ati 1 in
       fun c -> let b, ts, es = $2 c in
-      select (if b then (Some ts) else None) @@ at1, es }
+      (select (if b then (Some ts) else None) @@ at1) :: es }
 
-select_instr_results_instr :
-  | LPAR RESULT value_type_list RPAR select_instr_results_instr
+select_instr_results_instr_list :
+  | LPAR RESULT value_type_list RPAR select_instr_results_instr_list
     { fun c -> let _, ts, es = $5 c in true, $3 @ ts, es }
-  | instr
+  | instr_list
     { fun c -> false, [], $1 c }
 
 
-call_instr :
-  | CALL_INDIRECT var call_instr_type
-    { let at = at () in fun c -> call_indirect ($2 c table) ($3 c) @@ at }
-  | CALL_INDIRECT call_instr_type  /* Sugar */
-    { let at = at () in fun c -> call_indirect (0l @@ at) ($2 c) @@ at }
-
-call_instr_type :
-  | type_use call_instr_params
-    { let at1 = ati 1 in
-      fun c ->
-      match $2 c with
-      | FuncType ([], []) -> $1 c type_
-      | ft -> inline_type_explicit c ($1 c type_) ft at1 }
-  | call_instr_params
-    { let at = at () in fun c -> inline_type c ($1 c) at }
-
-call_instr_params :
-  | LPAR PARAM value_type_list RPAR call_instr_params
-    { fun c -> let FuncType (ts1, ts2) = $5 c in FuncType ($3 @ ts1, ts2) }
-  | call_instr_results
-    { fun c -> FuncType ([], $1 c) }
-
-call_instr_results :
-  | LPAR RESULT value_type_list RPAR call_instr_results
-    { fun c -> $3 @ $5 c }
-  | /* empty */
-    { fun c -> [] }
-
-
-call_instr_instr :
-  | CALL_INDIRECT var call_instr_type_instr
+call_instr_instr_list :
+  | CALL_INDIRECT var call_instr_type_instr_list
     { let at1 = ati 1 in
-      fun c -> let x, es = $3 c in call_indirect ($2 c table) x @@ at1, es }
-  | CALL_INDIRECT call_instr_type_instr  /* Sugar */
+      fun c -> let x, es = $3 c in
+      (call_indirect ($2 c table) x @@ at1) :: es }
+  | CALL_INDIRECT call_instr_type_instr_list  /* Sugar */
     { let at1 = ati 1 in
-      fun c -> let x, es = $2 c in call_indirect (0l @@ at1) x @@ at1, es }
+      fun c -> let x, es = $2 c in
+      (call_indirect (0l @@ at1) x @@ at1) :: es }
 
-call_instr_type_instr :
-  | type_use call_instr_params_instr
+call_instr_type_instr_list :
+  | type_use call_instr_params_instr_list
     { let at1 = ati 1 in
       fun c ->
       match $2 c with
       | FuncType ([], []), es -> $1 c type_, es
       | ft, es -> inline_type_explicit c ($1 c type_) ft at1, es }
-  | call_instr_params_instr
+  | call_instr_params_instr_list
     { let at = at () in
       fun c -> let ft, es = $1 c in inline_type c ft at, es }
 
-call_instr_params_instr :
-  | LPAR PARAM value_type_list RPAR call_instr_params_instr
+call_instr_params_instr_list :
+  | LPAR PARAM value_type_list RPAR call_instr_params_instr_list
     { fun c ->
       let FuncType (ts1, ts2), es = $5 c in FuncType ($3 @ ts1, ts2), es }
-  | call_instr_results_instr
+  | call_instr_results_instr_list
     { fun c -> let ts, es = $1 c in FuncType ([], ts), es }
 
-call_instr_results_instr :
-  | LPAR RESULT value_type_list RPAR call_instr_results_instr
+call_instr_results_instr_list :
+  | LPAR RESULT value_type_list RPAR call_instr_results_instr_list
     { fun c -> let ts, es = $5 c in $3 @ ts, es }
-  | instr
+  | instr_list
     { fun c -> [], $1 c }
 
 
@@ -657,12 +623,6 @@ if_ :
   | LPAR THEN instr_list RPAR  /* Sugar */
     { fun c c' -> [], $3 c', [] }
 
-instr_list :
-  | /* empty */ { fun c -> [] }
-  | select_instr { fun c -> [$1 c] }
-  | call_instr { fun c -> [$1 c] }
-  | instr instr_list { fun c -> $1 c @ $2 c }
-
 expr_list :
   | /* empty */ { fun c -> [] }
   | expr expr_list { fun c -> $1 c @ $2 c }
diff --git a/test/core/call_indirect.wast b/test/core/call_indirect.wast
index 1ecd9b7ba..79b8dc393 100644
--- a/test/core/call_indirect.wast
+++ b/test/core/call_indirect.wast
@@ -1015,3 +1015,23 @@
   (module (table funcref (elem 0 0)))
   "unknown function"
 )
+
+
+
+
+;; Flat syntax
+
+(module
+  (table 1 funcref)
+  (func unreachable call_indirect)
+  (func unreachable call_indirect nop)
+  (func unreachable call_indirect call_indirect)
+  (func unreachable call_indirect (call_indirect))
+  (func unreachable call_indirect call_indirect call_indirect)
+  (func unreachable call_indirect (result))
+  (func unreachable call_indirect (result) (result))
+  (func unreachable call_indirect (result) (result) call_indirect)
+  (func unreachable call_indirect (result) (result) call_indirect (result))
+  (func (result i32) unreachable call_indirect select)
+  (func (result i32) unreachable call_indirect select call_indirect)
+)
diff --git a/test/core/select.wast b/test/core/select.wast
index 046e6fe2c..673dcf478 100644
--- a/test/core/select.wast
+++ b/test/core/select.wast
@@ -512,3 +512,20 @@
   "type mismatch"
 )
 
+
+;; Flat syntax
+
+(module
+  (table 1 funcref)
+  (func (result i32) unreachable select)
+  (func (result i32) unreachable select nop)
+  (func (result i32) unreachable select (select))
+  (func (result i32) unreachable select select)
+  (func (result i32) unreachable select select select)
+  (func (result i32) unreachable select (result i32))
+  (func (result i32) unreachable select (result i32) (result))
+  (func (result i32) unreachable select (result i32) (result) select)
+  (func (result i32) unreachable select (result) (result i32) select (result i32))
+  (func (result i32) unreachable select call_indirect)
+  (func (result i32) unreachable select call_indirect select)
+)

From a54a1d85400db3cf243717a0ab1cc2fb6098170f Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 15 Dec 2022 16:23:26 +0100
Subject: [PATCH 232/285] [spec] Remove dead piece of grammar

---
 document/core/exec/runtime.rst | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index 9ee7eccc9..6c53a4e96 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -476,8 +476,8 @@ Intuitively, :math:`\instr^\ast` is the *continuation* to execute when the branc
 
    When branching, the empty continuation ends the targeted block, such that execution can proceed with consecutive instructions.
 
-Activations and Frames
-......................
+Activation Frames
+.................
 
 Activation frames carry the return arity :math:`n` of the respective function,
 hold the values of its :ref:`locals <syntax-local>` (including arguments) in the order corresponding to their static :ref:`local indices <syntax-localidx>`,
@@ -485,8 +485,6 @@ and a reference to the function's own :ref:`module instance <syntax-moduleinst>`
 
 .. math::
    \begin{array}{llll}
-   \production{activation} & \X{activation} &::=&
-     \FRAME_n\{\frame\} \\
    \production{frame} & \frame &::=&
      \{ \ALOCALS~\val^\ast, \AMODULE~\moduleinst \} \\
    \end{array}

From 1782235239ddebaf2cb079b00fdaa2d2c4dedba3 Mon Sep 17 00:00:00 2001
From: YAMAMOTO Takashi <yamamoto@midokura.com>
Date: Fri, 16 Dec 2022 00:24:54 +0900
Subject: [PATCH 233/285] [test] elem.wast: force to use exprs in a element
 (#1561)

---
 test/core/elem.wast | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/test/core/elem.wast b/test/core/elem.wast
index 8dc04e6e4..5857ae8bd 100644
--- a/test/core/elem.wast
+++ b/test/core/elem.wast
@@ -148,6 +148,25 @@
 (assert_return (invoke "call-7") (i32.const 65))
 (assert_return (invoke "call-9") (i32.const 66))
 
+;; Same as the above, but use ref.null to ensure the elements use exprs.
+;; Note: some tools like wast2json avoid using exprs when possible.
+(module
+  (type $out-i32 (func (result i32)))
+  (table 11 funcref)
+  (elem (i32.const 6) funcref (ref.null func) (ref.func $const-i32-a))
+  (elem (i32.const 9) funcref (ref.func $const-i32-b) (ref.null func))
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-7") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 7))
+  )
+  (func (export "call-9") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 9))
+  )
+)
+(assert_return (invoke "call-7") (i32.const 65))
+(assert_return (invoke "call-9") (i32.const 66))
+
 (assert_invalid
   (module (table 1 funcref) (global i32 (i32.const 0)) (elem (global.get 0) $f) (func $f))
   "unknown global"

From ca1d792430e353a7de0f2f4948fbb02bb0b83a65 Mon Sep 17 00:00:00 2001
From: Ng Zhi An <ngzhian@gmail.com>
Date: Tue, 17 Jan 2023 23:47:06 +0000
Subject: [PATCH 234/285] Fix typos in SIMD exec/instructions

---
 document/core/exec/instructions.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 6b0280603..72893d64e 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -394,7 +394,7 @@ Most vector instructions are defined in terms of generic numeric operators appli
 .. math::
    \begin{array}{l}
    \begin{array}{lcl@{\qquad}l}
-   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~\V128\K{.}\SWIZZLE &\stepto& (\V128\K{.}\VCONST~c')
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~\I8X16\K{.}\SWIZZLE &\stepto& (\V128\K{.}\VCONST~c')
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
@@ -431,7 +431,7 @@ Most vector instructions are defined in terms of generic numeric operators appli
 .. math::
    \begin{array}{l}
    \begin{array}{lcl@{\qquad}l}
-   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~\V128\K{.}\SHUFFLE~x^\ast &\stepto& (\V128\K{.}\VCONST~c)
+   (\V128\K{.}\VCONST~c_1)~(\V128\K{.}\VCONST~c_2)~\I8X16\K{.}\SHUFFLE~x^\ast &\stepto& (\V128\K{.}\VCONST~c)
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}

From 4c249c5a575e2b0e252e747af261bbb82f448dd4 Mon Sep 17 00:00:00 2001
From: Thomas Lively <tlively@google.com>
Date: Wed, 18 Jan 2023 16:34:13 -0600
Subject: [PATCH 235/285] Update interpreter README (#1571)

It previously stated that the formal spec did not exist, but the spec has existed for years now.
---
 interpreter/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interpreter/README.md b/interpreter/README.md
index 418b84501..18aa36c05 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -1,6 +1,6 @@
 # WebAssembly Reference Interpreter
 
-This repository implements a interpreter for WebAssembly. It is written for clarity and simplicity, _not_ speed. It is intended as a playground for trying out ideas and a device for nailing down the exact semantics, and as a proxy for the (yet to be produced) formal specification of WebAssembly. For that purpose, the code is written in a fairly declarative, "speccy" way.
+This repository implements an interpreter for WebAssembly. It is written for clarity and simplicity, _not_ speed. It is intended as a playground for trying out ideas and a device for nailing down their exact semantics. For that purpose, the code is written in a fairly declarative, "speccy" way.
 
 The interpreter can
 

From f54b5b81a3649461b4c8be0363844301983868ab Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Tue, 24 Jan 2023 12:22:06 +0100
Subject: [PATCH 236/285] [spec] Remove an obsolete exec step (#1580)

---
 document/core/exec/instructions.rst | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 72893d64e..cc66dbf2e 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -2912,15 +2912,13 @@ Invocation of :ref:`function address <syntax-funcaddr>` :math:`a`
 
 7. Pop the values :math:`\val^n` from the stack.
 
-8. Let :math:`\val_0^\ast` be the list of zero values of types :math:`t^\ast`.
+8. Let :math:`F` be the :ref:`frame <syntax-frame>` :math:`\{ \AMODULE~f.\FIMODULE, \ALOCALS~\val^n~(\default_t)^\ast \}`.
 
-9. Let :math:`F` be the :ref:`frame <syntax-frame>` :math:`\{ \AMODULE~f.\FIMODULE, \ALOCALS~\val^n~(\default_t)^\ast \}`.
+9. Push the activation of :math:`F` with arity :math:`m` to the stack.
 
-10. Push the activation of :math:`F` with arity :math:`m` to the stack.
+10. Let :math:`L` be the :ref:`label <syntax-label>` whose arity is :math:`m` and whose continuation is the end of the function.
 
-11. Let :math:`L` be the :ref:`label <syntax-label>` whose arity is :math:`m` and whose continuation is the end of the function.
-
-12. :ref:`Enter <exec-instr-seq-enter>` the instruction sequence :math:`\instr^\ast` with label :math:`L`.
+11. :ref:`Enter <exec-instr-seq-enter>` the instruction sequence :math:`\instr^\ast` with label :math:`L`.
 
 .. math::
    ~\\[-1ex]

From 6798f054ad1b0493919f0b5244fa46682ccd3e69 Mon Sep 17 00:00:00 2001
From: Keith Winstein <keithw@cs.stanford.edu>
Date: Tue, 24 Jan 2023 04:32:02 -0800
Subject: [PATCH 237/285] [test] Optional tableidx for
 table.{get,set,size,grow,fill} (#1582)

---
 test/core/table_fill.wast | 6 +++++-
 test/core/table_get.wast  | 2 +-
 test/core/table_grow.wast | 5 ++++-
 test/core/table_set.wast  | 2 +-
 test/core/table_size.wast | 2 +-
 5 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/test/core/table_fill.wast b/test/core/table_fill.wast
index 3df64da1a..a8e222552 100644
--- a/test/core/table_fill.wast
+++ b/test/core/table_fill.wast
@@ -5,6 +5,10 @@
     (table.fill $t (local.get $i) (local.get $r) (local.get $n))
   )
 
+  (func (export "fill-abbrev") (param $i i32) (param $r externref) (param $n i32)
+    (table.fill (local.get $i) (local.get $r) (local.get $n))
+  )
+
   (func (export "get") (param $i i32) (result externref)
     (table.get $t (local.get $i))
   )
@@ -39,7 +43,7 @@
 (assert_return (invoke "get" (i32.const 8)) (ref.extern 4))
 (assert_return (invoke "get" (i32.const 9)) (ref.extern 4))
 
-(assert_return (invoke "fill" (i32.const 9) (ref.null extern) (i32.const 1)))
+(assert_return (invoke "fill-abbrev" (i32.const 9) (ref.null extern) (i32.const 1)))
 (assert_return (invoke "get" (i32.const 8)) (ref.extern 4))
 (assert_return (invoke "get" (i32.const 9)) (ref.null extern))
 
diff --git a/test/core/table_get.wast b/test/core/table_get.wast
index 5d57c3198..0dedb19f5 100644
--- a/test/core/table_get.wast
+++ b/test/core/table_get.wast
@@ -10,7 +10,7 @@
   )
 
   (func (export "get-externref") (param $i i32) (result externref)
-    (table.get $t2 (local.get $i))
+    (table.get (local.get $i))
   )
   (func $f3 (export "get-funcref") (param $i i32) (result funcref)
     (table.get $t3 (local.get $i))
diff --git a/test/core/table_grow.wast b/test/core/table_grow.wast
index 7d5b5630f..9a931a7fa 100644
--- a/test/core/table_grow.wast
+++ b/test/core/table_grow.wast
@@ -7,6 +7,9 @@
   (func (export "grow") (param $sz i32) (param $init externref) (result i32)
     (table.grow $t (local.get $init) (local.get $sz))
   )
+  (func (export "grow-abbrev") (param $sz i32) (param $init externref) (result i32)
+    (table.grow (local.get $init) (local.get $sz))
+  )
   (func (export "size") (result i32) (table.size $t))
 )
 
@@ -22,7 +25,7 @@
 (assert_trap (invoke "set" (i32.const 1) (ref.extern 2)) "out of bounds table access")
 (assert_trap (invoke "get" (i32.const 1)) "out of bounds table access")
 
-(assert_return (invoke "grow" (i32.const 4) (ref.extern 3)) (i32.const 1))
+(assert_return (invoke "grow-abbrev" (i32.const 4) (ref.extern 3)) (i32.const 1))
 (assert_return (invoke "size") (i32.const 5))
 (assert_return (invoke "get" (i32.const 0)) (ref.extern 2))
 (assert_return (invoke "set" (i32.const 0) (ref.extern 2)))
diff --git a/test/core/table_set.wast b/test/core/table_set.wast
index 5a9cfa371..3362f9567 100644
--- a/test/core/table_set.wast
+++ b/test/core/table_set.wast
@@ -12,7 +12,7 @@
   )
 
   (func (export "set-externref") (param $i i32) (param $r externref)
-    (table.set $t2 (local.get $i) (local.get $r))
+    (table.set (local.get $i) (local.get $r))
   )
   (func (export "set-funcref") (param $i i32) (param $r funcref)
     (table.set $t3 (local.get $i) (local.get $r))
diff --git a/test/core/table_size.wast b/test/core/table_size.wast
index ad293b5ee..83fef02b3 100644
--- a/test/core/table_size.wast
+++ b/test/core/table_size.wast
@@ -4,7 +4,7 @@
   (table $t2 0 2 externref)
   (table $t3 3 8 externref)
 
-  (func (export "size-t0") (result i32) (table.size $t0))
+  (func (export "size-t0") (result i32) table.size)
   (func (export "size-t1") (result i32) (table.size $t1))
   (func (export "size-t2") (result i32) (table.size $t2))
   (func (export "size-t3") (result i32) (table.size $t3))

From 7d905dfa61b25ad58b71490eacfb13e70290b5ef Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Thu, 26 Jan 2023 17:03:14 +0100
Subject: [PATCH 238/285] [spec] Fix abstract grammar for const immediate
 (#1577)

---
 document/core/syntax/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index eae802cbd..9c48736b0 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -45,7 +45,7 @@ These operations closely match respective operations available in hardware.
    \production{signedness} & \sx &::=&
      \K{u} ~|~ \K{s} \\
    \production{instruction} & \instr &::=&
-     \K{i}\X{nn}\K{.}\CONST~\xref{syntax/values}{syntax-int}{\iX{\X{nn}}} ~|~
+     \K{i}\X{nn}\K{.}\CONST~\xref{syntax/values}{syntax-int}{\uX{\X{nn}}} ~|~
      \K{f}\X{nn}\K{.}\CONST~\xref{syntax/values}{syntax-float}{\fX{\X{nn}}} \\&&|&
      \K{i}\X{nn}\K{.}\iunop ~|~
      \K{f}\X{nn}\K{.}\funop \\&&|&

From 0031ea49613c72522eeff11e0511d423cb64645f Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Thu, 26 Jan 2023 17:03:48 +0100
Subject: [PATCH 239/285] [spec] Fix context composition in text format (#1578)

---
 document/core/text/modules.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/text/modules.rst b/document/core/text/modules.rst
index fde59878a..c34077326 100644
--- a/document/core/text/modules.rst
+++ b/document/core/text/modules.rst
@@ -108,7 +108,7 @@ If inline declarations are given, then their types must match the referenced :re
         \end{array} \\
    \end{array}
 
-The synthesized attribute of a |Ttypeuse| is a pair consisting of both the used :ref:`type index <syntax-typeidx>` and the updated :ref:`identifier context <text-context>` including possible parameter identifiers.
+The synthesized attribute of a |Ttypeuse| is a pair consisting of both the used :ref:`type index <syntax-typeidx>` and the local :ref:`identifier context <text-context>` containing possible parameter identifiers.
 The following auxiliary function extracts optional identifiers from parameters:
 
 .. math::
@@ -200,7 +200,7 @@ Function definitions can bind a symbolic :ref:`function identifier <text-id>`, a
      \text{(}~\text{func}~~\Tid^?~~x,I'{:}\Ttypeuse_I~~
      (t{:}\Tlocal)^\ast~~(\X{in}{:}\Tinstr_{I''})^\ast~\text{)} \\ &&& \qquad
        \Rightarrow\quad \{ \FTYPE~x, \FLOCALS~t^\ast, \FBODY~\X{in}^\ast~\END \} \\ &&& \qquad\qquad\qquad
-       (\iff I'' = I' \compose \{\ILOCALS~\F{id}(\Tlocal)^\ast\} \idcwellformed) \\[1ex]
+       (\iff I'' = I \compose I' \compose \{\ILOCALS~\F{id}(\Tlocal)^\ast\} \idcwellformed) \\[1ex]
    \production{local} & \Tlocal &::=&
      \text{(}~\text{local}~~\Tid^?~~t{:}\Tvaltype~\text{)}
        \quad\Rightarrow\quad t \\

From dcf4eaa08fe1b3f98e855e0581389bc29f5d496b Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Thu, 26 Jan 2023 17:04:44 +0100
Subject: [PATCH 240/285] [spec] Fix label shadowing (#1579)

---
 document/core/text/instructions.rst | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index 348aa7733..e846ccb50 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -34,6 +34,8 @@ The following grammar handles the corresponding update to the :ref:`identifier c
    \production{label} & \Tlabel_I &::=&
      v{:}\Tid &\Rightarrow& \{\ILABELS~v\} \compose I
        & (\iff v \notin I.\ILABELS) \\ &&|&
+     v{:}\Tid &\Rightarrow& \{\ILABELS~v\} \compose (I \with \ILABELS[i] = \epsilon)
+       & (\iff I.\ILABELS[i] = v) \\ &&|&
      \epsilon &\Rightarrow& \{\ILABELS~(\epsilon)\} \compose I \\
    \end{array}
 
@@ -42,6 +44,9 @@ The following grammar handles the corresponding update to the :ref:`identifier c
    This effectively shifts all existing labels up by one,
    mirroring the fact that control instructions are indexed relatively not absolutely.
 
+   If a label with the same name already exists,
+   then it is shadowed and the earlier label becomes inaccessible.
+
 
 .. index:: control instructions, structured control, label, block, branch, result type, label index, function index, type index, vector, polymorphism
    pair: text format; instruction

From c3e231e919b61942157e3ce6a351f45536e7b5f1 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Mon, 30 Jan 2023 20:24:28 +0100
Subject: [PATCH 241/285] Try bumping OCaml

---
 .github/workflows/main.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 00b70e8f0..214ba48d3 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -17,7 +17,7 @@ jobs:
       - name: Setup OCaml
         uses: ocaml/setup-ocaml@v2
         with:
-          ocaml-compiler: 4.12.x
+          ocaml-compiler: 4.13.x
       - run: opam install --yes ocamlbuild.0.14.0
       - run: cd interpreter && opam exec make all
 
@@ -28,7 +28,7 @@ jobs:
       - name: Setup OCaml
         uses: ocaml/setup-ocaml@v2
         with:
-          ocaml-compiler: 4.12.x
+          ocaml-compiler: 4.13.x
       - run: opam install --yes ocamlbuild.0.14.0 ocamlfind.1.9.5 js_of_ocaml.4.0.0 js_of_ocaml-ppx.4.0.0
       - run: cd interpreter && opam exec make wast.js
 

From a311f8adb6f9958a6a86caa808caaef24119a8dd Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Mon, 30 Jan 2023 20:38:47 +0100
Subject: [PATCH 242/285] Try bumping checkout

---
 .github/workflows/main.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 214ba48d3..fb5a9ec6d 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -13,7 +13,7 @@ jobs:
   ref-interpreter:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Setup OCaml
         uses: ocaml/setup-ocaml@v2
         with:

From abcab5d37374323f06650cda84aad776212bee65 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Mon, 30 Jan 2023 21:08:20 +0100
Subject: [PATCH 243/285] Adjust for multi-return

---
 document/core/valid/instructions.rst | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 3cd329546..5ef57ca1d 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -1520,17 +1520,17 @@ Control Instructions
 
 * The function :math:`C.\CFUNCS[x]` must be defined in the context.
 
-* Let :math:`[t_1^\ast] \to [t_2^?]` be the :ref:`function type <syntax-functype>` :math:`C.\CFUNCS[x]`.
+* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CFUNCS[x]`.
 
-* The :ref:`result type <syntax-resulttype>` :math:`[t_2^?]` must be the same as :math:`C.\CRETURN`.
+* The :ref:`result type <syntax-resulttype>` :math:`[t_2^\ast]` must be the same as :math:`C.\CRETURN`.
 
 * Then the instruction is valid with type :math:`[t_3^\ast~t_1^\ast] \to [t_4^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_3^\ast` and :math:`t_4^\ast`.
 
 .. math::
    \frac{
-     C.\CFUNCS[x] = [t_1^\ast] \to [t_2^?]
+     C.\CFUNCS[x] = [t_1^\ast] \to [t_2^\ast]
      \qquad
-     C.\CRETURN = [t_2^?]
+     C.\CRETURN = [t_2^\ast]
    }{
      C \vdashinstr \RETURNCALL~x : [t_3^\ast~t_1^\ast] \to [t_4^\ast]
    }
@@ -1554,9 +1554,9 @@ Control Instructions
 
 * The type :math:`C.\CTYPES[y]` must be defined in the context.
 
-* Let :math:`[t_1^\ast] \to [t_2^?]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[y]`.
+* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[y]`.
 
-* The :ref:`result type <syntax-resulttype>` :math:`[t_2^?]` must be the same as :math:`C.\CRETURN`.
+* The :ref:`result type <syntax-resulttype>` :math:`[t_2^\ast]` must be the same as :math:`C.\CRETURN`.
 
 * Then the instruction is valid with type :math:`[t_3^\ast~t_1^\ast~\I32] \to [t_4^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_3^\ast` and :math:`t_4^\ast`.
 
@@ -1565,9 +1565,9 @@ Control Instructions
    \frac{
      C.\CTABLES[x] = \limits~\FUNCREF
      \qquad
-     C.\CTYPES[y] = [t_1^\ast] \to [t_2^?]
+     C.\CTYPES[y] = [t_1^\ast] \to [t_2^\ast]
      \qquad
-     C.\CRETURN = [t_2^?]
+     C.\CRETURN = [t_2^\ast]
    }{
      C \vdashinstr \RETURNCALLINDIRECT~x~y : [t_3^\ast~t_1^\ast~\I32] \to [t_4^\ast]
    }

From 1f02322258b248bf770aa4fc5ea966665eb2acc1 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Mon, 30 Jan 2023 21:26:10 +0100
Subject: [PATCH 244/285] Tweak reduction rules

---
 document/core/exec/instructions.rst | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 3096760d5..75fea3e28 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -2848,7 +2848,7 @@ Control Instructions
 .. math::
    \begin{array}{lcl@{\qquad}l}
    (\RETURNCALL~x) &\stepto& (\RETURNINVOKE~a)
-     & (\iff \CALL~x \stepto \INVOKE~a)
+     & (\iff (\CALL~x) \stepto (\INVOKE~a))
    \end{array}
 
 
@@ -2900,10 +2900,10 @@ Control Instructions
 
 .. math::
    \begin{array}{lcl@{\qquad}l}
-   (\RETURNCALLINDIRECT~x) &\stepto& (\RETURNINVOKE~a)
-     & (\iff \CALLINDIRECT~x \stepto \INVOKE~a) \\
-   (\RETURNCALLINDIRECT~x) &\stepto& \TRAP
-     & (\iff \CALLINDIRECT~x \stepto \TRAP) \\
+   \val~(\RETURNCALLINDIRECT~x) &\stepto& (\RETURNINVOKE~a)
+     & (\iff \val~(\CALLINDIRECT~x) \stepto (\INVOKE~a)) \\
+   \val~(\RETURNCALLINDIRECT~x) &\stepto& \TRAP
+     & (\iff \val~(\CALLINDIRECT~x) \stepto \TRAP) \\
    \end{array}
 
 

From 8026a82e3c8f50cba7f1296f1357219851e02739 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Mon, 30 Jan 2023 21:26:55 +0100
Subject: [PATCH 245/285] Spec return_call_ref

---
 .../core/appendix/gen-index-instructions.py   |  2 +-
 document/core/binary/instructions.rst         |  1 +
 document/core/exec/instructions.rst           | 45 +++++++++++++++++--
 document/core/syntax/instructions.rst         |  5 ++-
 document/core/util/macros.def                 |  1 +
 document/core/valid/instructions.rst          | 23 ++++++++++
 interpreter/README.md                         | 11 +++--
 proposals/function-references/Overview.md     |  2 +-
 8 files changed, 76 insertions(+), 14 deletions(-)

diff --git a/document/core/appendix/gen-index-instructions.py b/document/core/appendix/gen-index-instructions.py
index 1eb4539ce..5cd519d42 100755
--- a/document/core/appendix/gen-index-instructions.py
+++ b/document/core/appendix/gen-index-instructions.py
@@ -90,7 +90,7 @@ def Instruction(name, opcode, type=None, validation=None, execution=None, operat
     Instruction(r'\RETURNCALL~x', r'\hex{12}', r'[t_1^\ast] \to [t_2^\ast]', r'valid-return_call', r'exec-return_call'),
     Instruction(r'\RETURNCALLINDIRECT~x', r'\hex{13}', r'[t_1^\ast~\I32] \to [t_2^\ast]', r'valid-return_call_indirect', r'exec-return_call_indirect'),
     Instruction(r'\CALLREF~x', r'\hex{14}', r'[t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]', r'valid-call_ref', r'exec-call_ref'),
-    Instruction(None, r'\hex{15}'),
+    Instruction(r'\RETURNCALLREF~x', r'\hex{15}', r'[t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]', r'valid-return_call_ref', r'exec-return_call_ref'),
     Instruction(None, r'\hex{16}'),
     Instruction(None, r'\hex{17}'),
     Instruction(None, r'\hex{18}'),
diff --git a/document/core/binary/instructions.rst b/document/core/binary/instructions.rst
index 95a84b141..175526bb8 100644
--- a/document/core/binary/instructions.rst
+++ b/document/core/binary/instructions.rst
@@ -71,6 +71,7 @@ Control Instructions
      \hex{12}~~x{:}\Bfuncidx &\Rightarrow& \RETURNCALL~x \\ &&|&
      \hex{13}~~y{:}\Btypeidx~~x{:}\Btableidx &\Rightarrow& \RETURNCALLINDIRECT~x~y \\ &&|&
      \hex{14}~~x{:}\Btypeidx &\Rightarrow& \CALLREF~x \\ &&|&
+     \hex{15}~~x{:}\Btypeidx &\Rightarrow& \RETURNCALLREF~x \\ &&|&
      \hex{D4}~~l{:}\Blabelidx &\Rightarrow& \BRONNULL~l \\ &&|&
      \hex{D6}~~l{:}\Blabelidx &\Rightarrow& \BRONNONNULL~l \\
    \end{array}
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 0c2d23921..35bc747e5 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -2842,15 +2842,24 @@ Control Instructions
 :math:`\CALLREF~x`
 ..................
 
-1. Assert: due to :ref:`validation <valid-call_ref>`, a :ref:`function reference <syntax-ref>` is on the top of the stack.
+1. Assert: due to :ref:`validation <valid-call_ref>`, a null or :ref:`function reference <syntax-ref>` is on the top of the stack.
 
-2. Pop the value :math:`\REFFUNCADDR~a` from the stack.
+2. Pop the reference value :math:`r` from the stack.
 
-3. :ref:`Invoke <exec-invoke>` the function instance at address :math:`a`.
+3. If :math:`r` is :math:`\REFNULL~\X{ht}`, then:
+
+    a. Trap.
+
+4. Assert: due to :ref:`validation <valid-call_ref>`, :math:`r` is a :ref:`function reference <syntax-ref>`.
+
+5. Let :math:`\REFFUNCADDR~a` be the reference :math:`r`.
+
+6. :ref:`Invoke <exec-invoke>` the function instance at address :math:`a`.
 
 .. math::
    \begin{array}{lcl@{\qquad}l}
-   F; (\REFFUNCADDR~a)~\CALLREF~x &\stepto& F; (\INVOKE~a)
+   F; (\REFFUNCADDR~a)~(\CALLREF~x) &\stepto& F; (\INVOKE~a) \\
+   F; (\REFNULL~\X{ht})~(\CALLREF~x) &\stepto& F; \TRAP \\
    \end{array}
 
 
@@ -2951,6 +2960,34 @@ Control Instructions
    \end{array}
 
 
+.. _exec-return_call_ref:
+
+:math:`\RETURNCALLREF~x`
+........................
+
+1. Assert: due to :ref:`validation <valid-return_call_ref>`, a :ref:`function reference <syntax-ref>` is on the top of the stack.
+
+2. Pop the reference value :math:`r` from the stack.
+
+3. If :math:`r` is :math:`\REFNULL~\X{ht}`, then:
+
+    a. Trap.
+
+4. Assert: due to :ref:`validation <valid-call_ref>`, :math:`r` is a :ref:`function reference <syntax-ref>`.
+
+5. Let :math:`\REFFUNCADDR~a` be the reference :math:`r`.
+
+6. :ref:`Tail-invoke <exec-return-invoke>` the function instance at address :math:`a`.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   \val~(\RETURNCALLREF~x) &\stepto& (\RETURNINVOKE~a)
+     & (\iff \val~(\CALLREF~x) \stepto (\INVOKE~a))
+   \val~(\RETURNCALLINDIRECT~x) &\stepto& \TRAP
+     & (\iff \val~(\CALLINDIRECT~x) \stepto \TRAP) \\
+   \end{array}
+
+
 .. _exec-return_call_indirect:
 
 :math:`\RETURNCALLINDIRECT~x`
diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index f1529f5a4..c9e4a892b 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -657,8 +657,9 @@ Instructions in this group affect the flow of control.
      \RETURN \\&&|&
      \CALL~\funcidx \\&&|&
      \CALLREF~\typeidx \\&&|&
-     \CALLINDIRECT~\tableidx~\typeidx \\
+     \CALLINDIRECT~\tableidx~\typeidx \\&&|&
      \RETURNCALL~\funcidx \\&&|&
+     \RETURNCALLREF~\funcidx \\&&|&
      \RETURNCALLINDIRECT~\tableidx~\typeidx \\
    \end{array}
 
@@ -708,7 +709,7 @@ The |CALLINDIRECT| instruction calls a function indirectly through an operand in
 Since it may contain functions of heterogeneous type,
 the callee is dynamically checked against the :ref:`function type <syntax-functype>` indexed by the instruction's second immediate, and the call is aborted with a :ref:`trap <trap>` if it does not match.
 
-The |RETURNCALL| and |RETURNCALLINDIRECT| instructions are *tail-call* variants of the previous ones.
+The |RETURNCALL|, |RETURNCALLREF|, and |RETURNCALLINDIRECT| instructions are *tail-call* variants of the previous ones.
 That is, they first return from the current function before actually performing the respective call.
 It is guaranteed that no sequence of nested calls using only these instructions can cause resource exhaustion due to hitting an :ref:`implementation's limit <impl-exec>` on the number of active calls.
 
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index cf8161b5f..8b37e8483 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -386,6 +386,7 @@
 .. |CALLREF| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{call\_ref}}
 .. |CALLINDIRECT| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{call\_indirect}}
 .. |RETURNCALL| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{return\_call}}
+.. |RETURNCALLREF| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{return\_call\_ref}}
 .. |RETURNCALLINDIRECT| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{return\_call\_indirect}}
 
 .. |DROP| mathdef:: \xref{syntax/instructions}{syntax-instr-parametric}{\K{drop}}
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 182ebd25c..1dfd2db22 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -1618,6 +1618,29 @@ Control Instructions
    The |RETURNCALL| instruction is :ref:`stack-polymorphic <polymorphism>`.
 
 
+.. _valid-call_ref:
+
+:math:`\RETURNCALLREF~x`
+........................
+
+* The type :math:`C.\CTYPES[x]` must be defined in the context.
+
+* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[x]`.
+
+* The :ref:`result type <syntax-resulttype>` :math:`[t_2^\ast]` must be the same as :math:`C.\CRETURN`.
+
+* Then the instruction is valid with type :math:`[t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]`.
+
+.. math::
+   \frac{
+     C.\CTYPES[x] = [t_1^\ast] \to [t_2^\ast]
+     \qquad
+     C.\CRETURN = [t_2^\ast]
+   }{
+     C \vdashinstr \CALLREF~x : [t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]
+   }
+
+
 .. _valid-return_call_indirect:
 
 :math:`\RETURNCALLINDIRECT~x~y`
diff --git a/interpreter/README.md b/interpreter/README.md
index 35f38321e..343875323 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -254,14 +254,13 @@ op:
   br_if <var>
   br_table <var>+
   br_on_null <var> <heap_type>
-  return
-  return_call <var>
-  return_call_indirect <func_type>
   call <var>
+  call_ref <var>
   call_indirect <var>? <func_type>
-  call_ref
-  return_call_ref
-  func.bind <func_type>
+  return
+  return_call <var>
+  return_call_ref <var>
+  return_call_indirect <var>? <func_type>
   local.get <var>
   local.set <var>
   local.tee <var>
diff --git a/proposals/function-references/Overview.md b/proposals/function-references/Overview.md
index 24e932370..03b7465ea 100644
--- a/proposals/function-references/Overview.md
+++ b/proposals/function-references/Overview.md
@@ -209,7 +209,7 @@ Note: Extending block types with index sets to allow initialization status to la
      - iff `$t = [t1*] -> [t2*]`
   - traps on `null`
 
-* With the [tail call proposal](https://github.com/WebAssembly/tail-call/blob/master/proposals/tail-call/Overview.md), there will also be `return_call_ref`:
+* `return_call_ref` tail-calls a function through a reference
   - `return_call_ref $t : [t1* (ref null $t)] -> [t2*]`
      - iff `$t = [t1*] -> [t2*]`
      - and `t2* <: C.result`

From 93755396900199f2756954e8abd2e36b982f68aa Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Mon, 30 Jan 2023 21:33:19 +0100
Subject: [PATCH 246/285] Fix

---
 document/core/appendix/index-instructions.rst | 2 +-
 document/core/exec/instructions.rst           | 6 +++---
 document/core/valid/instructions.rst          | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/document/core/appendix/index-instructions.rst b/document/core/appendix/index-instructions.rst
index f581773b4..6f59a3c2a 100644
--- a/document/core/appendix/index-instructions.rst
+++ b/document/core/appendix/index-instructions.rst
@@ -30,7 +30,7 @@ Instruction                                        Binary Opcode
 :math:`\RETURNCALL~x`                              :math:`\hex{12}`                      :math:`[t_1^\ast] \to [t_2^\ast]`                                :ref:`validation <valid-return_call>`           :ref:`execution <exec-return_call>`                               
 :math:`\RETURNCALLINDIRECT~x`                      :math:`\hex{13}`                      :math:`[t_1^\ast~\I32] \to [t_2^\ast]`                           :ref:`validation <valid-return_call_indirect>`  :ref:`execution <exec-return_call_indirect>`                      
 :math:`\CALLREF~x`                                 :math:`\hex{14}`                      :math:`[t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]`                 :ref:`validation <valid-call_ref>`              :ref:`execution <exec-call_ref>`                                  
-(reserved)                                         :math:`\hex{15}`                                                                                                                                                                                                         
+:math:`\RETURNCALLREF~x`                           :math:`\hex{15}`                      :math:`[t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]`                 :ref:`validation <valid-return_call_ref>`       :ref:`execution <exec-return_call_ref>`                           
 (reserved)                                         :math:`\hex{16}`                                                                                                                                                                                                         
 (reserved)                                         :math:`\hex{17}`                                                                                                                                                                                                         
 (reserved)                                         :math:`\hex{18}`                                                                                                                                                                                                         
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 35bc747e5..412db4bc5 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -2982,9 +2982,9 @@ Control Instructions
 .. math::
    \begin{array}{lcl@{\qquad}l}
    \val~(\RETURNCALLREF~x) &\stepto& (\RETURNINVOKE~a)
-     & (\iff \val~(\CALLREF~x) \stepto (\INVOKE~a))
-   \val~(\RETURNCALLINDIRECT~x) &\stepto& \TRAP
-     & (\iff \val~(\CALLINDIRECT~x) \stepto \TRAP) \\
+     & (\iff \val~(\CALLREF~x) \stepto (\INVOKE~a)) \\
+   \val~(\RETURNCALLREF~x) &\stepto& \TRAP
+     & (\iff \val~(\CALLREF~x) \stepto \TRAP) \\
    \end{array}
 
 
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 1dfd2db22..e35498d0c 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -1618,7 +1618,7 @@ Control Instructions
    The |RETURNCALL| instruction is :ref:`stack-polymorphic <polymorphism>`.
 
 
-.. _valid-call_ref:
+.. _valid-return_call_ref:
 
 :math:`\RETURNCALLREF~x`
 ........................

From 42ea1299a3c555e79d149bd53f2d98a93c37157e Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Mon, 30 Jan 2023 21:37:25 +0100
Subject: [PATCH 247/285] Text format

---
 document/core/text/instructions.rst | 1 +
 1 file changed, 1 insertion(+)

diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index 5f9389c93..1533c911c 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -128,6 +128,7 @@ All other control instruction are represented verbatim.
      \text{call\_indirect}~~x{:}\Ttableidx~~y,I'{:}\Ttypeuse_I &\Rightarrow& \CALLINDIRECT~x~y
        & (\iff I' = \{\ILOCALS~(\epsilon)^\ast\}) \\&&|&
      \text{return\_call}~~x{:}\Tfuncidx_I &\Rightarrow& \RETURNCALL~x \\ &&|&
+     \text{return\_call\_ref}~~x{:}\Ttypeidx &\Rightarrow& \RETURNCALLREF~x \\ &&|&
      \text{return\_call\_indirect}~~x{:}\Ttableidx~~y,I'{:}\Ttypeuse_I &\Rightarrow& \RETURNCALLINDIRECT~x~y
        & (\iff I' = \{\ILOCALS~(\epsilon)^\ast\}) \\
    \end{array}

From 45f9845d4ecb92984dd573c93b7143ad42726bf8 Mon Sep 17 00:00:00 2001
From: candymate <31069474+candymate@users.noreply.github.com>
Date: Tue, 31 Jan 2023 18:31:53 +0900
Subject: [PATCH 248/285] [spec] Fix typos in instruction index (#1584)

---
 document/core/appendix/gen-index-instructions.py | 8 ++++----
 document/core/appendix/index-instructions.rst    | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/document/core/appendix/gen-index-instructions.py b/document/core/appendix/gen-index-instructions.py
index 65a971715..fffa2b329 100755
--- a/document/core/appendix/gen-index-instructions.py
+++ b/document/core/appendix/gen-index-instructions.py
@@ -427,10 +427,10 @@ def Instruction(name, opcode, type=None, validation=None, execution=None, operat
     Instruction(r'\V128.\LOAD\K{16\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{55}', r'[\I32~\V128] \to [\V128]', r'valid-load-lane', r'exec-load-lane'),
     Instruction(r'\V128.\LOAD\K{32\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{56}', r'[\I32~\V128] \to [\V128]', r'valid-load-lane', r'exec-load-lane'),
     Instruction(r'\V128.\LOAD\K{64\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{57}', r'[\I32~\V128] \to [\V128]', r'valid-load-lane', r'exec-load-lane'),
-    Instruction(r'\V128.\STORE\K{8\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{58}', r'[\I32~\V128] \to [\V128]', r'valid-store-lane', r'exec-store-lane'),
-    Instruction(r'\V128.\STORE\K{16\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{59}', r'[\I32~\V128] \to [\V128]', r'valid-store-lane', r'exec-store-lane'),
-    Instruction(r'\V128.\STORE\K{32\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{5A}', r'[\I32~\V128] \to [\V128]', r'valid-store-lane', r'exec-store-lane'),
-    Instruction(r'\V128.\STORE\K{64\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{5B}', r'[\I32~\V128] \to [\V128]', r'valid-store-lane', r'exec-store-lane'),
+    Instruction(r'\V128.\STORE\K{8\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{58}', r'[\I32~\V128] \to []', r'valid-store-lane', r'exec-store-lane'),
+    Instruction(r'\V128.\STORE\K{16\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{59}', r'[\I32~\V128] \to []', r'valid-store-lane', r'exec-store-lane'),
+    Instruction(r'\V128.\STORE\K{32\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{5A}', r'[\I32~\V128] \to []', r'valid-store-lane', r'exec-store-lane'),
+    Instruction(r'\V128.\STORE\K{64\_lane}~\memarg~\laneidx', r'\hex{FD}~~\hex{5B}', r'[\I32~\V128] \to []', r'valid-store-lane', r'exec-store-lane'),
     Instruction(r'\V128.\LOAD\K{32\_zero}~\memarg~\laneidx', r'\hex{FD}~~\hex{5C}', r'[\I32] \to [\V128]', r'valid-load-zero', r'exec-load-zero'),
     Instruction(r'\V128.\LOAD\K{64\_zero}~\memarg~\laneidx', r'\hex{FD}~~\hex{5D}', r'[\I32] \to [\V128]', r'valid-load-zero', r'exec-load-zero'),
     Instruction(r'\F32X4.\VDEMOTE\K{\_f64x2\_zero}', r'\hex{FD}~~\hex{5E}', r'[\V128] \to [\V128]', r'valid-vcvtop', r'exec-vcvtop', r'op-demote'),
diff --git a/document/core/appendix/index-instructions.rst b/document/core/appendix/index-instructions.rst
index 84055a9fa..977c21fb3 100644
--- a/document/core/appendix/index-instructions.rst
+++ b/document/core/appendix/index-instructions.rst
@@ -367,10 +367,10 @@ Instruction                                        Binary Opcode
 :math:`\V128.\LOAD\K{16\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{55}`            :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
 :math:`\V128.\LOAD\K{32\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{56}`            :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
 :math:`\V128.\LOAD\K{64\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{57}`            :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
-:math:`\V128.\STORE\K{8\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{58}`            :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
-:math:`\V128.\STORE\K{16\_lane}~\memarg~\laneidx`  :math:`\hex{FD}~~\hex{59}`            :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
-:math:`\V128.\STORE\K{32\_lane}~\memarg~\laneidx`  :math:`\hex{FD}~~\hex{5A}`            :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
-:math:`\V128.\STORE\K{64\_lane}~\memarg~\laneidx`  :math:`\hex{FD}~~\hex{5B}`            :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
+:math:`\V128.\STORE\K{8\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{58}`            :math:`[\I32~\V128] \to []`                    :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
+:math:`\V128.\STORE\K{16\_lane}~\memarg~\laneidx`  :math:`\hex{FD}~~\hex{59}`            :math:`[\I32~\V128] \to []`                    :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
+:math:`\V128.\STORE\K{32\_lane}~\memarg~\laneidx`  :math:`\hex{FD}~~\hex{5A}`            :math:`[\I32~\V128] \to []`                    :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
+:math:`\V128.\STORE\K{64\_lane}~\memarg~\laneidx`  :math:`\hex{FD}~~\hex{5B}`            :math:`[\I32~\V128] \to []`                    :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
 :math:`\V128.\LOAD\K{32\_zero}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{5C}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-zero>`            :ref:`execution <exec-load-zero>`                                 
 :math:`\V128.\LOAD\K{64\_zero}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{5D}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-zero>`            :ref:`execution <exec-load-zero>`                                 
 :math:`\F32X4.\VDEMOTE\K{\_f64x2\_zero}`           :math:`\hex{FD}~~\hex{5E}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-demote>`       

From 947badf48a7e2b27aeec7a0eaad6b3053032d9f1 Mon Sep 17 00:00:00 2001
From: Bongjun Jang <bongjun.jang@kaist.ac.kr>
Date: Tue, 7 Feb 2023 17:00:10 +0900
Subject: [PATCH 249/285] [spec] Fix typo (#1587)

---
 document/core/text/instructions.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index e846ccb50..0e8c577de 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -165,7 +165,7 @@ Reference Instructions
    \production{instruction} & \Tplaininstr_I &::=& \dots \\ &&|&
      \text{ref.null}~~t{:}\Theaptype &\Rightarrow& \REFNULL~t \\ &&|&
      \text{ref.is\_null} &\Rightarrow& \REFISNULL \\ &&|&
-     \text{ref.func}~~x{:}\Tfuncidx &\Rightarrow& \REFFUNC~x \\ &&|&
+     \text{ref.func}~~x{:}\Tfuncidx &\Rightarrow& \REFFUNC~x \\
    \end{array}
 
 
@@ -891,7 +891,7 @@ Vector constant instructions have a mandatory :ref:`shape <syntax-vec-shape>` de
      \text{f64x2.convert\_low\_i32x4\_s} &\Rightarrow& \F64X2.\VCONVERT\K{\_low\_i32x4\_s}\\  &&|&
      \text{f64x2.convert\_low\_i32x4\_u} &\Rightarrow& \F64X2.\VCONVERT\K{\_low\_i32x4\_u}\\ &&|&
      \text{f32x4.demote\_f64x2\_zero} &\Rightarrow& \F32X4.\VDEMOTE\K{\_f64x2\_zero}\\ &&|&
-     \text{f64x2.promote\_low\_f32x4} &\Rightarrow& \F64X2.\VPROMOTE\K{\_low\_f32x4}\\ &&|&
+     \text{f64x2.promote\_low\_f32x4} &\Rightarrow& \F64X2.\VPROMOTE\K{\_low\_f32x4}\\
    \end{array}
 
 

From b1fbe1a89a812a031f556392185cb8d9c65beeb8 Mon Sep 17 00:00:00 2001
From: ShinWonho <50018375+ShinWonho@users.noreply.github.com>
Date: Wed, 8 Feb 2023 18:07:52 +0900
Subject: [PATCH 250/285] [spec] Remove inconsistent newline (#1589)

---
 document/core/exec/modules.rst | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index 4dfdb9735..578acfa29 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -449,8 +449,7 @@ and list of :ref:`reference <syntax-ref>` vectors for the module's :ref:`element
 
    a. Let :math:`\limits_i~t_i` be the :ref:`table type <syntax-tabletype>` :math:`\table_i.\TTYPE`.
 
-   b. Let :math:`\tableaddr_i` be the :ref:`table address <syntax-tableaddr>` resulting from :ref:`allocating <alloc-table>` :math:`\table_i.\TTYPE`
-   with initialization value :math:`\REFNULL~t_i`.
+   b. Let :math:`\tableaddr_i` be the :ref:`table address <syntax-tableaddr>` resulting from :ref:`allocating <alloc-table>` :math:`\table_i.\TTYPE` with initialization value :math:`\REFNULL~t_i`.
 
 4. For each :ref:`memory <syntax-mem>` :math:`\mem_i` in :math:`\module.\MMEMS`, do:
 

From 2b4222d04d33d7d69bdf7a54e018ce3a486d89b1 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Thu, 9 Feb 2023 10:24:19 +0100
Subject: [PATCH 251/285] [interpreter] Remove legacy bigarray linking (#1593)

---
 interpreter/Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interpreter/Makefile b/interpreter/Makefile
index 7820e6428..499b3a633 100644
--- a/interpreter/Makefile
+++ b/interpreter/Makefile
@@ -18,7 +18,7 @@ JSLIB =		wast
 WINMAKE =	winmake.bat
 
 DIRS =		util syntax binary text valid runtime exec script host main tests
-LIBS =		bigarray
+LIBS =		
 FLAGS = 	-lexflags -ml -cflags '-w +a-4-27-42-44-45-70 -warn-error +a-3'
 OCBA =		ocamlbuild $(FLAGS) $(DIRS:%=-I %)
 OCB =		$(OCBA) $(LIBS:%=-libs %)

From aa15776984dc41c5f07463297c02fc3f84185437 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=EC=84=9C=EB=8F=99=ED=9C=98?= <hwidongsuh@gmail.com>
Date: Fri, 10 Feb 2023 00:25:08 +0900
Subject: [PATCH 252/285] [spec] Show scrolls for overflow math blocks (#1594)

---
 document/core/static/custom.css | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/document/core/static/custom.css b/document/core/static/custom.css
index 45838c1e3..33bb863d4 100644
--- a/document/core/static/custom.css
+++ b/document/core/static/custom.css
@@ -44,6 +44,8 @@ div.admonition p.admonition-title {
 div.math {
   background-color: #F0F0F0;
   padding: 3px 0 3px 0;
+  overflow-x: auto;
+  overflow-y: hidden;
 }
 
 div.relations {

From 31cabf87f8e605d71933d724430831a841d2d298 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Thu, 9 Feb 2023 18:02:34 +0100
Subject: [PATCH 253/285] [interpreter] Run JS tests via node.js (#1595)

---
 .github/workflows/main.yml | 4 ++++
 interpreter/Makefile       | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 00b70e8f0..2e43f200a 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -19,6 +19,10 @@ jobs:
         with:
           ocaml-compiler: 4.12.x
       - run: opam install --yes ocamlbuild.0.14.0
+      - name: Setup Node.js
+        uses: actions/setup-node@v1
+        with:
+          node-version: 18.x
       - run: cd interpreter && opam exec make all
 
   ref-interpreter-js-library:
diff --git a/interpreter/Makefile b/interpreter/Makefile
index 499b3a633..78cbea556 100644
--- a/interpreter/Makefile
+++ b/interpreter/Makefile
@@ -23,7 +23,7 @@ FLAGS = 	-lexflags -ml -cflags '-w +a-4-27-42-44-45-70 -warn-error +a-3'
 OCBA =		ocamlbuild $(FLAGS) $(DIRS:%=-I %)
 OCB =		$(OCBA) $(LIBS:%=-libs %)
 JSO =		js_of_ocaml -q --opt 3
-JS =		# set to JS shell command to run JS tests
+JS =		node  # set to JS shell command to run JS tests, empty to skip
 
 
 # Main targets

From e7f6e1c45acc396281e31df78d8ad531ab65a2ee Mon Sep 17 00:00:00 2001
From: Jim Blandy <jimb@red-bean.com>
Date: Fri, 10 Feb 2023 17:46:52 -0800
Subject: [PATCH 254/285] [spec] Remove stray `x` indices (#1598)

---
 document/core/exec/instructions.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index cc66dbf2e..bf5acdfea 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -2244,7 +2244,7 @@ Memory Instructions
    S; F; (\I32.\CONST~d)~\val~(\I32.\CONST~n)~\MEMORYFILL
      \quad\stepto\quad S; F; \TRAP
      \\ \qquad
-     (\iff d + n > |S.\SMEMS[F.\AMODULE.\MIMEMS[x]].\MIDATA|)
+     (\iff d + n > |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA|)
    \\[1ex]
    S; F; (\I32.\CONST~d)~\val~(\I32.\CONST~0)~\MEMORYFILL
      \quad\stepto\quad S; F; \epsilon
@@ -2451,7 +2451,7 @@ Memory Instructions
      \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
      (\iff & s + n > |S.\SDATAS[F.\AMODULE.\MIDATAS[x]].\DIDATA| \\
-      \vee & d + n > |S.\SMEMS[F.\AMODULE.\MIMEMS[x]].\MIDATA|) \\[1ex]
+      \vee & d + n > |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA|) \\[1ex]
      \end{array}
    \\[1ex]
    S; F; (\I32.\CONST~d)~(\I32.\CONST~s)~(\I32.\CONST~0)~(\MEMORYINIT~x)

From f8ae6b2443a0f1e6ebc62e2fdbe49e2a98008a17 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Mon, 13 Feb 2023 12:43:34 +0100
Subject: [PATCH 255/285] [spec] Style tweak for cross-refs

---
 document/core/conf.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/document/core/conf.py b/document/core/conf.py
index 22a578a2d..3952701bd 100644
--- a/document/core/conf.py
+++ b/document/core/conf.py
@@ -297,7 +297,8 @@
   'pointsize': '10pt',
 
    # Additional stuff for the LaTeX preamble.
-   'preamble': '',
+   # Don't type-set cross references with emphasis.
+   'preamble': '\\renewcommand\\sphinxcrossref[1]{#1}\n',
 
    # Latex figure (float) alignment
   'figure_align': 'htbp',

From 0f068801d6bcd0219e5ede2a71fcde1d130e3853 Mon Sep 17 00:00:00 2001
From: Bongjun Jang <bongjun.jang@kaist.ac.kr>
Date: Mon, 13 Feb 2023 21:16:43 +0900
Subject: [PATCH 256/285] [spec] Style eps (#1601)

---
 document/core/text/lexical.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/text/lexical.rst b/document/core/text/lexical.rst
index f46646662..1dd34c863 100644
--- a/document/core/text/lexical.rst
+++ b/document/core/text/lexical.rst
@@ -48,7 +48,7 @@ The character stream in the source text is divided, from left to right, into a s
      \text{(} ~|~ \text{)} ~|~ \Treserved \\
    \production{keyword} & \Tkeyword &::=&
      (\text{a} ~|~ \dots ~|~ \text{z})~\Tidchar^\ast
-     \qquad (\mbox{if occurring as a literal terminal in the grammar}) \\
+     \qquad (\iff~\mbox{occurring as a literal terminal in the grammar}) \\
    \production{reserved} & \Treserved &::=&
      (\Tidchar ~|~ \Tstring)^+ \\
    \end{array}

From 3a882f26aecdf227d26ed6a34d14221b8c62faa1 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Sat, 11 Feb 2023 15:14:45 +0100
Subject: [PATCH 257/285] Separate subsumption from instr sequencing

---
 document/core/appendix/index-rules.rst |  1 +
 document/core/conf.py                  |  3 +-
 document/core/util/macros.def          |  2 +
 document/core/valid/instructions.rst   | 91 ++++++++++++++++----------
 document/core/valid/matching.rst       | 46 ++++++++++++-
 5 files changed, 107 insertions(+), 36 deletions(-)

diff --git a/document/core/appendix/index-rules.rst b/document/core/appendix/index-rules.rst
index 852296799..d4503a92b 100644
--- a/document/core/appendix/index-rules.rst
+++ b/document/core/appendix/index-rules.rst
@@ -106,6 +106,7 @@ Construct                                        Judgement
 :ref:`Reference type <match-reftype>`            :math:`C \vdashreftypematch \reftype_1 \matchesreftype \reftype_2`
 :ref:`Value type <match-valtype>`                :math:`C \vdashvaltypematch \valtype_1 \matchesvaltype \valtype_2`
 :ref:`Result type <match-resulttype>`            :math:`C \vdashresulttypematch \resulttype_1 \matchesresulttype \resulttype_2`
+:ref:`Instruction type <match-instrtype>`        :math:`C \vdashinstrtypematch \instrtype_1 \matchesinstrtype \instrtype_2`
 :ref:`Function type <match-functype>`            :math:`C \vdashfunctypematch \functype_1 \matchesfunctype \functype_2`
 :ref:`Table type <match-tabletype>`              :math:`C \vdashtabletypematch \tabletype_1 \matchestabletype \tabletype_2`
 :ref:`Memory type <match-memtype>`               :math:`C \vdashmemtypematch \memtype_1 \matchesmemtype \memtype_2`
diff --git a/document/core/conf.py b/document/core/conf.py
index 16799b4ea..2ae32adca 100644
--- a/document/core/conf.py
+++ b/document/core/conf.py
@@ -297,7 +297,8 @@
   'pointsize': '10pt',
 
    # Additional stuff for the LaTeX preamble.
-   'preamble': '',
+   # Don't type-set cross references with emphasis.
+   'preamble': '\\renewcommand\\sphinxcrossref[1]{#1}\n',
 
    # Latex figure (float) alignment
   'figure_align': 'htbp',
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index cf8161b5f..fce73cdc5 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -905,6 +905,7 @@
 .. |matchesreftype| mathdef:: \xref{valid/matching}{match-reftype}{\leq}
 .. |matchesvaltype| mathdef:: \xref{valid/matching}{match-valtype}{\leq}
 .. |matchesresulttype| mathdef:: \xref{valid/matching}{match-resulttype}{\leq}
+.. |matchesinstrtype| mathdef:: \xref{valid/matching}{match-instrtype}{\leq}
 .. |matchesfunctype| mathdef:: \xref{valid/matching}{match-functype}{\leq}
 .. |matchestabletype| mathdef:: \xref{valid/matching}{match-tabletype}{\leq}
 .. |matchesmemtype| mathdef:: \xref{valid/matching}{match-memtype}{\leq}
@@ -955,6 +956,7 @@
 .. |vdashreftypematch| mathdef:: \xref{valid/matching}{match-reftype}{\vdash}
 .. |vdashvaltypematch| mathdef:: \xref{valid/matching}{match-valtype}{\vdash}
 .. |vdashresulttypematch| mathdef:: \xref{valid/matching}{match-resulttype}{\vdash}
+.. |vdashinstrtypematch| mathdef:: \xref{valid/matching}{match-instrtype}{\vdash}
 .. |vdashfunctypematch| mathdef:: \xref{valid/matching}{match-functype}{\vdash}
 .. |vdashtabletypematch| mathdef:: \xref{valid/matching}{match-tabletype}{\vdash}
 .. |vdashmemtypematch| mathdef:: \xref{valid/matching}{match-memtype}{\vdash}
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 182ebd25c..de4bbfbc8 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -1280,7 +1280,7 @@ Control Instructions
 * Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the :ref:`result type <syntax-resulttype>` :math:`[t_2^\ast]` prepended to the |CLABELS| vector.
 
 * Under context :math:`C'`,
-  the instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]`, for any sequence of :ref:`local indices <syntax-localidx>` :math:`x^\ast`.
+  the instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[t_1^\ast] \to [t_2^\ast]`.
 
 * Then the compound instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`.
 
@@ -1288,7 +1288,7 @@ Control Instructions
    \frac{
      C \vdashblocktype \blocktype : [t_1^\ast] \to [t_2^\ast]
      \qquad
-     C,\CLABELS\,[t_2^\ast] \vdashinstrseq \instr^\ast : [t_1^\ast] \to_{x^\ast} [t_2^\ast]
+     C,\CLABELS\,[t_2^\ast] \vdashinstrseq \instr^\ast : [t_1^\ast] \to [t_2^\ast]
    }{
      C \vdashinstr \BLOCK~\blocktype~\instr^\ast~\END : [t_1^\ast] \to [t_2^\ast]
    }
@@ -1307,7 +1307,7 @@ Control Instructions
 * Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the :ref:`result type <syntax-resulttype>` :math:`[t_1^\ast]` prepended to the |CLABELS| vector.
 
 * Under context :math:`C'`,
-  the instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]`, for any sequence of :ref:`local indices <syntax-localidx>` :math:`x^\ast`.
+  the instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[t_1^\ast] \to [t_2^\ast]`.
 
 * Then the compound instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`.
 
@@ -1315,7 +1315,7 @@ Control Instructions
    \frac{
      C \vdashblocktype \blocktype : [t_1^\ast] \to [t_2^\ast]
      \qquad
-     C,\CLABELS\,[t_1^\ast] \vdashinstrseq \instr^\ast : [t_1^\ast] \to_{x^\ast} [t_2^\ast]
+     C,\CLABELS\,[t_1^\ast] \vdashinstrseq \instr^\ast : [t_1^\ast] \to [t_2^\ast]
    }{
      C \vdashinstr \LOOP~\blocktype~\instr^\ast~\END : [t_1^\ast] \to [t_2^\ast]
    }
@@ -1334,10 +1334,10 @@ Control Instructions
 * Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the :ref:`result type <syntax-resulttype>` :math:`[t_2^\ast]` prepended to the |CLABELS| vector.
 
 * Under context :math:`C'`,
-  the instruction sequence :math:`\instr_1^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[t_1^\ast] \to_{x_1^\ast} [t_2^\ast]`, for any sequence of :ref:`local indices <syntax-localidx>` :math:`x_1^\ast`.
+  the instruction sequence :math:`\instr_1^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[t_1^\ast] \to [t_2^\ast]`.
 
 * Under context :math:`C'`,
-  the instruction sequence :math:`\instr_2^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[t_1^\ast] \to_{x_2^\ast} [t_2^\ast]`, for any sequence of :ref:`local indices <syntax-localidx>` :math:`x_2^\ast`.
+  the instruction sequence :math:`\instr_2^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[t_1^\ast] \to [t_2^\ast]`.
 
 * Then the compound instruction is valid with type :math:`[t_1^\ast~\I32] \to [t_2^\ast]`.
 
@@ -1345,9 +1345,9 @@ Control Instructions
    \frac{
      C \vdashblocktype \blocktype : [t_1^\ast] \to [t_2^\ast]
      \qquad
-     C,\CLABELS\,[t_2^\ast] \vdashinstrseq \instr_1^\ast : [t_1^\ast] \to_{x_1^\ast} [t_2^\ast]
+     C,\CLABELS\,[t_2^\ast] \vdashinstrseq \instr_1^\ast : [t_1^\ast] \to [t_2^\ast]
      \qquad
-     C,\CLABELS\,[t_2^\ast] \vdashinstrseq \instr_2^\ast : [t_1^\ast] \to_{x_2^\ast} [t_2^\ast]
+     C,\CLABELS\,[t_2^\ast] \vdashinstrseq \instr_2^\ast : [t_1^\ast] \to [t_2^\ast]
    }{
      C \vdashinstr \IF~\blocktype~\instr_1^\ast~\ELSE~\instr_2^\ast~\END : [t_1^\ast~\I32] \to [t_2^\ast]
    }
@@ -1667,52 +1667,83 @@ Typing of instruction sequences is defined recursively.
 Empty Instruction Sequence: :math:`\epsilon`
 ............................................
 
-* The empty instruction sequence is valid with type :math:`[t^\ast] \to [t^\ast]`,
-  for any sequence of :ref:`value types <syntax-valtype>` :math:`t^\ast`.
+* The empty instruction sequence is valid with type :math:`[] \to []`.
 
 .. math::
    \frac{
    }{
-     C \vdashinstrseq \epsilon : [t^\ast] \to [t^\ast]
+     C \vdashinstrseq \epsilon : [] \to []
    }
 
 
 Non-empty Instruction Sequence: :math:`\instr~{\instr'}^\ast`
 .............................................................
 
-* The instruction :math:`\instr` must be valid with some type :math:`[t_1^\ast] \to_{x_1^\ast} [t_0^\ast]`.
+* The instruction :math:`\instr` must be valid with some type :math:`[t_1^\ast] \to_{x_1^\ast} [t_2^\ast]`.
 
 * Let :math:`C'` be the same :ref:`context <context>` as :math:`C`,
   but with:
 
   * |CLOCALS| the same as in C, except that for every :ref:`local index <syntax-localidx>` :math:`x` in :math:`x_1^\ast`, the :ref:`local type <syntax-localtype>` :math:`\CLOCALS[x]` has been updated to :ref:`initialization status <syntax-init>` :math:`\SET`.
 
-* The instruction sequence :math:`{\instr'}^\ast` must be valid with some type :math:`[{t'}^\ast] \to_{x_2^\ast} [t_3^\ast]`.
+* Under the context :math:`C'`, the instruction sequence :math:`{\instr'}^\ast` must be valid with some type :math:`[t_2^\ast] \to_{x_2^\ast} [t_3^\ast]`.
 
-* There must be a sequence of :ref:`value types <syntax-valtype>` :math:`t_0^\ast`,
-  such that :math:`t_0^\ast = t_2^\ast~t^\ast` where the type sequence :math:`t^\ast` is as long as :math:`{t'}^\ast`.
+* Then the combined instruction sequence is valid with type :math:`[t_1^\ast] \to_{x_1^\ast x_2^\ast} [t_3^\ast]`.
 
-* For each :ref:`value type <syntax-valtype>` :math:`t'_i` in :math:`{t'}^\ast` and corresponding type :math:`t_i` in :math:`t^\ast`, the type :math:`t_i` must :ref:`match <match-valtype>` :math:`t'_i`.
+.. math::
+   \frac{
+     \begin{array}{@{}l@{\qquad}l@{}}
+     C \vdashinstr \instr : [t_1^\ast] \to_{x_1^\ast} [t_2^\ast]
+     &
+     (C.\CLOCALS[x_1] = \init~t)^\ast
+     \\
+     C' \vdashinstrseq {\instr'}^\ast : [t_2^\ast] \to_{x_2^\ast} [t_3^\ast]
+     &
+     C' = C~(\with C.\CLOCALS[x_1] = \SET~t)^\ast
+     \end{array}
+   }{
+     C \vdashinstrseq \instr~{\instr'}^\ast : [t_1^\ast] \to_{x_1^\ast x_2^\ast} [t_2^\ast~t_3^\ast]
+   }
+
+
+Subsumption for :math:`\instr^\ast`
+...................................
+
+* The instruction sequence :math:`\instr^\ast` must be valid with some type :math:`\instrtype`.
+
+* The instruction type :math:`\instrtype'`: must be a :ref:`valid <valid-instrtype>`
+
+* The instruction type :math:`\instrtype` must :ref:`match <match-instrtype>` the type :math:`\instrtype'`.
 
-* Then the combined instruction sequence is valid with type :math:`[t_1^\ast] \to_{x_1^\ast x_2^\ast} [t_2^\ast~t_3^\ast]`.
+* Then the instruction sequence :math:`\instr^\ast` is also valid with type :math:`\instrtype'`.
 
 .. math::
    \frac{
      \begin{array}{@{}c@{}}
-     C \vdashinstr \instr : [t_1^\ast] \to_{x_1^\ast} [t_2^\ast~t^\ast]
+     C \vdashinstr \instr : \instrtype
      \qquad
-     (C \vdashvaltypematch t \matchesvaltype t')^\ast
+     C \vdashinstrtype \instrtype' \ok
      \qquad
-     C' \vdashinstrseq {\instr'}^\ast : [{t'}^\ast] \to_{x_2^\ast} [t_3^\ast]
-     \\
-     (\init~t = C.\CLOCALS[x_1])^\ast
-     \qquad
-     C' = C~(\with C.\CLOCALS[x_1] = \SET~t)^\ast
+     C \vdashinstrtypematch \instrtype \matchesinstrtype \instrtype'
      \end{array}
    }{
-     C \vdashinstrseq \instr~{\instr'}^\ast : [t_1^\ast] \to_{x_1^\ast x_2^\ast} [t_2^\ast~t_3^\ast]
+     C \vdashinstrseq \instr^\ast : \instrtype'
    }
 
+.. note::
+   In combination with the previous rule,
+   subsumption allows to compose instructions whose types would not directly fit otherwise.
+   For example, consider the instruction sequence
+
+   .. math::
+      (\I32.\CONST~1)~(\I32.\CONST~1)~\I32.\ADD
+
+   To type this sequence, its subsequence :math:`(\I32.\CONST~1)~\I32.\ADD` needs to be valid with an intermediate type.
+   But the direct type of :math:`(\I32.\CONST~1)` is :math:`[] \to [\I32]`, not matching the two inputs expected by :math:`\I32.\ADD`.
+   The subsumption rule allows to weaken the type of :math:`(\I32.\CONST~1)` to the supertype :math:`[\I32] \to [\I32~\I32]`, such that it can be composed with :math:`\I32.\ADD` and yields the intermediate type :math:`[\I32] \to [\I32]` for the subsequence. That can in turn be composed with the first constant.
+
+   Furthermore, subsumption allows to drop init variables :math:`x^\ast` from the instruction type in a context where they are not needed, for example, at the end of the body of a :ref:`block <valid-block>`.
+
 
 .. index:: expression, result type
    pair: validation; expression
@@ -1729,19 +1760,13 @@ Expressions :math:`\expr` are classified by :ref:`result types <syntax-resulttyp
 :math:`\instr^\ast~\END`
 ........................
 
-* The instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with some :ref:`type <syntax-instrtype>` :math:`[] \to_{x^\ast} [{t'}^\ast]`.
-
-* For each :ref:`value type <syntax-valtype>` :math:`t'_i` in :math:`{t'}^\ast` and corresponding :ref:`valid <valid-valtype>` :ref:`value type <syntax-valtype>` type :math:`t_i` in :math:`t^\ast`, :math:`t'_i` :ref:`matches <match-valtype>` :math:`t_i`.
+* The instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with :ref:`type <syntax-instrtype>` :math:`[] \to [t^\ast]`.
 
 * Then the expression is valid with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`.
 
 .. math::
    \frac{
-     C \vdashinstrseq \instr^\ast : [] \to_{x^\ast} [{t'}^\ast]
-     \qquad
-     C \vdashresulttype [t^\ast] \ok
-     \qquad
-     (C \vdashvaltypematch t' \matchesvaltype t)^\ast
+     C \vdashinstrseq \instr^\ast : [] \to [t^\ast]
    }{
      C \vdashexpr \instr^\ast~\END : [t^\ast]
    }
diff --git a/document/core/valid/matching.rst b/document/core/valid/matching.rst
index 4c1c6fa45..2a4a9bdd3 100644
--- a/document/core/valid/matching.rst
+++ b/document/core/valid/matching.rst
@@ -1,10 +1,11 @@
-.. index:: ! matching, subtyping
+.. index:: ! matching, ! subtyping
+.. _subtyping:
 .. _match:
 
 Matching
 --------
 
-On most types, a simple notion of subtyping is defined that is applicable in validation rules or during :ref:`module instantiation <exec-instantiation>` when checking the types of imports.
+On most types, a simple notion of *subtyping* is defined that is applicable in validation rules or during :ref:`module instantiation <exec-instantiation>` when checking the types of imports.
 
 
 .. index:: number type
@@ -152,6 +153,47 @@ That is, a :ref:`result type <syntax-resulttype>` :math:`[t_1^\ast]` matches a :
    }
 
 
+.. index:: instruction type, result type
+.. _match-instrtype:
+
+Instruction Types
+~~~~~~~~~~~~~~~~~
+
+Subtyping is further lifted to :ref:`instruction types <syntax-instrtype>`.
+An :ref:`instruction type <syntax-instrtype>` :math:`[t_{11}^\ast] \to_{x_1^\ast} [t_{12}^\ast]` matches a type :math:`[t_{21}^ast] \to_{x_2^\ast} [t_{22}^\ast]` if and only if:
+
+* There is a common sequence of :ref:`value types <syntax-valtype>` :math:`t^\ast` such that :math:`t_{21}^\ast` equals :math:`t^\ast~{t'_{21}}^\ast` and :math:`t_{22}^\ast` equals :math:`t^\ast~{t'_{22}}^\ast`.
+
+* The :ref:`result type <syntax-resulttype>` :math:`[{t'_{21}}^\ast]` :ref:`matches <match-resulttype>` :math:`[t_{11}^\ast]`.
+
+* The :ref:`result type <syntax-resulttype>` :math:`[t_{12}^\ast]` :ref:`matches <match-resulttype>` :math:`[{t'_{22}}^\ast]`.
+
+* For every :ref:`local index <syntax-localidx>` :math:`x` that is in :math:`x_2^\ast` but not in :math:`x_1^\ast`, the :ref:`local type <syntax-localtype>` :math:`C.\CLOCALS[x]` is :math:`\SET~t_x` for some :ref:`value type <syntax-valtype>` :math:`t_x`.
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+     \begin{array}{@{}c@{\qquad}l@{}}
+     C \vdashresulttypematch [t_{21}^\ast] \matchesresulttype [t_{11}^\ast]
+     &
+     \{ x^\ast \} = \{ x_2^\ast \} \setminus \{ x_1^\ast \}
+     \\
+     C \vdashresulttypematch [t_{12}^\ast] \matchesresulttype [t_{22}^\ast]
+     &
+     (C.\CLOCALS[x] = \SET~t_x)^\ast
+     \end{array}
+   }{
+     C \vdashinstrtypematch [t_{11}^\ast] \to_{x_1^\ast} [t_{12}^\ast] \matchesinstrtype [t^\ast~t_{21}^\ast] \to_{x_2^\ast} [t^\ast~t_{22}^\ast]
+   }
+
+.. note::
+   Instruction types are contravariant in their input and covariant in their output.
+   Subtyping also incorporates a sort of "frame" condition, which allows adding arbitrary invariant stack elements on both sides in the super type.
+
+   Finally, the supertype may ignore variables from the init set :math:`x_1^\ast`.
+   It may also *add* variables to the init set, provided these are already set in the context, i.e., are vacuously initialized.
+
+
 .. index:: function type, result type
 .. _match-functype:
 

From d594579c28e3bd74d1312292afeadc10f105163f Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Sat, 11 Feb 2023 15:14:45 +0100
Subject: [PATCH 258/285] State principal types

---
 document/core/appendix/index.rst      |  2 +-
 document/core/appendix/properties.rst | 67 ++++++++++++++++++++++++++-
 2 files changed, 66 insertions(+), 3 deletions(-)

diff --git a/document/core/appendix/index.rst b/document/core/appendix/index.rst
index c4173e955..448dbcb2f 100644
--- a/document/core/appendix/index.rst
+++ b/document/core/appendix/index.rst
@@ -8,9 +8,9 @@ Appendix
 
    embedding
    implementation
+   properties
    algorithm
    custom
-   properties
    changes
 
 .. only:: singlehtml
diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index baff1b13e..948a674e1 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -1,8 +1,8 @@
 .. index:: ! soundness, type system
 .. _soundness:
 
-Soundness
----------
+Type Soundness
+--------------
 
 The :ref:`type system <type-system>` of WebAssembly is *sound*, implying both *type safety* and *memory safety* with respect to the WebAssembly semantics. For example:
 
@@ -1006,3 +1006,66 @@ Consequently, given a :ref:`valid store <valid-store>`, no computation defined b
 .. [#cite-fm2021]
    Machine-verified formalizations and soundness proofs of the semantics from the official specification are described in the following article:
    Conrad Watt, Xiaojia Rao, Jean Pichon-Pharabod, Martin Bodin, Philippa Gardner. |FM2021|_. Proceedings of the 24th International Symposium on Formal Methods (FM 2021). Springer 2021.
+
+
+.. index:: ! principal types, type system, subtyping, polymorphism, instruction, syntax
+.. _principal:
+
+Principal Types
+---------------
+
+The :ref:`type system <type-system>` of WebAssembly features both :ref:`subtyping <match>` and simple forms of :ref:`polymorphism <polymorphism>` for :ref:`instruction types <syntax-instrtype>`.
+That has the effect that every instruction or instruction sequence can be classified with multiple different instruction types.
+
+However, the typing rules still allow deriving *principal types* for instruction sequences.
+That is, every valid instruction sequence has one particular type scheme, possibly containing some unconstrained place holder *type variables*, that is a subtype of all its valid instruction types, after substituting its type variables with suitable specific types.
+
+Moreover, when deriving an instruction type in a "forward" manner, i.e., the *input* of the instruction sequence is already fixed to specific types,
+then it has a principal *output* type expressible without type variables, up to a possibly :ref:`polymorphic stack <polymorphism>` bottom representable with one single variable.
+In other words, "forward" principal types are effectively *closed*.
+
+.. note::
+   For example, in isolation, the instruction :math:`\REFASNONNULL` has the type :math:`[(\REF~\NULL~\X{ht})] \to [(\REF~\X{ht})]` for any choice of valid :ref:`heap type <syntax-type>` :math:`\X{ht}`.
+   Moreover, if the input type :math:`[(\REF~\NULL~\X{ht})]` is already determined, i.e., a specific :math:`\X{ht}` is given, then the output type :math:`[(\REF~\X{ht})]` is fully determined as well.
+
+   The implication of the latter property is that a validator for *complete* instruction sequences (as they occur in valid modules) can be implemented with a simple left-to-right :ref:`algorithm <algo-valid>` that does not require the introduction of type variables.
+
+   A typing algorithm capable of handling *partial* instruction sequences (as might be considered for program analysis or program manipulation)
+   needs to introduce type variables and perform substitutions,
+   but it does not need to perform backtracking or record any non-syntactic constraints on these type variables.
+
+Technically, the :ref:`syntax <syntax-type>` of :ref:`heap <syntax-heaptype>`, :ref:`value <syntax-valtype>`, and :ref:`result <syntax-resulttype>` types can be enriched with type variables as follows:
+
+.. math::
+   \begin{array}{llll}
+   \production{heap type} & \heaptype &::=&
+     \dots ~|~ \alpha_{\heaptype} \\
+   \production{value type} & \valtype &::=&
+     \dots ~|~ \alpha_{\valtype} ~|~ \alpha_{\X{numvectype}} \\
+   \production{result type} & \resulttype &::=&
+     [\alpha_{\valtype^\ast}~\valtype^\ast] \\
+   \end{array}
+
+where each :math:`\alpha_{\X{xyz}}` ranges over a set of type variables for syntactic class :math:`\X{xyz}`, respectively.
+The special class :math:`\X{numvectype}` is defined as :math:`\numtype ~|~ \vectype ~|~ \BOT`,
+and is only needed to handle unannotated |SELECT| instructions.
+
+A type is *closed* when it does not contain any type variables, and *open* otherwise.
+A *type substitution* :math:`\sigma` is a finite mapping from type variables to closed types of the respective syntactic class.
+When applied to an open type, it replaces the type variables :math:`\alpha` from its domain with the respective :math:`\sigma(\alpha)`.
+
+**Theorem (Principal Types).**
+If an instruction sequence :math:`\instr^\ast` is :ref:`valid <valid-config>` with some closed :ref:`instruction type <syntax-instrtype>` :math:`\instrtype` (i.e., :math:`C \vdashinstrseq \instr^\ast : \instrtype`),
+then it is also valid with a possibly open instruction type :math:`\instrtype_{\min}` (i.e., :math:`C \vdashinstrseq \instr^\ast : \instrtype_{\min}`),
+such that for *every* closed type :math:`\instrtype'` with which :math:`\instr^\ast` is valid (i.e., for all :math:`C \vdashinstrseq \instr^\ast : \instrtype'`),
+there exists a substitution :math:`\sigma`,
+such that :math:`\sigma(\instrtype_{\min})` is a subtype of :math:`\instrtype'` (i.e., :math:`C \vdashinstrtypematch \sigma(\instrtype_{\min}) \matchesinstrtype \instrtype'`).
+Furthermore, :math:`\instrtype_{\min}` is unique up to the choice of type variables.
+
+**Theorem (Closed Principal Forward Types).**
+If closed input type :math:`[t_1^\ast]` is given and the instruction sequence :math:`\instr^\ast` is :ref:`valid <valid-config>` with :ref:`instruction type <syntax-instrtype>` :math:`[t_1^\ast] \to_{{\!x^\ast}} [t_2^\ast]` (i.e., :math:`C \vdashinstrseq \instr^\ast : [t_1^\ast] \to_{{\!x^\ast}} [t_2^\ast]`),
+then it is also valid with instruction type :math:`[t_1^\ast] \to_{{\!x^\ast}} [\alpha_{\valtype^\ast}~t^\ast]` (i.e., :math:`C \vdashinstrseq \instr^\ast : [t_1^\ast] \to_{\!x^\ast} [\alpha_{\valtype^\ast}~t^\ast]`),
+where all :math:`t^\ast` are closed,
+such that for *every* closed result type :math:`[{t'_2}^\ast]` with which :math:`\instr^\ast` is valid (i.e., for all :math:`C \vdashinstrseq \instr^\ast : [t_1^\ast] \to_{\!x^\ast} [{t'_2}^\ast]`),
+there exists a substitution :math:`\sigma`,
+such that :math:`[{t'_2}^\ast] = [\sigma(\alpha_{\valtype^\ast})~t^\ast]`.

From 138095cfe371ad69e08742c16066e3d19b5f7c2b Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 15 Feb 2023 17:22:13 +0100
Subject: [PATCH 259/285] Add statements about glbs, lubs, and disjoint
 hierarchies

---
 document/core/appendix/properties.rst | 64 +++++++++++++++++++++++++--
 1 file changed, 61 insertions(+), 3 deletions(-)

diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index 948a674e1..d30ae8bb2 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -1008,11 +1008,16 @@ Consequently, given a :ref:`valid store <valid-store>`, no computation defined b
    Conrad Watt, Xiaojia Rao, Jean Pichon-Pharabod, Martin Bodin, Philippa Gardner. |FM2021|_. Proceedings of the 24th International Symposium on Formal Methods (FM 2021). Springer 2021.
 
 
+.. index:: type system
+
+Type System Properties
+----------------------
+
 .. index:: ! principal types, type system, subtyping, polymorphism, instruction, syntax
-.. _principal:
+.. _principality:
 
 Principal Types
----------------
+~~~~~~~~~~~~~~~
 
 The :ref:`type system <type-system>` of WebAssembly features both :ref:`subtyping <match>` and simple forms of :ref:`polymorphism <polymorphism>` for :ref:`instruction types <syntax-instrtype>`.
 That has the effect that every instruction or instruction sequence can be classified with multiple different instruction types.
@@ -1043,7 +1048,7 @@ Technically, the :ref:`syntax <syntax-type>` of :ref:`heap <syntax-heaptype>`, :
    \production{value type} & \valtype &::=&
      \dots ~|~ \alpha_{\valtype} ~|~ \alpha_{\X{numvectype}} \\
    \production{result type} & \resulttype &::=&
-     [\alpha_{\valtype^\ast}~\valtype^\ast] \\
+     [\alpha_{\valtype^\ast}^?~\valtype^\ast] \\
    \end{array}
 
 where each :math:`\alpha_{\X{xyz}}` ranges over a set of type variables for syntactic class :math:`\X{xyz}`, respectively.
@@ -1069,3 +1074,56 @@ where all :math:`t^\ast` are closed,
 such that for *every* closed result type :math:`[{t'_2}^\ast]` with which :math:`\instr^\ast` is valid (i.e., for all :math:`C \vdashinstrseq \instr^\ast : [t_1^\ast] \to_{\!x^\ast} [{t'_2}^\ast]`),
 there exists a substitution :math:`\sigma`,
 such that :math:`[{t'_2}^\ast] = [\sigma(\alpha_{\valtype^\ast})~t^\ast]`.
+
+
+.. index:: ! type lattice, subtyping, least upper bound, greatest lower bound
+
+Type Lattice
+~~~~~~~~~~~~
+
+The :ref:`Principal Types <principality>` property depends on the existence of a *greatest lower bound* for any pair of types.
+
+**Theorem (Greatest Lower Bounds for Value Types).**
+For any two value types :math:`t_1` and :math:`t_2` that are :ref:`valid <valid-valtype>`
+(i.e., :math:`C \vdashvaltype t_1 \ok` and :math:`C \vdashvaltype t_2 \ok`),
+there exists a valid value type :math:`t` that is a subtype of both :math:`t_1` and :math:`t_2`
+(i.e., :math:`C \vdashvaltype t \ok` and :math:`C \vdashvaltypematch t \matchesvaltype t_1` and :math:`C \vdashvaltypematch t \matchesvaltype t_2`),
+such that *every* valid value type :math:`t'` that also is a subtype of both :math:`t_1` and :math:`t_2`
+(i.e., for all :math:`C \vdashvaltype t' \ok` and :math:`C \vdashvaltypematch t' \matchesvaltype t_1` and :math:`C \vdashvaltypematch t' \matchesvaltype t_2`),
+is a subtype of :math:`t`
+(i.e., :math:`C \vdashvaltypematch t' \matchesvaltype t`).
+
+.. note::
+   The greatest lower bound of two types may be |BOT|.
+
+**Theorem (Conditional Least Upper Bounds for Value Types).**
+Any two value types :math:`t_1` and :math:`t_2` that are :ref:`valid <valid-valtype>`
+(i.e., :math:`C \vdashvaltype t_1 \ok` and :math:`C \vdashvaltype t_2 \ok`)
+either have no common supertype,
+or there exists a valid value type :math:`t` that is a supertype of both :math:`t_1` and :math:`t_2`
+(i.e., :math:`C \vdashvaltype t \ok` and :math:`C \vdashvaltypematch t_1 \matchesvaltype t` and :math:`C \vdashvaltypematch t_2 \matchesvaltype t`),
+such that *every* valid value type :math:`t'` that also is a supertype of both :math:`t_1` and :math:`t_2`
+(i.e., for all :math:`C \vdashvaltype t' \ok` and :math:`C \vdashvaltypematch t_1 \matchesvaltype t'` and :math:`C \vdashvaltypematch t_2 \matchesvaltype t'`),
+is a supertype of :math:`t`
+(i.e., :math:`C \vdashvaltypematch t \matchesvaltype t'`).
+
+.. note::
+   If a top type was added to the type system,
+   a least upper bound would exist for any two types.
+
+**Corollary (Type Lattice).**
+Assuming the addition of a provisional top type,
+:ref:`value types <syntax-valtype>` form a lattice with respect to their :ref:`subtype <match-valtype>` relation.
+
+Finally, value types can be partitioned into multiple disjoint hierarchies that are not related by subtyping, except through |BOT|.
+
+**Theorem (Disjoint Subtype Hierarchies).**
+The greatest lower bound of two :ref:`value types <syntax-valtype>` is :math:`\BOT` or :math:`\REF~\BOT`
+if and only if they do not have a least upper bound.
+
+In other words, types that do not have common supertypes,
+do not have common subtypes either (other than :math:`\BOT` or :math:`\REF~\BOT`), and vice versa.
+
+.. note::
+   Types from disjoint hierarchies can safely be represented in mutually incompatible ways in an implementation,
+   because their values can never flow to the same place.

From 975aaf75a772adbbf53fe25df0eea2ff5c5cc5e1 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 15 Feb 2023 17:26:03 +0100
Subject: [PATCH 260/285] Add missing bot

---
 document/core/syntax/types.rst | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index c8994a2d7..41bae4e25 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -129,7 +129,7 @@ Heap Types
 .. math::
    \begin{array}{llll}
    \production{heap type} & \heaptype &::=&
-     \FUNC ~|~ \EXTERN ~|~ \typeid \\
+     \FUNC ~|~ \EXTERN ~|~ \typeid ~|~ \BOT \\
    \end{array}
 
 The type |FUNC| denotes the infinite union of all types of :ref:`functions <syntax-func>`, regardless of their concrete :ref:`function types <syntax-functype>`.
@@ -138,6 +138,10 @@ The type |EXTERN| denotes the infinite union of all objects owned by the :ref:`e
 
 A *concrete* heap type consists of a :ref:`type identifier <syntax-typeid>` and classifies an object of the respective :ref:`type <syntax-type>` defined in some module.
 
+The type :math:`\BOT` is a :ref:`subtype <match-heaptype>` of all other heap types.
+By virtue of being representable in neither the :ref:`binary format <binary-valtype>` nor the :ref:`text format <text-valtype>`, it cannot be used in a program;
+it only occurs during :ref:`validation <valid>`, as a part of a possible operand type for instructions.
+
 
 .. index:: ! reference type, heap type, reference, table, function, function type, null
    pair: abstract syntax; reference type
@@ -177,7 +181,7 @@ Value Types
 *Value types* classify the individual values that WebAssembly code can compute with and the values that a variable accepts.
 They are either :ref:`number types <syntax-numtype>`, :ref:`vector types <syntax-vectype>`, :ref:`reference types <syntax-reftype>`, or the unique *bottom type*, written :math:`\BOT`.
 
-The type :math:`\BOT` is a :ref:`subtype <match-valtype>` of all other types.
+The type :math:`\BOT` is a :ref:`subtype <match-valtype>` of all other value types.
 By virtue of being representable in neither the :ref:`binary format <binary-valtype>` nor the :ref:`text format <text-valtype>`, it cannot be used in a program;
 it only occurs during :ref:`validation <valid>`, as a possible operand type for instructions.
 

From 328e425226dad03539ec0a3891fe0ba6426cc62c Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Thu, 16 Feb 2023 07:00:49 +0100
Subject: [PATCH 261/285] [spec] Clarify that atoms can be symbolic (#1602)

---
 document/core/syntax/conventions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/syntax/conventions.rst b/document/core/syntax/conventions.rst
index 9e5dca182..5eeff48cd 100644
--- a/document/core/syntax/conventions.rst
+++ b/document/core/syntax/conventions.rst
@@ -20,7 +20,7 @@ Grammar Notation
 
 The following conventions are adopted in defining grammar rules for abstract syntax.
 
-* Terminal symbols (atoms) are written in sans-serif font: :math:`\K{i32}, \K{end}`.
+* Terminal symbols (atoms) are written in sans-serif font or in symbolic form: :math:`\K{i32}, \K{end}, {\to}, [, ]`.
 
 * Nonterminal symbols are written in italic font: :math:`\X{valtype}, \X{instr}`.
 

From deeb164186d17bdb8a5234c3639e143a8cf71700 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Thu, 16 Feb 2023 11:46:44 +0100
Subject: [PATCH 262/285] [test] Import v128 global (#1597)

---
 .github/workflows/main.yml |  2 +-
 interpreter/Makefile       |  2 +-
 test/core/linking.wast     | 14 ++++++++++++++
 3 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 2e43f200a..0ff1bd5fb 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -23,7 +23,7 @@ jobs:
         uses: actions/setup-node@v1
         with:
           node-version: 18.x
-      - run: cd interpreter && opam exec make all
+      - run: cd interpreter && opam exec make JS=node all
 
   ref-interpreter-js-library:
     runs-on: ubuntu-latest
diff --git a/interpreter/Makefile b/interpreter/Makefile
index 78cbea556..97e6e17c2 100644
--- a/interpreter/Makefile
+++ b/interpreter/Makefile
@@ -23,7 +23,7 @@ FLAGS = 	-lexflags -ml -cflags '-w +a-4-27-42-44-45-70 -warn-error +a-3'
 OCBA =		ocamlbuild $(FLAGS) $(DIRS:%=-I %)
 OCB =		$(OCBA) $(LIBS:%=-libs %)
 JSO =		js_of_ocaml -q --opt 3
-JS =		node  # set to JS shell command to run JS tests, empty to skip
+JS =		# set to JS shell command to run JS tests, empty to skip
 
 
 # Main targets
diff --git a/test/core/linking.wast b/test/core/linking.wast
index 994e0f49d..578a8c188 100644
--- a/test/core/linking.wast
+++ b/test/core/linking.wast
@@ -129,6 +129,20 @@
 )
 
 
+(module
+  (global (export "g-v128") v128 (v128.const i64x2 0 0))
+  (global (export "mg-v128") (mut v128) (v128.const i64x2 0 0))
+)
+(register "Mv128")
+
+(module
+  ;; TODO: Reactivate once the fix for https://bugs.chromium.org/p/v8/issues/detail?id=13732
+  ;; has made it to the downstream node.js that we use on CI.
+  ;; (import "Mv128" "g-v128" (global v128))
+  (import "Mv128" "mg-v128" (global (mut v128)))
+)
+
+
 ;; Tables
 
 (module $Mt

From 439f9b6ce7d5fef78268457e13abc2363bf0b175 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=96mer=20Sinan=20A=C4=9Facan?= <omeragacan@gmail.com>
Date: Thu, 16 Feb 2023 12:31:39 +0100
Subject: [PATCH 263/285] Update Overview.md

---
 proposals/function-references/Overview.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/proposals/function-references/Overview.md b/proposals/function-references/Overview.md
index 24e932370..89b642f8e 100644
--- a/proposals/function-references/Overview.md
+++ b/proposals/function-references/Overview.md
@@ -64,7 +64,7 @@ It is also possible to create a typed function table:
 ```wasm
 (table 0 (ref $i32-i32))
 ```
-Such a table can neither contain `null` entries nor functions of another type. Any use of `call_indirect` on this table does hence avoid all runtime checks beyond the basic bounds check. By using multiple tables, each one can be given a homogeneous type. The table can be initialised by growing it (provding an explicit initialiser value. (Open Question: we could also extend table definitions to provide an explicit initialiser.)
+Such a table can neither contain `null` entries nor functions of another type. Any use of `call_indirect` on this table does hence avoid all runtime checks beyond the basic bounds check. By using multiple tables, each one can be given a homogeneous type. The table can be initialised with an initializer or by growing it.
 
 Typed function references are a subtype of `funcref`, so they can also be used as untyped references. All previous uses of `ref.func` remain valid:
 ```wasm

From 19b1243cea1d8c3898ea56e9b193fa9fba9f4583 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@igalia.com>
Date: Wed, 12 Oct 2022 15:39:40 +0200
Subject: [PATCH 264/285] [js-api] Expose everywhere

---
 document/js-api/index.bs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index b22e825ca..1f7034010 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -282,7 +282,7 @@ dictionary WebAssemblyInstantiatedSource {
     required Instance instance;
 };
 
-[Exposed=(Window,Worker,Worklet)]
+[Exposed=*]
 namespace WebAssembly {
     boolean validate(BufferSource bytes);
     Promise&lt;Module> compile(BufferSource bytes);
@@ -537,7 +537,7 @@ dictionary ModuleImportDescriptor {
   required ImportExportKind kind;
 };
 
-[LegacyNamespace=WebAssembly, Exposed=(Window,Worker,Worklet)]
+[LegacyNamespace=WebAssembly, Exposed=*]
 interface Module {
   constructor(BufferSource bytes);
   static sequence&lt;ModuleExportDescriptor> exports(Module moduleObject);
@@ -601,7 +601,7 @@ interface Module {
 <h3 id="instances">Instances</h3>
 
 <pre class="idl">
-[LegacyNamespace=WebAssembly, Exposed=(Window,Worker,Worklet)]
+[LegacyNamespace=WebAssembly, Exposed=*]
 interface Instance {
   constructor(Module module, optional object importObject);
   readonly attribute object exports;
@@ -628,7 +628,7 @@ dictionary MemoryDescriptor {
   [EnforceRange] unsigned long maximum;
 };
 
-[LegacyNamespace=WebAssembly, Exposed=(Window,Worker,Worklet)]
+[LegacyNamespace=WebAssembly, Exposed=*]
 interface Memory {
   constructor(MemoryDescriptor descriptor);
   unsigned long grow([EnforceRange] unsigned long delta);
@@ -738,7 +738,7 @@ dictionary TableDescriptor {
   [EnforceRange] unsigned long maximum;
 };
 
-[LegacyNamespace=WebAssembly, Exposed=(Window,Worker,Worklet)]
+[LegacyNamespace=WebAssembly, Exposed=*]
 interface Table {
   constructor(TableDescriptor descriptor, optional any value);
   unsigned long grow([EnforceRange] unsigned long delta, optional any value);
@@ -860,7 +860,7 @@ dictionary GlobalDescriptor {
   boolean mutable = false;
 };
 
-[LegacyNamespace=WebAssembly, Exposed=(Window,Worker,Worklet)]
+[LegacyNamespace=WebAssembly, Exposed=*]
 interface Global {
   constructor(GlobalDescriptor descriptor, optional any v);
   any valueOf();

From 4feb91964f8e5e80d416abd6e9f62cc626c7c600 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@igalia.com>
Date: Thu, 16 Feb 2023 15:58:14 +0100
Subject: [PATCH 265/285] [js-api] Try to clarify NaN/infinity handling.
 (#1535)

---
 document/js-api/index.bs | 36 ++++++++++++++++++++++++++++++------
 1 file changed, 30 insertions(+), 6 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 1f7034010..961918eaa 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -93,6 +93,8 @@ urlPrefix: https://tc39.github.io/ecma262/; spec: ECMASCRIPT
         text: IterableToList; url: sec-iterabletolist
         text: ToBigInt64; url: #sec-tobigint64
         text: BigInt; url: #sec-ecmascript-language-types-bigint-type
+        text: 𝔽; url: #𝔽
+        text: ℤ; url: #ℤ
     type: abstract-op
         text: CreateMethodProperty; url: sec-createmethodproperty
 urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: dfn
@@ -163,6 +165,12 @@ urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: df
         text: reftype
         text: funcref
         text: externref
+    url: syntax/values.html#syntax-float
+        text: +∞
+        text: −∞
+        text: nan
+        text: canon
+        text: signif
     text: function element; url: exec/runtime.html#syntax-funcelem
     text: import component; url: syntax/modules.html#imports
     text: external value; url: exec/runtime.html#syntax-externval
@@ -1087,10 +1095,16 @@ The algorithm <dfn>ToJSValue</dfn>(|w|) coerces a [=WebAssembly value=] to a Jav
 1. Assert: |w| is not of  the form [=v128.const=] <var ignore>v128</var>.
 1. If |w| is of the form [=i64.const=] |i64|,
     1. Let |v| be [=signed_64=](|i64|).
-    1. Return a [=BigInt=] representing the mathematical value |v|.
-1. If |w| is of the form [=i32.const=] |i32|, return [=the Number value=] for [=signed_32=](|i32|).
-1. If |w| is of the form [=f32.const=] |f32|, return [=the Number value=] for |f32|.
-1. If |w| is of the form [=f64.const=] |f64|, return [=the Number value=] for |f64|.
+    1. Return [=ℤ=](|v| interpreted as a mathematical value).
+1. If |w| is of the form [=i32.const=] |i32|, return [=𝔽=]([=signed_32=](|i32| interpreted as a mathematical value)).
+1. If |w| is of the form [=f32.const=] |f32|,
+    1. If |f32| is [=+∞=] or [=−∞=], return **+∞**<sub>𝔽</sub> or **-∞**<sub>𝔽</sub>, respectively.
+    1. If |f32| is [=nan=], return **NaN**.
+    1. Return [=𝔽=](|f32| interpreted as a mathematical value).
+1. If |w| is of the form [=f64.const=] |f64|,
+    1. If |f64| is [=+∞=] or [=−∞=], return **+∞**<sub>𝔽</sub> or **-∞**<sub>𝔽</sub>, respectively.
+    1. If |f64| is [=nan=], return **NaN**.
+    1. Return [=𝔽=](|f64| interpreted as a mathematical value).
 1. If |w| is of the form [=ref.null=] <var ignore>t</var>, return null.
 1. If |w| is of the form [=ref.func=] |funcaddr|, return the result of creating [=a new Exported Function=] from |funcaddr|.
 1. If |w| is of the form [=ref.extern=] |externaddr|, return the result of [=retrieving an extern value=] from |externaddr|.
@@ -1119,10 +1133,20 @@ The algorithm <dfn>ToWebAssemblyValue</dfn>(|v|, |type|) coerces a JavaScript va
     1. Let |i32| be [=?=] [=ToInt32=](|v|).
     1. Return [=i32.const=] |i32|.
 1. If |type| is [=f32=],
-    1. Let |f32| be [=?=] [=ToNumber=](|v|) rounded to the nearest representable value using IEEE 754-2008 round to nearest, ties to even mode.
+    1. Let |number| be [=?=] [=ToNumber=](|v|).
+    1. If |number| is **NaN**,
+        1. Let |n| be an implementation-defined integer such that [=canon=]<sub>32</sub> ≤ |n| < 2<sup>[=signif=](32)</sup>.
+        1. Let |f32| be [=nan=](n).
+    1. Otherwise,
+        1. Let |f32| be |number| rounded to the nearest representable value using IEEE 754-2008 round to nearest, ties to even mode. [[IEEE-754]]
     1. Return [=f32.const=] |f32|.
 1. If |type| is [=f64=],
-    1. Let |f64| be [=?=] [=ToNumber=](|v|).
+    1. Let |number| be [=?=] [=ToNumber=](|v|).
+    1. If |number| is **NaN**,
+        1. Let |n| be an implementation-defined integer such that [=canon=]<sub>64</sub> ≤ |n| < 2<sup>[=signif=](64)</sup>.
+        1. Let |f64| be [=nan=](n).
+    1. Otherwise,
+        1. Let |f64| be |number|.
     1. Return [=f64.const=] |f64|.
 1. If |type| is [=funcref=],
     1. If |v| is null,

From 51ff50a1f4f580e8d3bc185fd83479fdbb62ca7a Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@igalia.com>
Date: Fri, 17 Feb 2023 12:26:24 +0100
Subject: [PATCH 266/285] [web-api] Correct MIME type check. (#1537)

Fixes #1138.
---
 document/web-api/index.bs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index 1e74e0941..64c8ecf38 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -69,6 +69,7 @@ url:https://fetch.spec.whatwg.org/#concept-body-consume-body;text:consume body;t
 
 <pre class='link-defaults'>
 spec:ecma-262; type:exception; for:ECMAScript; text:TypeError
+spec:fetch; type:dfn; text:get
 spec:webidl; type:dfn; text:resolve
 </pre>
 
@@ -111,8 +112,10 @@ Note: This algorithm accepts a {{Response}} object, or a
     1. Let |returnValue| be [=a new promise=]
     1. [=Upon fulfillment=] of |source| with value |unwrappedSource|:
         1. Let |response| be |unwrappedSource|'s [=Response/response=].
-        1. Let |mimeType| be the result of [=extracting a MIME type=] from |response|'s [=response/header list=].
-        1. If |mimeType| is not `` `application/wasm` ``, reject |returnValue| with a {{TypeError}} and abort these substeps.
+        1. Let |mimeType| be the result of [=header list/getting=] `` `Content-Type` `` from |response|'s [=response/header list=].
+        1. If |mimeType| is null, reject |returnValue| with a {{TypeError}} and abort these substeps.
+        1. Remove all [=HTTP tab or space byte=] from the start and end of |mimeType|.
+        1. If |mimeType| is not a [=byte-case-insensitive=] match for `` `application/wasm` ``, reject |returnValue| with a {{TypeError}} and abort these substeps.
 
             Note: extra parameters are not allowed, including the empty `` `application/wasm;` ``.
 

From e8a83b22635281a62731df2dcd0488445f71744f Mon Sep 17 00:00:00 2001
From: Heejin Ahn <aheejin@gmail.com>
Date: Tue, 21 Feb 2023 02:53:49 -0800
Subject: [PATCH 267/285] [ci] Pin nodejs version to avoid fetching failures
 (#1603)

The issues appears to be related to https://github.com/actions/runner-images/issues/7002.

Co-authored-by: Ms2ger <Ms2ger@igalia.com>
---
 .github/workflows/main.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 0ff1bd5fb..b64d31bb3 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -64,6 +64,9 @@ jobs:
       - uses: actions/checkout@v2
         with:
           submodules: "recursive"
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
       - run: pip install bikeshed && bikeshed update
       - run: pip install six
       - run: sudo apt-get update -y && sudo apt-get install -y latexmk texlive-latex-recommended texlive-latex-extra texlive-fonts-recommended

From 3545ad06f20d7cd4068aeb470f5c8050b5a44e09 Mon Sep 17 00:00:00 2001
From: Tom Stuart <hi@tomstu.art>
Date: Tue, 21 Feb 2023 11:03:02 +0000
Subject: [PATCH 268/285] [spec] Add missing value to table.grow reduction rule
 (#1607)

---
 document/core/exec/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index bf5acdfea..8bc05499b 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -1312,7 +1312,7 @@ Table Instructions
      \end{array}
    \\[1ex]
    \begin{array}{lcl@{\qquad}l}
-   S; F; (\I32.\CONST~n)~(\TABLEGROW~x) &\stepto& S; F; (\I32.\CONST~\signed_{32}^{-1}(-1))
+   S; F; \val~(\I32.\CONST~n)~(\TABLEGROW~x) &\stepto& S; F; (\I32.\CONST~\signed_{32}^{-1}(-1))
    \end{array}
    \end{array}
 

From 585bfa7e08ca1ef2556781707f0668731a0ab63d Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Tue, 21 Feb 2023 12:28:29 +0100
Subject: [PATCH 269/285] [test] Move SIMD linking test to simd dir (#1610)

---
 test/core/linking.wast           | 14 --------------
 test/core/simd/simd_linking.wast | 12 ++++++++++++
 2 files changed, 12 insertions(+), 14 deletions(-)
 create mode 100644 test/core/simd/simd_linking.wast

diff --git a/test/core/linking.wast b/test/core/linking.wast
index 578a8c188..994e0f49d 100644
--- a/test/core/linking.wast
+++ b/test/core/linking.wast
@@ -129,20 +129,6 @@
 )
 
 
-(module
-  (global (export "g-v128") v128 (v128.const i64x2 0 0))
-  (global (export "mg-v128") (mut v128) (v128.const i64x2 0 0))
-)
-(register "Mv128")
-
-(module
-  ;; TODO: Reactivate once the fix for https://bugs.chromium.org/p/v8/issues/detail?id=13732
-  ;; has made it to the downstream node.js that we use on CI.
-  ;; (import "Mv128" "g-v128" (global v128))
-  (import "Mv128" "mg-v128" (global (mut v128)))
-)
-
-
 ;; Tables
 
 (module $Mt
diff --git a/test/core/simd/simd_linking.wast b/test/core/simd/simd_linking.wast
new file mode 100644
index 000000000..1a1d16355
--- /dev/null
+++ b/test/core/simd/simd_linking.wast
@@ -0,0 +1,12 @@
+(module
+  (global (export "g-v128") v128 (v128.const i64x2 0 0))
+  (global (export "mg-v128") (mut v128) (v128.const i64x2 0 0))
+)
+(register "Mv128")
+
+(module
+  ;; TODO: Reactivate once the fix for https://bugs.chromium.org/p/v8/issues/detail?id=13732
+  ;; has made it to the downstream node.js that we use on CI.
+  ;; (import "Mv128" "g-v128" (global v128))
+  (import "Mv128" "mg-v128" (global (mut v128)))
+)

From f9a726780deb99b3c87cb2f0bad56b90580c60fb Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Mon, 18 Mar 2019 10:46:12 +0100
Subject: [PATCH 270/285] Editorial: Clarify the name of the instantiate
 algorithm.

---
 document/js-api/index.bs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 961918eaa..df23c7a71 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -485,7 +485,7 @@ The verification of WebAssembly type requirements is deferred to the
 </div>
 
 <div algorithm="instantiate">
-  To <dfn>instantiate a WebAssembly module</dfn> from a {{Module}} |moduleObject| and imports |importObject|, perform the following steps:
+  To <dfn>synchronously instantiate a WebAssembly module</dfn> from a {{Module}} |moduleObject| and imports |importObject|, perform the following steps:
     1. Let |module| be |moduleObject|.\[[Module]].
     1. [=Read the imports=] of |module| with imports |importObject|, and let |imports| be the result.
     1. [=Instantiate the core of a WebAssembly module=] |module| with |imports|, and let |instance| be the result.
@@ -499,7 +499,7 @@ The verification of WebAssembly type requirements is deferred to the
 
     1. Let |promise| be [=a new promise=].
     1. [=Upon fulfillment=] of |promiseOfModule| with value |module|:
-        1. [=instantiate a WebAssembly module|Instantiate the WebAssembly module=] |module| importing |importObject|, and let |instance| be the result.  If this throws an exception, catch it, [=reject=] |promise| with the exception, and abort these substeps.
+        1. [=synchronously instantiate a WebAssembly module|Synchronously instantiate the WebAssembly module=] |module| importing |importObject|, and let |instance| be the result.  If this throws an exception, catch it, [=reject=] |promise| with the exception, and abort these substeps.
         1. Let |result| be the {{WebAssemblyInstantiatedSource}} value «[ "{{WebAssemblyInstantiatedSource/module}}" → |module|, "{{WebAssemblyInstantiatedSource/instance}}" → |instance| ]».
         1. [=Resolve=] |promise| with |result|.
     1. [=Upon rejection=] of |promiseOfModule| with reason |reason|:

From a114f7a06bb0e867f1a66570dedcf2ebebe95f3c Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Mon, 18 Mar 2019 10:51:53 +0100
Subject: [PATCH 271/285] Add notes to discourage using synchronous APIs.

---
 document/js-api/index.bs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index df23c7a71..19600b85c 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -604,6 +604,8 @@ interface Module {
     1. If |module| is [=error=], throw a {{CompileError}} exception.
     1. Set **this**.\[[Module]] to |module|.
     1. Set **this**.\[[Bytes]] to |stableBytes|.
+
+Note: Some implementations enforce a size limitation on |bytes|. Use of this API is discouraged, in favor of asynchronous APIs.
 </div>
 
 <h3 id="instances">Instances</h3>
@@ -622,6 +624,8 @@ interface Instance {
     1. [=Read the imports=] of |module| with imports |importObject|, and let |imports| be the result.
     1. [=Instantiate the core of a WebAssembly module=] |module| with |imports|, and let |instance| be the result.
     1. [=initialize an instance object|Initialize=] **this** from |module| and |instance|.
+
+Note: The use of this synchronous API is discouraged, as some implementations sometimes do long-running compilation work when instantiating.
 </div>
 
 <div algorithm>

From 25b3df3e21324465fefd9aed2cf3901cfd76a7c1 Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Mon, 18 Mar 2019 10:52:13 +0100
Subject: [PATCH 272/285] [jsapi] Normative: Always queue a task during
 asynchronous instantiation

JSC will have to do asynchronous compilation work during some instantiations.
To be consistent, this PR always queues a task to complete instantiation,
except through the synchronous Instance(module) API, to ensure consistency
across platforms.

This patch also cleans up the specification in various surrounding ways:
- Include notes about APIs whose use is discouraged/may be limited

Closes #741
See also https://github.com/webpack/webpack/issues/6433
---
 document/js-api/index.bs | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 19600b85c..19faf7ed0 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -474,13 +474,15 @@ The verification of WebAssembly type requirements is deferred to the
     1. Let |module| be |moduleObject|.\[[Module]].
     1. [=Read the imports=] of |module| with imports |importObject|, and let |imports| be the result.
         If this operation throws an exception, catch it, [=reject=] |promise| with the exception, and return |promise|.
-    1. [=Queue a task=] to perform the following steps:
-        1.  [=Instantiate the core of a WebAssembly module=] |module| with |imports|, and let |instance| be the result.
-            If this throws an exception, catch it, [=reject=] |promise| with the exception, and terminate these substeps.
-        1.  Let |instanceObject| be a [=/new=] {{Instance}}.
-        1.  [=initialize an instance object|Initialize=] |instanceObject| from |module| and |instance|.
-            If this throws an exception, catch it, [=reject=] |promise| with the exception, and terminate these substeps.
-        1. [=Resolve=] |promise| with |instanceObject|.
+    1. Run the following steps [=in parallel=]:
+        1. [=Queue a task=] to perform the following steps:
+            Note: Implementation-specific work may be performed here.
+            1.  [=Instantiate the core of a WebAssembly module=] |module| with |imports|, and let |instance| be the result.
+                If this throws an exception, catch it, [=reject=] |promise| with the exception, and terminate these substeps.
+            1.  Let |instanceObject| be a [=/new=] {{Instance}}.
+            1.  [=initialize an instance object|Initialize=] |instanceObject| from |module| and |instance|.
+                If this throws an exception, catch it, [=reject=] |promise| with the exception, and terminate these substeps.
+            1. [=Resolve=] |promise| with |instanceObject|.
     1. Return |promise|.
 </div>
 
@@ -499,14 +501,15 @@ The verification of WebAssembly type requirements is deferred to the
 
     1. Let |promise| be [=a new promise=].
     1. [=Upon fulfillment=] of |promiseOfModule| with value |module|:
-        1. [=synchronously instantiate a WebAssembly module|Synchronously instantiate the WebAssembly module=] |module| importing |importObject|, and let |instance| be the result.  If this throws an exception, catch it, [=reject=] |promise| with the exception, and abort these substeps.
-        1. Let |result| be the {{WebAssemblyInstantiatedSource}} value «[ "{{WebAssemblyInstantiatedSource/module}}" → |module|, "{{WebAssemblyInstantiatedSource/instance}}" → |instance| ]».
-        1. [=Resolve=] |promise| with |result|.
+        1. [=asynchronously instantiate a WebAssembly module|Instantiate the WebAssembly module=] |module| importing |importObject|, and let |innerPromise| be the result.
+        1. [=Upon fulfillment=] of |innerPromise| with value |instance|.
+            1. Let |result| be the {{WebAssemblyInstantiatedSource}} value «[ "{{WebAssemblyInstantiatedSource/module}}" → |module|, "{{WebAssemblyInstantiatedSource/instance}}" → |instance| ]».
+            1. [=Resolve=] |promise| with |result|.
+        1. [=Upon rejection=] of |innerPromise| with reason |reason|:
+            1. [=Reject=] |promise| with |reason|.
     1. [=Upon rejection=] of |promiseOfModule| with reason |reason|:
         1. [=Reject=] |promise| with |reason|.
     1. Return |promise|.
-
-    Note: It would be valid to perform certain parts of the instantiation [=in parallel=], but several parts need to happen in the event loop, including JavaScript operations to access the |importObject| and execution of the start function.
 </div>
 
 <div algorithm>

From 036365a10e47ac1bec0151c148d0b334b3b2ef2b Mon Sep 17 00:00:00 2001
From: Heejin Ahn <aheejin@gmail.com>
Date: Fri, 17 Feb 2023 17:12:31 -0800
Subject: [PATCH 273/285] [test] Exception -> Tag in wasm-module-builder.js

The section name has changed to the tag section a few years ago. This
adds the corresponding changes added in
WebAssembly/exception-handling#252 and
WebAssembly/exception-handling#256.
---
 test/js-api/wasm-module-builder.js | 46 +++++++++++++++---------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/test/js-api/wasm-module-builder.js b/test/js-api/wasm-module-builder.js
index 7be72f86d..d0f9e78bc 100644
--- a/test/js-api/wasm-module-builder.js
+++ b/test/js-api/wasm-module-builder.js
@@ -65,7 +65,7 @@ let kElementSectionCode = 9;     // Elements section
 let kCodeSectionCode = 10;       // Function code
 let kDataSectionCode = 11;       // Data segments
 let kDataCountSectionCode = 12;  // Data segment count (between Element & Code)
-let kExceptionSectionCode = 13;  // Exception section (between Global & Export)
+let kTagSectionCode = 13;        // Tag section (between Memory & Global)
 
 // Name section types
 let kModuleNameCode = 0;
@@ -104,13 +104,13 @@ let kExternalFunction = 0;
 let kExternalTable = 1;
 let kExternalMemory = 2;
 let kExternalGlobal = 3;
-let kExternalException = 4;
+let kExternalTag = 4;
 
 let kTableZero = 0;
 let kMemoryZero = 0;
 let kSegmentZero = 0;
 
-let kExceptionAttribute = 0;
+let kTagAttribute = 0;
 
 // Useful signatures
 let kSig_i_i = makeSig([kWasmI32], [kWasmI32]);
@@ -681,7 +681,7 @@ class WasmModuleBuilder {
     this.exports = [];
     this.globals = [];
     this.tables = [];
-    this.exceptions = [];
+    this.tags = [];
     this.functions = [];
     this.element_segments = [];
     this.data_segments = [];
@@ -689,7 +689,7 @@ class WasmModuleBuilder {
     this.num_imported_funcs = 0;
     this.num_imported_globals = 0;
     this.num_imported_tables = 0;
-    this.num_imported_exceptions = 0;
+    this.num_imported_tags = 0;
     return this;
   }
 
@@ -752,11 +752,11 @@ class WasmModuleBuilder {
     return table;
   }
 
-  addException(type) {
+  addTag(type) {
     let type_index = (typeof type) == "number" ? type : this.addType(type);
-    let except_index = this.exceptions.length + this.num_imported_exceptions;
-    this.exceptions.push(type_index);
-    return except_index;
+    let tag_index = this.tags.length + this.num_imported_tags;
+    this.tags.push(type_index);
+    return tag_index;
   }
 
   addFunction(name, type) {
@@ -804,14 +804,14 @@ class WasmModuleBuilder {
     return this.num_imported_tables++;
   }
 
-  addImportedException(module, name, type) {
-    if (this.exceptions.length != 0) {
-      throw new Error('Imported exceptions must be declared before local ones');
+  addImportedTag(module, name, type) {
+    if (this.tags.length != 0) {
+      throw new Error('Imported tags must be declared before local ones');
     }
     let type_index = (typeof type) == "number" ? type : this.addType(type);
-    let o = {module: module, name: name, kind: kExternalException, type: type_index};
+    let o = {module: module, name: name, kind: kExternalTag, type: type_index};
     this.imports.push(o);
-    return this.num_imported_exceptions++;
+    return this.num_imported_tags++;
   }
 
   addExport(name, index) {
@@ -938,8 +938,8 @@ class WasmModuleBuilder {
             section.emit_u8(has_max ? 1 : 0); // flags
             section.emit_u32v(imp.initial); // initial
             if (has_max) section.emit_u32v(imp.maximum); // maximum
-          } else if (imp.kind == kExternalException) {
-            section.emit_u32v(kExceptionAttribute);
+          } else if (imp.kind == kExternalTag) {
+            section.emit_u32v(kTagAttribute);
             section.emit_u32v(imp.type);
           } else {
             throw new Error("unknown/unsupported import kind " + imp.kind);
@@ -1036,13 +1036,13 @@ class WasmModuleBuilder {
       });
     }
 
-    // Add exceptions.
-    if (wasm.exceptions.length > 0) {
-      if (debug) print("emitting exceptions @ " + binary.length);
-      binary.emit_section(kExceptionSectionCode, section => {
-        section.emit_u32v(wasm.exceptions.length);
-        for (let type of wasm.exceptions) {
-          section.emit_u32v(kExceptionAttribute);
+    // Add tags.
+    if (wasm.tags.length > 0) {
+      if (debug) print("emitting tags @ " + binary.length);
+      binary.emit_section(kTagSectionCode, section => {
+        section.emit_u32v(wasm.tags.length);
+        for (let type of wasm.tags) {
+          section.emit_u32v(kTagAttribute);
           section.emit_u32v(type);
         }
       });

From 8f5c48955b688965c18948c2866d84913347bad4 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Wed, 22 Feb 2023 12:43:02 +0100
Subject: [PATCH 274/285] [spec] Fix reduction rule for label (#1612)

Fix #1605.
---
 document/core/exec/instructions.rst | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 8bc05499b..3f82dce39 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -2860,22 +2860,20 @@ Exiting :math:`\instr^\ast` with label :math:`L`
 
 When the end of a block is reached without a jump or trap aborting it, then the following steps are performed.
 
-1. Let :math:`n` be the number of values on the top of the stack.
+1. Pop all values :math:`\val^\ast` from the top of the stack.
 
-2. Pop the values :math:`\val^n` from the stack.
+2. Assert: due to :ref:`validation <valid-instr-seq>`, the label :math:`L` is now on the top of the stack.
 
-3. Assert: due to :ref:`validation <valid-instr-seq>`, the label :math:`L` is now on the top of the stack and has arity :math:`n`.
+3. Pop the label from the stack.
 
-4. Pop the label from the stack.
+4. Push :math:`\val^\ast` back to the stack.
 
-5. Push :math:`\val^n` back to the stack.
-
-6. Jump to the position after the |END| of the :ref:`structured control instruction <syntax-instr-control>` associated with the label :math:`L`.
+5. Jump to the position after the |END| of the :ref:`structured control instruction <syntax-instr-control>` associated with the label :math:`L`.
 
 .. math::
    ~\\[-1ex]
    \begin{array}{lcl@{\qquad}l}
-   \LABEL_n\{\instr^\ast\}~\val^n~\END &\stepto& \val^n
+   \LABEL_n\{\instr^\ast\}~\val^\ast~\END &\stepto& \val^\ast
    \end{array}
 
 .. note::

From 6db9011875a0cbcac53ec67ce81e240088e021a3 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Wed, 22 Feb 2023 18:20:55 +0100
Subject: [PATCH 275/285] [spec] Clarifying note about canonical NaNs (#1614)

---
 document/core/syntax/values.rst | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/document/core/syntax/values.rst b/document/core/syntax/values.rst
index 564ddc2d6..1b155df42 100644
--- a/document/core/syntax/values.rst
+++ b/document/core/syntax/values.rst
@@ -140,6 +140,8 @@ An *arithmetic NaN*  is a floating-point value :math:`\pm\NAN(n)` with :math:`n
 .. note::
    In the abstract syntax, subnormals are distinguished by the leading 0 of the significand. The exponent of subnormals has the same value as the smallest possible exponent of a normal number. Only in the :ref:`binary representation <binary-float>` the exponent of a subnormal is encoded differently than the exponent of any normal number.
 
+   The notion of canonical NaN defined here is unrelated to the notion of canonical NaN that the |IEEE754|_ standard (Section 3.5.2) defines for decimal interchange formats.
+
 Conventions
 ...........
 

From 721dd6ce2cf53028133bd2ceeea9b0655570c641 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Wed, 22 Feb 2023 21:14:40 +0100
Subject: [PATCH 276/285] [spec] Tweak crossref

---
 document/core/util/macros.def | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index aaefc4069..3ab6d5480 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -9,7 +9,7 @@
 .. |WasmIssues| replace:: |issuelink|
 .. _WasmIssues: |issuelink|
 
-.. |IEEE754| replace:: IEEE 754-2019
+.. |IEEE754| replace:: IEEE 754
 .. _IEEE754: https://ieeexplore.ieee.org/document/8766229
 
 .. |Unicode| replace:: Unicode

From 2558d66b716b8b85e028a595a2a51a3a9063c0f7 Mon Sep 17 00:00:00 2001
From: Heejin Ahn <aheejin@gmail.com>
Date: Thu, 23 Feb 2023 00:00:44 -0800
Subject: [PATCH 277/285] [test] Fix invalid section ID tests (#1615)

---
 .github/workflows/main.yml |  2 +-
 test/core/binary.wast      | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index b64d31bb3..a158de1ee 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -22,7 +22,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v1
         with:
-          node-version: 18.x
+          node-version: 19.x
       - run: cd interpreter && opam exec make JS=node all
 
   ref-interpreter-js-library:
diff --git a/test/core/binary.wast b/test/core/binary.wast
index 1b6b47129..526e0a20e 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -45,11 +45,11 @@
 (assert_malformed (module binary "\00asm\00\00\00\01") "unknown binary version")
 
 ;; Invalid section id.
-(assert_malformed (module binary "\00asm" "\01\00\00\00" "\0d\00") "malformed section id")
-(assert_malformed (module binary "\00asm" "\01\00\00\00" "\7f\00") "malformed section id")
-(assert_malformed (module binary "\00asm" "\01\00\00\00" "\80\00\01\00") "malformed section id")
-(assert_malformed (module binary "\00asm" "\01\00\00\00" "\81\00\01\00") "malformed section id")
-(assert_malformed (module binary "\00asm" "\01\00\00\00" "\ff\00\01\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\0e\01\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\7f\01\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\80\01\00\01\01\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\81\01\00\01\01\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\ff\01\00\01\01\00") "malformed section id")
 
 ;; Unsigned LEB128 can have non-minimal length
 (module binary

From af09dd3d584d7227e172496c1823f6586efa9676 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Tue, 28 Feb 2023 17:33:28 +0100
Subject: [PATCH 278/285] [tests] Disable node run for now

---
 .github/workflows/main.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 7a94b860d..ad98ff6fa 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -23,7 +23,9 @@ jobs:
         uses: actions/setup-node@v1
         with:
           node-version: 19.x
-      - run: cd interpreter && opam exec make JS=node all
+      # TODO: disable node run until it fully implements proposal
+      # - run: cd interpreter && opam exec make JS=node all
+      - run: cd interpreter && opam exec make all
 
   ref-interpreter-js-library:
     runs-on: ubuntu-latest

From 87461da7a4500bd907b963956ad83ef2d75060af Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 1 Mar 2023 09:43:47 +0100
Subject: [PATCH 279/285] [spec] Don't check in generated index, to avoid
 spurious merge conflicts

---
 document/core/.gitignore                      |   1 +
 document/core/Makefile                        |   1 +
 document/core/appendix/index-instructions.rst | 523 ------------------
 3 files changed, 2 insertions(+), 523 deletions(-)
 delete mode 100644 document/core/appendix/index-instructions.rst

diff --git a/document/core/.gitignore b/document/core/.gitignore
index b932ec283..d21e55e36 100644
--- a/document/core/.gitignore
+++ b/document/core/.gitignore
@@ -1,3 +1,4 @@
 _build
 _static
 document/*.pyc
+appendix/index-instructions.rst
diff --git a/document/core/Makefile b/document/core/Makefile
index 3ff1a87cb..bfbf70bfc 100644
--- a/document/core/Makefile
+++ b/document/core/Makefile
@@ -103,6 +103,7 @@ pdf:	index latexpdf
 clean:
 	rm -rf $(BUILDDIR)
 	rm -rf $(STATICDIR)
+	rm -f appendix/index-instructions.rst
 
 .PHONY: html
 html: index
diff --git a/document/core/appendix/index-instructions.rst b/document/core/appendix/index-instructions.rst
deleted file mode 100644
index 977c21fb3..000000000
--- a/document/core/appendix/index-instructions.rst
+++ /dev/null
@@ -1,523 +0,0 @@
-.. DO NOT EDIT: This file is auto-generated by the gen-index-instructions.py script.
-
-.. index:: instruction
-.. _index-instr:
-
-Index of Instructions
----------------------
-
-=================================================  ====================================  =============================================  =============================================  ==================================================================
-Instruction                                        Binary Opcode                         Type                                           Validation                                     Execution                                                         
-=================================================  ====================================  =============================================  =============================================  ==================================================================
-:math:`\UNREACHABLE`                               :math:`\hex{00}`                      :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-unreachable>`          :ref:`execution <exec-unreachable>`                               
-:math:`\NOP`                                       :math:`\hex{01}`                      :math:`[] \to []`                              :ref:`validation <valid-nop>`                  :ref:`execution <exec-nop>`                                       
-:math:`\BLOCK~\X{bt}`                              :math:`\hex{02}`                      :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-block>`                :ref:`execution <exec-block>`                                     
-:math:`\LOOP~\X{bt}`                               :math:`\hex{03}`                      :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-loop>`                 :ref:`execution <exec-loop>`                                      
-:math:`\IF~\X{bt}`                                 :math:`\hex{04}`                      :math:`[t_1^\ast~\I32] \to [t_2^\ast]`         :ref:`validation <valid-if>`                   :ref:`execution <exec-if>`                                        
-:math:`\ELSE`                                      :math:`\hex{05}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{06}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{07}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{08}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{09}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{0A}`                                                                                                                                                                                      
-:math:`\END`                                       :math:`\hex{0B}`                                                                                                                                                                                      
-:math:`\BR~l`                                      :math:`\hex{0C}`                      :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`       :ref:`validation <valid-br>`                   :ref:`execution <exec-br>`                                        
-:math:`\BRIF~l`                                    :math:`\hex{0D}`                      :math:`[t^\ast~\I32] \to [t^\ast]`             :ref:`validation <valid-br_if>`                :ref:`execution <exec-br_if>`                                     
-:math:`\BRTABLE~l^\ast~l`                          :math:`\hex{0E}`                      :math:`[t_1^\ast~t^\ast~\I32] \to [t_2^\ast]`  :ref:`validation <valid-br_table>`             :ref:`execution <exec-br_table>`                                  
-:math:`\RETURN`                                    :math:`\hex{0F}`                      :math:`[t_1^\ast~t^\ast] \to [t_2^\ast]`       :ref:`validation <valid-return>`               :ref:`execution <exec-return>`                                    
-:math:`\CALL~x`                                    :math:`\hex{10}`                      :math:`[t_1^\ast] \to [t_2^\ast]`              :ref:`validation <valid-call>`                 :ref:`execution <exec-call>`                                      
-:math:`\CALLINDIRECT~x~y`                          :math:`\hex{11}`                      :math:`[t_1^\ast~\I32] \to [t_2^\ast]`         :ref:`validation <valid-call_indirect>`        :ref:`execution <exec-call_indirect>`                             
-(reserved)                                         :math:`\hex{12}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{13}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{14}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{15}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{16}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{17}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{18}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{19}`                                                                                                                                                                                      
-:math:`\DROP`                                      :math:`\hex{1A}`                      :math:`[t] \to []`                             :ref:`validation <valid-drop>`                 :ref:`execution <exec-drop>`                                      
-:math:`\SELECT`                                    :math:`\hex{1B}`                      :math:`[t~t~\I32] \to [t]`                     :ref:`validation <valid-select>`               :ref:`execution <exec-select>`                                    
-:math:`\SELECT~t`                                  :math:`\hex{1C}`                      :math:`[t~t~\I32] \to [t]`                     :ref:`validation <valid-select>`               :ref:`execution <exec-select>`                                    
-(reserved)                                         :math:`\hex{1D}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{1E}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{1F}`                                                                                                                                                                                      
-:math:`\LOCALGET~x`                                :math:`\hex{20}`                      :math:`[] \to [t]`                             :ref:`validation <valid-local.get>`            :ref:`execution <exec-local.get>`                                 
-:math:`\LOCALSET~x`                                :math:`\hex{21}`                      :math:`[t] \to []`                             :ref:`validation <valid-local.set>`            :ref:`execution <exec-local.set>`                                 
-:math:`\LOCALTEE~x`                                :math:`\hex{22}`                      :math:`[t] \to [t]`                            :ref:`validation <valid-local.tee>`            :ref:`execution <exec-local.tee>`                                 
-:math:`\GLOBALGET~x`                               :math:`\hex{23}`                      :math:`[] \to [t]`                             :ref:`validation <valid-global.get>`           :ref:`execution <exec-global.get>`                                
-:math:`\GLOBALSET~x`                               :math:`\hex{24}`                      :math:`[t] \to []`                             :ref:`validation <valid-global.set>`           :ref:`execution <exec-global.set>`                                
-:math:`\TABLEGET~x`                                :math:`\hex{25}`                      :math:`[\I32] \to [t]`                         :ref:`validation <valid-table.get>`            :ref:`execution <exec-table.get>`                                 
-:math:`\TABLESET~x`                                :math:`\hex{26}`                      :math:`[\I32~t] \to []`                        :ref:`validation <valid-table.set>`            :ref:`execution <exec-table.set>`                                 
-(reserved)                                         :math:`\hex{27}`                                                                                                                                                                                      
-:math:`\I32.\LOAD~\memarg`                         :math:`\hex{28}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
-:math:`\I64.\LOAD~\memarg`                         :math:`\hex{29}`                      :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
-:math:`\F32.\LOAD~\memarg`                         :math:`\hex{2A}`                      :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
-:math:`\F64.\LOAD~\memarg`                         :math:`\hex{2B}`                      :math:`[\I32] \to [\F64]`                      :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
-:math:`\I32.\LOAD\K{8\_s}~\memarg`                 :math:`\hex{2C}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
-:math:`\I32.\LOAD\K{8\_u}~\memarg`                 :math:`\hex{2D}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
-:math:`\I32.\LOAD\K{16\_s}~\memarg`                :math:`\hex{2E}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
-:math:`\I32.\LOAD\K{16\_u}~\memarg`                :math:`\hex{2F}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
-:math:`\I64.\LOAD\K{8\_s}~\memarg`                 :math:`\hex{30}`                      :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
-:math:`\I64.\LOAD\K{8\_u}~\memarg`                 :math:`\hex{31}`                      :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
-:math:`\I64.\LOAD\K{16\_s}~\memarg`                :math:`\hex{32}`                      :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
-:math:`\I64.\LOAD\K{16\_u}~\memarg`                :math:`\hex{33}`                      :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
-:math:`\I64.\LOAD\K{32\_s}~\memarg`                :math:`\hex{34}`                      :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
-:math:`\I64.\LOAD\K{32\_u}~\memarg`                :math:`\hex{35}`                      :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-loadn>`                :ref:`execution <exec-loadn>`                                     
-:math:`\I32.\STORE~\memarg`                        :math:`\hex{36}`                      :math:`[\I32~\I32] \to []`                     :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
-:math:`\I64.\STORE~\memarg`                        :math:`\hex{37}`                      :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
-:math:`\F32.\STORE~\memarg`                        :math:`\hex{38}`                      :math:`[\I32~\F32] \to []`                     :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
-:math:`\F64.\STORE~\memarg`                        :math:`\hex{39}`                      :math:`[\I32~\F64] \to []`                     :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
-:math:`\I32.\STORE\K{8}~\memarg`                   :math:`\hex{3A}`                      :math:`[\I32~\I32] \to []`                     :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
-:math:`\I32.\STORE\K{16}~\memarg`                  :math:`\hex{3B}`                      :math:`[\I32~\I32] \to []`                     :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
-:math:`\I64.\STORE\K{8}~\memarg`                   :math:`\hex{3C}`                      :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
-:math:`\I64.\STORE\K{16}~\memarg`                  :math:`\hex{3D}`                      :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
-:math:`\I64.\STORE\K{32}~\memarg`                  :math:`\hex{3E}`                      :math:`[\I32~\I64] \to []`                     :ref:`validation <valid-storen>`               :ref:`execution <exec-storen>`                                    
-:math:`\MEMORYSIZE`                                :math:`\hex{3F}`                      :math:`[] \to [\I32]`                          :ref:`validation <valid-memory.size>`          :ref:`execution <exec-memory.size>`                               
-:math:`\MEMORYGROW`                                :math:`\hex{40}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-memory.grow>`          :ref:`execution <exec-memory.grow>`                               
-:math:`\I32.\CONST~\i32`                           :math:`\hex{41}`                      :math:`[] \to [\I32]`                          :ref:`validation <valid-const>`                :ref:`execution <exec-const>`                                     
-:math:`\I64.\CONST~\i64`                           :math:`\hex{42}`                      :math:`[] \to [\I64]`                          :ref:`validation <valid-const>`                :ref:`execution <exec-const>`                                     
-:math:`\F32.\CONST~\f32`                           :math:`\hex{43}`                      :math:`[] \to [\F32]`                          :ref:`validation <valid-const>`                :ref:`execution <exec-const>`                                     
-:math:`\F64.\CONST~\f64`                           :math:`\hex{44}`                      :math:`[] \to [\F64]`                          :ref:`validation <valid-const>`                :ref:`execution <exec-const>`                                     
-:math:`\I32.\EQZ`                                  :math:`\hex{45}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-testop>`               :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`         
-:math:`\I32.\EQ`                                   :math:`\hex{46}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`           
-:math:`\I32.\NE`                                   :math:`\hex{47}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`           
-:math:`\I32.\LT\K{\_s}`                            :math:`\hex{48}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`         
-:math:`\I32.\LT\K{\_u}`                            :math:`\hex{49}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`         
-:math:`\I32.\GT\K{\_s}`                            :math:`\hex{4A}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`         
-:math:`\I32.\GT\K{\_u}`                            :math:`\hex{4B}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`         
-:math:`\I32.\LE\K{\_s}`                            :math:`\hex{4C}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`         
-:math:`\I32.\LE\K{\_u}`                            :math:`\hex{4D}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`         
-:math:`\I32.\GE\K{\_s}`                            :math:`\hex{4E}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`         
-:math:`\I32.\GE\K{\_u}`                            :math:`\hex{4F}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`         
-:math:`\I64.\EQZ`                                  :math:`\hex{50}`                      :math:`[\I64] \to [\I32]`                      :ref:`validation <valid-testop>`               :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`         
-:math:`\I64.\EQ`                                   :math:`\hex{51}`                      :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`           
-:math:`\I64.\NE`                                   :math:`\hex{52}`                      :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`           
-:math:`\I64.\LT\K{\_s}`                            :math:`\hex{53}`                      :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`         
-:math:`\I64.\LT\K{\_u}`                            :math:`\hex{54}`                      :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`         
-:math:`\I64.\GT\K{\_s}`                            :math:`\hex{55}`                      :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`         
-:math:`\I64.\GT\K{\_u}`                            :math:`\hex{56}`                      :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`         
-:math:`\I64.\LE\K{\_s}`                            :math:`\hex{57}`                      :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`         
-:math:`\I64.\LE\K{\_u}`                            :math:`\hex{58}`                      :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`         
-:math:`\I64.\GE\K{\_s}`                            :math:`\hex{59}`                      :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`         
-:math:`\I64.\GE\K{\_u}`                            :math:`\hex{5A}`                      :math:`[\I64~\I64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`         
-:math:`\F32.\EQ`                                   :math:`\hex{5B}`                      :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`           
-:math:`\F32.\NE`                                   :math:`\hex{5C}`                      :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`           
-:math:`\F32.\LT`                                   :math:`\hex{5D}`                      :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`           
-:math:`\F32.\GT`                                   :math:`\hex{5E}`                      :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`           
-:math:`\F32.\LE`                                   :math:`\hex{5F}`                      :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`           
-:math:`\F32.\GE`                                   :math:`\hex{60}`                      :math:`[\F32~\F32] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`           
-:math:`\F64.\EQ`                                   :math:`\hex{61}`                      :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`           
-:math:`\F64.\NE`                                   :math:`\hex{62}`                      :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`           
-:math:`\F64.\LT`                                   :math:`\hex{63}`                      :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`           
-:math:`\F64.\GT`                                   :math:`\hex{64}`                      :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`           
-:math:`\F64.\LE`                                   :math:`\hex{65}`                      :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`           
-:math:`\F64.\GE`                                   :math:`\hex{66}`                      :math:`[\F64~\F64] \to [\I32]`                 :ref:`validation <valid-relop>`                :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`           
-:math:`\I32.\CLZ`                                  :math:`\hex{67}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`           
-:math:`\I32.\CTZ`                                  :math:`\hex{68}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`           
-:math:`\I32.\POPCNT`                               :math:`\hex{69}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`        
-:math:`\I32.\ADD`                                  :math:`\hex{6A}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`          
-:math:`\I32.\SUB`                                  :math:`\hex{6B}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`          
-:math:`\I32.\MUL`                                  :math:`\hex{6C}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`          
-:math:`\I32.\DIV\K{\_s}`                           :math:`\hex{6D}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`        
-:math:`\I32.\DIV\K{\_u}`                           :math:`\hex{6E}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`        
-:math:`\I32.\REM\K{\_s}`                           :math:`\hex{6F}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`        
-:math:`\I32.\REM\K{\_u}`                           :math:`\hex{70}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`        
-:math:`\I32.\AND`                                  :math:`\hex{71}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`          
-:math:`\I32.\OR`                                   :math:`\hex{72}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`           
-:math:`\I32.\XOR`                                  :math:`\hex{73}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`          
-:math:`\I32.\SHL`                                  :math:`\hex{74}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`          
-:math:`\I32.\SHR\K{\_s}`                           :math:`\hex{75}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`        
-:math:`\I32.\SHR\K{\_u}`                           :math:`\hex{76}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`        
-:math:`\I32.\ROTL`                                 :math:`\hex{77}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`         
-:math:`\I32.\ROTR`                                 :math:`\hex{78}`                      :math:`[\I32~\I32] \to [\I32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`         
-:math:`\I64.\CLZ`                                  :math:`\hex{79}`                      :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`           
-:math:`\I64.\CTZ`                                  :math:`\hex{7A}`                      :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`           
-:math:`\I64.\POPCNT`                               :math:`\hex{7B}`                      :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`        
-:math:`\I64.\ADD`                                  :math:`\hex{7C}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`          
-:math:`\I64.\SUB`                                  :math:`\hex{7D}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`          
-:math:`\I64.\MUL`                                  :math:`\hex{7E}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`          
-:math:`\I64.\DIV\K{\_s}`                           :math:`\hex{7F}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`        
-:math:`\I64.\DIV\K{\_u}`                           :math:`\hex{80}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`        
-:math:`\I64.\REM\K{\_s}`                           :math:`\hex{81}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`        
-:math:`\I64.\REM\K{\_u}`                           :math:`\hex{82}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`        
-:math:`\I64.\AND`                                  :math:`\hex{83}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`          
-:math:`\I64.\OR`                                   :math:`\hex{84}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`           
-:math:`\I64.\XOR`                                  :math:`\hex{85}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`          
-:math:`\I64.\SHL`                                  :math:`\hex{86}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`          
-:math:`\I64.\SHR\K{\_s}`                           :math:`\hex{87}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`        
-:math:`\I64.\SHR\K{\_u}`                           :math:`\hex{88}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`        
-:math:`\I64.\ROTL`                                 :math:`\hex{89}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`         
-:math:`\I64.\ROTR`                                 :math:`\hex{8A}`                      :math:`[\I64~\I64] \to [\I64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`         
-:math:`\F32.\ABS`                                  :math:`\hex{8B}`                      :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`           
-:math:`\F32.\NEG`                                  :math:`\hex{8C}`                      :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`           
-:math:`\F32.\CEIL`                                 :math:`\hex{8D}`                      :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`          
-:math:`\F32.\FLOOR`                                :math:`\hex{8E}`                      :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`         
-:math:`\F32.\TRUNC`                                :math:`\hex{8F}`                      :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`         
-:math:`\F32.\NEAREST`                              :math:`\hex{90}`                      :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`       
-:math:`\F32.\SQRT`                                 :math:`\hex{91}`                      :math:`[\F32] \to [\F32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`          
-:math:`\F32.\ADD`                                  :math:`\hex{92}`                      :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`          
-:math:`\F32.\SUB`                                  :math:`\hex{93}`                      :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`          
-:math:`\F32.\MUL`                                  :math:`\hex{94}`                      :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`          
-:math:`\F32.\DIV`                                  :math:`\hex{95}`                      :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`          
-:math:`\F32.\FMIN`                                 :math:`\hex{96}`                      :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`          
-:math:`\F32.\FMAX`                                 :math:`\hex{97}`                      :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`          
-:math:`\F32.\COPYSIGN`                             :math:`\hex{98}`                      :math:`[\F32~\F32] \to [\F32]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`     
-:math:`\F64.\ABS`                                  :math:`\hex{99}`                      :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`           
-:math:`\F64.\NEG`                                  :math:`\hex{9A}`                      :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`           
-:math:`\F64.\CEIL`                                 :math:`\hex{9B}`                      :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`          
-:math:`\F64.\FLOOR`                                :math:`\hex{9C}`                      :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`         
-:math:`\F64.\TRUNC`                                :math:`\hex{9D}`                      :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`         
-:math:`\F64.\NEAREST`                              :math:`\hex{9E}`                      :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`       
-:math:`\F64.\SQRT`                                 :math:`\hex{9F}`                      :math:`[\F64] \to [\F64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`          
-:math:`\F64.\ADD`                                  :math:`\hex{A0}`                      :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`          
-:math:`\F64.\SUB`                                  :math:`\hex{A1}`                      :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`          
-:math:`\F64.\MUL`                                  :math:`\hex{A2}`                      :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`          
-:math:`\F64.\DIV`                                  :math:`\hex{A3}`                      :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`          
-:math:`\F64.\FMIN`                                 :math:`\hex{A4}`                      :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`          
-:math:`\F64.\FMAX`                                 :math:`\hex{A5}`                      :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`          
-:math:`\F64.\COPYSIGN`                             :math:`\hex{A6}`                      :math:`[\F64~\F64] \to [\F64]`                 :ref:`validation <valid-binop>`                :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`     
-:math:`\I32.\WRAP\K{\_}\I64`                       :math:`\hex{A7}`                      :math:`[\I64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-wrap>`          
-:math:`\I32.\TRUNC\K{\_}\F32\K{\_s}`               :math:`\hex{A8}`                      :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`       
-:math:`\I32.\TRUNC\K{\_}\F32\K{\_u}`               :math:`\hex{A9}`                      :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`       
-:math:`\I32.\TRUNC\K{\_}\F64\K{\_s}`               :math:`\hex{AA}`                      :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`       
-:math:`\I32.\TRUNC\K{\_}\F64\K{\_u}`               :math:`\hex{AB}`                      :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`       
-:math:`\I64.\EXTEND\K{\_}\I32\K{\_s}`              :math:`\hex{AC}`                      :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_s>`      
-:math:`\I64.\EXTEND\K{\_}\I32\K{\_u}`              :math:`\hex{AD}`                      :math:`[\I32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_u>`      
-:math:`\I64.\TRUNC\K{\_}\F32\K{\_s}`               :math:`\hex{AE}`                      :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`       
-:math:`\I64.\TRUNC\K{\_}\F32\K{\_u}`               :math:`\hex{AF}`                      :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`       
-:math:`\I64.\TRUNC\K{\_}\F64\K{\_s}`               :math:`\hex{B0}`                      :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`       
-:math:`\I64.\TRUNC\K{\_}\F64\K{\_u}`               :math:`\hex{B1}`                      :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`       
-:math:`\F32.\CONVERT\K{\_}\I32\K{\_s}`             :math:`\hex{B2}`                      :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`     
-:math:`\F32.\CONVERT\K{\_}\I32\K{\_u}`             :math:`\hex{B3}`                      :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`     
-:math:`\F32.\CONVERT\K{\_}\I64\K{\_s}`             :math:`\hex{B4}`                      :math:`[\I64] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`     
-:math:`\F32.\CONVERT\K{\_}\I64\K{\_u}`             :math:`\hex{B5}`                      :math:`[\I64] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`     
-:math:`\F32.\DEMOTE\K{\_}\F64`                     :math:`\hex{B6}`                      :math:`[\F64] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-demote>`        
-:math:`\F64.\CONVERT\K{\_}\I32\K{\_s}`             :math:`\hex{B7}`                      :math:`[\I32] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`     
-:math:`\F64.\CONVERT\K{\_}\I32\K{\_u}`             :math:`\hex{B8}`                      :math:`[\I32] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`     
-:math:`\F64.\CONVERT\K{\_}\I64\K{\_s}`             :math:`\hex{B9}`                      :math:`[\I64] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`     
-:math:`\F64.\CONVERT\K{\_}\I64\K{\_u}`             :math:`\hex{BA}`                      :math:`[\I64] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`     
-:math:`\F64.\PROMOTE\K{\_}\F32`                    :math:`\hex{BB}`                      :math:`[\F32] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-promote>`       
-:math:`\I32.\REINTERPRET\K{\_}\F32`                :math:`\hex{BC}`                      :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`   
-:math:`\I64.\REINTERPRET\K{\_}\F64`                :math:`\hex{BD}`                      :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`   
-:math:`\F32.\REINTERPRET\K{\_}\I32`                :math:`\hex{BE}`                      :math:`[\I32] \to [\F32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`   
-:math:`\F64.\REINTERPRET\K{\_}\I64`                :math:`\hex{BF}`                      :math:`[\I64] \to [\F64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`   
-:math:`\I32.\EXTEND\K{8\_s}`                       :math:`\hex{C0}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
-:math:`\I32.\EXTEND\K{16\_s}`                      :math:`\hex{C1}`                      :math:`[\I32] \to [\I32]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
-:math:`\I64.\EXTEND\K{8\_s}`                       :math:`\hex{C2}`                      :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
-:math:`\I64.\EXTEND\K{16\_s}`                      :math:`\hex{C3}`                      :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
-:math:`\I64.\EXTEND\K{32\_s}`                      :math:`\hex{C4}`                      :math:`[\I64] \to [\I64]`                      :ref:`validation <valid-unop>`                 :ref:`execution <exec-unop>`, :ref:`operator <op-iextendn_s>`     
-(reserved)                                         :math:`\hex{C5}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{C6}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{C7}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{C8}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{C9}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{CA}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{CB}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{CC}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{CD}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{CE}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{CF}`                                                                                                                                                                                      
-:math:`\REFNULL~t`                                 :math:`\hex{D0}`                      :math:`[] \to [t]`                             :ref:`validation <valid-ref.null>`             :ref:`execution <exec-ref.null>`                                  
-:math:`\REFISNULL`                                 :math:`\hex{D1}`                      :math:`[t] \to [\I32]`                         :ref:`validation <valid-ref.is_null>`          :ref:`execution <exec-ref.is_null>`                               
-:math:`\REFFUNC~x`                                 :math:`\hex{D2}`                      :math:`[] \to [\FUNCREF]`                      :ref:`validation <valid-ref.func>`             :ref:`execution <exec-ref.func>`                                  
-(reserved)                                         :math:`\hex{D3}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{D4}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{D5}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{D6}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{D7}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{D8}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{D9}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{DA}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{DB}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{DC}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{DD}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{DE}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{DF}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{E0}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{E1}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{E2}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{E3}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{E4}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{E5}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{E6}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{E7}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{E8}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{E9}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{EA}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{EB}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{EC}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{ED}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{EE}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{EF}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{F0}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{F1}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{F2}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{F3}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{F4}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{F5}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{F6}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{F7}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{F8}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{F9}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{FA}`                                                                                                                                                                                      
-(reserved)                                         :math:`\hex{FB}`                                                                                                                                                                                      
-:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_s}`          :math:`\hex{FC}~\hex{00}`             :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
-:math:`\I32.\TRUNC\K{\_sat\_}\F32\K{\_u}`          :math:`\hex{FC}~\hex{01}`             :math:`[\F32] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
-:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_s}`          :math:`\hex{FC}~\hex{02}`             :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
-:math:`\I32.\TRUNC\K{\_sat\_}\F64\K{\_u}`          :math:`\hex{FC}~\hex{03}`             :math:`[\F64] \to [\I32]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
-:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_s}`          :math:`\hex{FC}~\hex{04}`             :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
-:math:`\I64.\TRUNC\K{\_sat\_}\F32\K{\_u}`          :math:`\hex{FC}~\hex{05}`             :math:`[\F32] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
-:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_s}`          :math:`\hex{FC}~\hex{06}`             :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_s>`   
-:math:`\I64.\TRUNC\K{\_sat\_}\F64\K{\_u}`          :math:`\hex{FC}~\hex{07}`             :math:`[\F64] \to [\I64]`                      :ref:`validation <valid-cvtop>`                :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_sat_u>`   
-:math:`\MEMORYINIT~x`                              :math:`\hex{FC}~\hex{08}`             :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-memory.init>`          :ref:`execution <exec-memory.init>`                               
-:math:`\DATADROP~x`                                :math:`\hex{FC}~\hex{09}`             :math:`[] \to []`                              :ref:`validation <valid-data.drop>`            :ref:`execution <exec-data.drop>`                                 
-:math:`\MEMORYCOPY`                                :math:`\hex{FC}~\hex{0A}`             :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-memory.copy>`          :ref:`execution <exec-memory.copy>`                               
-:math:`\MEMORYFILL`                                :math:`\hex{FC}~\hex{0B}`             :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-memory.fill>`          :ref:`execution <exec-memory.fill>`                               
-:math:`\TABLEINIT~x~y`                             :math:`\hex{FC}~\hex{0C}`             :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-table.init>`           :ref:`execution <exec-table.init>`                                
-:math:`\ELEMDROP~x`                                :math:`\hex{FC}~\hex{0D}`             :math:`[] \to []`                              :ref:`validation <valid-elem.drop>`            :ref:`execution <exec-elem.drop>`                                 
-:math:`\TABLECOPY~x~y`                             :math:`\hex{FC}~\hex{0E}`             :math:`[\I32~\I32~\I32] \to []`                :ref:`validation <valid-table.copy>`           :ref:`execution <exec-table.copy>`                                
-:math:`\TABLEGROW~x`                               :math:`\hex{FC}~\hex{0F}`             :math:`[t~\I32] \to [\I32]`                    :ref:`validation <valid-table.grow>`           :ref:`execution <exec-table.grow>`                                
-:math:`\TABLESIZE~x`                               :math:`\hex{FC}~\hex{10}`             :math:`[] \to [\I32]`                          :ref:`validation <valid-table.size>`           :ref:`execution <exec-table.size>`                                
-:math:`\TABLEFILL~x`                               :math:`\hex{FC}~\hex{11}`             :math:`[\I32~t~\I32] \to []`                   :ref:`validation <valid-table.fill>`           :ref:`execution <exec-table.fill>`                                
-:math:`\V128.\LOAD~\memarg`                        :math:`\hex{FD}~~\hex{00}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load>`                 :ref:`execution <exec-load>`                                      
-:math:`\V128.\LOAD\K{8x8\_s}~\memarg`              :math:`\hex{FD}~~\hex{01}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
-:math:`\V128.\LOAD\K{8x8\_u}~\memarg`              :math:`\hex{FD}~~\hex{02}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
-:math:`\V128.\LOAD\K{16x4\_s}~\memarg`             :math:`\hex{FD}~~\hex{03}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
-:math:`\V128.\LOAD\K{16x4\_u}~\memarg`             :math:`\hex{FD}~~\hex{04}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
-:math:`\V128.\LOAD\K{32x2\_s}~\memarg`             :math:`\hex{FD}~~\hex{05}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
-:math:`\V128.\LOAD\K{32x2\_u}~\memarg`             :math:`\hex{FD}~~\hex{06}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-extend>`          :ref:`execution <exec-load-extend>`                               
-:math:`\V128.\LOAD\K{8\_splat}~\memarg`            :math:`\hex{FD}~~\hex{07}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
-:math:`\V128.\LOAD\K{16\_splat}~\memarg`           :math:`\hex{FD}~~\hex{08}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
-:math:`\V128.\LOAD\K{32\_splat}~\memarg`           :math:`\hex{FD}~~\hex{09}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
-:math:`\V128.\LOAD\K{64\_splat}~\memarg`           :math:`\hex{FD}~~\hex{0A}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-splat>`           :ref:`execution <exec-load-splat>`                                
-:math:`\V128.\STORE~\memarg`                       :math:`\hex{FD}~~\hex{0B}`            :math:`[\I32~\V128] \to []`                    :ref:`validation <valid-store>`                :ref:`execution <exec-store>`                                     
-:math:`\V128.\VCONST~\i128`                        :math:`\hex{FD}~~\hex{0C}`            :math:`[] \to [\V128]`                         :ref:`validation <valid-vconst>`               :ref:`execution <exec-vconst>`                                    
-:math:`\I8X16.\SHUFFLE~\laneidx^{16}`              :math:`\hex{FD}~~\hex{0D}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-shuffle>`          :ref:`execution <exec-vec-shuffle>`                               
-:math:`\I8X16.\SWIZZLE`                            :math:`\hex{FD}~~\hex{0E}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-swizzle>`                               
-:math:`\I8X16.\SPLAT`                              :math:`\hex{FD}~~\hex{0F}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
-:math:`\I16X8.\SPLAT`                              :math:`\hex{FD}~~\hex{10}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
-:math:`\I32X4.\SPLAT`                              :math:`\hex{FD}~~\hex{11}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
-:math:`\I64X2.\SPLAT`                              :math:`\hex{FD}~~\hex{12}`            :math:`[\I64] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
-:math:`\F32X4.\SPLAT`                              :math:`\hex{FD}~~\hex{13}`            :math:`[\F32] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
-:math:`\F64X2.\SPLAT`                              :math:`\hex{FD}~~\hex{14}`            :math:`[\F64] \to [\V128]`                     :ref:`validation <valid-vec-splat>`            :ref:`execution <exec-vec-splat>`                                 
-:math:`\I8X16.\EXTRACTLANE\K{\_s}~\laneidx`        :math:`\hex{FD}~~\hex{15}`            :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
-:math:`\I8X16.\EXTRACTLANE\K{\_u}~\laneidx`        :math:`\hex{FD}~~\hex{16}`            :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
-:math:`\I8X16.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{17}`            :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
-:math:`\I16X8.\EXTRACTLANE\K{\_s}~\laneidx`        :math:`\hex{FD}~~\hex{18}`            :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
-:math:`\I16X8.\EXTRACTLANE\K{\_u}~\laneidx`        :math:`\hex{FD}~~\hex{19}`            :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
-:math:`\I16X8.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{1A}`            :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
-:math:`\I32X4.\EXTRACTLANE~\laneidx`               :math:`\hex{FD}~~\hex{1B}`            :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
-:math:`\I32X4.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{1C}`            :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
-:math:`\I64X2.\EXTRACTLANE~\laneidx`               :math:`\hex{FD}~~\hex{1D}`            :math:`[\V128] \to [\I64]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
-:math:`\I64X2.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{1E}`            :math:`[\V128~\I64] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
-:math:`\F32X4.\EXTRACTLANE~\laneidx`               :math:`\hex{FD}~~\hex{1F}`            :math:`[\V128] \to [\F32]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
-:math:`\F32X4.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{20}`            :math:`[\V128~\F32] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
-:math:`\F64X2.\EXTRACTLANE~\laneidx`               :math:`\hex{FD}~~\hex{21}`            :math:`[\V128] \to [\F64]`                     :ref:`validation <valid-vec-extract_lane>`     :ref:`execution <exec-vec-extract_lane>`                          
-:math:`\F64X2.\REPLACELANE~\laneidx`               :math:`\hex{FD}~~\hex{22}`            :math:`[\V128~\F64] \to [\V128]`               :ref:`validation <valid-vec-replace_lane>`     :ref:`execution <exec-vec-replace_lane>`                          
-:math:`\I8X16.\VEQ`                                :math:`\hex{FD}~~\hex{23}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ieq>`          
-:math:`\I8X16.\VNE`                                :math:`\hex{FD}~~\hex{24}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ine>`          
-:math:`\I8X16.\VLT\K{\_s}`                         :math:`\hex{FD}~~\hex{25}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_s>`        
-:math:`\I8X16.\VLT\K{\_u}`                         :math:`\hex{FD}~~\hex{26}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_u>`        
-:math:`\I8X16.\VGT\K{\_s}`                         :math:`\hex{FD}~~\hex{27}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_s>`        
-:math:`\I8X16.\VGT\K{\_u}`                         :math:`\hex{FD}~~\hex{28}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_u>`        
-:math:`\I8X16.\VLE\K{\_s}`                         :math:`\hex{FD}~~\hex{29}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_s>`        
-:math:`\I8X16.\VLE\K{\_u}`                         :math:`\hex{FD}~~\hex{2A}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_u>`        
-:math:`\I8X16.\VGE\K{\_s}`                         :math:`\hex{FD}~~\hex{2B}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_s>`        
-:math:`\I8X16.\VGE\K{\_u}`                         :math:`\hex{FD}~~\hex{2C}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_u>`        
-:math:`\I16X8.\VEQ`                                :math:`\hex{FD}~~\hex{2D}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ieq>`          
-:math:`\I16X8.\VNE`                                :math:`\hex{FD}~~\hex{2E}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ine>`          
-:math:`\I16X8.\VLT\K{\_s}`                         :math:`\hex{FD}~~\hex{2F}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_s>`        
-:math:`\I16X8.\VLT\K{\_u}`                         :math:`\hex{FD}~~\hex{30}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_u>`        
-:math:`\I16X8.\VGT\K{\_s}`                         :math:`\hex{FD}~~\hex{31}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_s>`        
-:math:`\I16X8.\VGT\K{\_u}`                         :math:`\hex{FD}~~\hex{32}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_u>`        
-:math:`\I16X8.\VLE\K{\_s}`                         :math:`\hex{FD}~~\hex{33}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_s>`        
-:math:`\I16X8.\VLE\K{\_u}`                         :math:`\hex{FD}~~\hex{34}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_u>`        
-:math:`\I16X8.\VGE\K{\_s}`                         :math:`\hex{FD}~~\hex{35}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_s>`        
-:math:`\I16X8.\VGE\K{\_u}`                         :math:`\hex{FD}~~\hex{36}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_u>`        
-:math:`\I32X4.\VEQ`                                :math:`\hex{FD}~~\hex{37}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ieq>`          
-:math:`\I32X4.\VNE`                                :math:`\hex{FD}~~\hex{38}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ine>`          
-:math:`\I32X4.\VLT\K{\_s}`                         :math:`\hex{FD}~~\hex{39}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_s>`        
-:math:`\I32X4.\VLT\K{\_u}`                         :math:`\hex{FD}~~\hex{3A}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_u>`        
-:math:`\I32X4.\VGT\K{\_s}`                         :math:`\hex{FD}~~\hex{3B}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_s>`        
-:math:`\I32X4.\VGT\K{\_u}`                         :math:`\hex{FD}~~\hex{3C}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_u>`        
-:math:`\I32X4.\VLE\K{\_s}`                         :math:`\hex{FD}~~\hex{3D}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_s>`        
-:math:`\I32X4.\VLE\K{\_u}`                         :math:`\hex{FD}~~\hex{3E}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_u>`        
-:math:`\I32X4.\VGE\K{\_s}`                         :math:`\hex{FD}~~\hex{3F}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_s>`        
-:math:`\I32X4.\VGE\K{\_u}`                         :math:`\hex{FD}~~\hex{40}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_u>`        
-:math:`\F32X4.\VEQ`                                :math:`\hex{FD}~~\hex{41}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-feq>`          
-:math:`\F32X4.\VNE`                                :math:`\hex{FD}~~\hex{42}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fne>`          
-:math:`\F32X4.\VLT`                                :math:`\hex{FD}~~\hex{43}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-flt>`          
-:math:`\F32X4.\VGT`                                :math:`\hex{FD}~~\hex{44}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fgt>`          
-:math:`\F32X4.\VLE`                                :math:`\hex{FD}~~\hex{45}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fle>`          
-:math:`\F32X4.\VGE`                                :math:`\hex{FD}~~\hex{46}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fge>`          
-:math:`\F64X2.\VEQ`                                :math:`\hex{FD}~~\hex{47}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-feq>`          
-:math:`\F64X2.\VNE`                                :math:`\hex{FD}~~\hex{48}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fne>`          
-:math:`\F64X2.\VLT`                                :math:`\hex{FD}~~\hex{49}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-flt>`          
-:math:`\F64X2.\VGT`                                :math:`\hex{FD}~~\hex{4A}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fgt>`          
-:math:`\F64X2.\VLE`                                :math:`\hex{FD}~~\hex{4B}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fle>`          
-:math:`\F64X2.\VGE`                                :math:`\hex{FD}~~\hex{4C}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fge>`          
-:math:`\V128.\VNOT`                                :math:`\hex{FD}~~\hex{4D}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vvunop>`               :ref:`execution <exec-vvunop>`, :ref:`operator <op-inot>`         
-:math:`\V128.\VAND`                                :math:`\hex{FD}~~\hex{4E}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vvbinop>`              :ref:`execution <exec-vvbinop>`, :ref:`operator <op-iand>`        
-:math:`\V128.\VANDNOT`                             :math:`\hex{FD}~~\hex{4F}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vvbinop>`              :ref:`execution <exec-vvbinop>`, :ref:`operator <op-iandnot>`     
-:math:`\V128.\VOR`                                 :math:`\hex{FD}~~\hex{50}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vvbinop>`              :ref:`execution <exec-vvbinop>`, :ref:`operator <op-ior>`         
-:math:`\V128.\VXOR`                                :math:`\hex{FD}~~\hex{51}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vvbinop>`              :ref:`execution <exec-vvbinop>`, :ref:`operator <op-ixor>`        
-:math:`\V128.\BITSELECT`                           :math:`\hex{FD}~~\hex{52}`            :math:`[\V128~\V128~\V128] \to [\V128]`        :ref:`validation <valid-vvternop>`             :ref:`execution <exec-vvternop>`, :ref:`operator <op-ibitselect>` 
-:math:`\V128.\ANYTRUE`                             :math:`\hex{FD}~~\hex{53}`            :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vvtestop>`             :ref:`execution <exec-vvtestop>`                                  
-:math:`\V128.\LOAD\K{8\_lane}~\memarg~\laneidx`    :math:`\hex{FD}~~\hex{54}`            :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
-:math:`\V128.\LOAD\K{16\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{55}`            :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
-:math:`\V128.\LOAD\K{32\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{56}`            :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
-:math:`\V128.\LOAD\K{64\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{57}`            :math:`[\I32~\V128] \to [\V128]`               :ref:`validation <valid-load-lane>`            :ref:`execution <exec-load-lane>`                                 
-:math:`\V128.\STORE\K{8\_lane}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{58}`            :math:`[\I32~\V128] \to []`                    :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
-:math:`\V128.\STORE\K{16\_lane}~\memarg~\laneidx`  :math:`\hex{FD}~~\hex{59}`            :math:`[\I32~\V128] \to []`                    :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
-:math:`\V128.\STORE\K{32\_lane}~\memarg~\laneidx`  :math:`\hex{FD}~~\hex{5A}`            :math:`[\I32~\V128] \to []`                    :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
-:math:`\V128.\STORE\K{64\_lane}~\memarg~\laneidx`  :math:`\hex{FD}~~\hex{5B}`            :math:`[\I32~\V128] \to []`                    :ref:`validation <valid-store-lane>`           :ref:`execution <exec-store-lane>`                                
-:math:`\V128.\LOAD\K{32\_zero}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{5C}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-zero>`            :ref:`execution <exec-load-zero>`                                 
-:math:`\V128.\LOAD\K{64\_zero}~\memarg~\laneidx`   :math:`\hex{FD}~~\hex{5D}`            :math:`[\I32] \to [\V128]`                     :ref:`validation <valid-load-zero>`            :ref:`execution <exec-load-zero>`                                 
-:math:`\F32X4.\VDEMOTE\K{\_f64x2\_zero}`           :math:`\hex{FD}~~\hex{5E}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-demote>`       
-:math:`\F64X2.\VPROMOTE\K{\_low\_f32x4}`           :math:`\hex{FD}~~\hex{5F}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-promote>`      
-:math:`\I8X16.\VABS`                               :math:`\hex{FD}~~\hex{60}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-iabs>`          
-:math:`\I8X16.\VNEG`                               :math:`\hex{FD}~~\hex{61}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ineg>`          
-:math:`\I8X16.\VPOPCNT`                            :math:`\hex{FD}~~\hex{62}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ipopcnt>`       
-:math:`\I8X16.\ALLTRUE`                            :math:`\hex{FD}~~\hex{63}`            :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vtestop>`              :ref:`execution <exec-vtestop>`                                   
-:math:`\I8X16.\BITMASK`                            :math:`\hex{FD}~~\hex{64}`            :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-bitmask>`          :ref:`execution <exec-vec-bitmask>`                               
-:math:`\I8X16.\NARROW\K{\_i16x8\_s}`               :math:`\hex{FD}~~\hex{65}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-narrow>`                                
-:math:`\I8X16.\NARROW\K{\_i16x8\_u}`               :math:`\hex{FD}~~\hex{66}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-narrow>`                                
-:math:`\F32X4.\VCEIL`                              :math:`\hex{FD}~~\hex{67}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fceil>`         
-:math:`\F32X4.\VFLOOR`                             :math:`\hex{FD}~~\hex{68}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ffloor>`        
-:math:`\F32X4.\VTRUNC`                             :math:`\hex{FD}~~\hex{69}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ftrunc>`        
-:math:`\F32X4.\VNEAREST`                           :math:`\hex{FD}~~\hex{6A}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fnearest>`      
-:math:`\I8X16.\VSHL`                               :math:`\hex{FD}~~\hex{6B}`            :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishl>`      
-:math:`\I8X16.\VSHR\K{\_s}`                        :math:`\hex{FD}~~\hex{6C}`            :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_s>`    
-:math:`\I8X16.\VSHR\K{\_u}`                        :math:`\hex{FD}~~\hex{6D}`            :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_u>`    
-:math:`\I8X16.\VADD`                               :math:`\hex{FD}~~\hex{6E}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd>`         
-:math:`\I8X16.\VADD\K{\_sat\_s}`                   :math:`\hex{FD}~~\hex{6F}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd_sat_s>`   
-:math:`\I8X16.\VADD\K{\_sat\_u}`                   :math:`\hex{FD}~~\hex{70}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd_sat_u>`   
-:math:`\I8X16.\VSUB`                               :math:`\hex{FD}~~\hex{71}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub>`         
-:math:`\I8X16.\VSUB\K{\_sat\_s}`                   :math:`\hex{FD}~~\hex{72}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub_sat_s>`   
-:math:`\I8X16.\VSUB\K{\_sat\_u}`                   :math:`\hex{FD}~~\hex{73}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub_sat_u>`   
-:math:`\F64X2.\VCEIL`                              :math:`\hex{FD}~~\hex{74}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fceil>`         
-:math:`\F64X2.\VFLOOR`                             :math:`\hex{FD}~~\hex{75}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ffloor>`        
-:math:`\I8X16.\VMIN\K{\_s}`                        :math:`\hex{FD}~~\hex{76}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_s>`       
-:math:`\I8X16.\VMIN\K{\_u}`                        :math:`\hex{FD}~~\hex{77}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_u>`       
-:math:`\I8X16.\VMAX\K{\_s}`                        :math:`\hex{FD}~~\hex{78}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_s>`       
-:math:`\I8X16.\VMAX\K{\_u}`                        :math:`\hex{FD}~~\hex{79}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_u>`       
-:math:`\F64X2.\VTRUNC`                             :math:`\hex{FD}~~\hex{7A}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ftrunc>`        
-:math:`\I8X16.\AVGR\K{\_u}`                        :math:`\hex{FD}~~\hex{7B}`            :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iavgr_u>`      
-:math:`\I16X8.\EXTADDPAIRWISE\K{\_i8x16\_s}`       :math:`\hex{FD}~~\hex{7C}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vec-extadd_pairwise>`  :ref:`execution <exec-vec-extadd_pairwise>`                       
-:math:`\I16X8.\EXTADDPAIRWISE\K{\_i8x16\_u}`       :math:`\hex{FD}~~\hex{7D}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vec-extadd_pairwise>`  :ref:`execution <exec-vec-extadd_pairwise>`                       
-:math:`\I32X4.\EXTADDPAIRWISE\K{\_i16x8\_s}`       :math:`\hex{FD}~~\hex{7E}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vec-extadd_pairwise>`  :ref:`execution <exec-vec-extadd_pairwise>`                       
-:math:`\I32X4.\EXTADDPAIRWISE\K{\_i16x8\_u}`       :math:`\hex{FD}~~\hex{7F}`            :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vec-extadd_pairwise>`  :ref:`execution <exec-vec-extadd_pairwise>`                       
-:math:`\I16X8.\VABS`                               :math:`\hex{FD}~~\hex{80}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-iabs>`          
-:math:`\I16X8.\VNEG`                               :math:`\hex{FD}~~\hex{81}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ineg>`          
-:math:`\I16X8.\Q15MULRSAT\K{\_s}`                  :math:`\hex{FD}~~\hex{82}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iq15mulrsat_s>`
-:math:`\I16X8.\ALLTRUE`                            :math:`\hex{FD}~~\hex{83}~~\hex{01}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vtestop>`              :ref:`execution <exec-vtestop>`                                   
-:math:`\I16X8.\BITMASK`                            :math:`\hex{FD}~~\hex{84}~~\hex{01}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-bitmask>`          :ref:`execution <exec-vec-bitmask>`                               
-:math:`\I16X8.\NARROW\K{\_i32x4\_s}`               :math:`\hex{FD}~~\hex{85}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-narrow>`                                
-:math:`\I16X8.\NARROW\K{\_i32x4\_u}`               :math:`\hex{FD}~~\hex{86}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vec-narrow>`                                
-:math:`\I16X8.\VEXTEND\K{\_low\_i8x16\_s}`         :math:`\hex{FD}~~\hex{87}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I16X8.\VEXTEND\K{\_high\_i8x16\_s}`        :math:`\hex{FD}~~\hex{88}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I16X8.\VEXTEND\K{\_low\_i8x16\_u}`         :math:`\hex{FD}~~\hex{89}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I16X8.\VEXTEND\K{\_high\_i8x16\_u}`        :math:`\hex{FD}~~\hex{8A}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I16X8.\VSHL`                               :math:`\hex{FD}~~\hex{8B}~~\hex{01}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishl>`      
-:math:`\I16X8.\VSHR\K{\_s}`                        :math:`\hex{FD}~~\hex{8C}~~\hex{01}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_s>`    
-:math:`\I16X8.\VSHR\K{\_u}`                        :math:`\hex{FD}~~\hex{8D}~~\hex{01}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_u>`    
-:math:`\I16X8.\VADD`                               :math:`\hex{FD}~~\hex{8E}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd>`         
-:math:`\I16X8.\VADD\K{\_sat\_s}`                   :math:`\hex{FD}~~\hex{8F}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd_sat_s>`   
-:math:`\I16X8.\VADD\K{\_sat\_u}`                   :math:`\hex{FD}~~\hex{90}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd_sat_u>`   
-:math:`\I16X8.\VSUB`                               :math:`\hex{FD}~~\hex{91}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub>`         
-:math:`\I16X8.\VSUB\K{\_sat\_s}`                   :math:`\hex{FD}~~\hex{92}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub_sat_s>`   
-:math:`\I16X8.\VSUB\K{\_sat\_u}`                   :math:`\hex{FD}~~\hex{93}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub_sat_u>`   
-:math:`\F64X2.\VNEAREST`                           :math:`\hex{FD}~~\hex{94}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fnearest>`      
-:math:`\I16X8.\VMUL`                               :math:`\hex{FD}~~\hex{95}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imul>`         
-:math:`\I16X8.\VMIN\K{\_s}`                        :math:`\hex{FD}~~\hex{96}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_s>`       
-:math:`\I16X8.\VMIN\K{\_u}`                        :math:`\hex{FD}~~\hex{97}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_u>`       
-:math:`\I16X8.\VMAX\K{\_s}`                        :math:`\hex{FD}~~\hex{98}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_s>`       
-:math:`\I16X8.\VMAX\K{\_u}`                        :math:`\hex{FD}~~\hex{99}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_u>`       
-:math:`\I16X8.\AVGR\K{\_u}`                        :math:`\hex{FD}~~\hex{9B}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iavgr_u>`      
-:math:`\I16X8.\EXTMUL\K{\_low\_i8x16\_s}`          :math:`\hex{FD}~~\hex{9C}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I16X8.\EXTMUL\K{\_high\_i8x16\_s}`         :math:`\hex{FD}~~\hex{9D}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I16X8.\EXTMUL\K{\_low\_i8x16\_u}`          :math:`\hex{FD}~~\hex{9E}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I16X8.\EXTMUL\K{\_high\_i8x16\_u}`         :math:`\hex{FD}~~\hex{9F}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I32X4.\VABS`                               :math:`\hex{FD}~~\hex{A0}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-iabs>`          
-:math:`\I32X4.\VNEG`                               :math:`\hex{FD}~~\hex{A1}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ineg>`          
-:math:`\I32X4.\ALLTRUE`                            :math:`\hex{FD}~~\hex{A3}~~\hex{01}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vtestop>`              :ref:`execution <exec-vtestop>`                                   
-:math:`\I32X4.\BITMASK`                            :math:`\hex{FD}~~\hex{A4}~~\hex{01}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-bitmask>`          :ref:`execution <exec-vec-bitmask>`                               
-:math:`\I32X4.\VEXTEND\K{\_low\_i16x8\_s}`         :math:`\hex{FD}~~\hex{A7}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I32X4.\VEXTEND\K{\_high\_i16x8\_s}`        :math:`\hex{FD}~~\hex{A8}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I32X4.\VEXTEND\K{\_low\_i16x8\_u}`         :math:`\hex{FD}~~\hex{A9}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I32X4.\VEXTEND\K{\_high\_i16x8\_u}`        :math:`\hex{FD}~~\hex{AA}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I32X4.\VSHL`                               :math:`\hex{FD}~~\hex{AB}~~\hex{01}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishl>`      
-:math:`\I32X4.\VSHR\K{\_s}`                        :math:`\hex{FD}~~\hex{AC}~~\hex{01}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_s>`    
-:math:`\I32X4.\VSHR\K{\_u}`                        :math:`\hex{FD}~~\hex{AD}~~\hex{01}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_u>`    
-:math:`\I32X4.\VADD`                               :math:`\hex{FD}~~\hex{AE}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd>`         
-:math:`\I32X4.\VSUB`                               :math:`\hex{FD}~~\hex{B1}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub>`         
-:math:`\I32X4.\VMUL`                               :math:`\hex{FD}~~\hex{B5}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imul>`         
-:math:`\I32X4.\VMIN\K{\_s}`                        :math:`\hex{FD}~~\hex{B6}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_s>`       
-:math:`\I32X4.\VMIN\K{\_u}`                        :math:`\hex{FD}~~\hex{B7}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imin_u>`       
-:math:`\I32X4.\VMAX\K{\_s}`                        :math:`\hex{FD}~~\hex{B8}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_s>`       
-:math:`\I32X4.\VMAX\K{\_u}`                        :math:`\hex{FD}~~\hex{B9}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imax_u>`       
-:math:`\I32X4.\DOT\K{\_i16x8\_s}`                  :math:`\hex{FD}~~\hex{BA}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-dot>`              :ref:`execution <exec-vec-dot>`                                   
-:math:`\I32X4.\EXTMUL\K{\_low\_i16x8\_s}`          :math:`\hex{FD}~~\hex{BC}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I32X4.\EXTMUL\K{\_high\_i16x8\_s}`         :math:`\hex{FD}~~\hex{BD}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I32X4.\EXTMUL\K{\_low\_i16x8\_u}`          :math:`\hex{FD}~~\hex{BE}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I32X4.\EXTMUL\K{\_high\_i16x8\_u}`         :math:`\hex{FD}~~\hex{BF}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I64X2.\VABS`                               :math:`\hex{FD}~~\hex{C0}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-iabs>`          
-:math:`\I64X2.\VNEG`                               :math:`\hex{FD}~~\hex{C1}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-ineg>`          
-:math:`\I64X2.\ALLTRUE`                            :math:`\hex{FD}~~\hex{C3}~~\hex{01}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vtestop>`              :ref:`execution <exec-vtestop>`                                   
-:math:`\I64X2.\BITMASK`                            :math:`\hex{FD}~~\hex{C4}~~\hex{01}`  :math:`[\V128] \to [\I32]`                     :ref:`validation <valid-vec-bitmask>`          :ref:`execution <exec-vec-bitmask>`                               
-:math:`\I64X2.\VEXTEND\K{\_low\_i32x4\_s}`         :math:`\hex{FD}~~\hex{C7}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I64X2.\VEXTEND\K{\_high\_i32x4\_s}`        :math:`\hex{FD}~~\hex{C8}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I64X2.\VEXTEND\K{\_low\_i32x4\_u}`         :math:`\hex{FD}~~\hex{C9}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I64X2.\VEXTEND\K{\_high\_i32x4\_u}`        :math:`\hex{FD}~~\hex{CA}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vcvtop>`                                    
-:math:`\I64X2.\VSHL`                               :math:`\hex{FD}~~\hex{CB}~~\hex{01}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishl>`      
-:math:`\I64X2.\VSHR\K{\_s}`                        :math:`\hex{FD}~~\hex{CC}~~\hex{01}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_s>`    
-:math:`\I64X2.\VSHR\K{\_u}`                        :math:`\hex{FD}~~\hex{CD}~~\hex{01}`  :math:`[\V128~\I32] \to [\V128]`               :ref:`validation <valid-vishiftop>`            :ref:`execution <exec-vishiftop>`, :ref:`operator <op-ishr_u>`    
-:math:`\I64X2.\VADD`                               :math:`\hex{FD}~~\hex{CE}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-iadd>`         
-:math:`\I64X2.\VSUB`                               :math:`\hex{FD}~~\hex{D1}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-isub>`         
-:math:`\I64X2.\VMUL`                               :math:`\hex{FD}~~\hex{D5}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-imul>`         
-:math:`\I64X2.\VEQ`                                :math:`\hex{FD}~~\hex{D6}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ieq>`          
-:math:`\I64X2.\VNE`                                :math:`\hex{FD}~~\hex{D7}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ine>`          
-:math:`\I64X2.\VLT\K{\_s}`                         :math:`\hex{FD}~~\hex{D8}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ilt_s>`        
-:math:`\I64X2.\VGT\K{\_s}`                         :math:`\hex{FD}~~\hex{D9}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-igt_s>`        
-:math:`\I64X2.\VLE\K{\_s}`                         :math:`\hex{FD}~~\hex{DA}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ile_s>`        
-:math:`\I64X2.\VGE\K{\_s}`                         :math:`\hex{FD}~~\hex{DB}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-ige_s>`        
-:math:`\I64X2.\EXTMUL\K{\_low\_i32x4\_s}`          :math:`\hex{FD}~~\hex{DC}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I64X2.\EXTMUL\K{\_high\_i32x4\_s}`         :math:`\hex{FD}~~\hex{DD}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I64X2.\EXTMUL\K{\_low\_i32x4\_u}`          :math:`\hex{FD}~~\hex{DE}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\I64X2.\EXTMUL\K{\_high\_i32x4\_u}`         :math:`\hex{FD}~~\hex{DF}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vec-extmul>`           :ref:`execution <exec-vec-extmul>`                                
-:math:`\F32X4.\VABS`                               :math:`\hex{FD}~~\hex{E0}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fabs>`          
-:math:`\F32X4.\VNEG`                               :math:`\hex{FD}~~\hex{E1}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fneg>`          
-:math:`\F32X4.\VSQRT`                              :math:`\hex{FD}~~\hex{E3}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fsqrt>`         
-:math:`\F32X4.\VADD`                               :math:`\hex{FD}~~\hex{E4}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fadd>`         
-:math:`\F32X4.\VSUB`                               :math:`\hex{FD}~~\hex{E5}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fsub>`         
-:math:`\F32X4.\VMUL`                               :math:`\hex{FD}~~\hex{E6}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmul>`         
-:math:`\F32X4.\VDIV`                               :math:`\hex{FD}~~\hex{E7}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fdiv>`         
-:math:`\F32X4.\VMIN`                               :math:`\hex{FD}~~\hex{E8}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmin>`         
-:math:`\F32X4.\VMAX`                               :math:`\hex{FD}~~\hex{E9}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmax>`         
-:math:`\F32X4.\VPMIN`                              :math:`\hex{FD}~~\hex{EA}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fpmin>`        
-:math:`\F32X4.\VPMAX`                              :math:`\hex{FD}~~\hex{EB}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fpmax>`        
-:math:`\F64X2.\VABS`                               :math:`\hex{FD}~~\hex{EC}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fabs>`          
-:math:`\F64X2.\VNEG`                               :math:`\hex{FD}~~\hex{ED}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fneg>`          
-:math:`\F64X2.\VSQRT`                              :math:`\hex{FD}~~\hex{EF}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vunop>`                :ref:`execution <exec-vunop>`, :ref:`operator <op-fsqrt>`         
-:math:`\F64X2.\VADD`                               :math:`\hex{FD}~~\hex{F0}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fadd>`         
-:math:`\F64X2.\VSUB`                               :math:`\hex{FD}~~\hex{F1}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fsub>`         
-:math:`\F64X2.\VMUL`                               :math:`\hex{FD}~~\hex{F2}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmul>`         
-:math:`\F64X2.\VDIV`                               :math:`\hex{FD}~~\hex{F3}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fdiv>`         
-:math:`\F64X2.\VMIN`                               :math:`\hex{FD}~~\hex{F4}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmin>`         
-:math:`\F64X2.\VMAX`                               :math:`\hex{FD}~~\hex{F5}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fmax>`         
-:math:`\F64X2.\VPMIN`                              :math:`\hex{FD}~~\hex{F6}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fpmin>`        
-:math:`\F64X2.\VPMAX`                              :math:`\hex{FD}~~\hex{F7}~~\hex{01}`  :math:`[\V128~\V128] \to [\V128]`              :ref:`validation <valid-vbinop>`               :ref:`execution <exec-vbinop>`, :ref:`operator <op-fpmax>`        
-:math:`\I32X4.\TRUNC\K{\_sat\_f32x4\_s}`           :math:`\hex{FD}~~\hex{F8}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-trunc_sat_s>`  
-:math:`\I32X4.\TRUNC\K{\_sat\_f32x4\_u}`           :math:`\hex{FD}~~\hex{F9}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-trunc_sat_u>`  
-:math:`\F32X4.\VCONVERT\K{\_i32x4\_s}`             :math:`\hex{FD}~~\hex{FA}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_s>`    
-:math:`\F32X4.\VCONVERT\K{\_i32x4\_u}`             :math:`\hex{FD}~~\hex{FB}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_u>`    
-:math:`\I32X4.\VTRUNC\K{\_sat\_f64x2\_s\_zero}`    :math:`\hex{FD}~~\hex{FC}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-trunc_sat_s>`  
-:math:`\I32X4.\VTRUNC\K{\_sat\_f64x2\_u\_zero}`    :math:`\hex{FD}~~\hex{FD}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-trunc_sat_u>`  
-:math:`\F64X2.\VCONVERT\K{\_low\_i32x4\_s}`        :math:`\hex{FD}~~\hex{FE}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_s>`    
-:math:`\F64X2.\VCONVERT\K{\_low\_i32x4\_u}`        :math:`\hex{FD}~~\hex{FF}~~\hex{01}`  :math:`[\V128] \to [\V128]`                    :ref:`validation <valid-vcvtop>`               :ref:`execution <exec-vcvtop>`, :ref:`operator <op-convert_u>`    
-=================================================  ====================================  =============================================  =============================================  ==================================================================
-
-.. note::
-   Multi-byte opcodes are given with the shortest possible encoding in the table.
-   However, what is following the first byte is actually a :ref:`u32 <binary-uint>` with variable-length encoding
-   and consequently has multiple possible representations.

From 55333ae8ea53249c2749216e833b5834c73f8d98 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 1 Mar 2023 09:50:47 +0100
Subject: [PATCH 280/285] [spec] Rename script

---
 document/core/Makefile                                          | 2 +-
 .../{gen-index-instructions.py => index-instructions.py}        | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)
 rename document/core/appendix/{gen-index-instructions.py => index-instructions.py} (99%)

diff --git a/document/core/Makefile b/document/core/Makefile
index bfbf70bfc..d8b357c73 100644
--- a/document/core/Makefile
+++ b/document/core/Makefile
@@ -91,7 +91,7 @@ bikeshed-keep:
 
 .PHONY: index
 index:
-	(cd appendix; ./gen-index-instructions.py)
+	(cd appendix; ./index-instructions.py)
 
 .PHONY: pdf
 pdf:	index latexpdf
diff --git a/document/core/appendix/gen-index-instructions.py b/document/core/appendix/index-instructions.py
similarity index 99%
rename from document/core/appendix/gen-index-instructions.py
rename to document/core/appendix/index-instructions.py
index fffa2b329..2503a7ab0 100755
--- a/document/core/appendix/gen-index-instructions.py
+++ b/document/core/appendix/index-instructions.py
@@ -12,7 +12,7 @@
 INDEX_INSTRUCTIONS_RST = os.path.join(SCRIPT_DIR, 'index-instructions.rst')
 
 HEADER = """\
-.. DO NOT EDIT: This file is auto-generated by the gen-index-instructions.py script.
+.. DO NOT EDIT: This file is auto-generated by the index-instructions.py script.
 
 .. index:: instruction
 .. _index-instr:

From 269f18b7d0ce330b809a4deaf658704c6e735419 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 1 Mar 2023 10:19:20 +0100
Subject: [PATCH 281/285] [ci] deactivate node run for now

---
 .github/workflows/main.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index a158de1ee..7cd34fbcd 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -23,7 +23,9 @@ jobs:
         uses: actions/setup-node@v1
         with:
           node-version: 19.x
-      - run: cd interpreter && opam exec make JS=node all
+      # TODO: disable node.js run until it fully implements proposal
+      # - run: cd interpreter && opam exec make JS=node all
+      - run: cd interpreter && opam exec make all
 
   ref-interpreter-js-library:
     runs-on: ubuntu-latest

From c2a9001438fdbb6cc09b3b8f329050cac6b58556 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 1 Mar 2023 20:19:19 +0100
Subject: [PATCH 282/285] Fix uses of \to; compositionality

---
 document/core/appendix/embedding.rst   |  6 +--
 document/core/appendix/index-rules.rst |  2 +-
 document/core/appendix/index-types.rst |  2 +-
 document/core/appendix/properties.rst  | 54 +++++++++++++++++++------
 document/core/exec/instructions.rst    | 16 ++++----
 document/core/exec/modules.rst         |  6 +--
 document/core/exec/runtime.rst         |  4 +-
 document/core/syntax/instructions.rst  |  2 +-
 document/core/syntax/types.rst         |  4 +-
 document/core/text/modules.rst         |  8 ++--
 document/core/util/macros.def          |  4 +-
 document/core/valid/instructions.rst   | 56 +++++++++++++-------------
 document/core/valid/matching.rst       |  8 ++--
 document/core/valid/modules.rst        | 12 +++---
 document/core/valid/types.rst          | 16 ++++----
 15 files changed, 115 insertions(+), 85 deletions(-)

diff --git a/document/core/appendix/embedding.rst b/document/core/appendix/embedding.rst
index e9c7dbd2e..dda856738 100644
--- a/document/core/appendix/embedding.rst
+++ b/document/core/appendix/embedding.rst
@@ -132,7 +132,7 @@ Modules
 
 .. math::
    \begin{array}{lclll}
-   \F{module\_validate}(m) &=& \epsilon && (\iff {} \vdashmodule m : \externtype^\ast \to {\externtype'}^\ast) \\
+   \F{module\_validate}(m) &=& \epsilon && (\iff {} \vdashmodule m : \externtype^\ast \rightarrow {\externtype'}^\ast) \\
    \F{module\_validate}(m) &=& \ERROR && (\otherwise) \\
    \end{array}
 
@@ -185,7 +185,7 @@ Modules
    ~ \\
    \begin{array}{lclll}
    \F{module\_imports}(m) &=& (\X{im}.\IMODULE, \X{im}.\INAME, \externtype)^\ast \\
-     && \qquad (\iff \X{im}^\ast = m.\MIMPORTS \wedge {} \vdashmodule m : \externtype^\ast \to {\externtype'}^\ast) \\
+     && \qquad (\iff \X{im}^\ast = m.\MIMPORTS \wedge {} \vdashmodule m : \externtype^\ast \rightarrow {\externtype'}^\ast) \\
    \end{array}
 
 
@@ -213,7 +213,7 @@ Modules
    ~ \\
    \begin{array}{lclll}
    \F{module\_exports}(m) &=& (\X{ex}.\ENAME, \externtype')^\ast \\
-     && \qquad (\iff \X{ex}^\ast = m.\MEXPORTS \wedge {} \vdashmodule m : \externtype^\ast \to {\externtype'}^\ast) \\
+     && \qquad (\iff \X{ex}^\ast = m.\MEXPORTS \wedge {} \vdashmodule m : \externtype^\ast \rightarrow {\externtype'}^\ast) \\
    \end{array}
 
 
diff --git a/document/core/appendix/index-rules.rst b/document/core/appendix/index-rules.rst
index d4503a92b..ba337a76d 100644
--- a/document/core/appendix/index-rules.rst
+++ b/document/core/appendix/index-rules.rst
@@ -43,7 +43,7 @@ Construct                                        Judgement
 :ref:`Export description <valid-exportdesc>`     :math:`C \vdashexportdesc \exportdesc : \externtype`
 :ref:`Import <valid-import>`                     :math:`C \vdashimport \import : \externtype`
 :ref:`Import description <valid-importdesc>`     :math:`C \vdashimportdesc \importdesc : \externtype`
-:ref:`Module <valid-module>`                     :math:`\vdashmodule \module : \externtype^\ast \to \externtype^\ast`
+:ref:`Module <valid-module>`                     :math:`\vdashmodule \module : \externtype^\ast \rightarrow \externtype^\ast`
 ===============================================  ===============================================================================
 
 
diff --git a/document/core/appendix/index-types.rst b/document/core/appendix/index-types.rst
index e8988f5f5..9db74d3b3 100644
--- a/document/core/appendix/index-types.rst
+++ b/document/core/appendix/index-types.rst
@@ -20,7 +20,7 @@ Category                                  Constructor
 :ref:`Reference type <syntax-reftype>`    |REF| |NULL|                                 :math:`\hex{6C}` (-20 as |Bs7|)
 :ref:`Reference type <syntax-reftype>`    |REF|                                        :math:`\hex{6B}` (-21 as |Bs7|)
 (reserved)                                                                             :math:`\hex{6A}` .. :math:`\hex{61}`
-:ref:`Function type <syntax-functype>`    :math:`[\valtype^\ast] \to [\valtype^\ast]`  :math:`\hex{60}` (-32 as |Bs7|)
+:ref:`Function type <syntax-functype>`    :math:`[\valtype^\ast] \toF[\valtype^\ast]`  :math:`\hex{60}` (-32 as |Bs7|)
 (reserved)                                                                             :math:`\hex{5F}` .. :math:`\hex{41}`
 :ref:`Result type <syntax-resulttype>`    :math:`[\epsilon]`                           :math:`\hex{40}` (-64 as |Bs7|)
 :ref:`Table type <syntax-tabletype>`      :math:`\limits~\reftype`                     (none)
diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index d30ae8bb2..cd52c3999 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -191,7 +191,7 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 
 * The :ref:`type instance <syntax-typeinst>` :math:`S.\STYPES[\typeaddr]` must exist.
 
-* Let the :ref:`dynamic <syntax-type-dyn>` :ref:`function type <syntax-functype>` :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`type instance <syntax-typeinst>` :math:`S.\STYPES[\typeaddr]`.
+* Let the :ref:`dynamic <syntax-type-dyn>` :ref:`function type <syntax-functype>` :math:`[t_1^\ast] \toF [t_2^\ast]` be the :ref:`type instance <syntax-typeinst>` :math:`S.\STYPES[\typeaddr]`.
 
 * For every :ref:`valid <valid-store>` :ref:`store <syntax-store>` :math:`S_1` :ref:`extending <extend-store>` :math:`S` and every sequence :math:`\val^\ast` of :ref:`values <syntax-val>` whose :ref:`types <valid-val>` coincide with :math:`t_1^\ast`:
 
@@ -208,7 +208,7 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 .. math::
    \frac{
      \begin{array}[b]{@{}l@{}}
-     S.\STYPES[\typeaddr] = [t_1^\ast] \to [t_2^\ast] \\
+     S.\STYPES[\typeaddr] = [t_1^\ast] \toF [t_2^\ast] \\
      \end{array}
      \quad
      \begin{array}[b]{@{}l@{}}
@@ -678,7 +678,7 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
 
 * Assert: The :ref:`type address <syntax-typeaddr>` :math:`S.\STYPES[a']` is defined in the store.
 
-* Let :math:`[t_1^\ast] \to [t_2^\ast])` be the :ref:`function type <syntax-functype>` :math:`S.\STYPES[a']`.
+* Let :math:`[t_1^\ast] \toF [t_2^\ast])` be the :ref:`function type <syntax-functype>` :math:`S.\STYPES[a']`.
 
 * Then the instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`.
 
@@ -686,7 +686,7 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
    \frac{
      S \vdashexternval \EVFUNC~\funcaddr : \ETFUNC~a'
      \qquad
-     S.\STYPES[a'] = [t_1^\ast] \to [t_2^\ast]
+     S.\STYPES[a'] = [t_1^\ast] \toF [t_2^\ast]
    }{
      S; C \vdashadmininstr \INVOKE~\funcaddr : [t_1^\ast] \to [t_2^\ast]
    }
@@ -697,20 +697,20 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
 :math:`\LABEL_n\{\instr_0^\ast\}~\instr^\ast~\END`
 ..................................................
 
-* The instruction sequence :math:`\instr_0^\ast` must be :ref:`valid <valid-instr-seq>` with some type :math:`[t_1^n] \to_{x^\ast} [t_2^*]`.
+* The instruction sequence :math:`\instr_0^\ast` must be :ref:`valid <valid-instr-seq>` with some type :math:`[t_1^n] \toX{x^\ast} [t_2^*]`.
 
 * Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the :ref:`result type <syntax-resulttype>` :math:`[t_1^n]` prepended to the |CLABELS| vector.
 
 * Under context :math:`C'`,
-  the instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[] \to_{{x'}^\ast} [t_2^*]`.
+  the instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[] \toX{{x'}^\ast} [t_2^*]`.
 
 * Then the compound instruction is valid with type :math:`[] \to [t_2^*]`.
 
 .. math::
    \frac{
-     S; C \vdashinstrseq \instr_0^\ast : [t_1^n] \to_{x^\ast} [t_2^*]
+     S; C \vdashinstrseq \instr_0^\ast : [t_1^n] \toX{x^\ast} [t_2^*]
      \qquad
-     S; C,\CLABELS\,[t_1^n] \vdashinstrseq \instr^\ast : [] \to_{{x'}^\ast} [t_2^*]
+     S; C,\CLABELS\,[t_1^n] \vdashinstrseq \instr^\ast : [] \toX{{x'}^\ast} [t_2^*]
    }{
      S; C \vdashadmininstr \LABEL_n\{\instr_0^\ast\}~\instr^\ast~\END : [] \to [t_2^*]
    }
@@ -1013,7 +1013,7 @@ Consequently, given a :ref:`valid store <valid-store>`, no computation defined b
 Type System Properties
 ----------------------
 
-.. index:: ! principal types, type system, subtyping, polymorphism, instruction, syntax
+.. index:: ! principal types, type system, subtyping, polymorphism, instruction, syntax, instruction type
 .. _principality:
 
 Principal Types
@@ -1068,15 +1068,15 @@ such that :math:`\sigma(\instrtype_{\min})` is a subtype of :math:`\instrtype'`
 Furthermore, :math:`\instrtype_{\min}` is unique up to the choice of type variables.
 
 **Theorem (Closed Principal Forward Types).**
-If closed input type :math:`[t_1^\ast]` is given and the instruction sequence :math:`\instr^\ast` is :ref:`valid <valid-config>` with :ref:`instruction type <syntax-instrtype>` :math:`[t_1^\ast] \to_{{\!x^\ast}} [t_2^\ast]` (i.e., :math:`C \vdashinstrseq \instr^\ast : [t_1^\ast] \to_{{\!x^\ast}} [t_2^\ast]`),
-then it is also valid with instruction type :math:`[t_1^\ast] \to_{{\!x^\ast}} [\alpha_{\valtype^\ast}~t^\ast]` (i.e., :math:`C \vdashinstrseq \instr^\ast : [t_1^\ast] \to_{\!x^\ast} [\alpha_{\valtype^\ast}~t^\ast]`),
+If closed input type :math:`[t_1^\ast]` is given and the instruction sequence :math:`\instr^\ast` is :ref:`valid <valid-config>` with :ref:`instruction type <syntax-instrtype>` :math:`[t_1^\ast] \toX{x^\ast} [t_2^\ast]` (i.e., :math:`C \vdashinstrseq \instr^\ast : [t_1^\ast] \toX{x^\ast} [t_2^\ast]`),
+then it is also valid with instruction type :math:`[t_1^\ast] \toX{x^\ast} [\alpha_{\valtype^\ast}~t^\ast]` (i.e., :math:`C \vdashinstrseq \instr^\ast : [t_1^\ast] \toX{x^\ast} [\alpha_{\valtype^\ast}~t^\ast]`),
 where all :math:`t^\ast` are closed,
-such that for *every* closed result type :math:`[{t'_2}^\ast]` with which :math:`\instr^\ast` is valid (i.e., for all :math:`C \vdashinstrseq \instr^\ast : [t_1^\ast] \to_{\!x^\ast} [{t'_2}^\ast]`),
+such that for *every* closed result type :math:`[{t'_2}^\ast]` with which :math:`\instr^\ast` is valid (i.e., for all :math:`C \vdashinstrseq \instr^\ast : [t_1^\ast] \toX{x^\ast} [{t'_2}^\ast]`),
 there exists a substitution :math:`\sigma`,
 such that :math:`[{t'_2}^\ast] = [\sigma(\alpha_{\valtype^\ast})~t^\ast]`.
 
 
-.. index:: ! type lattice, subtyping, least upper bound, greatest lower bound
+.. index:: ! type lattice, subtyping, least upper bound, greatest lower bound, instruction type
 
 Type Lattice
 ~~~~~~~~~~~~
@@ -1127,3 +1127,31 @@ do not have common subtypes either (other than :math:`\BOT` or :math:`\REF~\BOT`
 .. note::
    Types from disjoint hierarchies can safely be represented in mutually incompatible ways in an implementation,
    because their values can never flow to the same place.
+
+
+.. index:: ! compositionality, instruction type, subtyping
+
+Compositionality
+~~~~~~~~~~~~~~~~
+
+:ref:`Valid <valid-instr-seq>` :ref:`instruction sequences <syntax-instr>` can be freely *composed*, as long as their types match up.
+
+**Theorem (Composition).**
+If two instruction sequences :math:`\instr_1^\ast` and :math:`\instr_2^\ast` are valid with types :math:`[t_1^\ast] \toX{x_1^\ast} [t^\ast]` and  :math:`[t^\ast] \toX{x_2^\ast} [t_2^\ast]`, respectively (i.e., :math:`C \vdashinstrseq \instr_1^\ast : [t_1^\ast] \toX{x_1^\ast} [t^\ast]` and :math:`C \vdashinstrseq \instr_1^\ast : [t^\ast] \toX{x_2^\ast} [t_2^\ast]`),
+then the concatenated instruction sequence :math:`(\instr_1^\ast\;\instr_2^\ast)` is valid with type :math:`[t_1^\ast] \toX{x_1^\ast\,x_2^\ast} [t_2^\ast]` (i.e., :math:`C \vdashinstrseq \instr_1^\ast\;\instr_2^\ast : [t_1^\ast] \toX{x_1^\ast\,x_2^\ast} [t_2^\ast]`).
+
+.. note::
+   More generally, instead of a shared type :math:`[t^\ast]`, it suffices if the output type of :math:`\instr_1^\ast` is a :ref:`subtype <match-resulttype>` of the input type of  :math:`\instr_1^\ast`,
+   since the subtype can always be weakened to its supertype by subsumption.
+
+Inversely, valid instruction sequences can also freely be *decomposed*, that is, splitting them anywhere produces two instruction sequences that are both :ref:`valid <valid-instr-seq>`.
+
+**Theorem (Decomposition).**
+If an instruction sequence :math:`\instr^\ast` that is valid with type :math:`[t_1^\ast] \toX{x^\ast} [t_2^\ast]` (i.e., :math:`C \vdashinstrseq \instr^\ast : [t_1^\ast] \toX{x^\ast} [t_2^\ast]`)
+is split into two instruction sequences :math:`\instr_1^\ast` and :math:`\instr_2^\ast` at any point (i.e., :math:`\instr^\ast = \instr_1^\ast\;\instr_2^\ast`),
+then these are separately valid with some types :math:`[t_1^\ast] \toX{x_1^\ast} [t^\ast]` and  :math:`[t^\ast] \toX{x_2^\ast} [t_2^\ast]`, respectively (i.e., :math:`C \vdashinstrseq \instr_1^\ast : [t_1^\ast] \toX{x_1^\ast} [t^\ast]` and :math:`C \vdashinstrseq \instr_1^\ast : [t^\ast] \toX{x_2^\ast} [t_2^\ast]`),
+where :math:`x^\ast = x_1^\ast\;x_2^\ast`.
+
+.. note::
+   This property holds because validation is required even for unreachable code.
+   Without that, :math:`\instr_2^\ast` might not be valid in isolation.
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index a5d34b839..f5154fd50 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -2563,7 +2563,7 @@ Control Instructions
 
 1. Assert: due to :ref:`validation <valid-blocktype>`, :math:`\expand_{S;F}(\blocktype)` is defined.
 
-2. Let :math:`[t_1^m] \to [t_2^n]` be the :ref:`function type <syntax-functype>` :math:`\expand_{S;F}(\blocktype)`.
+2. Let :math:`[t_1^m] \to [t_2^n]` be the :ref:`instruction type <syntax-instrtype>` :math:`\expand_{S;F}(\blocktype)`.
 
 3. Let :math:`L` be the label whose arity is :math:`n` and whose continuation is the end of the block.
 
@@ -2589,7 +2589,7 @@ Control Instructions
 
 1. Assert: due to :ref:`validation <valid-blocktype>`, :math:`\expand_{S;F}(\blocktype)` is defined.
 
-2. Let :math:`[t_1^m] \to [t_2^n]` be the :ref:`function type <syntax-functype>` :math:`\expand_{S;F}(\blocktype)`.
+2. Let :math:`[t_1^m] \to [t_2^n]` be the :ref:`instruction type <syntax-instrtype>` :math:`\expand_{S;F}(\blocktype)`.
 
 3. Let :math:`L` be the label whose arity is :math:`m` and whose continuation is the start of the loop.
 
@@ -3116,7 +3116,7 @@ Invocation of :ref:`function address <syntax-funcaddr>` :math:`a`
 
 3. Let :math:`\X{ta}` be the :ref:`type address <syntax-typeaddr>` :math:`\X{f}.\FITYPE`.
 
-4. Let :math:`[t_1^n] \to [t_2^m]` be the :ref:`function type <syntax-functype>` :math:`S.\STYPES[\X{ta}]`.
+4. Let :math:`[t_1^n] \toF [t_2^m]` be the :ref:`function type <syntax-functype>` :math:`S.\STYPES[\X{ta}]`.
 
 5. Let :math:`\local^\ast` be the list of :ref:`locals <syntax-local>` :math:`f.\FICODE.\FLOCALS`.
 
@@ -3143,7 +3143,7 @@ Invocation of :ref:`function address <syntax-funcaddr>` :math:`a`
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
      (\iff & S.\SFUNCS[a] = f \\
-     \wedge & S.\STYPES[f.\FITYPE] = [t_1^n] \to [t_2^m] \\
+     \wedge & S.\STYPES[f.\FITYPE] = [t_1^n] \toF [t_2^m] \\
      \wedge & f.\FICODE = \{ \FTYPE~x, \FLOCALS~\{\LTYPE~t\}^k, \FBODY~\instr^\ast~\END \} \\
      \wedge & F = \{ \AMODULE~f.\FIMODULE, ~\ALOCALS~\val^n~(\default_t)^k \})
      \end{array} \\
@@ -3160,7 +3160,7 @@ Tail-invocation of :ref:`function address <syntax-funcaddr>` :math:`a`
 
 1. Assert: due to :ref:`validation <valid-call>`, :math:`S.\SFUNCS[a]` exists.
 
-2. Let :math:`[t_1^n] \to [t_2^m]` be the :ref:`function type <syntax-functype>` :math:`S.\SFUNCS[a].\FITYPE`.
+2. Let :math:`[t_1^n] \toF [t_2^m]` be the :ref:`function type <syntax-functype>` :math:`S.\SFUNCS[a].\FITYPE`.
 
 3. Assert: due to :ref:`validation <valid-return_call>`, there are at least :math:`n` values on the top of the stack.
 
@@ -3185,7 +3185,7 @@ Tail-invocation of :ref:`function address <syntax-funcaddr>` :math:`a`
    \begin{array}{lcl@{\qquad}l}
     S; \FRAME_m\{F\}~B^\ast[\val^n~(\RETURNINVOKE~a)]~\END &\stepto&
       \val^n~(\INVOKE~a)
-      & (\iff S.\SFUNCS[a].\FITYPE = [t_1^n] \to [t_2^m])
+      & (\iff S.\SFUNCS[a].\FITYPE = [t_1^n] \toF [t_2^m])
    \end{array}
 
 
@@ -3243,7 +3243,7 @@ Furthermore, the resulting store must be :ref:`valid <valid-store>`, i.e., all d
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
      (\iff & S.\SFUNCS[a] = \{ \FITYPE~\X{ta}, \FIHOSTCODE~\X{hf} \} \\
-     \wedge & S.\STYPES[\X{ta}] = [t_1^n] \to [t_2^m] \\
+     \wedge & S.\STYPES[\X{ta}] = [t_1^n] \toF [t_2^m] \\
      \wedge & (S'; \result) \in \X{hf}(S; \val^n)) \\
      \end{array} \\
    \begin{array}{lcl@{\qquad}l}
@@ -3251,7 +3251,7 @@ Furthermore, the resulting store must be :ref:`valid <valid-store>`, i.e., all d
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
-     (\iff & S.\SFUNCS[a] = \{ \FITYPE~[t_1^n] \to [t_2^m], \FIHOSTCODE~\X{hf} \} \\
+     (\iff & S.\SFUNCS[a] = \{ \FITYPE~[t_1^n] \toF [t_2^m], \FIHOSTCODE~\X{hf} \} \\
      \wedge & \bot \in \X{hf}(S; \val^n)) \\
      \end{array} \\
    \end{array}
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index adf1e359e..42cc0dd87 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -622,7 +622,7 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
      (\CALL~\start.\SFUNC)^? \\
      \end{array} \\
    &(\iff
-     & \vdashmodule \module : \externtype_{\F{im}}^k \to \externtype_{\F{ex}}^\ast \\
+     & \vdashmodule \module : \externtype_{\F{im}}^k \rightarrow \externtype_{\F{ex}}^\ast \\
      &\wedge& (S' \vdashexternval \externval : \externtype)^k \\
      &\wedge& (S' \vdashexterntypematch \externtype \matchesexterntype \dyn_{\moduleinst}(\externtype_{\F{im}}))^k \\[1ex]
      &\wedge& \module.\MGLOBALS = \global^\ast \\
@@ -698,7 +698,7 @@ The following steps are performed:
 
 4. Assert: :math:`S.\STYPES[\typeaddr]` exists.
 
-5. Let :math:`[t_1^n] \to [t_2^m]` be the :ref:`dynamic <syntax-type-dyn>` :ref:`function type <syntax-functype>` :math:`S.\STYPES[\typeaddr]`.
+5. Let :math:`[t_1^n] \toF [t_2^m]` be the :ref:`dynamic <syntax-type-dyn>` :ref:`function type <syntax-functype>` :math:`S.\STYPES[\typeaddr]`.
 
 6. If the length :math:`|\val^\ast|` of the provided argument values is different from the number :math:`n` of expected arguments, then:
 
@@ -730,7 +730,7 @@ The values :math:`\val_{\F{res}}^m` are returned as the results of the invocatio
    ~\\[-1ex]
    \begin{array}{@{}lcl}
    \invoke(S, \funcaddr, \val^n) &=& S; F; \val^n~(\INVOKE~\funcaddr) \\
-     &(\iff & S.\STYPES[S.\SFUNCS[\funcaddr].\FITYPE] = [t_1^n] \to [t_2^m] \\
+     &(\iff & S.\STYPES[S.\SFUNCS[\funcaddr].\FITYPE] = [t_1^n] \toF [t_2^m] \\
      &\wedge& (S \vdashval \val : t_1)^n \\
      &\wedge& F = \{ \AMODULE~\{\}, \ALOCALS~\epsilon \}) \\
    \end{array}
diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index bffa6dba5..01655984b 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -425,7 +425,7 @@ It defines the export's :ref:`name <syntax-name>` and the associated :ref:`exter
    \end{array}
 
 
-.. index:: ! external value, function address, table address, memory address, global address, store, function, table, memory, global
+.. index:: ! external value, function address, table address, memory address, global address, store, function, table, memory, global, instruction type
    pair: abstract syntax; external value
    pair: external; value
 .. _syntax-externval:
@@ -548,7 +548,7 @@ Conventions
 
 * The meta variable :math:`F` ranges over frames where clear from context.
 
-* The following auxiliary definition takes a :ref:`block type <syntax-blocktype>` and looks up the :ref:`function type <syntax-functype>` that it denotes in the current frame:
+* The following auxiliary definition takes a :ref:`block type <syntax-blocktype>` and looks up the :ref:`instruction type <syntax-instrtype>` that it denotes in the current frame:
 
 .. math::
    \begin{array}{lll}
diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index c9e4a892b..564bf5ace 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -672,7 +672,7 @@ They bracket nested sequences of instructions, called *blocks*, terminated with,
 As the grammar prescribes, they must be well-nested.
 
 A structured instruction can consume *input* and produce *output* on the operand stack according to its annotated *block type*.
-It is given either as a :ref:`type index <syntax-funcidx>` that refers to a suitable :ref:`function type <syntax-functype>`, or as an optional :ref:`value type <syntax-valtype>` inline, which is a shorthand for the function type :math:`[] \to [\valtype^?]`.
+It is given either as a :ref:`type index <syntax-funcidx>` that refers to a suitable :ref:`function type <syntax-functype>` reinterpreted as an :ref:`instruction type <syntax-instrtype>`, or as an optional :ref:`value type <syntax-valtype>` inline, which is a shorthand for the instruction type :math:`[] \to [\valtype^?]`.
 
 Each structured control instruction introduces an implicit *label*.
 Labels are targets for branch instructions that reference them with :ref:`label indices <syntax-labelidx>`.
diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index 41bae4e25..15a57fb10 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -228,10 +228,10 @@ Instruction Types
 .. math::
    \begin{array}{llll}
    \production{instruction type} & \instrtype &::=&
-     \resulttype \to_{\localidx^\ast} \resulttype \\
+     \resulttype \toX{\localidx^\ast} \resulttype \\
    \end{array}
 
-An instruction type :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]` describes the required input stack with argument values of types :math:`t_1^\ast` that an instruction pops off
+An instruction type :math:`[t_1^\ast] \toX{x^\ast} [t_2^\ast]` describes the required input stack with argument values of types :math:`t_1^\ast` that an instruction pops off
 and the provided output stack with result values of types :math:`t_2^\ast` that it pushes back.
 Moreover, it enumerates the :ref:`indices <syntax-localidx>` :math:`x^\ast` of locals that have been set by the instruction or sequence.
 
diff --git a/document/core/text/modules.rst b/document/core/text/modules.rst
index b8f4c287d..42edfd659 100644
--- a/document/core/text/modules.rst
+++ b/document/core/text/modules.rst
@@ -96,14 +96,14 @@ If inline declarations are given, then their types must match the referenced :re
      \text{(}~\text{type}~~x{:}\Ttypeidx_I~\text{)}
        \quad\Rightarrow\quad x, I' \\ &&& \qquad
        (\iff \begin{array}[t]{@{}l@{}}
-        I.\ITYPEDEFS[x] = [t_1^n] \to [t_2^\ast] \wedge
+        I.\ITYPEDEFS[x] = [t_1^n] \toF [t_2^\ast] \wedge
         I' = \{\ILOCALS~(\epsilon)^n\}) \\
         \end{array} \\[1ex] &&|&
      \text{(}~\text{type}~~x{:}\Ttypeidx_I~\text{)}
      ~~(t_1{:}\Tparam)^\ast~~(t_2{:}\Tresult)^\ast
        \quad\Rightarrow\quad x, I' \\ &&& \qquad
        (\iff \begin{array}[t]{@{}l@{}}
-        I.\ITYPEDEFS[x] = [t_1^\ast] \to [t_2^\ast] \wedge
+        I.\ITYPEDEFS[x] = [t_1^\ast] \toF [t_2^\ast] \wedge
         I' = \{\ILOCALS~\F{id}(\Tparam)^\ast\} \idcwellformed) \\
         \end{array} \\
    \end{array}
@@ -117,7 +117,7 @@ The following auxiliary function extracts optional identifiers from parameters:
    \end{array}
 
 .. note::
-   Both productions overlap for the case that the function type is :math:`[] \to []`.
+   Both productions overlap for the case that the function type is :math:`[] \toF []`.
    However, in that case, they also produce the same results, so that the choice is immaterial.
 
    The :ref:`well-formedness <text-context-wf>` condition on :math:`I'` ensures that the parameters do not contain duplicate identifiers.
@@ -138,7 +138,7 @@ In that case, a :ref:`type index <syntax-typeidx>` is automatically inserted:
      \text{(}~\text{type}~~x~\text{)}~~\Tparam^\ast~~\Tresult^\ast \\
    \end{array}
 
-where :math:`x` is the smallest existing :ref:`type index <syntax-typeidx>` whose definition in the current module is the :ref:`function type <syntax-functype>` :math:`[t_1^\ast] \to [t_2^\ast]`.
+where :math:`x` is the smallest existing :ref:`type index <syntax-typeidx>` whose definition in the current module is the :ref:`function type <syntax-functype>` :math:`[t_1^\ast] \toF [t_2^\ast]`.
 If no such index exists, then a new :ref:`type definition <text-type>` of the form
 
 .. math::
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index 21a268022..73a238ec5 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -176,7 +176,9 @@
 
 .. Types, terminals
 
-.. |to| mathdef:: \xref{syntax/types}{syntax-functype}{\rightarrow}
+.. |toF| mathdef:: \xref{syntax/types}{syntax-functype}{\rightarrow}
+.. |to| mathdef:: \xref{syntax/types}{syntax-instrtype}{\rightarrow}
+.. |toX#1| mathdef:: \xref{syntax/types}{syntax-instrtype}{\rightarrow_{#1}}
 
 .. |BOT| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{bot}}
 
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 251dee8c8..d8539c0b9 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -5,7 +5,7 @@ Instructions
 ------------
 
 :ref:`Instructions <syntax-instr>` are classified by :ref:`instruction types <syntax-instrtype>` that describe how they manipulate the :ref:`operand stack <stack>` and initialize :ref:`locals <syntax-local>`:
-A type :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]` describes the required input stack with argument values of types :math:`t_1^\ast` that an instruction pops off
+A type :math:`[t_1^\ast] \toX{x^\ast} [t_2^\ast]` describes the required input stack with argument values of types :math:`t_1^\ast` that an instruction pops off
 and the provided output stack with result values of types :math:`t_2^\ast` that it pushes back.
 Moreover, it enumerates the :ref:`indices <syntax-localidx>` :math:`x^\ast` of locals that have been set by the instruction.
 In most cases, this is empty.
@@ -13,10 +13,10 @@ In most cases, this is empty.
 .. note::
    For example, the instruction :math:`\I32.\ADD` has type :math:`[\I32~\I32] \to [\I32]`,
    consuming two |I32| values and producing one.
-   The instruction :math:`\LOCALSET~x` has type :math:`[t] \to_x []`, provided :math:`t` is the type declared for the local :math:`x`.
+   The instruction :math:`\LOCALSET~x` has type :math:`[t] \toX{x} []`, provided :math:`t` is the type declared for the local :math:`x`.
 
 Typing extends to :ref:`instruction sequences <valid-instr-seq>` :math:`\instr^\ast`.
-Such a sequence has an instruction type :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]` if the accumulative effect of executing the instructions is consuming values of types :math:`t_1^\ast` off the operand stack, pushing new values of types :math:`t_2^\ast`, and setting all locals :math:`x^\ast`.
+Such a sequence has an instruction type :math:`[t_1^\ast] \toX{x^\ast} [t_2^\ast]` if the accumulative effect of executing the instructions is consuming values of types :math:`t_1^\ast` off the operand stack, pushing new values of types :math:`t_2^\ast`, and setting all locals :math:`x^\ast`.
 
 .. _polymorphism:
 
@@ -675,13 +675,13 @@ Variable Instructions
 
 * Let :math:`\init~t` be the :ref:`local type <syntax-localtype>` :math:`C.\CLOCALS[x]`.
 
-* Then the instruction is valid with type :math:`[t] \to_x []`.
+* Then the instruction is valid with type :math:`[t] \toX{x} []`.
 
 .. math::
    \frac{
      C.\CLOCALS[x] = \init~t
    }{
-     C \vdashinstr \LOCALSET~x : [t] \to_x []
+     C \vdashinstr \LOCALSET~x : [t] \toX{x} []
    }
 
 
@@ -694,13 +694,13 @@ Variable Instructions
 
 * Let :math:`\init~t` be the :ref:`local type <syntax-localtype>` :math:`C.\CLOCALS[x]`.
 
-* Then the instruction is valid with type :math:`[t] \to_x [t]`.
+* Then the instruction is valid with type :math:`[t] \toX{x} [t]`.
 
 .. math::
    \frac{
      C.\CLOCALS[x] = \init~t
    }{
-     C \vdashinstr \LOCALTEE~x : [t] \to_x [t]
+     C \vdashinstr \LOCALTEE~x : [t] \toX{x} [t]
    }
 
 
@@ -1275,7 +1275,7 @@ Control Instructions
 :math:`\BLOCK~\blocktype~\instr^\ast~\END`
 ..........................................
 
-* The :ref:`block type <syntax-blocktype>` must be :ref:`valid <valid-blocktype>` as some :ref:`function type <syntax-functype>` :math:`[t_1^\ast] \to [t_2^\ast]`.
+* The :ref:`block type <syntax-blocktype>` must be :ref:`valid <valid-blocktype>` as some :ref:`instruction type <syntax-instrtype>` :math:`[t_1^\ast] \to [t_2^\ast]`.
 
 * Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the :ref:`result type <syntax-resulttype>` :math:`[t_2^\ast]` prepended to the |CLABELS| vector.
 
@@ -1302,7 +1302,7 @@ Control Instructions
 :math:`\LOOP~\blocktype~\instr^\ast~\END`
 .........................................
 
-* The :ref:`block type <syntax-blocktype>` must be :ref:`valid <valid-blocktype>` as some :ref:`instruction type <syntax-functype>` :math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]`.
+* The :ref:`block type <syntax-blocktype>` must be :ref:`valid <valid-blocktype>` as some :ref:`instruction type <syntax-functype>` :math:`[t_1^\ast] \toX{x^\ast} [t_2^\ast]`.
 
 * Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the :ref:`result type <syntax-resulttype>` :math:`[t_1^\ast]` prepended to the |CLABELS| vector.
 
@@ -1329,7 +1329,7 @@ Control Instructions
 :math:`\IF~\blocktype~\instr_1^\ast~\ELSE~\instr_2^\ast~\END`
 .............................................................
 
-* The :ref:`block type <syntax-blocktype>` must be :ref:`valid <valid-blocktype>` as some :ref:`function type <syntax-functype>` :math:`[t_1^\ast] \to [t_2^\ast]`.
+* The :ref:`block type <syntax-blocktype>` must be :ref:`valid <valid-blocktype>` as some :ref:`instruction type <syntax-instrtype>` :math:`[t_1^\ast] \to [t_2^\ast]`.
 
 * Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the :ref:`result type <syntax-resulttype>` :math:`[t_2^\ast]` prepended to the |CLABELS| vector.
 
@@ -1530,13 +1530,13 @@ Control Instructions
 
 * Assert: The type :math:`C.\CTYPES[y]` is defined in the context.
 
-* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[y]`.
+* Let :math:`[t_1^\ast] \toF [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[y]`.
 
 * Then the instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`.
 
 .. math::
    \frac{
-     C.\CTYPES[C.\CFUNCS[x]] = [t_1^\ast] \to [t_2^\ast]
+     C.\CTYPES[C.\CFUNCS[x]] = [t_1^\ast] \toF [t_2^\ast]
    }{
      C \vdashinstr \CALL~x : [t_1^\ast] \to [t_2^\ast]
    }
@@ -1549,13 +1549,13 @@ Control Instructions
 
 * The type :math:`C.\CTYPES[x]` must be defined in the context.
 
-* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[x]`.
+* Let :math:`[t_1^\ast] \toF [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[x]`.
 
 * Then the instruction is valid with type :math:`[t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]`.
 
 .. math::
    \frac{
-     C.\CTYPES[x] = [t_1^\ast] \to [t_2^\ast]
+     C.\CTYPES[x] = [t_1^\ast] \toF [t_2^\ast]
    }{
      C \vdashinstr \CALLREF~x : [t_1^\ast~(\REF~\NULL~x)] \to [t_2^\ast]
    }
@@ -1574,7 +1574,7 @@ Control Instructions
 
 * The type :math:`C.\CTYPES[y]` must be defined in the context.
 
-* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[y]`.
+* Let :math:`[t_1^\ast] \toF [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[y]`.
 
 * Then the instruction is valid with type :math:`[t_1^\ast~\I32] \to [t_2^\ast]`.
 
@@ -1584,7 +1584,7 @@ Control Instructions
      \qquad
      C \vdashvaltypematch t \matchesreftype \REF~\NULL~\FUNC
      \qquad
-     C.\CTYPES[y] = [t_1^\ast] \to [t_2^\ast]
+     C.\CTYPES[y] = [t_1^\ast] \toF [t_2^\ast]
    }{
      C \vdashinstr \CALLINDIRECT~x~y : [t_1^\ast~\I32] \to [t_2^\ast]
    }
@@ -1599,7 +1599,7 @@ Control Instructions
 
 * The function :math:`C.\CFUNCS[x]` must be defined in the context.
 
-* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CFUNCS[x]`.
+* Let :math:`[t_1^\ast] \toF [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CFUNCS[x]`.
 
 * The :ref:`result type <syntax-resulttype>` :math:`[t_2^\ast]` must be the same as :math:`C.\CRETURN`.
 
@@ -1607,7 +1607,7 @@ Control Instructions
 
 .. math::
    \frac{
-     C.\CFUNCS[x] = [t_1^\ast] \to [t_2^\ast]
+     C.\CFUNCS[x] = [t_1^\ast] \toF [t_2^\ast]
      \qquad
      C.\CRETURN = [t_2^\ast]
    }{
@@ -1625,7 +1625,7 @@ Control Instructions
 
 * The type :math:`C.\CTYPES[x]` must be defined in the context.
 
-* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[x]`.
+* Let :math:`[t_1^\ast] \toF [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[x]`.
 
 * The :ref:`result type <syntax-resulttype>` :math:`[t_2^\ast]` must be the same as :math:`C.\CRETURN`.
 
@@ -1633,7 +1633,7 @@ Control Instructions
 
 .. math::
    \frac{
-     C.\CTYPES[x] = [t_1^\ast] \to [t_2^\ast]
+     C.\CTYPES[x] = [t_1^\ast] \toF [t_2^\ast]
      \qquad
      C.\CRETURN = [t_2^\ast]
    }{
@@ -1656,7 +1656,7 @@ Control Instructions
 
 * The type :math:`C.\CTYPES[y]` must be defined in the context.
 
-* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[y]`.
+* Let :math:`[t_1^\ast] \toF [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[y]`.
 
 * The :ref:`result type <syntax-resulttype>` :math:`[t_2^\ast]` must be the same as :math:`C.\CRETURN`.
 
@@ -1667,7 +1667,7 @@ Control Instructions
    \frac{
      C.\CTABLES[x] = \limits~\FUNCREF
      \qquad
-     C.\CTYPES[y] = [t_1^\ast] \to [t_2^\ast]
+     C.\CTYPES[y] = [t_1^\ast] \toF [t_2^\ast]
      \qquad
      C.\CRETURN = [t_2^\ast]
    }{
@@ -1702,30 +1702,30 @@ Empty Instruction Sequence: :math:`\epsilon`
 Non-empty Instruction Sequence: :math:`\instr~{\instr'}^\ast`
 .............................................................
 
-* The instruction :math:`\instr` must be valid with some type :math:`[t_1^\ast] \to_{x_1^\ast} [t_2^\ast]`.
+* The instruction :math:`\instr` must be valid with some type :math:`[t_1^\ast] \toX{x_1^\ast} [t_2^\ast]`.
 
 * Let :math:`C'` be the same :ref:`context <context>` as :math:`C`,
   but with:
 
   * |CLOCALS| the same as in C, except that for every :ref:`local index <syntax-localidx>` :math:`x` in :math:`x_1^\ast`, the :ref:`local type <syntax-localtype>` :math:`\CLOCALS[x]` has been updated to :ref:`initialization status <syntax-init>` :math:`\SET`.
 
-* Under the context :math:`C'`, the instruction sequence :math:`{\instr'}^\ast` must be valid with some type :math:`[t_2^\ast] \to_{x_2^\ast} [t_3^\ast]`.
+* Under the context :math:`C'`, the instruction sequence :math:`{\instr'}^\ast` must be valid with some type :math:`[t_2^\ast] \toX{x_2^\ast} [t_3^\ast]`.
 
-* Then the combined instruction sequence is valid with type :math:`[t_1^\ast] \to_{x_1^\ast x_2^\ast} [t_3^\ast]`.
+* Then the combined instruction sequence is valid with type :math:`[t_1^\ast] \toX{x_1^\ast x_2^\ast} [t_3^\ast]`.
 
 .. math::
    \frac{
      \begin{array}{@{}l@{\qquad}l@{}}
-     C \vdashinstr \instr : [t_1^\ast] \to_{x_1^\ast} [t_2^\ast]
+     C \vdashinstr \instr : [t_1^\ast] \toX{x_1^\ast} [t_2^\ast]
      &
      (C.\CLOCALS[x_1] = \init~t)^\ast
      \\
-     C' \vdashinstrseq {\instr'}^\ast : [t_2^\ast] \to_{x_2^\ast} [t_3^\ast]
+     C' \vdashinstrseq {\instr'}^\ast : [t_2^\ast] \toX{x_2^\ast} [t_3^\ast]
      &
      C' = C~(\with C.\CLOCALS[x_1] = \SET~t)^\ast
      \end{array}
    }{
-     C \vdashinstrseq \instr~{\instr'}^\ast : [t_1^\ast] \to_{x_1^\ast x_2^\ast} [t_2^\ast~t_3^\ast]
+     C \vdashinstrseq \instr~{\instr'}^\ast : [t_1^\ast] \toX{x_1^\ast x_2^\ast} [t_2^\ast~t_3^\ast]
    }
 
 
diff --git a/document/core/valid/matching.rst b/document/core/valid/matching.rst
index 2a4a9bdd3..ac9229559 100644
--- a/document/core/valid/matching.rst
+++ b/document/core/valid/matching.rst
@@ -160,7 +160,7 @@ Instruction Types
 ~~~~~~~~~~~~~~~~~
 
 Subtyping is further lifted to :ref:`instruction types <syntax-instrtype>`.
-An :ref:`instruction type <syntax-instrtype>` :math:`[t_{11}^\ast] \to_{x_1^\ast} [t_{12}^\ast]` matches a type :math:`[t_{21}^ast] \to_{x_2^\ast} [t_{22}^\ast]` if and only if:
+An :ref:`instruction type <syntax-instrtype>` :math:`[t_{11}^\ast] \toX{x_1^\ast} [t_{12}^\ast]` matches a type :math:`[t_{21}^ast] \toX{x_2^\ast} [t_{22}^\ast]` if and only if:
 
 * There is a common sequence of :ref:`value types <syntax-valtype>` :math:`t^\ast` such that :math:`t_{21}^\ast` equals :math:`t^\ast~{t'_{21}}^\ast` and :math:`t_{22}^\ast` equals :math:`t^\ast~{t'_{22}}^\ast`.
 
@@ -183,7 +183,7 @@ An :ref:`instruction type <syntax-instrtype>` :math:`[t_{11}^\ast] \to_{x_1^\ast
      (C.\CLOCALS[x] = \SET~t_x)^\ast
      \end{array}
    }{
-     C \vdashinstrtypematch [t_{11}^\ast] \to_{x_1^\ast} [t_{12}^\ast] \matchesinstrtype [t^\ast~t_{21}^\ast] \to_{x_2^\ast} [t^\ast~t_{22}^\ast]
+     C \vdashinstrtypematch [t_{11}^\ast] \toX{x_1^\ast} [t_{12}^\ast] \matchesinstrtype [t^\ast~t_{21}^\ast] \toX{x_2^\ast} [t^\ast~t_{22}^\ast]
    }
 
 .. note::
@@ -202,7 +202,7 @@ Function Types
 
 Subtyping is also defined for :ref:`function types <syntax-functype>`.
 However, it is required that they match in both directions, effectively demanding type equivalence.
-That is, a :ref:`function type <syntax-functype>` :math:`[t_{11}^\ast] \to [t_{12}^\ast]` matches a type :math:`[t_{21}^ast] \to [t_{22}^\ast]` if and only if:
+That is, a :ref:`function type <syntax-functype>` :math:`[t_{11}^\ast] \toF [t_{12}^\ast]` matches a type :math:`[t_{21}^ast] \toF [t_{22}^\ast]` if and only if:
 
 * The :ref:`result type <syntax-resulttype>` :math:`[t_{11}^\ast]` :ref:`matches <match-resulttype>` :math:`[t_{21}^\ast]`, and vice versa.
 
@@ -221,7 +221,7 @@ That is, a :ref:`function type <syntax-functype>` :math:`[t_{11}^\ast] \to [t_{1
      C \vdashresulttypematch [t_{22}^\ast] \matchesresulttype [t_{12}^\ast]
      \end{array}
    }{
-     C \vdashfunctypematch [t_{11}^\ast] \to [t_{12}^\ast] \matchesfunctype [t_{21}^\ast] \to [t_{22}^\ast]
+     C \vdashfunctypematch [t_{11}^\ast] \toF [t_{12}^\ast] \matchesfunctype [t_{21}^\ast] \toF [t_{22}^\ast]
    }
 
 .. note::
diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index cafb84e60..4419aa6d3 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -14,7 +14,7 @@ Furthermore, most definitions are themselves classified with a suitable type.
 Functions
 ~~~~~~~~~
 
-Functions :math:`\func` are classified by :ref:`type indices <syntax-typeidx>` referring to :ref:`function types <syntax-functype>` of the form :math:`[t_1^\ast] \to [t_2^\ast]`.
+Functions :math:`\func` are classified by :ref:`type indices <syntax-typeidx>` referring to :ref:`function types <syntax-functype>` of the form :math:`[t_1^\ast] \toF [t_2^\ast]`.
 
 
 :math:`\{ \FTYPE~x, \FLOCALS~t^\ast, \FBODY~\expr \}`
@@ -22,7 +22,7 @@ Functions :math:`\func` are classified by :ref:`type indices <syntax-typeidx>` r
 
 * The type :math:`C.\CTYPES[x]` must be defined in the context.
 
-* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[x]`.
+* Let :math:`[t_1^\ast] \toF [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[x]`.
 
 * For each local declared by a :ref:`value type <syntax-valtype>` :math:`t` in :math:`t^\ast`:
 
@@ -42,11 +42,11 @@ Functions :math:`\func` are classified by :ref:`type indices <syntax-typeidx>` r
 * Under the context :math:`C'`,
   the expression :math:`\expr` must be valid with type :math:`[t_2^\ast]`.
 
-* Then the function definition is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`.
+* Then the function definition is valid with type :math:`[t_1^\ast] \toF [t_2^\ast]`.
 
 .. math::
    \frac{
-     C.\CTYPES[x] = [t_1^\ast] \to [t_2^\ast]
+     C.\CTYPES[x] = [t_1^\ast] \toF [t_2^\ast]
      \qquad
      (C \vdashlocal t : \init~t)^\ast
      \qquad
@@ -379,14 +379,14 @@ Start function declarations :math:`\start` are not classified by any type.
 
 * Assert: The type :math:`C.\CTYPES[y]` is defined in the context.
 
-* The type :math:`C.\CTYPES[y]` must be the :ref:`function type <syntax-functype>` :math:`[] \to []`.
+* The type :math:`C.\CTYPES[y]` must be the :ref:`function type <syntax-functype>` :math:`[] \toF []`.
 
 * Then the start function is valid.
 
 
 .. math::
    \frac{
-     C.\CTYPES[C.\CFUNCS[x]] = [] \to []
+     C.\CTYPES[C.\CFUNCS[x]] = [] \toF []
    }{
      C \vdashstart \{ \SFUNC~x \} \ok
    }
diff --git a/document/core/valid/types.rst b/document/core/valid/types.rst
index 097e82f6e..d281885b3 100644
--- a/document/core/valid/types.rst
+++ b/document/core/valid/types.rst
@@ -193,13 +193,13 @@ Block Types
 
 * The type :math:`C.\CTYPES[\typeidx]` must be defined in the context.
 
-* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[\typeidx]`.
+* Let :math:`[t_1^\ast] \toF [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[\typeidx]`.
 
 * Then the block type is valid as :ref:`instruction type <syntax-instrtype>` :math:`[t_1^\ast] \to [t_2^\ast]`.
 
 .. math::
    \frac{
-     C.\CTYPES[\typeidx] = [t_1^\ast] \to [t_2^\ast]
+     C.\CTYPES[\typeidx] = [t_1^\ast] \toF [t_2^\ast]
    }{
      C \vdashblocktype \typeidx : [t_1^\ast] \to [t_2^\ast]
    }
@@ -251,8 +251,8 @@ Result Types
 Instruction Types
 ~~~~~~~~~~~~~~~~~
 
-:math:`[t_1^\ast] \to_{x^\ast} [t_2^\ast]`
-..........................................
+:math:`[t_1^\ast] \rightarrow_{x^\ast} [t_2^\ast]`
+..................................................
 
 * The :ref:`result type <syntax-resulttype>` :math:`[t_1^\ast]` must be :ref:`valid <valid-resulttype>`.
 
@@ -270,7 +270,7 @@ Instruction Types
      \qquad
      (C.\CLOCALS[x] = \localtype)^\ast
    }{
-     C \vdashfunctype [t_1^\ast] \to_{x^\ast} [t_2^\ast] \ok
+     C \vdashfunctype [t_1^\ast] \toX{x^\ast} [t_2^\ast] \ok
    }
 
 
@@ -282,8 +282,8 @@ Instruction Types
 Function Types
 ~~~~~~~~~~~~~~
 
-:math:`[t_1^\ast] \to [t_2^\ast]`
-.................................
+:math:`[t_1^\ast] \toF [t_2^\ast]`
+..................................
 
 * The :ref:`result type <syntax-resulttype>` :math:`[t_1^\ast]` must be :ref:`valid <valid-resulttype>`.
 
@@ -297,7 +297,7 @@ Function Types
      \qquad
      C \vdashvaltype [t_2^\ast] \ok
    }{
-     C \vdashfunctype [t_1^\ast] \to [t_2^\ast] \ok
+     C \vdashfunctype [t_1^\ast] \toF [t_2^\ast] \ok
    }
 
 

From f919dde1f35c2d2210840474040a007cbfb7e527 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Mon, 6 Mar 2023 20:20:37 +0100
Subject: [PATCH 283/285] Fix typo in text expansion

---
 document/core/text/modules.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/text/modules.rst b/document/core/text/modules.rst
index 42edfd659..477c6488c 100644
--- a/document/core/text/modules.rst
+++ b/document/core/text/modules.rst
@@ -302,7 +302,7 @@ An :ref:`element segment <text-elem>` can be given inline with a table definitio
    \production{module field} &
      \text{(}~\text{table}~~\Tid^?~~\Treftype~~\text{(}~\text{elem}~~x^n{:}\Tvec(\Tfuncidx)~\text{)}~\text{)} \quad\equiv \\ & \qquad
        \text{(}~\text{table}~~\Tid'~~n~~n~~\Treftype~\text{)} \\ & \qquad
-       \text{(}~\text{elem}~~\text{(}~\text{table}~~\Tid'~\text{)}~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\text{func}~~\Tvec(\Tfuncidx)~\text{)}
+       \text{(}~\text{elem}~~\text{(}~\text{table}~~\Tid'~\text{)}~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Treftype~~\Tvec(\Tfuncidx)~\text{)}
        \\ & \qquad\qquad
        (\iff \Tid^? \neq \epsilon \wedge \Tid' = \Tid^? \vee \Tid^? = \epsilon \wedge \Tid' \idfresh) \\
    \end{array}

From 3d09c2201cb694a21fd9bbdfee93fe74aeb5b47b Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Tue, 7 Mar 2023 17:09:31 +0100
Subject: [PATCH 284/285] Follow-up fix

---
 document/core/text/modules.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/text/modules.rst b/document/core/text/modules.rst
index 477c6488c..f095ba2e2 100644
--- a/document/core/text/modules.rst
+++ b/document/core/text/modules.rst
@@ -302,7 +302,7 @@ An :ref:`element segment <text-elem>` can be given inline with a table definitio
    \production{module field} &
      \text{(}~\text{table}~~\Tid^?~~\Treftype~~\text{(}~\text{elem}~~x^n{:}\Tvec(\Tfuncidx)~\text{)}~\text{)} \quad\equiv \\ & \qquad
        \text{(}~\text{table}~~\Tid'~~n~~n~~\Treftype~\text{)} \\ & \qquad
-       \text{(}~\text{elem}~~\text{(}~\text{table}~~\Tid'~\text{)}~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Treftype~~\Tvec(\Tfuncidx)~\text{)}
+       \text{(}~\text{elem}~~\text{(}~\text{table}~~\Tid'~\text{)}~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Treftype~~\Tvec(\text{(}~\text{ref.func}~~\Tfuncidx~\text{)})~\text{)}
        \\ & \qquad\qquad
        (\iff \Tid^? \neq \epsilon \wedge \Tid' = \Tid^? \vee \Tid^? = \epsilon \wedge \Tid' \idfresh) \\
    \end{array}

From f4a1f12c0704a6e9af2e67ded9ab34efc9a8faeb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Daniel=20Hillerstr=C3=B6m?= <daniel.hillerstrom@ed.ac.uk>
Date: Mon, 13 Mar 2023 12:01:25 +0100
Subject: [PATCH 285/285] Fix compilation errors after merge.

This commit fixes the errors introduced by the merge of
function-references/main into this tree.
---
 interpreter/binary/decode.ml      |  25 ++----
 interpreter/binary/encode.ml      |   8 +-
 interpreter/exec/eval.ml          |  49 ++++++-----
 interpreter/host/spectest.ml      |   8 +-
 interpreter/runtime/instance.ml   |   2 +-
 interpreter/script/js.ml          |   1 +
 interpreter/syntax/free.ml        |   4 +-
 interpreter/syntax/types.ml       | 141 ++++++++++++++++++++++++------
 interpreter/text/arrange.ml       |   2 +-
 interpreter/text/lexer.mll        |   3 +
 interpreter/text/parser.conflicts |   0
 interpreter/text/parser.mly       |  53 ++++++-----
 interpreter/valid/match.ml        |  11 ++-
 interpreter/valid/valid.ml        | 136 ++++++++++++++--------------
 test/core/cont.wast               |   2 +-
 15 files changed, 265 insertions(+), 180 deletions(-)
 delete mode 100644 interpreter/text/parser.conflicts

diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 9f815f7e5..0d7ec86c1 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -144,15 +144,8 @@ let sized f s =
 
 open Types
 
-let var s = vu32 s
 let zero s = expect 0x00 s "zero byte expected"
 
-let var_type s =
-  let pos = pos s in
-  match vs33 s with
-  | i when i >= 0l -> SynVar i
-  | _ -> error s pos "malformed type index"
-
 let num_type s =
   match s7 s with
   | -0x01 -> I32T
@@ -208,12 +201,12 @@ let func_type s =
   FuncT (ts1, ts2)
 
 let cont_type s =
-  ContType (var_type s)
+  ContT (Stat (var_type s))
 
 let def_type s =
   match s7 s with
   | -0x20 -> DefFuncT (func_type s)
-  | -0x21 -> ContDefType (cont_type s)
+  | -0x21 -> DefContT (cont_type s)
   | _ -> error s (pos s - 1) "malformed definition type"
 
 
@@ -234,8 +227,8 @@ let memory_type s =
 
 let tag_type s =
   zero s;
-  let x = var_type s in
-  TagType x
+  let x = Stat (var_type s) in
+  TagT x
 
 let mutability s =
   match byte s with
@@ -329,7 +322,7 @@ let rec instr s =
     let ct = catch_list s in
     let ca =
       if peek s = Some 0x19 then begin
-        ignore (u8 s);
+        ignore (byte s);
         Some (instr_block s)
       end else
         None
@@ -372,13 +365,11 @@ let rec instr s =
   | 0x14 -> call_ref (at var s)
   | 0x15 -> return_call_ref (at var s)
 
-  | 0x16 as b -> illegal s pos b
+  | (0x16 | 0x17) as b -> illegal s pos b
 
   | 0x18 -> error s pos "misplaced DELEGATE opcode"
   | 0x19 -> error s pos "misplaced CATCH_ALL opcode"
 
-  | 0x17 | 0x19 as b -> illegal s pos b
-
   | 0x1a -> drop
   | 0x1b -> select None
   | 0x1c -> select (Some (vec val_type s))
@@ -900,7 +891,7 @@ and instr_block' s es =
     instr_block' s (Source.(e' @@ region s pos pos) :: es)
 and catch_list s =
   if peek s = Some 0x07 then begin
-    ignore (u8 s);
+    ignore (byte s);
     let tag = at var s in
     let instrs = instr_block s in
     (tag, instrs) :: catch_list s
@@ -1244,7 +1235,7 @@ let module_ s =
     s (len s) "data count section required";
   let funcs =
     List.map2 (fun t f -> {f.it with ftype = t} @@ f.at) func_types func_bodies
-  in {types; tables; memories; globals; funcs; imports; exports; elems; datas; start}
+  in {types; tables; memories; tags; globals; funcs; imports; exports; elems; datas; start}
 
 
 let decode name bs = at module_ (stream name bs)
diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index 26d4cfca0..abe07f75a 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -130,11 +130,11 @@ struct
     | FuncT (ts1, ts2) -> vec val_type ts1; vec val_type ts2
 
   let cont_type = function
-    | ContType x -> var_type x
+    | ContT x -> var_type x
 
   let def_type = function
     | DefFuncT ft -> s7 (-0x20); func_type ft
-    | ContDefType ct -> vs7 (-0x21); cont_type ct
+    | DefContT ct -> s7 (-0x21); cont_type ct (* TODO(dhil): I think the GC proposal claims opcode -0x21 for one of the struct/array types. *)
 
   let limits vu {min; max} =
     bool (max <> None); vu min; opt vu max
@@ -152,8 +152,8 @@ struct
   let global_type = function
     | GlobalT (mut, t) -> val_type t; mutability mut
 
-  let tag_type (TagType x) =
-    vu32 0x00l; var_type x
+  let tag_type (TagT x) =
+    u32 0x00l; var_type x
 
   (* Instructions *)
 
diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index 253df15b6..aa6c99992 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -64,9 +64,8 @@ and admin_instr' =
   | Plain of instr'
   | Refer of ref_
   | Invoke of func_inst
-  | Label of int * instr list * code
-  | Frame of int * frame * code
-  | Local of int32 * value list * code
+  | Label of int32 * instr list * code
+  | Frame of int32 * frame * code
   | Handle of (tag_inst * idx) list option * code
   | Trapping of string
   | Throwing of tag_inst * value stack
@@ -88,7 +87,7 @@ type ref_ += ContRef of cont option ref
 let () =
   let type_of_ref' = !Value.type_of_ref' in
   Value.type_of_ref' := function
-    | ContRef _ -> BotHeapType  (* TODO *)
+    | ContRef _ -> BotHT  (* TODO *)
     | r -> type_of_ref' r
 
 let () =
@@ -199,7 +198,7 @@ let rec step (c : config) : config =
     match e.it, vs with
     | Plain e', vs ->
       (match e', vs with
-      | Unreachable, vs ->
+       | Unreachable, vs ->
         vs, [Trapping "unreachable executed" @@ e.at]
 
       | Nop, vs ->
@@ -207,14 +206,14 @@ let rec step (c : config) : config =
 
       | Block (bt, es'), vs ->
         let InstrT (ts1, ts2, _xs) = block_type c.frame.inst bt e.at in
-        let n1 = List.length ts1 in
-        let n2 = List.length ts2 in
+        let n1 = Lib.List32.length ts1 in
+        let n2 = Lib.List32.length ts2 in
         let args, vs' = take n1 vs e.at, drop n1 vs e.at in
         vs', [Label (n2, [], (args, List.map plain es')) @@ e.at]
 
       | Loop (bt, es'), vs ->
         let InstrT (ts1, ts2, _xs) = block_type c.frame.inst bt e.at in
-        let n1 = List.length ts1 in
+        let n1 = Lib.List32.length ts1 in
         let args, vs' = take n1 vs e.at, drop n1 vs e.at in
         vs', [Label (n1, [e' @@ e.at], (args, List.map plain es')) @@ e.at]
 
@@ -227,7 +226,7 @@ let rec step (c : config) : config =
       | Throw x, vs ->
         let tagt = tag c.frame.inst x in
         let TagT x' = Tag.type_of tagt in
-        let FuncT (ts, _) = as_func_def_type (def_of (as_sem_var x')) in
+        let FuncT (ts, _) = as_func_def_type (def_of (as_dyn_var x')) in
         let vs0, vs' = split (Lib.List32.length ts) vs e.at in
         vs', [Throwing (tagt, vs0) @@ e.at]
 
@@ -235,7 +234,7 @@ let rec step (c : config) : config =
         vs, [Rethrowing (x.it, fun e -> e) @@ e.at]
 
       | TryCatch (bt, es', cts, ca), vs ->
-        let FuncType (ts1, ts2) = block_type c.frame.inst bt e.at in
+        let InstrT (ts1, ts2, _xs) = block_type c.frame.inst bt e.at in
         let n1 = Lib.List32.length ts1 in
         let n2 = Lib.List32.length ts2 in
         let args, vs' = take n1 vs e.at, drop n1 vs e.at in
@@ -243,7 +242,7 @@ let rec step (c : config) : config =
         vs', [Label (n2, [], ([], [Catch (n2, cts', ca, (args, List.map plain es')) @@ e.at])) @@ e.at]
 
       | TryDelegate (bt, es', x), vs ->
-        let FuncType (ts1, ts2) = block_type c.frame.inst bt e.at in
+        let InstrT (ts1, ts2, _xs) = block_type c.frame.inst bt e.at in
         let n1 = Lib.List32.length ts1 in
         let n2 = Lib.List32.length ts2 in
         let args, vs' = take n1 vs e.at, drop n1 vs e.at in
@@ -315,7 +314,7 @@ let rec step (c : config) : config =
         vs, [Trapping "null function reference" @@ e.at]
 
       | ContNew x, Ref (FuncRef f) :: vs ->
-        let FuncType (ts, _) = Func.type_of f in
+        let FuncT (ts, _) = Func.type_of f in
         let ctxt code = compose code ([], [Invoke f @@ e.at]) in
         Ref (ContRef (ref (Some (Lib.List32.length ts, ctxt)))) :: vs, []
 
@@ -326,8 +325,8 @@ let rec step (c : config) : config =
         vs, [Trapping "continuation already consumed" @@ e.at]
 
       | ContBind x, Ref (ContRef ({contents = Some (n, ctxt)} as cont)) :: vs ->
-        let ContType z = cont_type c.frame.inst x in
-        let FuncType (ts', _) = as_func_def_type (def_of (as_sem_var z)) in
+        let ContT z = cont_type c.frame.inst x in
+        let FuncT (ts', _) = as_func_def_type (def_of (as_dyn_var z)) in
         let args, vs' =
           try split (Int32.sub n (Lib.List32.length ts')) vs e.at
           with Failure _ -> Crash.error e.at "type mismatch at continuation bind"
@@ -339,7 +338,7 @@ let rec step (c : config) : config =
       | Suspend x, vs ->
         let tagt = tag c.frame.inst x in
         let TagT x' = Tag.type_of tagt in
-        let FuncT (ts, _) = as_func_def_type (def_of (as_sem_var x')) in
+        let FuncT (ts, _) = as_func_def_type (def_of (as_dyn_var x')) in
         let args, vs' = split (Lib.List32.length ts) vs e.at in
         vs', [Suspending (tagt, args, fun code -> code) @@ e.at]
 
@@ -364,14 +363,14 @@ let rec step (c : config) : config =
       | ResumeThrow x, Ref (ContRef ({contents = Some (n, ctxt)} as cont)) :: vs ->
         let tagt = tag c.frame.inst x in
         let TagT x' = Tag.type_of tagt in
-        let FuncType (ts, _) = as_func_def_type (def_of (as_sem_var x')) in
+        let FuncT (ts, _) = as_func_def_type (def_of (as_dyn_var x')) in
         let args, vs' = split (Lib.List32.length ts) vs e.at in
         let vs1', es1' = ctxt (args, [Plain (Throw x) @@ e.at]) in
         cont := None;
         vs1' @ vs', es1'
 
       | Barrier (bt, es'), vs ->
-        let FuncType (ts1, _) = block_type c.frame.inst bt e.at in
+        let InstrT (ts1, _, _xs) = block_type c.frame.inst bt e.at in
         let args, vs' = split (Lib.List32.length ts1) vs e.at in
         vs', [
           Handle (None,
@@ -821,6 +820,12 @@ let rec step (c : config) : config =
     | Frame (n, frame', (vs', [])), vs ->
       vs' @ vs, []
 
+    | Frame (n, frame', (vs', {it = Trapping msg; at} :: es')), vs ->
+      vs, [Trapping msg @@ at]
+
+    | Frame (n, frame', (vs', {it = Throwing (a, vs0); at} :: es')), vs ->
+      vs, [Throwing (a, vs0) @@ at]
+
     | Frame (n, frame', (vs', {it = Suspending (tagt, vs1, ctxt); at} :: es')), vs ->
       let ctxt' code = [], [Frame (n, frame', compose (ctxt code) (vs', es')) @@ e.at] in
       vs, [Suspending (tagt, vs1, ctxt') @@ at]
@@ -830,7 +835,7 @@ let rec step (c : config) : config =
 
     | Frame (n, frame', (vs', {it = ReturningInvoke (vs0, f); at} :: es')), vs ->
       let FuncT (ts1, _ts2) = Func.type_of f in
-      take (List.length ts1) vs0 e.at @ vs, [Invoke f @@ at]
+      take (Lib.List32.length ts1) vs0 e.at @ vs, [Invoke f @@ at]
 
     | Frame (n, frame', code'), vs ->
       let c' = step {frame = frame'; code = code'; budget = c.budget - 1} in
@@ -895,10 +900,10 @@ let rec step (c : config) : config =
 
     | Invoke f, vs ->
       let FuncT (ts1, ts2) = Func.type_of f in
-      let n1, n2 = List.length ts1, List.length ts2 in
+      let n1, n2 = Lib.List32.length ts1, Lib.List32.length ts2 in
       let args, vs' = split n1 vs e.at in
       (match f with
-      | Func.AstFunc (_, inst', func) ->
+       | Func.AstFunc (_, inst', func) ->
         let {locals; body; _} = func.it in
         let m = Lib.Promise.value inst' in
         let ts = List.map (fun loc -> Types.dyn_val_type m.types loc.it.ltype) locals in
@@ -921,7 +926,7 @@ let rec step (c : config) : config =
     | Handle (Some hs, (vs', {it = Suspending (tagt, vs1, ctxt); at} :: es')), vs
       when List.mem_assq tagt hs ->
       let TagT x' = Tag.type_of tagt in
-      let FuncT (_, ts) = as_func_def_type (def_of (as_sem_var x')) in
+      let FuncT (_, ts) = as_func_def_type (def_of (as_dyn_var x')) in
       let ctxt' code = compose (ctxt code) (vs', es') in
       [Ref (ContRef (ref (Some (Lib.List32.length ts, ctxt'))))] @ vs1 @ vs,
       [Plain (Br (List.assq tagt hs)) @@ e.at]
@@ -1025,7 +1030,7 @@ let create_global (inst : module_inst) (glob : global) : global_inst =
 
 let create_tag (inst : module_inst) (tag : tag) : tag_inst =
   let {tagtype} = tag.it in
-  Tag.alloc (Types.sem_tag_type inst.types tagtype)
+  Tag.alloc (Types.dyn_tag_type inst.types tagtype)
 
 let create_export (inst : module_inst) (ex : export) : export_inst =
   let {name; edesc} = ex.it in
diff --git a/interpreter/host/spectest.ml b/interpreter/host/spectest.ml
index 6c13c8bb1..598ec05e9 100644
--- a/interpreter/host/spectest.ml
+++ b/interpreter/host/spectest.ml
@@ -26,11 +26,11 @@ let memory = Memory.alloc (MemoryT {min = 1l; max = Some 2l})
 let func f ft = Func.alloc_host (Types.alloc (DefFuncT ft)) (f ft)
 
 let tag =
-  let p = Types.alloc (FuncDefType (FuncType ([NumType I32Type], [NumType I32Type]))) in
-  Tag.alloc (TagType (SemVar p))
+  let p = Types.alloc (DefFuncT (FuncT ([NumT I32T], [NumT I32T]))) in
+  Tag.alloc (TagT (Dyn p))
 let except =
-  let p = Types.alloc (FuncDefType (FuncType ([NumType I32Type], []))) in
-  Tag.alloc (TagType (SemVar p))
+  let p = Types.alloc (DefFuncT (FuncT ([NumT I32T], []))) in
+  Tag.alloc (TagT (Dyn p))
 
 let print_value v =
   Printf.printf "%s : %s\n"
diff --git a/interpreter/runtime/instance.ml b/interpreter/runtime/instance.ml
index e6bf09207..8ab5fffc0 100644
--- a/interpreter/runtime/instance.ml
+++ b/interpreter/runtime/instance.ml
@@ -66,7 +66,7 @@ let extern_type_of c = function
   | ExternTable tab -> ExternTableT (Table.type_of tab)
   | ExternMemory mem -> ExternMemoryT (Memory.type_of mem)
   | ExternGlobal glob -> ExternGlobalT (Global.type_of glob)
-  | ExternTag tag -> ExternTagType (Tag.type_of tag)
+  | ExternTag tag -> ExternTagT (Tag.type_of tag)
 
 let export inst name =
   try Some (List.assoc name inst.exports) with Not_found -> None
diff --git a/interpreter/script/js.ml b/interpreter/script/js.ml
index f02003020..7f660b74d 100644
--- a/interpreter/script/js.ml
+++ b/interpreter/script/js.ml
@@ -288,6 +288,7 @@ let null_heap_type_of = function
   | Types.DefHT (Dyn a) ->
     match Types.def_of a with
     | Types.DefFuncT _ -> FuncHT
+    | Types.DefContT _ -> assert false
 
 let value v =
   match v.it with
diff --git a/interpreter/syntax/free.ml b/interpreter/syntax/free.ml
index ce0c5a940..dd22343c8 100644
--- a/interpreter/syntax/free.ml
+++ b/interpreter/syntax/free.ml
@@ -90,11 +90,11 @@ let val_type = function
   | BotT -> empty
 
 let func_type (FuncT (ins, out)) = list val_type ins ++ list val_type out
-let cont_type (ContType x) = var_type x
+let cont_type (ContT x) = var_type x
 let global_type (GlobalT (_mut, t)) = val_type t
 let table_type (TableT (_lim, t)) = ref_type t
 let memory_type (MemoryT (_lim)) = empty
-let tag_type (TagType x) = var_type x
+let tag_type (TagT x) = var_type x
 
 let def_type = function
   | DefFuncT ft -> func_type ft
diff --git a/interpreter/syntax/types.ml b/interpreter/syntax/types.ml
index d76dd2e59..c93089d1b 100644
--- a/interpreter/syntax/types.ml
+++ b/interpreter/syntax/types.ml
@@ -70,30 +70,6 @@ let defaultable : val_type -> bool = function
   | BotT -> assert false
 
 
-(* Projections *)
-
-let as_syn_var = function
-  | SynVar x -> x
-  | SemVar _ -> assert false
-
-let as_sem_var = function
-  | SynVar _ -> assert false
-  | SemVar x -> x
-
-let as_func_def_type (dt : def_type) : func_type =
-  match dt with
-  | DefFuncT ft -> ft
-  | _ -> assert false
-
-let as_cont_def_type (dt : def_type) : cont_type =
-  match dt with
-  | DefContT ct -> ct
-  | _ -> assert false
-
-let extern_type_of_import_type (ImportT (et, _, _)) = et
-let extern_type_of_export_type (ExportT (et, _)) = et
-
-
 (* Filters *)
 
 let funcs (ets : extern_type list) : func_type list =
@@ -107,6 +83,96 @@ let globals (ets : extern_type list) : global_type list =
 let tags (ets : extern_type list) : tag_type list =
   Lib.List.map_filter (function ExternTagT t -> Some t | _ -> None) ets
 
+(* String conversion *)
+
+let string_of_idx x =
+  I32.to_string_u x
+
+let string_of_name n =
+  let b = Buffer.create 16 in
+  let escape uc =
+    if uc < 0x20 || uc >= 0x7f then
+      Buffer.add_string b (Printf.sprintf "\\u{%02x}" uc)
+    else begin
+      let c = Char.chr uc in
+      if c = '\"' || c = '\\' then Buffer.add_char b '\\';
+      Buffer.add_char b c
+    end
+  in
+  List.iter escape n;
+  Buffer.contents b
+
+let string_of_null : null -> string = function
+  | NoNull -> ""
+  | Null -> "null "
+
+let string_of_addr' = ref (fun (a : type_addr) -> assert false)
+let string_of_addr a = !string_of_addr' a
+
+let string_of_var : var -> string = function
+  | Stat x -> I32.to_string_u x
+  | Dyn a -> string_of_addr a
+
+let string_of_num_type : num_type -> string = function
+  | I32T -> "i32"
+  | I64T -> "i64"
+  | F32T -> "f32"
+  | F64T -> "f64"
+
+let string_of_vec_type : vec_type -> string = function
+  | V128T -> "v128"
+
+let string_of_heap_type : heap_type -> string = function
+  | FuncHT -> "func"
+  | ExternHT -> "extern"
+  | DefHT x -> string_of_var x
+  | BotHT -> "something"
+
+let string_of_ref_type : ref_type -> string = function
+  | (nul, t) ->
+    "(ref " ^ string_of_null nul ^ string_of_heap_type t ^ ")"
+
+let string_of_val_type : val_type -> string = function
+  | NumT t -> string_of_num_type t
+  | VecT t -> string_of_vec_type t
+  | RefT t -> string_of_ref_type t
+  | BotT -> "(something)"
+
+let string_of_result_type : result_type -> string = function
+  | ts -> "[" ^ String.concat " " (List.map string_of_val_type ts) ^ "]"
+
+let string_of_func_type : func_type -> string = function
+  | FuncT (ts1, ts2) ->
+    string_of_result_type ts1 ^ " -> " ^ string_of_result_type ts2
+
+let string_of_cont_type = function
+  | ContT x -> string_of_var x
+
+let string_of_def_type : def_type -> string = function
+  | DefFuncT ft -> "func " ^ string_of_func_type ft
+  | DefContT ct -> "cont " ^ string_of_cont_type ct
+
+let string_of_tag_type (TagT x) = string_of_var x
+
+let string_of_limits : I32.t limits -> string = function
+  | {min; max} ->
+    I32.to_string_u min ^
+    (match max with None -> "" | Some n -> " " ^ I32.to_string_u n)
+
+let string_of_memory_type : memory_type -> string = function
+  | MemoryT lim -> string_of_limits lim
+
+let string_of_table_type : table_type -> string = function
+  | TableT (lim, t) -> string_of_limits lim ^ " " ^ string_of_ref_type t
+
+let string_of_global_type : global_type -> string = function
+  | GlobalT (Cons, t) -> string_of_val_type t
+  | GlobalT (Var, t) -> "(mut " ^ string_of_val_type t ^ ")"
+
+let string_of_local_type : local_type -> string = function
+  | LocalT (Set, t) -> string_of_val_type t
+  | LocalT (Unset, t) -> "(unset " ^ string_of_val_type t ^ ")"
+
 let string_of_extern_type : extern_type -> string = function
   | ExternFuncT ft -> "func " ^ string_of_func_type ft
   | ExternTableT tt -> "table " ^ string_of_table_type tt
@@ -132,11 +198,6 @@ let string_of_module_type : module_type -> string = function
       List.map (fun et -> "export " ^ string_of_export_type et ^ "\n") ets
     )
 
-let string_of_tag_type (TagT x) = string_of_var x
-
-let string_of_cont_type = function
-  | ContT x -> string_of_var x
-
 (* Dynamic Types *)
 
 type type_addr += Addr of def_type Lib.Promise.t
@@ -238,3 +299,25 @@ let dyn_module_type = function
     let its = List.map (dyn_import_type c) its in
     let ets = List.map (dyn_export_type c) ets in
     ModuleT ([], its, ets)
+
+(* Projections *)
+let as_stat_var = function
+  | Stat x -> x
+  | Dyn _ -> assert false
+
+let as_dyn_var = function
+  | Dyn a -> a
+  | Stat _ -> assert false
+
+let as_func_def_type (dt : def_type) : func_type =
+  match dt with
+  | DefFuncT ft -> ft
+  | _ -> assert false
+
+let as_cont_def_type (dt : def_type) : cont_type =
+  match dt with
+  | DefContT ct -> ct
+  | _ -> assert false
+
+let extern_type_of_import_type (ImportT (et, _, _)) = et
+let extern_type_of_export_type (ExportT (et, _)) = et
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index b4e6914eb..2b2bfc439 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -576,7 +576,7 @@ let memory off i mem =
   Node ("memory $" ^ nat (off + i) ^ " " ^ limits nat32 lim, [])
 
 let tag off i tag =
-  let {tagtype = TagType x} = tag.it in
+  let {tagtype = TagT x} = tag.it in
   Node ("tag $" ^ nat (off + i),
     [Node ("type", [atom var_type x])]
   )
diff --git a/interpreter/text/lexer.mll b/interpreter/text/lexer.mll
index e985ca07a..def5aeb99 100644
--- a/interpreter/text/lexer.mll
+++ b/interpreter/text/lexer.mll
@@ -154,6 +154,7 @@ rule token = parse
       | "ref" -> REF
       | "null" -> NULL
       | "mut" -> MUT
+      | "tag" -> TAG
       | "cont" -> CONT
 
       | "nop" -> NOP
@@ -711,6 +712,8 @@ rule token = parse
       | "assert_return" -> ASSERT_RETURN
       | "assert_trap" -> ASSERT_TRAP
       | "assert_exhaustion" -> ASSERT_EXHAUSTION
+      | "assert_exception" -> ASSERT_EXCEPTION
+      | "assert_suspension" -> ASSERT_SUSPENSION
       | "nan:canonical" -> NAN Script.CanonicalNan
       | "nan:arithmetic" -> NAN Script.ArithmeticNan
       | "input" -> INPUT
diff --git a/interpreter/text/parser.conflicts b/interpreter/text/parser.conflicts
deleted file mode 100644
index e69de29bb..000000000
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index e974d0e61..b51ff6843 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -163,7 +163,7 @@ let label (c : context) x = lookup "label " c.labels x
 let func_type (c : context) x =
   match (Lib.List32.nth c.types.list x.it).it with
   | DefFuncT ft -> ft
-  | DefContT ct -> ct
+  | _ -> error x.at ("non-function type " ^ Int32.to_string x.it)
   | exception Failure _ -> error x.at ("unknown type " ^ Int32.to_string x.it)
 
 let handlers (c : context) h =
@@ -263,7 +263,7 @@ let inline_func_type_explicit (c : context) x ft at =
 %token<Ast.instr'> VEC_SHIFT VEC_BITMASK VEC_SPLAT
 %token VEC_SHUFFLE
 %token<int -> Ast.instr'> VEC_EXTRACT VEC_REPLACE
-%token FUNC START TYPE PARAM RESULT LOCAL GLOBAL TAG
+%token FUNC START TYPE PARAM RESULT LOCAL GLOBAL TAG CONT
 %token TABLE ELEM MEMORY DATA DECLARE OFFSET ITEM IMPORT EXPORT
 %token MODULE BIN QUOTE
 %token SCRIPT REGISTER INVOKE GET
@@ -321,15 +321,15 @@ global_type :
 
 def_type :
   | LPAR FUNC func_type RPAR { fun c -> DefFuncT ($3 c) }
-  | LPAR CONT cont_type RPAR { fun c -> DefContT (ContT (SynVar ($3 c).it)) }
+  | LPAR CONT cont_type RPAR { fun c -> DefContT (ContT (Stat ($3 c).it)) }
 
 cont_type :
   | type_use cont_type_params
     { let at1 = ati 1 in
       fun c ->
       match $2 c with
-      | FuncType ([], []) -> $1 c type_
-      | ft -> inline_func_type_explicit c ($1 c type_) ft at1 }
+      | FuncT ([], []) -> $1 c
+      | ft -> inline_func_type_explicit c ($1 c) ft at1 }
   | cont_type_params
     /* TODO: the inline type is broken for now */
     { let at = at () in fun c -> inline_func_type c ($1 c) at }
@@ -337,19 +337,18 @@ cont_type :
     { fun c -> $1 c type_ }
 
 cont_type_params :
-  | LPAR PARAM value_type_list RPAR cont_type_params
-    { fun c -> let FuncType (ts1, ts2) = $5 c in
-      FuncType (snd $3 c @ ts1, ts2) }
+  | LPAR PARAM val_type_list RPAR cont_type_params
+    { fun c -> let FuncT (ts1, ts2) = $5 c in
+      FuncT (snd $3 c @ ts1, ts2) }
   | cont_type_results
-    { fun c -> FuncType ([], $1 c) }
+    { fun c -> FuncT ([], $1 c) }
 
 cont_type_results :
-  | LPAR RESULT value_type_list RPAR cont_type_results
+  | LPAR RESULT val_type_list RPAR cont_type_results
     { fun c -> snd $3 c @ $5 c }
   | /* empty */
     { fun c -> [] }
 
-
 func_type :
   | func_type_result
     { fun c -> FuncT ([], $1 c) }
@@ -368,9 +367,9 @@ func_type_result :
 
 tag_type :
   | type_use
-    { fun c -> TagType (SynVar ($1 c type_).it) }
+    { fun c -> TagT (Stat ($1 c).it) }
   | func_type
-    { let at = at () in fun c -> TagType (SynVar (inline_func_type c ($1 c) at).it) }
+    { let at = at () in fun c -> TagT (Stat (inline_func_type c ($1 c) at).it) }
 
 table_type :
   | limits ref_type { fun c -> TableT ($1, $2 c) }
@@ -631,16 +630,15 @@ catch :
 catch_all :
   | CATCH_ALL instr_list { $2 }
 
-resume_instr :
-  | RESUME resume_instr_handler
-    { let at = at () in fun c -> resume ($2 c) @@ at }
-
-resume_instr_handler :
-  | LPAR TAG var var RPAR resume_instr_handler
-    { fun c -> ($3 c tag, $4 c label) :: $6 c }
-  | /* empty */
-    { fun c -> [] }
+/* resume_instr : */
+/*   | RESUME resume_instr_handler */
+/*     { let at = at () in fun c -> resume ($2 c) @@ at } */
 
+/* resume_instr_handler : */
+/*   | LPAR TAG var var RPAR resume_instr_handler */
+/*     { fun c -> ($3 c tag, $4 c label) :: $6 c } */
+/*   | /\* empty *\/ */
+/*     { fun c -> [] } */
 
 resume_instr_instr :
   | RESUME resume_instr_handler_instr
@@ -650,10 +648,9 @@ resume_instr_instr :
 resume_instr_handler_instr :
   | LPAR TAG var var RPAR resume_instr_handler_instr
     { fun c -> let hs, es = $6 c in ($3 c tag, $4 c label) :: hs, es }
-  | instr
+  | instr1
     { fun c -> [], $1 c }
 
-
 block_instr :
   | BLOCK labeling_opt block END labeling_end_opt
     { fun c -> let c' = $2 c $5 in let bt, es = $3 c' in block bt es }
@@ -812,7 +809,7 @@ try_block :
     { let at = at () in
       fun c c' ->
       let body = $2 c in
-      let bt = VarBlockType (SynVar (inline_func_type_explicit c' ($1 c' type_) (fst body) at).it) in
+      let bt = VarBlockType (inline_func_type_explicit c' ($1 c') (fst body) at) in
       snd body bt c c' }
   | try_block_param_body  /* Sugar */
     { let at = at () in
@@ -822,19 +819,19 @@ try_block :
         match fst body with
         | FuncT ([], []) -> ValBlockType None
         | FuncT ([], [t]) -> ValBlockType (Some t)
-        | ft ->  VarBlockT (SynVar (inline_func_type c' ft at).it)
+        | ft ->  VarBlockType (inline_func_type c' ft at)
       in snd body bt c c' }
 
 try_block_param_body :
   | try_block_result_body { $1 }
-  | LPAR PARAM value_type_list RPAR try_block_param_body
+  | LPAR PARAM val_type_list RPAR try_block_param_body
     { fun c ->
       let FuncT (ins, out) = fst ($5 c) in
       FuncT ((snd $3) c @ ins, out), snd ($5 c) }
 
 try_block_result_body :
   | try_ { fun _c -> FuncT ([], []), $1 }
-  | LPAR RESULT value_type_list RPAR try_block_result_body
+  | LPAR RESULT val_type_list RPAR try_block_result_body
     { fun c ->
       let FuncT (ins, out) = fst ($5 c) in
       let vs = (snd $3) c in
diff --git a/interpreter/valid/match.ml b/interpreter/valid/match.ml
index b00adfd58..7bc1a0f56 100644
--- a/interpreter/valid/match.ml
+++ b/interpreter/valid/match.ml
@@ -64,7 +64,8 @@ and eq_cont_type c (ContT x1) (ContT x2) =
 and eq_def_type c dt1 dt2 =
   match dt1, dt2 with
   | DefFuncT ft1, DefFuncT ft2 -> eq_func_type c ft1 ft2
-  | DefContT ct1, ContDefT ct2 -> eq_cont_type c ct1 ct2
+  | DefContT ct1, DefContT ct2 -> eq_cont_type c ct1 ct2
+  | _, _ -> false
 
 and eq_var_type c x1 x2 =
   eq_var x1 x2 ||
@@ -80,7 +81,7 @@ let eq_memory_type c (MemoryT lim1) (MemoryT lim2) =
 let eq_global_type c (GlobalT (mut1, t1)) (GlobalT (mut2, t2)) =
   eq_mutability c mut1 mut2 && eq_val_type c t1 t2
 
-and eq_tag_type c (TagT x1) (TagT x2) =
+let eq_tag_type c (TagT x1) (TagT x2) =
   eq_var_type c x1 x2
 
 let eq_extern_type c et1 et2 =
@@ -147,6 +148,8 @@ and match_func_type c ft1 ft2 =
 and match_def_type c dt1 dt2 =
   match dt1, dt2 with
   | DefFuncT ft1, DefFuncT ft2 -> match_func_type c ft1 ft2
+  | DefContT ct1, DefContT ct2 -> match_cont_type c ct1 ct2
+  | _, _ -> false
 
 and match_var_type c x1 x2 =
   eq_var x1 x2 ||
@@ -167,8 +170,8 @@ let match_global_type c (GlobalT (mut1, t1)) (GlobalT (mut2, t2)) =
   | Cons -> match_val_type c t1 t2
   | Var -> eq_val_type c t1 t2
 
-and match_tag_type c (TagT x1) (TagT x2) =
-  match_var_type c x1 x2
+let match_tag_type c tt1 tt2 =
+  eq_tag_type c tt1 tt2
 
 let match_extern_type c et1 et2 =
   match et1, et2 with
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index 3f81e49f3..0eeb0beac 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -76,9 +76,6 @@ let cont_type (c : context) x =
   | DefContT ct -> ct
   | _ -> error x.at ("non-continuation type " ^ Int32.to_string x.it)
 
-
-let func (c : context) x = func_type c (func_var c x @@ x.at)
-
 let refer category (s : Free.Set.t) x =
   if not (Free.Set.mem x.it s) then
     error x.at
@@ -133,7 +130,7 @@ let check_func_type (c : context) (ft : func_type) at =
 
 let check_cont_type (c : context) (ct : cont_type) at =
   let ContT x = ct in
-  ignore (func_type c (as_syn_var x @@ at))
+  ignore (func_type c (as_stat_var x @@ at))
 
 let check_table_type (c : context) (tt : table_type) at =
   let TableT (lim, t) = tt in
@@ -146,8 +143,8 @@ let check_memory_type (c : context) (mt : memory_type) at =
     "memory size must be at most 65536 pages (4GiB)"
 
 let check_tag_type (c : context) (et : tag_type) at =
-  let TagType x = et in
-  ignore (func_type c (as_syn_var x @@ at))
+  let TagT x = et in
+  ignore (func_type c (as_stat_var x @@ at))
 
 let check_global_type (c : context) (gt : global_type) at =
   let GlobalT (_mut, t) = gt in
@@ -178,6 +175,7 @@ type infer_instr_type = infer_func_type * idx list
 
 let stack ts = (NoEllipses, ts)
 let (-->) ts1 ts2 = {ins = NoEllipses, ts1; outs = NoEllipses, ts2}
+let (-->..) ts1 ts2 = {ins = Ellipses, ts1; outs = NoEllipses, ts2}
 let (-->...) ts1 ts2 = {ins = Ellipses, ts1; outs = Ellipses, ts2}
 
 let check_stack (c : context) ts1 ts2 at =
@@ -360,72 +358,76 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
 
   | Block (bt, es) ->
     let InstrT (ts1, ts2, xs) as it = check_block_type c bt e.at in
-    check_block {c with labels = ts2 :: c.labels} es it e.at;
+    check_block {c with labels = (BlockLabel, ts2) :: c.labels} es it e.at;
     ts1 --> ts2, List.map (fun x -> x @@ e.at) xs
 
   | Loop (bt, es) ->
     let InstrT (ts1, ts2, xs) as it = check_block_type c bt e.at in
-    check_block {c with labels = ts1 :: c.labels} es it e.at;
+    check_block {c with labels = (BlockLabel, ts1) :: c.labels} es it e.at;
     ts1 --> ts2, List.map (fun x -> x @@ e.at) xs
 
   | If (bt, es1, es2) ->
     let InstrT (ts1, ts2, xs) as it = check_block_type c bt e.at in
-    check_block {c with labels = ts2 :: c.labels} es1 it e.at;
-    check_block {c with labels = ts2 :: c.labels} es2 it e.at;
+    check_block {c with labels = (BlockLabel, ts2) :: c.labels} es1 it e.at;
+    check_block {c with labels = (BlockLabel, ts2) :: c.labels} es2 it e.at;
     (ts1 @ [NumT I32T]) --> ts2, List.map (fun x -> x @@ e.at) xs
 
   | Throw x ->
-    let TagType y = tag c x in
-    let FuncType (ts1, _) = func_type c (as_syn_var y @@ e.at) in
-    ts1 -->... []
+    let TagT y = tag c x in
+    let FuncT (ts1, _) = func_type c (as_stat_var y @@ e.at) in
+    ts1 -->... [], []
 
   | Rethrow x ->
     let (kind, _) = label c x in
     require (kind = CatchLabel) e.at "invalid rethrow label";
-    [] -->... []
+    [] -->... [], []
 
   | TryCatch (bt, es, cts, ca) ->
-    let FuncType (ts1, ts2) as ft = check_block_type c bt e.at in
+    let InstrT (ts1, ts2, xs) as ft = check_block_type c bt e.at in
     let c_try = {c with labels = (BlockLabel, ts2) :: c.labels} in
     let c_catch = {c with labels = (CatchLabel, ts2) :: c.labels} in
     check_block c_try es ft e.at;
     List.iter (fun ct -> check_catch ct c_catch ft e.at) cts;
     Lib.Option.app (fun es -> check_block c_catch es ft e.at) ca;
-    ts1 --> ts2
+    ts1 --> ts2, List.map (fun x -> x @@ e.at) xs
 
   | TryDelegate (bt, es, x) ->
-    let FuncType (ts1, ts2) as ft = check_block_type c bt e.at in
+    let InstrT (ts1, ts2, xs) as ft = check_block_type c bt e.at in
     ignore (label c x);
     check_block {c with labels = (BlockLabel, ts2) :: c.labels} es ft e.at;
-    ts1 --> ts2
+    ts1 --> ts2, List.map (fun x -> x @@ e.at) xs
 
   | Br x ->
-    label c x -->... [], []
+    let (_, ts) = label c x in
+    ts -->... [], []
 
   | BrIf x ->
-    (label c x @ [NumT I32T]) --> label c x, []
+    let (_, ts) = label c x in
+    (ts @ [NumT I32T]) --> ts, []
 
   | BrTable (xs, x) ->
-    let n = List.length (label c x) in
+    let n = List.length (snd (label c x)) in
     let ts = Lib.List.table n (fun i -> peek (n - i) s) in
-    check_stack c ts (label c x) x.at;
-    List.iter (fun x' -> check_stack c ts (label c x') x'.at) xs;
+    check_stack c ts (snd (label c x)) x.at;
+    List.iter (fun x' -> check_stack c ts (snd (label c x')) x'.at) xs;
     (ts @ [NumT I32T]) -->... [], []
 
   | BrOnNull x ->
     let (_, ht) = peek_ref 0 s e.at in
-    (label c x @ [RefT (Null, ht)]) --> (label c x @ [RefT (NoNull, ht)]), []
+    let (_, ts) = label c x in
+    (ts @ [RefT (Null, ht)]) --> (ts @ [RefT (NoNull, ht)]), []
 
   | BrOnNonNull x ->
     let (_, ht) = peek_ref 0 s e.at in
     let t' = RefT (NoNull, ht) in
-    require (label c x <> []) e.at
+    let (_, ts) = label c x in
+    require (ts <> []) e.at
       ("type mismatch: instruction requires type " ^ string_of_val_type t' ^
-       " but label has " ^ string_of_result_type (label c x));
-    let ts0, t1 = Lib.List.split_last (label c x) in
+       " but label has " ^ string_of_result_type ts);
+    let ts0, t1 = Lib.List.split_last ts in
     require (match_val_type c.types t' t1) e.at
       ("type mismatch: instruction requires type " ^ string_of_val_type t' ^
-       " but label has " ^ string_of_result_type (label c x));
+       " but label has " ^ string_of_result_type ts);
     (ts0 @ [RefT (Null, ht)]) --> ts0, []
 
   | Return ->
@@ -474,86 +476,86 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
 
   | ContNew x ->
     let ContT y = cont_type c x in
-    [RefType (NonNullable, DefHeapType y)] -->
-    [RefType (NonNullable, DefHeapType (SynVar x.it))]
+    [RefT (NoNull, DefHT y)] -->
+    [RefT (NoNull, DefHT (Stat x.it))], []
 
   | ContBind x ->
     (match peek_ref 0 s e.at with
-    | nul, DefHeapType (SynVar y) ->
+    | nul, DefHT (Stat y) ->
       let ContT z = cont_type c (y @@ e.at) in
-      let FuncT (ts1, ts2) = func_type c (as_syn_var z @@ e.at) in
+      let FuncT (ts1, ts2) = func_type c (as_stat_var z @@ e.at) in
       let ContT z' = cont_type c x in
-      let FuncT (ts1', _) as ft' = func_type c (as_syn_var z' @@ x.at) in
+      let FuncT (ts1', _) as ft' = func_type c (as_stat_var z' @@ x.at) in
       require (List.length ts1 >= List.length ts1') x.at
         "type mismatch in continuation arguments";
       let ts11, ts12 = Lib.List.split (List.length ts1 - List.length ts1') ts1 in
-      require (match_func_type c.types [] (FuncType (ts12, ts2)) ft') e.at
+      require (match_func_type c.types (FuncT (ts12, ts2)) ft') e.at
         "type mismatch in continuation type";
-      (ts11 @ [RefType (nul, DefHeapType (SynVar y))]) -->
-        [RefType (NonNullable, DefHeapType (SynVar x.it))]
-    | (_, BotHeapType) as rt ->
-      [RefType rt] -->.. [RefType (NonNullable, DefHeapType (SynVar x.it))]
+      (ts11 @ [RefT (nul, DefHT (Stat y))]) -->
+        [RefT (NoNull, DefHT (Stat x.it))], []
+    | (_, BotHT) as rt ->
+      [RefT rt] -->.. [RefT (NoNull, DefHT (Stat x.it))], []
     | rt ->
       error e.at
         ("type mismatch: instruction requires continuation reference type" ^
-         " but stack has " ^ string_of_value_type (RefType rt))
+         " but stack has " ^ string_of_val_type (RefT rt))
     )
 
   | Suspend x ->
     let TagT x' = tag c x in
-    let FuncT (ts1, ts2) = func_type c (as_syn_var x' @@ x.at) in
-    ts1 --> ts2
+    let FuncT (ts1, ts2) = func_type c (as_stat_var x' @@ x.at) in
+    ts1 --> ts2, []
 
   | Resume xys ->
     (match peek_ref 0 s e.at with
-    | nul, DefHeapType (SynVar y) ->
+    | nul, DefHT (Stat y) ->
       let ContT z = cont_type c (y @@ e.at) in
-      let FuncT (ts1, ts2) = func_type c (as_syn_var z @@ e.at) in
+      let FuncT (ts1, ts2) = func_type c (as_stat_var z @@ e.at) in
       List.iter (fun (x1, x2) ->
         let TagT x1' = tag c x1 in
-        let FuncT (ts3, ts4) = func_type c (as_syn_var x1' @@ x1.at) in
+        let FuncT (ts3, ts4) = func_type c (as_stat_var x1' @@ x1.at) in
         let (_, ts') = label c x2 in
         match Lib.List.last_opt ts'  with
-        | Some (RefType (nul', DefHeapType (SynVar y'))) ->
+        | Some (RefT (nul', DefHT (Stat y'))) ->
           let ContT z' = cont_type c (y' @@ x2.at) in
-          let ft' = func_type c (as_syn_var z' @@ x2.at) in
-          require (match_func_type c.types [] (FuncType (ts4, ts2)) ft') x2.at
+          let ft' = func_type c (as_stat_var z' @@ x2.at) in
+          require (match_func_type c.types (FuncT (ts4, ts2)) ft') x2.at
             "type mismatch in continuation type";
-          check_stack c (ts3 @ [RefType (nul', DefHeapType (SynVar y'))]) ts' x2.at
+          check_stack c (ts3 @ [RefT (nul', DefHT (Stat y'))]) ts' x2.at
         | _ ->
          error e.at
            ("type mismatch: instruction requires continuation reference type" ^
             " but label has " ^ string_of_result_type ts')
       ) xys;
-      (ts1 @ [RefType (nul, DefHeapType (SynVar y))]) --> ts2
-    | _, BotHeapType ->
-      [] -->... []
+      (ts1 @ [RefT (nul, DefHT (Stat y))]) --> ts2, []
+    | _, BotHT ->
+      [] -->... [], []
     | rt ->
       error e.at
         ("type mismatch: instruction requires continuation reference type" ^
-         " but stack has " ^ string_of_value_type (RefType rt))
+         " but stack has " ^ string_of_val_type (RefT rt))
     )
 
   | ResumeThrow x ->
     let TagT x' = tag c x in
-    let FuncT (ts0, _) = func_type c (as_syn_var x' @@ x.at) in
+    let FuncT (ts0, _) = func_type c (as_stat_var x' @@ x.at) in
     (match peek_ref 0 s e.at with
-    | nul, DefHeapType (SynVar y) ->
+    | nul, DefHT (Stat y) ->
       let ContT z = cont_type c (y @@ e.at) in
-      let FuncT (ts1, ts2) = func_type c (as_syn_var z @@ e.at) in
-      (ts0 @ [RefType (nul, DefHeapType (SynVar y))]) --> ts2
-    | _, BotHeapType ->
-      [] -->... []
+      let FuncT (ts1, ts2) = func_type c (as_stat_var z @@ e.at) in
+      (ts0 @ [RefT (nul, DefHT (Stat y))]) --> ts2, []
+    | _, BotHT ->
+      [] -->... [], []
     | rt ->
       error e.at
         ("type mismatch: instruction requires continuation reference type" ^
-         " but stack has " ^ string_of_value_type (RefType rt))
+         " but stack has " ^ string_of_val_type (RefT rt))
     )
 
   | Barrier (bt, es) ->
-    let FuncT (ts1, ts2) as ft = check_block_type c bt e.at in
+    let InstrT (ts1, ts2, xs) as ft = check_block_type c bt e.at in
     check_block {c with labels = (BlockLabel, ts2) :: c.labels} es ft e.at;
-    ts1 --> ts2
+    ts1 --> ts2, List.map (fun x -> x @@ e.at) xs
 
   | LocalGet x ->
     let LocalT (init, t) = local c x in
@@ -799,12 +801,12 @@ and check_block (c : context) (es : instr list) (it : instr_type) at =
     ("type mismatch: block requires " ^ string_of_result_type ts2 ^
      " but stack has " ^ string_of_result_type (snd s))
 
-and check_catch (ct : idx * instr list) (c : context) (ft : func_type) at =
+and check_catch (ct : idx * instr list) (c : context) (ft : instr_type) at =
   let (x, es) = ct in
-  let TagType y = tag c x in
-  let FuncType (ts1, _) = func_type c (as_syn_var y @@ at) in
-  let FuncType (_, ts2) = ft in
-  check_block c es (FuncType (ts1, ts2)) at
+  let TagT y = tag c x in
+  let FuncT (ts1, _) = func_type c (as_stat_var y @@ at) in
+  let InstrT (_, ts2, xs) = ft in
+  check_block c es (InstrT (ts1, ts2, xs)) at
 
 (* Functions & Constants *)
 
@@ -933,7 +935,7 @@ let check_import (c : context) (im : import) : context =
     {c with globals = c.globals @ [gt]}
   | TagImport et ->
     check_tag_type c et idesc.at;
-    {c with tags = et :: c.tags}
+    {c with tags = c.tags @ [et]}
 
 module NameSet = Set.Make(struct type t = Ast.name let compare = compare end)
 
diff --git a/test/core/cont.wast b/test/core/cont.wast
index 6830c9e31..ae02ae2e7 100644
--- a/test/core/cont.wast
+++ b/test/core/cont.wast
@@ -204,7 +204,7 @@
   (func $gen (export "start") (param $i i64)
     (loop $l
       (br_if 1 (suspend $yield (local.get $i)))
-      (call_ref (local.get $i) (global.get $hook))
+      (call_ref $gen (local.get $i) (global.get $hook))
       (local.set $i (i64.add (local.get $i) (i64.const 1)))
       (br $l)
     )